diff --git a/venv/lib/python3.10/site-packages/Cython/Build/BuildExecutable.py b/venv/lib/python3.10/site-packages/Cython/Build/BuildExecutable.py new file mode 100644 index 0000000000000000000000000000000000000000..5377c166f847498fe570f53e61e4d71d5785515e --- /dev/null +++ b/venv/lib/python3.10/site-packages/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:]) diff --git a/venv/lib/python3.10/site-packages/Cython/Build/Cache.py b/venv/lib/python3.10/site-packages/Cython/Build/Cache.py new file mode 100644 index 0000000000000000000000000000000000000000..0009d17add81897643dd37c85c9b13904f52250a --- /dev/null +++ b/venv/lib/python3.10/site-packages/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 diff --git a/venv/lib/python3.10/site-packages/Cython/Build/Cythonize.py b/venv/lib/python3.10/site-packages/Cython/Build/Cythonize.py new file mode 100644 index 0000000000000000000000000000000000000000..314ddcc50eea33b86125d7e2cdb0a2b1e3416ba6 --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Build/Cythonize.py @@ -0,0 +1,350 @@ +import concurrent.futures +import os +import shutil +import sys +import tempfile +from collections import defaultdict +from contextlib import contextmanager + +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 + + +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) + + +@contextmanager +def _interruptible_pool(pool_cm): + with pool_cm as proc_pool: + try: + yield proc_pool + except KeyboardInterrupt: + proc_pool.terminate_workers() + proc_pool.shutdown(cancel_futures=True) + raise + + +def _build(ext_modules, parallel): + modcount = sum(len(modules) for _, modules in ext_modules) + if not modcount: + return + + serial_execution_mode = modcount == 1 or parallel < 2 + + try: + pool_cm = ( + None if serial_execution_mode + else concurrent.futures.ProcessPoolExecutor(max_workers=parallel) + ) + except (OSError, ImportError): + # `OSError` is a historic exception in `multiprocessing` + # `ImportError` happens e.g. under pyodide (`ModuleNotFoundError`) + serial_execution_mode = True + + if serial_execution_mode: + for ext in ext_modules: + run_distutils(ext) + return + + with _interruptible_pool(pool_cm) as proc_pool: + compiler_tasks = [ + proc_pool.submit(run_distutils, (base_dir, [ext])) + for base_dir, modules in ext_modules + for ext in modules + ] + + concurrent.futures.wait(compiler_tasks, return_when=concurrent.futures.FIRST_EXCEPTION) + + worker_exceptions = [] + for task in compiler_tasks: # discover any crashes + try: + task.result() + except BaseException as proc_err: # could be SystemExit + worker_exceptions.append(proc_err) + + if worker_exceptions: + exc_msg = 'Compiling Cython modules failed with these errors:\n\n' + exc_msg += '\n\t* '.join(('', *map(str, worker_exceptions))) + exc_msg += '\n\n' + + non_base_exceptions = [ + exc for exc in worker_exceptions + if isinstance(exc, Exception) + ] + if sys.version_info[:2] >= (3, 11) and non_base_exceptions: + raise ExceptionGroup(exc_msg, non_base_exceptions) + else: + raise RuntimeError(exc_msg) from worker_exceptions[0] + + +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: + 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 + + 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() diff --git a/venv/lib/python3.10/site-packages/Cython/Build/Dependencies.py b/venv/lib/python3.10/site-packages/Cython/Build/Dependencies.py new file mode 100644 index 0000000000000000000000000000000000000000..f41c8bbb7337ae3906c02849eb066276cee37250 --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Build/Dependencies.py @@ -0,0 +1,1311 @@ +import cython + +import collections +import os +import re, sys, time +from glob import iglob +from io import StringIO +from os.path import relpath as _relpath +from .Cache import Cache, FingerprintFlags + +from collections.abc import Iterable + +try: + import pythran +except: + pythran = None + +from .. import Utils +from ..Utils import (cached_function, cached_method, path_exists, + safe_makedirs, copy_file_to_dir_if_newer, is_package_dir, write_depfile) +from ..Compiler import Errors +from ..Compiler.Main import Context +from ..Compiler import Options +from ..Compiler.Options import (CompilationOptions, default_options, + get_directive_defaults) + +join_path = cached_function(os.path.join) +copy_once_if_newer = cached_function(copy_file_to_dir_if_newer) +safe_makedirs_once = cached_function(safe_makedirs) + + +def _make_relative(file_paths, base=None): + if not base: + base = os.getcwd() + if base[-1] != os.path.sep: + base += os.path.sep + return [_relpath(path, base) if path.startswith(base) else path + for path in file_paths] + + +def extended_iglob(pattern): + if '{' in pattern: + m = re.match('(.*){([^}]+)}(.*)', pattern) + if m: + before, switch, after = m.groups() + for case in switch.split(','): + for path in extended_iglob(before + case + after): + yield path + return + + # We always accept '/' and also '\' on Windows, + # because '/' is generally common for relative paths. + if '**/' in pattern or os.sep == '\\' and '**\\' in pattern: + seen = set() + first, rest = re.split(r'\*\*[%s]' % ('/\\\\' if os.sep == '\\' else '/'), pattern, 1) + if first: + first = iglob(first + os.sep) + else: + first = [''] + for root in first: + for path in extended_iglob(join_path(root, rest)): + if path not in seen: + seen.add(path) + yield path + for path in extended_iglob(join_path(root, '*', '**', rest)): + if path not in seen: + seen.add(path) + yield path + else: + for path in iglob(pattern): + yield path + + +def nonempty(it, error_msg="expected non-empty iterator"): + empty = True + for value in it: + empty = False + yield value + if empty: + raise ValueError(error_msg) + + +def update_pythran_extension(ext): + if pythran is None: + raise RuntimeError("You first need to install Pythran to use the np_pythran directive.") + try: + pythran_ext = pythran.config.make_extension(python=True) + except TypeError: # older pythran version only + pythran_ext = pythran.config.make_extension() + + ext.include_dirs.extend(pythran_ext['include_dirs']) + ext.extra_compile_args.extend(pythran_ext['extra_compile_args']) + ext.extra_link_args.extend(pythran_ext['extra_link_args']) + ext.define_macros.extend(pythran_ext['define_macros']) + ext.undef_macros.extend(pythran_ext['undef_macros']) + ext.library_dirs.extend(pythran_ext['library_dirs']) + ext.libraries.extend(pythran_ext['libraries']) + ext.language = 'c++' + + # These options are not compatible with the way normal Cython extensions work + for bad_option in ["-fwhole-program", "-fvisibility=hidden"]: + try: + ext.extra_compile_args.remove(bad_option) + except ValueError: + pass + + +def parse_list(s): + """ + >>> parse_list("") + [] + >>> parse_list("a") + ['a'] + >>> parse_list("a b c") + ['a', 'b', 'c'] + >>> parse_list("[a, b, c]") + ['a', 'b', 'c'] + >>> parse_list('a " " b') + ['a', ' ', 'b'] + >>> parse_list('[a, ",a", "a,", ",", ]') + ['a', ',a', 'a,', ','] + """ + if len(s) >= 2 and s[0] == '[' and s[-1] == ']': + s = s[1:-1] + delimiter = ',' + else: + delimiter = ' ' + s, literals = strip_string_literals(s) + def unquote(literal): + literal = literal.strip() + if literal[0] in "'\"": + return literals[literal[1:-1]] + else: + return literal + return [unquote(item) for item in s.split(delimiter) if item.strip()] + + +transitive_str = object() +transitive_list = object() +bool_or = object() + +distutils_settings = { + 'name': str, + 'sources': list, + 'define_macros': list, + 'undef_macros': list, + 'libraries': transitive_list, + 'library_dirs': transitive_list, + 'runtime_library_dirs': transitive_list, + 'include_dirs': transitive_list, + 'extra_objects': list, + 'extra_compile_args': transitive_list, + 'extra_link_args': transitive_list, + 'export_symbols': list, + 'depends': transitive_list, + 'language': transitive_str, + 'np_pythran': bool_or +} + + +def _legacy_strtobool(val): + # Used to be "distutils.util.strtobool", adapted for deprecation warnings. + if val == "True": + return True + elif val == "False": + return False + + import warnings + warnings.warn("The 'np_python' option requires 'True' or 'False'", category=DeprecationWarning) + val = val.lower() + if val in ('y', 'yes', 't', 'true', 'on', '1'): + return True + elif val in ('n', 'no', 'f', 'false', 'off', '0'): + return False + else: + raise ValueError("invalid truth value %r" % (val,)) + + +class DistutilsInfo: + + def __init__(self, source=None, exn=None): + self.values = {} + if source is not None: + source_lines = StringIO(source) if isinstance(source, str) else source + for line in source_lines: + line = line.lstrip() + if not line: + continue + if line[0] != '#': + break + line = line[1:].lstrip() + kind = next((k for k in ("distutils:","cython:") if line.startswith(k)), None) + if kind is not None: + key, _, value = [s.strip() for s in line[len(kind):].partition('=')] + type = distutils_settings.get(key, None) + if line.startswith("cython:") and type is None: continue + if type in (list, transitive_list): + value = parse_list(value) + if key == 'define_macros': + value = [tuple(macro.split('=', 1)) + if '=' in macro else (macro, None) + for macro in value] + if type is bool_or: + value = _legacy_strtobool(value) + self.values[key] = value + elif exn is not None: + for key in distutils_settings: + if key in ('name', 'sources','np_pythran'): + continue + value = getattr(exn, key, None) + if value: + self.values[key] = value + + def merge(self, other): + if other is None: + return self + for key, value in other.values.items(): + type = distutils_settings[key] + if type is transitive_str and key not in self.values: + self.values[key] = value + elif type is transitive_list: + if key in self.values: + # Change a *copy* of the list (Trac #845) + all = self.values[key][:] + for v in value: + if v not in all: + all.append(v) + value = all + self.values[key] = value + elif type is bool_or: + self.values[key] = self.values.get(key, False) | value + return self + + def subs(self, aliases): + if aliases is None: + return self + resolved = DistutilsInfo() + for key, value in self.values.items(): + type = distutils_settings[key] + if type in [list, transitive_list]: + new_value_list = [] + for v in value: + if v in aliases: + v = aliases[v] + if isinstance(v, list): + new_value_list += v + else: + new_value_list.append(v) + value = new_value_list + else: + if value in aliases: + value = aliases[value] + resolved.values[key] = value + return resolved + + def apply(self, extension): + for key, value in self.values.items(): + type = distutils_settings[key] + if type in [list, transitive_list]: + value = getattr(extension, key) + list(value) + setattr(extension, key, value) + + +_FIND_TOKEN = cython.declare(object, re.compile(r""" + (?P [#] ) | + (?P [{}] ) | + (?P f )? (?P '+ | "+ ) +""", re.VERBOSE).search) + +_FIND_STRING_TOKEN = cython.declare(object, re.compile(r""" + (?P [\\]+ ) (?P ['"] ) | + (?P f )? (?P '+ | "+ ) +""", re.VERBOSE).search) + +_FIND_FSTRING_TOKEN = cython.declare(object, re.compile(r""" + (?P [{]+ | [}]+ ) | + (?P [\\]+ ) (?P ['"] ) | + (?P f )? (?P '+ | "+ ) +""", re.VERBOSE).search) + + +def strip_string_literals(code: str, prefix: str = '__Pyx_L'): + """ + Normalizes every string literal to be of the form '__Pyx_Lxxx', + returning the normalized code and a mapping of labels to + string literals. + """ + new_code: list = [] + literals: dict = {} + counter: cython.Py_ssize_t = 0 + find_token = _FIND_TOKEN + + def append_new_label(literal): + nonlocal counter + counter += 1 + label = f"{prefix}{counter}_" + literals[label] = literal + new_code.append(label) + + def parse_string(quote_type: str, start: cython.Py_ssize_t, is_fstring: cython.bint) -> cython.Py_ssize_t: + charpos: cython.Py_ssize_t = start + + find_token = _FIND_FSTRING_TOKEN if is_fstring else _FIND_STRING_TOKEN + + while charpos != -1: + token = find_token(code, charpos) + if token is None: + # This probably indicates an unclosed string literal, i.e. a broken file. + append_new_label(code[start:]) + charpos = -1 + break + charpos = token.end() + + if token['escape']: + if len(token['escape']) % 2 == 0 and token['escaped_quote'] == quote_type[0]: + # Quote is not actually escaped and might be part of a terminator, look at it next. + charpos -= 1 + + elif is_fstring and token['braces']: + # Formats or brace(s) in fstring. + if len(token['braces']) % 2 == 0: + # Normal brace characters in string. + continue + if token['braces'][-1] == '{': + if start < charpos-1: + append_new_label(code[start : charpos-1]) + new_code.append('{') + start = charpos = parse_code(charpos, in_fstring=True) + + elif token['quote'].startswith(quote_type): + # Closing quote found (potentially together with further, unrelated quotes). + charpos = token.start('quote') + if charpos > start: + append_new_label(code[start : charpos]) + new_code.append(quote_type) + charpos += len(quote_type) + break + + return charpos + + def parse_code(start: cython.Py_ssize_t, in_fstring: cython.bint = False) -> cython.Py_ssize_t: + charpos: cython.Py_ssize_t = start + end: cython.Py_ssize_t + quote: str + + while charpos != -1: + token = find_token(code, charpos) + if token is None: + new_code.append(code[start:]) + charpos = -1 + break + charpos = end = token.end() + + if token['quote']: + quote = token['quote'] + if len(quote) >= 6: + # Ignore empty tripple-quoted strings: '''''' or """""" + quote = quote[:len(quote) % 6] + if quote and len(quote) != 2: + if len(quote) > 3: + end -= len(quote) - 3 + quote = quote[:3] + new_code.append(code[start:end]) + start = charpos = parse_string(quote, end, is_fstring=token['fstring']) + + elif token['comment']: + new_code.append(code[start:end]) + charpos = code.find('\n', end) + append_new_label(code[end : charpos if charpos != -1 else None]) + if charpos == -1: + break # EOF + start = charpos + + elif in_fstring and token['brace']: + if token['brace'] == '}': + # Closing '}' of f-string. + charpos = end = token.start() + 1 + new_code.append(code[start:end]) # with '}' + break + else: + # Starting a calculated format modifier inside of an f-string format. + end = token.start() + 1 + new_code.append(code[start:end]) # with '{' + start = charpos = parse_code(end, in_fstring=True) + + return charpos + + parse_code(0) + return "".join(new_code), literals + + +# We need to allow spaces to allow for conditional compilation like +# IF ...: +# cimport ... +dependency_regex = re.compile( + r"(?:^ [ \t\f]* from [ \t\f]+ cython\.cimports\.([\w.]+) [ \t\f]+ c?import ) |" + r"(?:^ [ \t\f]* from [ \t\f]+ ([\w.]+) [ \t\f]+ cimport ) |" + r"(?:^ [ \t\f]* c?import [ \t\f]+ cython\.cimports\.([\w.]+) ) |" + r"(?:^ [ \t\f]* cimport [ \t\f]+ ([\w.]+ (?:[ \t\f]* , [ \t\f]* [\w.]+)*) ) |" + r"(?:^ [ \t\f]* cdef [ \t\f]+ extern [ \t\f]+ from [ \t\f]+ ['\"] ([^'\"]+) ['\"] ) |" + r"(?:^ [ \t\f]* include [ \t\f]+ ['\"] ([^'\"]+) ['\"] )", + re.MULTILINE | re.VERBOSE) +dependency_after_from_regex = re.compile( + r"(?:^ [ \t\f]+ \( ([\w., \t\f]*) \) [ \t\f]* [#\n]) |" + r"(?:^ [ \t\f]+ ([\w., \t\f]*) [ \t\f]* [#\n])", + re.MULTILINE | re.VERBOSE) + + +def normalize_existing(base_path, rel_paths): + return normalize_existing0(os.path.dirname(base_path), tuple(set(rel_paths))) + + +@cached_function +def normalize_existing0(base_dir, rel_paths): + """ + Given some base directory ``base_dir`` and a list of path names + ``rel_paths``, normalize each relative path name ``rel`` by + replacing it by ``os.path.join(base, rel)`` if that file exists. + + Return a couple ``(normalized, needed_base)`` where ``normalized`` + if the list of normalized file names and ``needed_base`` is + ``base_dir`` if we actually needed ``base_dir``. If no paths were + changed (for example, if all paths were already absolute), then + ``needed_base`` is ``None``. + """ + normalized = [] + needed_base = None + for rel in rel_paths: + if os.path.isabs(rel): + normalized.append(rel) + continue + path = join_path(base_dir, rel) + if path_exists(path): + normalized.append(os.path.normpath(path)) + needed_base = base_dir + else: + normalized.append(rel) + return (normalized, needed_base) + + +def resolve_depends(depends, include_dirs): + include_dirs = tuple(include_dirs) + resolved = [] + for depend in depends: + path = resolve_depend(depend, include_dirs) + if path is not None: + resolved.append(path) + return resolved + + +@cached_function +def resolve_depend(depend, include_dirs): + if depend[0] == '<' and depend[-1] == '>': + return None + for dir in include_dirs: + path = join_path(dir, depend) + if path_exists(path): + return os.path.normpath(path) + return None + + +@cached_function +def package(filename): + dir = os.path.dirname(os.path.abspath(str(filename))) + if dir != filename and is_package_dir(dir): + return package(dir) + (os.path.basename(dir),) + else: + return () + + +@cached_function +def fully_qualified_name(filename): + module = os.path.splitext(os.path.basename(filename))[0] + return '.'.join(package(filename) + (module,)) + + +@cached_function +def parse_dependencies(source_filename): + # Actual parsing is way too slow, so we use regular expressions. + # The only catch is that we must strip comments and string + # literals ahead of time. + with Utils.open_source_file(source_filename, error_handling='ignore') as fh: + source = fh.read() + distutils_info = DistutilsInfo(source) + source, literals = strip_string_literals(source) + source = source.replace('\\\n', ' ').replace('\t', ' ') + + # TODO: pure mode + cimports = [] + includes = [] + externs = [] + for m in dependency_regex.finditer(source): + pycimports_from, cimport_from, pycimports_list, cimport_list, extern, include = m.groups() + if pycimports_from: + cimport_from = pycimports_from + if pycimports_list: + cimport_list = pycimports_list + + if cimport_from: + cimports.append(cimport_from) + m_after_from = dependency_after_from_regex.search(source, pos=m.end()) + if m_after_from: + multiline, one_line = m_after_from.groups() + subimports = multiline or one_line + cimports.extend("{}.{}".format(cimport_from, s.strip()) + for s in subimports.split(',')) + + elif cimport_list: + cimports.extend(x.strip() for x in cimport_list.split(",")) + elif extern: + externs.append(literals[extern]) + else: + includes.append(literals[include]) + return cimports, includes, externs, distutils_info + + +class DependencyTree: + + def __init__(self, context, quiet=False): + self.context = context + self.quiet = quiet + self._transitive_cache = {} + + def parse_dependencies(self, source_filename): + if path_exists(source_filename): + source_filename = os.path.normpath(source_filename) + return parse_dependencies(source_filename) + + @cached_method + def included_files(self, filename): + # This is messy because included files are textually included, resolving + # cimports (but not includes) relative to the including file. + all = set() + for include in self.parse_dependencies(filename)[1]: + include_path = join_path(os.path.dirname(filename), include) + if not path_exists(include_path): + include_path = self.context.find_include_file(include, source_file_path=filename) + if include_path: + if '.' + os.path.sep in include_path: + include_path = os.path.normpath(include_path) + all.add(include_path) + all.update(self.included_files(include_path)) + elif not self.quiet: + print("Unable to locate '%s' referenced from '%s'" % (filename, include)) + return all + + @cached_method + def cimports_externs_incdirs(self, filename): + # This is really ugly. Nested cimports are resolved with respect to the + # includer, but includes are resolved with respect to the includee. + cimports, includes, externs = self.parse_dependencies(filename)[:3] + cimports = set(cimports) + externs = set(externs) + incdirs = set() + for include in self.included_files(filename): + included_cimports, included_externs, included_incdirs = self.cimports_externs_incdirs(include) + cimports.update(included_cimports) + externs.update(included_externs) + incdirs.update(included_incdirs) + externs, incdir = normalize_existing(filename, externs) + if incdir: + incdirs.add(incdir) + return tuple(cimports), externs, incdirs + + def cimports(self, filename): + return self.cimports_externs_incdirs(filename)[0] + + def package(self, filename): + return package(filename) + + def fully_qualified_name(self, filename): + return fully_qualified_name(filename) + + @cached_method + def find_pxd(self, module, filename=None): + is_relative = module[0] == '.' + if is_relative and not filename: + raise NotImplementedError("New relative imports.") + if filename is not None: + module_path = module.split('.') + if is_relative: + module_path.pop(0) # just explicitly relative + package_path = list(self.package(filename)) + while module_path and not module_path[0]: + try: + package_path.pop() + except IndexError: + return None # FIXME: error? + module_path.pop(0) + relative = '.'.join(package_path + module_path) + pxd = self.context.find_pxd_file(relative, source_file_path=filename) + if pxd: + return pxd + if is_relative: + return None # FIXME: error? + return self.context.find_pxd_file(module, source_file_path=filename) + + @cached_method + def cimported_files(self, filename): + filename_root, filename_ext = os.path.splitext(filename) + if filename_ext in ('.pyx', '.py') and path_exists(filename_root + '.pxd'): + pxd_list = [filename_root + '.pxd'] + else: + pxd_list = [] + # Cimports generates all possible combinations package.module + # when imported as from package cimport module. + for module in self.cimports(filename): + if module[:7] == 'cython.' or module == 'cython': + continue + pxd_file = self.find_pxd(module, filename) + if pxd_file is not None: + pxd_list.append(pxd_file) + return tuple(pxd_list) + + @cached_method + def immediate_dependencies(self, filename): + all_deps = {filename} + all_deps.update(self.cimported_files(filename)) + all_deps.update(self.included_files(filename)) + return all_deps + + def all_dependencies(self, filename): + return self.transitive_merge(filename, self.immediate_dependencies, set.union) + + @cached_method + def timestamp(self, filename): + return os.path.getmtime(filename) + + def extract_timestamp(self, filename): + return self.timestamp(filename), filename + + def newest_dependency(self, filename): + return max([self.extract_timestamp(f) for f in self.all_dependencies(filename)]) + + def distutils_info0(self, filename): + info = self.parse_dependencies(filename)[3] + kwds = info.values + cimports, externs, incdirs = self.cimports_externs_incdirs(filename) + basedir = os.getcwd() + # Add dependencies on "cdef extern from ..." files + if externs: + externs = _make_relative(externs, basedir) + if 'depends' in kwds: + kwds['depends'] = list(set(kwds['depends']).union(externs)) + else: + kwds['depends'] = list(externs) + # Add include_dirs to ensure that the C compiler will find the + # "cdef extern from ..." files + if incdirs: + include_dirs = list(kwds.get('include_dirs', [])) + for inc in _make_relative(incdirs, basedir): + if inc not in include_dirs: + include_dirs.append(inc) + kwds['include_dirs'] = include_dirs + return info + + def distutils_info(self, filename, aliases=None, base=None): + return (self.transitive_merge(filename, self.distutils_info0, DistutilsInfo.merge) + .subs(aliases) + .merge(base)) + + def transitive_merge(self, node, extract, merge): + try: + seen = self._transitive_cache[extract, merge] + except KeyError: + seen = self._transitive_cache[extract, merge] = {} + return self.transitive_merge_helper( + node, extract, merge, seen, {}, self.cimported_files)[0] + + def transitive_merge_helper(self, node, extract, merge, seen, stack, outgoing): + if node in seen: + return seen[node], None + deps = extract(node) + if node in stack: + return deps, node + try: + stack[node] = len(stack) + loop = None + for next in outgoing(node): + sub_deps, sub_loop = self.transitive_merge_helper(next, extract, merge, seen, stack, outgoing) + if sub_loop is not None: + if loop is not None and stack[loop] < stack[sub_loop]: + pass + else: + loop = sub_loop + deps = merge(deps, sub_deps) + if loop == node: + loop = None + if loop is None: + seen[node] = deps + return deps, loop + finally: + del stack[node] + + +_dep_tree = None + +def create_dependency_tree(ctx=None, quiet=False): + global _dep_tree + if _dep_tree is None: + if ctx is None: + ctx = Context(["."], get_directive_defaults(), + options=CompilationOptions(default_options)) + _dep_tree = DependencyTree(ctx, quiet=quiet) + return _dep_tree + + +# If this changes, change also docs/src/reference/compilation.rst +# which mentions this function +def default_create_extension(template, kwds): + if 'depends' in kwds: + include_dirs = kwds.get('include_dirs', []) + ["."] + depends = resolve_depends(kwds['depends'], include_dirs) + kwds['depends'] = sorted(set(depends + template.depends)) + + t = template.__class__ + ext = t(**kwds) + if hasattr(template, "py_limited_api"): + ext.py_limited_api = template.py_limited_api + metadata = dict(distutils=kwds, module_name=kwds['name']) + return (ext, metadata) + + +# This may be useful for advanced users? +def create_extension_list(patterns, exclude=None, ctx=None, aliases=None, quiet=False, language=None, + exclude_failures=False): + if language is not None: + print('Warning: passing language={0!r} to cythonize() is deprecated. ' + 'Instead, put "# distutils: language={0}" in your .pyx or .pxd file(s)'.format(language)) + if exclude is None: + exclude = [] + if patterns is None: + return [], {} + elif isinstance(patterns, str) or not isinstance(patterns, Iterable): + patterns = [patterns] + + from distutils.extension import Extension + if 'setuptools' in sys.modules: + # Support setuptools Extension instances as well. + extension_classes = ( + Extension, # should normally be the same as 'setuptools.extension._Extension' + sys.modules['setuptools.extension']._Extension, + sys.modules['setuptools'].Extension, + ) + else: + extension_classes = (Extension,) + + explicit_modules = {m.name for m in patterns if isinstance(m, extension_classes)} + deps = create_dependency_tree(ctx, quiet=quiet) + shared_utility_qualified_name = ctx.shared_utility_qualified_name + + to_exclude = set() + if not isinstance(exclude, list): + exclude = [exclude] + for pattern in exclude: + to_exclude.update(map(os.path.abspath, extended_iglob(pattern))) + + module_list = [] + module_metadata = {} + + # if no create_extension() function is defined, use a simple + # default function. + create_extension = ctx.options.create_extension or default_create_extension + + seen = set() + for pattern in patterns: + if isinstance(pattern, str): + filepattern = pattern + template = Extension(pattern, []) # Fake Extension without sources + name = '*' + base = None + ext_language = language + elif isinstance(pattern, extension_classes): + cython_sources = [s for s in pattern.sources + if os.path.splitext(s)[1] in ('.py', '.pyx')] + if cython_sources: + filepattern = cython_sources[0] + if len(cython_sources) > 1: + print("Warning: Multiple cython sources found for extension '%s': %s\n" + "See https://cython.readthedocs.io/en/latest/src/userguide/sharing_declarations.html " + "for sharing declarations among Cython files." % (pattern.name, cython_sources)) + elif shared_utility_qualified_name and pattern.name == shared_utility_qualified_name: + # This is the shared utility code file. + m, _ = create_extension(pattern, dict( + name=shared_utility_qualified_name, + sources=pattern.sources or [ + shared_utility_qualified_name.replace('.', os.sep) + ('.cpp' if pattern.language == 'c++' else '.c')], + language=pattern.language, + )) + m.np_pythran = False + m.shared_utility_qualified_name = None + module_list.append(m) + continue + else: + # ignore non-cython modules + module_list.append(pattern) + continue + template = pattern + name = template.name + base = DistutilsInfo(exn=template) + ext_language = None # do not override whatever the Extension says + else: + msg = str("pattern is not of type str nor subclass of Extension (%s)" + " but of type %s and class %s" % (repr(Extension), + type(pattern), + pattern.__class__)) + raise TypeError(msg) + + for file in nonempty(sorted(extended_iglob(filepattern)), "'%s' doesn't match any files" % filepattern): + if os.path.abspath(file) in to_exclude: + continue + module_name = deps.fully_qualified_name(file) + if '*' in name: + if module_name in explicit_modules: + continue + elif name: + module_name = name + + Utils.raise_error_if_module_name_forbidden(module_name) + + if module_name not in seen: + try: + kwds = deps.distutils_info(file, aliases, base).values + except Exception: + if exclude_failures: + continue + raise + if base is not None: + for key, value in base.values.items(): + if key not in kwds: + kwds[key] = value + + kwds['name'] = module_name + + sources = [file] + [m for m in template.sources if m != filepattern] + if 'sources' in kwds: + # allow users to add .c files etc. + for source in kwds['sources']: + if source not in sources: + sources.append(source) + kwds['sources'] = sources + + if ext_language and 'language' not in kwds: + kwds['language'] = ext_language + + np_pythran = kwds.pop('np_pythran', False) + + # Create the new extension + m, metadata = create_extension(template, kwds) + m.np_pythran = np_pythran or getattr(m, 'np_pythran', False) + m.shared_utility_qualified_name = shared_utility_qualified_name + if m.np_pythran: + update_pythran_extension(m) + module_list.append(m) + + # Store metadata (this will be written as JSON in the + # generated C file but otherwise has no purpose) + module_metadata[module_name] = metadata + + if file not in m.sources: + # Old setuptools unconditionally replaces .pyx with .c/.cpp + target_file = os.path.splitext(file)[0] + ('.cpp' if m.language == 'c++' else '.c') + try: + m.sources.remove(target_file) + except ValueError: + # never seen this in the wild, but probably better to warn about this unexpected case + print("Warning: Cython source file not found in sources list, adding %s" % file) + m.sources.insert(0, file) + seen.add(name) + return module_list, module_metadata + + +# This is the user-exposed entry point. +def cythonize(module_list, exclude=None, nthreads=0, aliases=None, quiet=False, force=None, language=None, + exclude_failures=False, show_all_warnings=False, **options): + """ + Compile a set of source modules into C/C++ files and return a list of distutils + Extension objects for them. + + :param module_list: As module list, pass either a glob pattern, a list of glob + patterns or a list of Extension objects. The latter + allows you to configure the extensions separately + through the normal distutils options. + You can also pass Extension objects that have + glob patterns as their sources. Then, cythonize + will resolve the pattern and create a + copy of the Extension for every matching file. + + :param exclude: When passing glob patterns as ``module_list``, you can exclude certain + module names explicitly by passing them into the ``exclude`` option. + + :param nthreads: The number of concurrent builds for parallel compilation + (requires the ``multiprocessing`` module). + + :param aliases: If you want to use compiler directives like ``# distutils: ...`` but + can only know at compile time (when running the ``setup.py``) which values + to use, you can use aliases and pass a dictionary mapping those aliases + to Python strings when calling :func:`cythonize`. As an example, say you + want to use the compiler + directive ``# distutils: include_dirs = ../static_libs/include/`` + but this path isn't always fixed and you want to find it when running + the ``setup.py``. You can then do ``# distutils: include_dirs = MY_HEADERS``, + find the value of ``MY_HEADERS`` in the ``setup.py``, put it in a python + variable called ``foo`` as a string, and then call + ``cythonize(..., aliases={'MY_HEADERS': foo})``. + + :param quiet: If True, Cython won't print error, warning, or status messages during the + compilation. + + :param force: Forces the recompilation of the Cython modules, even if the timestamps + don't indicate that a recompilation is necessary. + + :param language: To globally enable C++ mode, you can pass ``language='c++'``. Otherwise, this + will be determined at a per-file level based on compiler directives. This + affects only modules found based on file names. Extension instances passed + into :func:`cythonize` will not be changed. It is recommended to rather + use the compiler directive ``# distutils: language = c++`` than this option. + + :param exclude_failures: For a broad 'try to compile' mode that ignores compilation + failures and simply excludes the failed extensions, + pass ``exclude_failures=True``. Note that this only + really makes sense for compiling ``.py`` files which can also + be used without compilation. + + :param show_all_warnings: By default, not all Cython warnings are printed. + Set to true to show all warnings. + + :param annotate: If ``True``, will produce a HTML file for each of the ``.pyx`` or ``.py`` + files compiled. The HTML file gives an indication + of how much Python interaction there is in + each of the source code lines, compared to plain C code. + It also allows you to see the C/C++ code + generated for each line of Cython code. This report is invaluable when + optimizing a function for speed, + and for determining when to :ref:`release the GIL `: + in general, a ``nogil`` block may contain only "white" code. + See examples in :ref:`determining_where_to_add_types` or + :ref:`primes`. + + + :param annotate-fullc: If ``True`` will produce a colorized HTML version of + the source which includes entire generated C/C++-code. + + + :param compiler_directives: Allow to set compiler directives in the ``setup.py`` like this: + ``compiler_directives={'embedsignature': True}``. + See :ref:`compiler-directives`. + + :param depfile: produce depfiles for the sources if True. + :param cache: If ``True`` the cache enabled with default path. If the value is a path to a directory, + then the directory is used to cache generated ``.c``/``.cpp`` files. By default cache is disabled. + See :ref:`cython-cache`. + """ + if exclude is None: + exclude = [] + if 'include_path' not in options: + options['include_path'] = ['.'] + if 'common_utility_include_dir' in options: + safe_makedirs(options['common_utility_include_dir']) + + depfile = options.pop('depfile', None) + + if pythran is None: + pythran_options = None + else: + pythran_options = CompilationOptions(**options) + pythran_options.cplus = True + pythran_options.np_pythran = True + + if force is None: + force = os.environ.get("CYTHON_FORCE_REGEN") == "1" # allow global overrides for build systems + + c_options = CompilationOptions(**options) + cpp_options = CompilationOptions(**options); cpp_options.cplus = True + ctx = Context.from_options(c_options) + options = c_options + shared_utility_qualified_name = ctx.shared_utility_qualified_name + module_list, module_metadata = create_extension_list( + module_list, + exclude=exclude, + ctx=ctx, + quiet=quiet, + exclude_failures=exclude_failures, + language=language, + aliases=aliases) + + fix_windows_unicode_modules(module_list) + + deps = create_dependency_tree(ctx, quiet=quiet) + build_dir = getattr(options, 'build_dir', None) + if options.cache and not (options.annotate or Options.annotate): + # cache is enabled when: + # * options.cache is True (the default path to the cache base dir is used) + # * options.cache is the explicit path to the cache base dir + # * annotations are not generated + cache_path = None if options.cache is True else options.cache + cache = Cache(cache_path, getattr(options, 'cache_size', None)) + else: + cache = None + + def copy_to_build_dir(filepath, root=os.getcwd()): + filepath_abs = os.path.abspath(filepath) + if os.path.isabs(filepath): + filepath = filepath_abs + if filepath_abs.startswith(root): + # distutil extension depends are relative to cwd + mod_dir = join_path(build_dir, + os.path.dirname(_relpath(filepath, root))) + copy_once_if_newer(filepath_abs, mod_dir) + + def file_in_build_dir(c_file): + if not build_dir: + return c_file + if os.path.isabs(c_file): + c_file = os.path.splitdrive(c_file)[1] + c_file = c_file.split(os.sep, 1)[1] + c_file = os.path.join(build_dir, c_file) + dir = os.path.dirname(c_file) + safe_makedirs_once(dir) + return c_file + + modules_by_cfile = collections.defaultdict(list) + to_compile = [] + for m in module_list: + if build_dir: + for dep in m.depends: + copy_to_build_dir(dep) + + cy_sources = [ + source for source in m.sources + if os.path.splitext(source)[1] in ('.pyx', '.py')] + if len(cy_sources) == 1: + # normal "special" case: believe the Extension module name to allow user overrides + full_module_name = m.name + else: + # infer FQMN from source files + full_module_name = None + + np_pythran = getattr(m, 'np_pythran', False) + py_limited_api = getattr(m, 'py_limited_api', False) + + if np_pythran: + options = pythran_options + elif m.language == 'c++': + options = cpp_options + else: + options = c_options + + new_sources = [] + for source in m.sources: + base, ext = os.path.splitext(source) + if ext in ('.pyx', '.py'): + c_file = base + ('.cpp' if m.language == 'c++' or np_pythran else '.c') + + # setup for out of place build directory if enabled + c_file = file_in_build_dir(c_file) + + # write out the depfile, if requested + if depfile: + dependencies = deps.all_dependencies(source) + write_depfile(c_file, source, dependencies) + + # Missing files and those generated by other Cython versions should always be recreated. + if Utils.file_generated_by_this_cython(c_file): + c_timestamp = os.path.getmtime(c_file) + else: + c_timestamp = -1 + + # Priority goes first to modified files, second to direct + # dependents, and finally to indirect dependents. + if c_timestamp < deps.timestamp(source): + dep_timestamp, dep = deps.timestamp(source), source + priority = 0 + else: + dep_timestamp, dep = deps.newest_dependency(source) + priority = 2 - (dep in deps.immediate_dependencies(source)) + if force or c_timestamp < dep_timestamp: + if not quiet and not force: + if source == dep: + print("Compiling %s because it changed." % Utils.decode_filename(source)) + else: + print("Compiling %s because it depends on %s." % ( + Utils.decode_filename(source), + Utils.decode_filename(dep), + )) + if not force and cache: + fingerprint = cache.transitive_fingerprint( + source, deps.all_dependencies(source), options, + FingerprintFlags(m.language or 'c', py_limited_api, np_pythran) + ) + else: + fingerprint = None + to_compile.append(( + priority, source, c_file, fingerprint, quiet, + options, not exclude_failures, module_metadata.get(m.name), + full_module_name, show_all_warnings)) + modules_by_cfile[c_file].append(m) + elif shared_utility_qualified_name and m.name == shared_utility_qualified_name: + # Generate shared utility code module now. + c_file = file_in_build_dir(source) + module_options = CompilationOptions( + options, shared_c_file_path=c_file, shared_utility_qualified_name=None) + if not Utils.is_cython_generated_file(c_file): + print(f"Warning: Shared module source file is not a Cython file - not creating '{m.name}' as '{c_file}'") + elif force or not Utils.file_generated_by_this_cython(c_file): + from .SharedModule import generate_shared_module + if not quiet: + print(f"Generating shared module '{m.name}'") + generate_shared_module(module_options) + else: + c_file = source + if build_dir: + copy_to_build_dir(source) + + new_sources.append(c_file) + + m.sources = new_sources + + to_compile.sort() + N = len(to_compile) + + # Drop "priority" sorting component of "to_compile" entries + # and add a simple progress indicator and the remaining arguments. + build_progress_indicator = ("[{0:%d}/%d] " % (len(str(N)), N)).format + to_compile = [ + task[1:] + (build_progress_indicator(i), cache) + for i, task in enumerate(to_compile, 1) + ] + + if N <= 1: + nthreads = 0 + try: + from concurrent.futures import ProcessPoolExecutor + except ImportError: + nthreads = 0 + + if nthreads: + with ProcessPoolExecutor( + max_workers=nthreads, + initializer=_init_multiprocessing_helper, + ) as proc_pool: + try: + list(proc_pool.map(cythonize_one_helper, to_compile, chunksize=1)) + except KeyboardInterrupt: + proc_pool.terminate_workers() + proc_pool.shutdown(cancel_futures=True) + raise + else: + for args in to_compile: + cythonize_one(*args) + + if exclude_failures: + failed_modules = set() + for c_file, modules in modules_by_cfile.items(): + if not os.path.exists(c_file): + failed_modules.update(modules) + elif os.path.getsize(c_file) < 200: + f = open(c_file, 'r', encoding='iso8859-1') + try: + if f.read(len('#error ')) == '#error ': + # dead compilation result + failed_modules.update(modules) + finally: + f.close() + if failed_modules: + for module in failed_modules: + module_list.remove(module) + print("Failed compilations: %s" % ', '.join(sorted([ + module.name for module in failed_modules]))) + + if cache: + cache.cleanup_cache() + + # cythonize() is often followed by the (non-Python-buffered) + # compiler output, flush now to avoid interleaving output. + sys.stdout.flush() + return module_list + + +def fix_windows_unicode_modules(module_list): + # Hack around a distutils 3.[5678] bug on Windows for unicode module names. + # https://bugs.python.org/issue39432 + if sys.platform != "win32": + return + if sys.version_info >= (3, 8, 2): + return + + def make_filtered_list(ignored_symbol, old_entries): + class FilteredExportSymbols(list): + # export_symbols for unicode filename cause link errors on Windows + # Cython doesn't need them (it already defines PyInit with the correct linkage) + # so use this class as a temporary fix to stop them from being generated + def __contains__(self, val): + # so distutils doesn't "helpfully" add PyInit_ + return val == ignored_symbol or list.__contains__(self, val) + + filtered_list = FilteredExportSymbols(old_entries) + if old_entries: + filtered_list.extend(name for name in old_entries if name != ignored_symbol) + return filtered_list + + for m in module_list: + if m.name.isascii(): + continue + m.export_symbols = make_filtered_list( + "PyInit_" + m.name.rsplit(".", 1)[-1], + m.export_symbols, + ) + + +if os.environ.get('XML_RESULTS'): + compile_result_dir = os.environ['XML_RESULTS'] + def record_results(func): + def with_record(*args): + t = time.time() + success = True + try: + try: + func(*args) + except: + success = False + finally: + t = time.time() - t + module = fully_qualified_name(args[0]) + name = "cythonize." + module + failures = 1 - success + if success: + failure_item = "" + else: + failure_item = "failure" + output = open(os.path.join(compile_result_dir, name + ".xml"), "w") + output.write(""" + + + + %(failure_item)s + + + """.strip() % locals()) + output.close() + return with_record +else: + def record_results(func): + return func + + +# TODO: Share context? Issue: pyx processing leaks into pxd module +@record_results +def cythonize_one(pyx_file, c_file, + fingerprint=None, quiet=False, options=None, + raise_on_failure=True, embedded_metadata=None, + full_module_name=None, show_all_warnings=False, + progress="", cache=None): + from ..Compiler.Main import compile_single, default_options + from ..Compiler.Errors import CompileError, PyrexError + + if not quiet: + if cache and fingerprint and cache.lookup_cache(c_file, fingerprint): + print(f"{progress}Found compiled {pyx_file} in cache") + else: + print(f"{progress}Cythonizing {Utils.decode_filename(pyx_file)}") + if options is None: + options = CompilationOptions(default_options) + options.output_file = c_file + options.embedded_metadata = embedded_metadata + + old_warning_level = Errors.LEVEL + if show_all_warnings: + Errors.LEVEL = 0 + + any_failures = 0 + try: + result = compile_single(pyx_file, options, full_module_name=full_module_name, cache=cache, fingerprint=fingerprint) + if result.num_errors > 0: + any_failures = 1 + except (OSError, PyrexError) as e: + sys.stderr.write('%s\n' % e) + any_failures = 1 + # XXX + import traceback + traceback.print_exc() + except Exception: + if raise_on_failure: + raise + import traceback + traceback.print_exc() + any_failures = 1 + finally: + if show_all_warnings: + Errors.LEVEL = old_warning_level + + if any_failures: + if raise_on_failure: + raise CompileError(None, pyx_file) + elif os.path.exists(c_file): + os.remove(c_file) + + +def cythonize_one_helper(m): + import traceback + try: + return cythonize_one(*m) + except Exception: + traceback.print_exc() + raise + + +def _init_multiprocessing_helper(): + # KeyboardInterrupt kills workers, so don't let them get it + import signal + signal.signal(signal.SIGINT, signal.SIG_IGN) diff --git a/venv/lib/python3.10/site-packages/Cython/Build/Distutils.py b/venv/lib/python3.10/site-packages/Cython/Build/Distutils.py new file mode 100644 index 0000000000000000000000000000000000000000..3efcc0d7b5101f5b5fbacfaa47c9afe760dbaaa6 --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Build/Distutils.py @@ -0,0 +1 @@ +from Cython.Distutils.build_ext import build_ext diff --git a/venv/lib/python3.10/site-packages/Cython/Build/Inline.py b/venv/lib/python3.10/site-packages/Cython/Build/Inline.py new file mode 100644 index 0000000000000000000000000000000000000000..11084bd788351485e2b4ead1c8db5019d35501b8 --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Build/Inline.py @@ -0,0 +1,463 @@ +import gc +import hashlib +import inspect +import os +import re +import sys +import time + +from distutils.core import Distribution, Extension +from distutils.command.build_ext import build_ext + +import Cython +from ..Compiler.Main import Context +from ..Compiler.Options import (default_options, CompilationOptions, + get_directive_defaults) + +from ..Compiler.Visitor import CythonTransform, EnvTransform +from ..Compiler.ParseTreeTransforms import SkipDeclarations +from ..Compiler.TreeFragment import parse_from_strings +from .Dependencies import strip_string_literals, cythonize, cached_function +from .Cache import get_cython_cache_dir +from ..Compiler import Pipeline +import cython as cython_module + +import importlib.util +from importlib.machinery import ExtensionFileLoader + +def load_dynamic(name, path): + spec = importlib.util.spec_from_file_location(name, loader=ExtensionFileLoader(name, path)) + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + return module + + +class UnboundSymbols(EnvTransform, SkipDeclarations): + def __init__(self): + super(EnvTransform, self).__init__(context=None) + self.unbound = set() + def visit_NameNode(self, node): + if not self.current_env().lookup(node.name): + self.unbound.add(node.name) + return node + def __call__(self, node): + super().__call__(node) + return self.unbound + + +@cached_function +def unbound_symbols(code, context=None): + if context is None: + context = Context([], get_directive_defaults(), + options=CompilationOptions(default_options)) + from ..Compiler.ParseTreeTransforms import AnalyseDeclarationsTransform + tree = parse_from_strings('(tree fragment)', code) + for phase in Pipeline.create_pipeline(context, 'pyx'): + if phase is None: + continue + tree = phase(tree) + if isinstance(phase, AnalyseDeclarationsTransform): + break + import builtins + return tuple(UnboundSymbols()(tree) - set(dir(builtins))) + + +def unsafe_type(arg, context=None): + py_type = type(arg) + if py_type is int: + return 'long' + else: + return safe_type(arg, context) + + +def safe_type(arg, context=None): + py_type = type(arg) + if py_type in (list, tuple, dict, str): + return py_type.__name__ + elif py_type is complex: + return 'double complex' + elif py_type is float: + return 'double' + elif py_type is bool: + return 'bint' + elif 'numpy' in sys.modules and isinstance(arg, sys.modules['numpy'].ndarray): + return 'numpy.ndarray[numpy.%s_t, ndim=%s]' % (arg.dtype.name, arg.ndim) + else: + for base_type in py_type.__mro__: + if base_type.__module__ in ('__builtin__', 'builtins'): + return 'object' + module = context.find_module(base_type.__module__, need_pxd=False) + if module: + entry = module.lookup(base_type.__name__) + if entry.is_type: + return '%s.%s' % (base_type.__module__, base_type.__name__) + return 'object' + + +def _get_build_extension(): + dist = Distribution() + # Ensure the build respects distutils configuration by parsing + # the configuration files + config_files = dist.find_config_files() + dist.parse_config_files(config_files) + build_extension = build_ext(dist) + build_extension.finalize_options() + return build_extension + + +@cached_function +def _create_context(cython_include_dirs): + return Context( + list(cython_include_dirs), + get_directive_defaults(), + options=CompilationOptions(default_options) + ) + + +_cython_inline_cache = {} +_cython_inline_default_context = _create_context(('.',)) + + +def _populate_unbound(kwds, unbound_symbols, locals=None, globals=None): + for symbol in unbound_symbols: + if symbol not in kwds: + if locals is None or globals is None: + calling_frame = inspect.currentframe().f_back.f_back.f_back + if locals is None: + locals = calling_frame.f_locals + if globals is None: + globals = calling_frame.f_globals + if not isinstance(locals, dict): + # FrameLocalsProxy is stricter than dict on how it looks up keys + # and this means our "EncodedStrings" don't match the keys in locals. + # Therefore copy to a dict. + locals = dict(locals) + if symbol in locals: + kwds[symbol] = locals[symbol] + elif symbol in globals: + kwds[symbol] = globals[symbol] + else: + print("Couldn't find %r" % symbol) + + +def _inline_key(orig_code, arg_sigs, language_level): + key = orig_code, arg_sigs, sys.version_info, sys.executable, language_level, Cython.__version__ + return hashlib.sha256(str(key).encode('utf-8')).hexdigest() + + +def cython_inline(code, get_type=unsafe_type, + lib_dir=os.path.join(get_cython_cache_dir(), 'inline'), + cython_include_dirs=None, cython_compiler_directives=None, + force=False, quiet=False, locals=None, globals=None, language_level=None, **kwds): + + if get_type is None: + get_type = lambda x: 'object' + ctx = _create_context(tuple(cython_include_dirs)) if cython_include_dirs else _cython_inline_default_context + + cython_compiler_directives = dict(cython_compiler_directives) if cython_compiler_directives else {} + if language_level is None and 'language_level' not in cython_compiler_directives: + language_level = '3' + if language_level is not None: + cython_compiler_directives['language_level'] = language_level + + key_hash = None + + # Fast path if this has been called in this session. + _unbound_symbols = _cython_inline_cache.get(code) + if _unbound_symbols is not None: + _populate_unbound(kwds, _unbound_symbols, locals, globals) + args = sorted(kwds.items()) + arg_sigs = tuple([(get_type(value, ctx), arg) for arg, value in args]) + key_hash = _inline_key(code, arg_sigs, language_level) + invoke = _cython_inline_cache.get((code, arg_sigs, key_hash)) + if invoke is not None: + arg_list = [arg[1] for arg in args] + return invoke(*arg_list) + + orig_code = code + code, literals = strip_string_literals(code) + code = strip_common_indent(code) + if locals is None: + locals = inspect.currentframe().f_back.f_back.f_locals + if globals is None: + globals = inspect.currentframe().f_back.f_back.f_globals + try: + _cython_inline_cache[orig_code] = _unbound_symbols = unbound_symbols(code) + _populate_unbound(kwds, _unbound_symbols, locals, globals) + except AssertionError: + if not quiet: + # Parsing from strings not fully supported (e.g. cimports). + print("Could not parse code as a string (to extract unbound symbols).") + + cimports = [] + for name, arg in list(kwds.items()): + if arg is cython_module: + cimports.append('\ncimport cython as %s' % name) + del kwds[name] + arg_names = sorted(kwds) + arg_sigs = tuple([(get_type(kwds[arg], ctx), arg) for arg in arg_names]) + if key_hash is None: + key_hash = _inline_key(orig_code, arg_sigs, language_level) + module_name = "_cython_inline_" + key_hash + + if module_name in sys.modules: + module = sys.modules[module_name] + + else: + build_extension = None + if cython_inline.so_ext is None: + # Figure out and cache current extension suffix + build_extension = _get_build_extension() + cython_inline.so_ext = build_extension.get_ext_filename('') + + lib_dir = os.path.abspath(lib_dir) + module_path = os.path.join(lib_dir, module_name + cython_inline.so_ext) + + if not os.path.exists(lib_dir): + os.makedirs(lib_dir) + if force or not os.path.isfile(module_path): + cflags = [] + define_macros = [] + c_include_dirs = [] + qualified = re.compile(r'([.\w]+)[.]') + for type, _ in arg_sigs: + m = qualified.match(type) + if m: + cimports.append('\ncimport %s' % m.groups()[0]) + # one special case + if m.groups()[0] == 'numpy': + import numpy + c_include_dirs.append(numpy.get_include()) + define_macros.append(("NPY_NO_DEPRECATED_API", "NPY_1_7_API_VERSION")) + # cflags.append('-Wno-unused') + module_body, func_body = extract_func_code(code) + params = ', '.join(['%s %s' % a for a in arg_sigs]) + module_code = """ +%(module_body)s +%(cimports)s +def __invoke(%(params)s): +%(func_body)s + return locals() + """ % {'cimports': '\n'.join(cimports), + 'module_body': module_body, + 'params': params, + 'func_body': func_body } + for key, value in literals.items(): + module_code = module_code.replace(key, value) + pyx_file = os.path.join(lib_dir, module_name + '.pyx') + fh = open(pyx_file, 'w') + try: + fh.write(module_code) + finally: + fh.close() + extension = Extension( + name=module_name, + sources=[pyx_file], + include_dirs=c_include_dirs or None, + extra_compile_args=cflags or None, + define_macros=define_macros or None, + ) + if build_extension is None: + build_extension = _get_build_extension() + build_extension.extensions = cythonize( + [extension], + include_path=cython_include_dirs or ['.'], + compiler_directives=cython_compiler_directives, + quiet=quiet) + build_extension.build_temp = os.path.dirname(pyx_file) + build_extension.build_lib = lib_dir + build_extension.run() + + if sys.platform == 'win32' and sys.version_info >= (3, 8): + with os.add_dll_directory(os.path.abspath(lib_dir)): + module = load_dynamic(module_name, module_path) + else: + module = load_dynamic(module_name, module_path) + + _cython_inline_cache[orig_code, arg_sigs, key_hash] = module.__invoke + arg_list = [kwds[arg] for arg in arg_names] + return module.__invoke(*arg_list) + + +# The code template used for cymeit benchmark runs. +# We keep the benchmark repetition separate from the benchmarked code +# to prevent the C compiler from doing unhelpful loop optimisations. +_CYMEIT_TEMPLATE = """ +def __PYX_repeat_benchmark(benchmark, timer, size_t number): + cdef size_t i + + t0 = timer() + for i in range(number): + benchmark() + t1 = timer() + return t1 - t0 + +def __PYX_make_benchmark(): + {setup_code} + + def __PYX_run_benchmark(): + {benchmark_code} + + return __PYX_run_benchmark +""" + + +def cymeit(code, setup_code=None, import_module=None, directives=None, timer=time.perf_counter, repeat=9): + """Benchmark a Cython code string similar to 'timeit'. + + 'setup_code': string of setup code that will be run before taking the timings. + + 'import_module': a module namespace to run the benchmark in + (usually a compiled Cython module). + + 'directives': Cython directives to use when compiling the benchmark code. + + 'timer': The timer function. Defaults to 'time.perf_counter', returning float seconds. + Nanosecond timers are detected (and can only be used) if they return integers. + + 'repeat': The number of timings to take and return. + + Returns a tuple: (list of single-loop timings, number of loops run for each) + """ + import textwrap + + # Compile the benchmark code as an inline closure function. + + setup_code = strip_common_indent(setup_code) if setup_code else '' + code = strip_common_indent(code) if code.strip() else 'pass' + + module_namespace = __import__(import_module).__dict__ if import_module else None + + cymeit_code = _CYMEIT_TEMPLATE.format( + setup_code=textwrap.indent(setup_code, ' '*4).strip(), + benchmark_code=textwrap.indent(code, ' '*8).strip(), + + ) + + namespace = cython_inline( + cymeit_code, + cython_compiler_directives=directives, + locals=module_namespace, + ) + + make_benchmark = namespace['__PYX_make_benchmark'] + repeat_benchmark = namespace['__PYX_repeat_benchmark'] + + # Based on 'timeit' in CPython 3.13. + + def timeit(number): + benchmark = make_benchmark() + + gcold = gc.isenabled() + gc.disable() + try: + timing = repeat_benchmark(benchmark, timer, number) + finally: + if gcold: + gc.enable() + return timing + + # Find a sufficiently large number of loops, warm up the system. + + timer_returns_nanoseconds = isinstance(timer(), int) + one_second = 1_000_000_000 if timer_returns_nanoseconds else 1.0 + + # Run for at least 0.2 seconds, either as integer nanoseconds or floating point seconds. + min_runtime = one_second // 5 if timer_returns_nanoseconds else one_second / 5 + + def autorange(): + i = 1 + while True: + for j in 1, 2, 5: + number = i * j + time_taken = timeit(number) + assert isinstance(time_taken, int if timer_returns_nanoseconds else float) + if time_taken >= min_runtime: + return number + elif timer_returns_nanoseconds and (time_taken < 10 and number >= 10): + # Arbitrary sanity check to prevent endless loops for non-ns timers. + raise RuntimeError(f"Timer seems to return non-ns timings: {timer}") + i *= 10 + + autorange() # warmup + number = autorange() + + # Run and repeat the benchmark. + timings = [ + timeit(number) + for _ in range(repeat) + ] + + half = number // 2 # for integer rounding + + timings = [ + (timing + half) // number if timer_returns_nanoseconds else timing / number + for timing in timings + ] + + return (timings, number) + + +# Cached suffix used by cython_inline above. None should get +# overridden with actual value upon the first cython_inline invocation +cython_inline.so_ext = None + +_find_non_space = re.compile(r'\S').search + + +def strip_common_indent(code): + min_indent = None + lines = code.splitlines() + for line in lines: + match = _find_non_space(line) + if not match: + continue # blank + indent = match.start() + if line[indent] == '#': + continue # comment + if min_indent is None or min_indent > indent: + min_indent = indent + for ix, line in enumerate(lines): + match = _find_non_space(line) + if not match or not line or line[indent:indent+1] == '#': + continue + lines[ix] = line[min_indent:] + return '\n'.join(lines) + + +module_statement = re.compile(r'^((cdef +(extern|class))|cimport|(from .+ cimport)|(from .+ import +[*]))') +def extract_func_code(code): + module = [] + function = [] + current = function + code = code.replace('\t', ' ') + lines = code.split('\n') + for line in lines: + if not line.startswith(' '): + if module_statement.match(line): + current = module + else: + current = function + current.append(line) + return '\n'.join(module), ' ' + '\n '.join(function) + + +def get_body(source): + ix = source.index(':') + if source[:5] == 'lambda': + return "return %s" % source[ix+1:] + else: + return source[ix+1:] + + +# Lots to be done here... It would be especially cool if compiled functions +# could invoke each other quickly. +class RuntimeCompiledFunction: + + def __init__(self, f): + self._f = f + self._body = get_body(inspect.getsource(f)) + + def __call__(self, *args, **kwds): + all = inspect.getcallargs(self._f, *args, **kwds) + return cython_inline(self._body, locals=self._f.__globals__, globals=self._f.__globals__, **all) diff --git a/venv/lib/python3.10/site-packages/Cython/Build/IpythonMagic.py b/venv/lib/python3.10/site-packages/Cython/Build/IpythonMagic.py new file mode 100644 index 0000000000000000000000000000000000000000..2ae539b44f43719ea2e279d0432777cab1759867 --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Build/IpythonMagic.py @@ -0,0 +1,560 @@ +""" +===================== +Cython related magics +===================== + +Magic command interface for interactive work with Cython + +.. note:: + + The ``Cython`` package needs to be installed separately. It + can be obtained using ``easy_install`` or ``pip``. + +Usage +===== + +To enable the magics below, execute ``%load_ext cython``. + +``%%cython`` + +{CYTHON_DOC} + +``%%cython_inline`` + +{CYTHON_INLINE_DOC} + +``%%cython_pyximport`` + +{CYTHON_PYXIMPORT_DOC} + +Author: +* Brian Granger + +Code moved from IPython and adapted by: +* Martín Gaitán + +Parts of this code were taken from Cython.inline. +""" +#----------------------------------------------------------------------------- +# Copyright (C) 2010-2011, IPython Development Team. +# +# Distributed under the terms of the Modified BSD License. +# +# The full license is in the file ipython-COPYING.rst, distributed with this software. +#----------------------------------------------------------------------------- + + +import io +import os +import re +import sys +import time +import copy +import distutils.log +import textwrap + +IO_ENCODING = sys.getfilesystemencoding() + +import hashlib +from distutils.core import Distribution, Extension +from distutils.command.build_ext import build_ext + +from IPython.core import display +from IPython.core import magic_arguments +from IPython.core.magic import Magics, magics_class, cell_magic +try: + from IPython.paths import get_ipython_cache_dir +except ImportError: + # older IPython version + from IPython.utils.path import get_ipython_cache_dir +from IPython.utils.text import dedent + +from ..Shadow import __version__ as cython_version +from ..Compiler.Errors import CompileError +from .Inline import cython_inline, load_dynamic +from .Dependencies import cythonize +from ..Utils import captured_fd, print_captured + + +PGO_CONFIG = { + 'gcc': { + 'gen': ['-fprofile-generate', '-fprofile-dir={TEMPDIR}'], + 'use': ['-fprofile-use', '-fprofile-correction', '-fprofile-dir={TEMPDIR}'], + }, + # blind copy from 'configure' script in CPython 3.7 + 'icc': { + 'gen': ['-prof-gen'], + 'use': ['-prof-use'], + } +} +PGO_CONFIG['mingw32'] = PGO_CONFIG['gcc'] + + +@magics_class +class CythonMagics(Magics): + + def __init__(self, shell): + super().__init__(shell) + self._reloads = {} + self._code_cache = {} + self._pyximport_installed = False + + def _import_all(self, module): + mdict = module.__dict__ + if '__all__' in mdict: + keys = mdict['__all__'] + else: + keys = [k for k in mdict if not k.startswith('_')] + + for k in keys: + try: + self.shell.push({k: mdict[k]}) + except KeyError: + msg = "'module' object has no attribute '%s'" % k + raise AttributeError(msg) + + @cell_magic + def cython_inline(self, line, cell): + """Compile and run a Cython code cell using Cython.inline. + + This magic simply passes the body of the cell to Cython.inline + and returns the result. If the variables `a` and `b` are defined + in the user's namespace, here is a simple example that returns + their sum:: + + %%cython_inline + return a+b + + For most purposes, we recommend the usage of the `%%cython` magic. + """ + locs = self.shell.user_global_ns + globs = self.shell.user_ns + return cython_inline(cell, locals=locs, globals=globs) + + @cell_magic + def cython_pyximport(self, line, cell): + """Compile and import a Cython code cell using pyximport. + + The contents of the cell are written to a `.pyx` file in the current + working directory, which is then imported using `pyximport`. This + magic requires a module name to be passed:: + + %%cython_pyximport modulename + def f(x): + return 2.0*x + + The compiled module is then imported and all of its symbols are + injected into the user's namespace. For most purposes, we recommend + the usage of the `%%cython` magic. + """ + module_name = line.strip() + if not module_name: + raise ValueError('module name must be given') + fname = module_name + '.pyx' + with open(fname, 'w', encoding='utf-8') as f: + f.write(cell) + if 'pyximport' not in sys.modules or not self._pyximport_installed: + import pyximport + pyximport.install() + self._pyximport_installed = True + if module_name in self._reloads: + module = self._reloads[module_name] + # Note: reloading extension modules is not actually supported + # (requires PEP-489 reinitialisation support). + # Don't know why this should ever have worked as it reads here. + # All we really need to do is to update the globals below. + #reload(module) + else: + __import__(module_name) + module = sys.modules[module_name] + self._reloads[module_name] = module + self._import_all(module) + + @magic_arguments.magic_arguments() + @magic_arguments.argument( + '-a', '--annotate', action='store_const', const='default', dest='annotate', + help="Produce a colorized HTML version of the source." + ) + @magic_arguments.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." + ) + @magic_arguments.argument( + '-+', '--cplus', action='store_true', default=False, + help="Output a C++ rather than C file." + ) + @magic_arguments.argument( + '-3', dest='language_level', action='store_const', const=3, default=None, + help="Select Python 3 syntax." + ) + @magic_arguments.argument( + '-2', dest='language_level', action='store_const', const=2, default=None, + help="Select Python 2 syntax." + ) + @magic_arguments.argument( + '-f', '--force', action='store_true', default=False, + help="Force the compilation of a new module, even if the source has been " + "previously compiled." + ) + @magic_arguments.argument( + '-c', '--compile-args', action='append', default=[], + help="Extra flags to pass to compiler via the `extra_compile_args` " + "Extension flag (can be specified multiple times)." + ) + @magic_arguments.argument( + '--link-args', action='append', default=[], + help="Extra flags to pass to linker via the `extra_link_args` " + "Extension flag (can be specified multiple times)." + ) + @magic_arguments.argument( + '-l', '--lib', action='append', default=[], + help="Add a library to link the extension against (can be specified " + "multiple times)." + ) + @magic_arguments.argument( + '-n', '--name', + help="Specify a name for the Cython module." + ) + @magic_arguments.argument( + '-L', dest='library_dirs', metavar='dir', action='append', default=[], + help="Add a path to the list of library directories (can be specified " + "multiple times)." + ) + @magic_arguments.argument( + '-I', '--include', action='append', default=[], + help="Add a path to the list of include directories (can be specified " + "multiple times)." + ) + @magic_arguments.argument( + '-S', '--src', action='append', default=[], + help="Add a path to the list of src files (can be specified " + "multiple times)." + ) + @magic_arguments.argument( + '--pgo', dest='pgo', action='store_true', default=False, + help=("Enable profile guided optimisation in the C compiler. " + "Compiles the cell twice and executes it in between to generate a runtime profile.") + ) + @magic_arguments.argument( + '--verbose', dest='quiet', action='store_false', default=True, + help=("Print debug information like generated .c/.cpp file location " + "and exact gcc/g++ command invoked.") + ) + @cell_magic + def cython(self, line, cell): + """Compile and import everything from a Cython code cell. + + The contents of the cell are written to a `.pyx` file in the + directory returned by `get_ipython_cache_dir()/cython` using a filename + with the hash of the code. This file is then cythonized and compiled. + The resulting module is imported and all of its symbols are injected + into the user's namespace. The usage is similar to that of + `%%cython_pyximport` but you don't have to pass a module name:: + + %%cython + def f(x): + return 2.0*x + + To compile OpenMP codes, pass the required `--compile-args` + and `--link-args`. For example with gcc:: + + %%cython --compile-args=-fopenmp --link-args=-fopenmp + ... + + To enable profile guided optimisation, pass the ``--pgo`` option. + Note that the cell itself needs to take care of establishing a suitable + profile when executed. This can be done by implementing the functions to + optimise, and then calling them directly in the same cell on some realistic + training data like this:: + + %%cython --pgo + def critical_function(data): + for item in data: + ... + + # execute function several times to build profile + from somewhere import some_typical_data + for _ in range(100): + critical_function(some_typical_data) + + In Python 3.5 and later, you can distinguish between the profile and + non-profile runs as follows:: + + if "_pgo_" in __name__: + ... # execute critical code here + """ + args = magic_arguments.parse_argstring(self.cython, line) + code = cell if cell.endswith('\n') else cell + '\n' + lib_dir = os.path.join(get_ipython_cache_dir(), 'cython') + key = (code, line, sys.version_info, sys.executable, cython_version) + + if not os.path.exists(lib_dir): + os.makedirs(lib_dir) + + if args.pgo: + key += ('pgo',) + if args.force: + # Force a new module name by adding the current time to the + # key which is hashed to determine the module name. + key += (time.time(),) + + if args.name: + module_name = str(args.name) # no-op in Py3 + else: + module_name = "_cython_magic_" + hashlib.sha256(str(key).encode('utf-8')).hexdigest() + html_file = os.path.join(lib_dir, module_name + '.html') + module_path = os.path.join(lib_dir, module_name + self.so_ext) + + have_module = os.path.isfile(module_path) + need_cythonize = args.pgo or not have_module + + if args.annotate: + if not os.path.isfile(html_file): + need_cythonize = True + + extension = None + if need_cythonize: + extensions = self._cythonize(module_name, code, lib_dir, args, quiet=args.quiet) + if extensions is None: + # Compilation failed and printed error message + return None + assert len(extensions) == 1 + extension = extensions[0] + self._code_cache[key] = module_name + + if args.pgo: + self._profile_pgo_wrapper(extension, lib_dir) + + def print_compiler_output(stdout, stderr, where): + # On windows, errors are printed to stdout, we redirect both to sys.stderr. + print_captured(stdout, where, "Content of stdout:\n") + print_captured(stderr, where, "Content of stderr:\n") + + get_stderr = get_stdout = None + try: + with captured_fd(1) as get_stdout: + with captured_fd(2) as get_stderr: + self._build_extension( + extension, lib_dir, pgo_step_name='use' if args.pgo else None, quiet=args.quiet) + except (distutils.errors.CompileError, distutils.errors.LinkError): + # Build failed, print error message from compiler/linker + print_compiler_output(get_stdout(), get_stderr(), sys.stderr) + return None + + # Build seems ok, but we might still want to show any warnings that occurred + print_compiler_output(get_stdout(), get_stderr(), sys.stdout) + + module = load_dynamic(module_name, module_path) + self._import_all(module) + + if args.annotate: + try: + with open(html_file, encoding='utf-8') as f: + annotated_html = f.read() + except OSError as e: + # File could not be opened. Most likely the user has a version + # of Cython before 0.15.1 (when `cythonize` learned the + # `force` keyword argument) and has already compiled this + # exact source without annotation. + print('Cython completed successfully but the annotated ' + 'source could not be read.', file=sys.stderr) + print(e, file=sys.stderr) + else: + return display.HTML(self.clean_annotated_html(annotated_html)) + + def _profile_pgo_wrapper(self, extension, lib_dir): + """ + Generate a .c file for a separate extension module that calls the + module init function of the original module. This makes sure that the + PGO profiler sees the correct .o file of the final module, but it still + allows us to import the module under a different name for profiling, + before recompiling it into the PGO optimised module. Overwriting and + reimporting the same shared library is not portable. + """ + extension = copy.copy(extension) # shallow copy, do not modify sources in place! + module_name = extension.name + pgo_module_name = '_pgo_' + module_name + pgo_wrapper_c_file = os.path.join(lib_dir, pgo_module_name + '.c') + with open(pgo_wrapper_c_file, 'w', encoding='utf-8') as f: + f.write(textwrap.dedent(""" + #include "Python.h" + extern PyMODINIT_FUNC PyInit_%(module_name)s(void); + PyMODINIT_FUNC PyInit_%(pgo_module_name)s(void); /*proto*/ + PyMODINIT_FUNC PyInit_%(pgo_module_name)s(void) { + return PyInit_%(module_name)s(); + } + """ % {'module_name': module_name, 'pgo_module_name': pgo_module_name})) + + extension.sources = extension.sources + [pgo_wrapper_c_file] # do not modify in place! + extension.name = pgo_module_name + + self._build_extension(extension, lib_dir, pgo_step_name='gen') + + # import and execute module code to generate profile + so_module_path = os.path.join(lib_dir, pgo_module_name + self.so_ext) + load_dynamic(pgo_module_name, so_module_path) + + def _cythonize(self, module_name, code, lib_dir, args, quiet=True): + pyx_file = os.path.join(lib_dir, module_name + '.pyx') + + c_include_dirs = args.include + c_src_files = list(map(str, args.src)) + if 'numpy' in code: + import numpy + c_include_dirs.append(numpy.get_include()) + with open(pyx_file, 'w', encoding='utf-8') as f: + f.write(code) + extension = Extension( + name=module_name, + sources=[pyx_file] + c_src_files, + include_dirs=c_include_dirs, + library_dirs=args.library_dirs, + extra_compile_args=args.compile_args, + extra_link_args=args.link_args, + libraries=args.lib, + language='c++' if args.cplus else 'c', + ) + try: + opts = dict( + quiet=quiet, + annotate=args.annotate, + force=True, + language_level=min(3, sys.version_info[0]), + ) + if args.language_level is not None: + assert args.language_level in (2, 3) + opts['language_level'] = args.language_level + return cythonize([extension], **opts) + except CompileError: + return None + + def _build_extension(self, extension, lib_dir, temp_dir=None, pgo_step_name=None, quiet=True): + build_extension = self._get_build_extension( + extension, lib_dir=lib_dir, temp_dir=temp_dir, pgo_step_name=pgo_step_name) + old_threshold = None + try: + if not quiet: + old_threshold = distutils.log.set_threshold(distutils.log.DEBUG) + build_extension.run() + finally: + if not quiet and old_threshold is not None: + distutils.log.set_threshold(old_threshold) + + def _add_pgo_flags(self, build_extension, step_name, temp_dir): + compiler_type = build_extension.compiler.compiler_type + if compiler_type == 'unix': + compiler_cmd = build_extension.compiler.compiler_so + # TODO: we could try to call "[cmd] --version" for better insights + if not compiler_cmd: + pass + elif 'clang' in compiler_cmd or 'clang' in compiler_cmd[0]: + compiler_type = 'clang' + elif 'icc' in compiler_cmd or 'icc' in compiler_cmd[0]: + compiler_type = 'icc' + elif 'gcc' in compiler_cmd or 'gcc' in compiler_cmd[0]: + compiler_type = 'gcc' + elif 'g++' in compiler_cmd or 'g++' in compiler_cmd[0]: + compiler_type = 'gcc' + config = PGO_CONFIG.get(compiler_type) + orig_flags = [] + if config and step_name in config: + flags = [f.format(TEMPDIR=temp_dir) for f in config[step_name]] + for extension in build_extension.extensions: + orig_flags.append((extension.extra_compile_args, extension.extra_link_args)) + extension.extra_compile_args = extension.extra_compile_args + flags + extension.extra_link_args = extension.extra_link_args + flags + else: + print("No PGO %s configuration known for C compiler type '%s'" % (step_name, compiler_type), + file=sys.stderr) + return orig_flags + + @property + def so_ext(self): + """The extension suffix for compiled modules.""" + try: + return self._so_ext + except AttributeError: + self._so_ext = self._get_build_extension().get_ext_filename('') + return self._so_ext + + def _clear_distutils_mkpath_cache(self): + """clear distutils mkpath cache + + prevents distutils from skipping re-creation of dirs that have been removed + """ + try: + from distutils.dir_util import _path_created + except ImportError: + pass + else: + _path_created.clear() + + def _get_build_extension(self, extension=None, lib_dir=None, temp_dir=None, + pgo_step_name=None, _build_ext=build_ext): + self._clear_distutils_mkpath_cache() + dist = Distribution() + config_files = dist.find_config_files() + try: + config_files.remove('setup.cfg') + except ValueError: + pass + dist.parse_config_files(config_files) + + if not temp_dir: + temp_dir = lib_dir + add_pgo_flags = self._add_pgo_flags + + if pgo_step_name: + base_build_ext = _build_ext + class _build_ext(_build_ext): + def build_extensions(self): + add_pgo_flags(self, pgo_step_name, temp_dir) + base_build_ext.build_extensions(self) + + build_extension = _build_ext(dist) + build_extension.finalize_options() + if temp_dir: + build_extension.build_temp = temp_dir + if lib_dir: + build_extension.build_lib = lib_dir + if extension is not None: + build_extension.extensions = [extension] + return build_extension + + @staticmethod + def clean_annotated_html(html, include_style=True): + """Clean up the annotated HTML source. + + Strips the link to the generated C or C++ file, which we do not + present to the user. + + Returns an HTML snippet (no , , or ), + containing only the style tag(s) and _contents_ of the body, + appropriate for embedding multiple times in cell output. + """ + # extract CSS and body, rather than full HTML document + chunks = [] + if include_style: + styles = re.findall("", html, re.MULTILINE | re.DOTALL) + chunks.extend(styles) + # extract body + body = re.search( + r"]*>(.+)", html, re.MULTILINE | re.DOTALL + ).group(1) + + # exclude link to generated file + r = re.compile('

Raw output: (.*)') + for line in body.splitlines(): + if not r.match(line): + chunks.append(line) + return "\n".join(chunks) + +__doc__ = __doc__.format( + # rST doesn't see the -+ flag as part of an option list, so we + # hide it from the module-level docstring. + CYTHON_DOC=dedent(CythonMagics.cython.__doc__ + .replace('-+, --cplus', '--cplus ')), + CYTHON_INLINE_DOC=dedent(CythonMagics.cython_inline.__doc__), + CYTHON_PYXIMPORT_DOC=dedent(CythonMagics.cython_pyximport.__doc__), +) diff --git a/venv/lib/python3.10/site-packages/Cython/Build/SharedModule.py b/venv/lib/python3.10/site-packages/Cython/Build/SharedModule.py new file mode 100644 index 0000000000000000000000000000000000000000..84e5bfde5aaf60d0b71bb5b3d2f2cbb9453c0d89 --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Build/SharedModule.py @@ -0,0 +1,76 @@ +import tempfile +import os +import shutil + +from Cython.Compiler import ( + MemoryView, Code, Options, Pipeline, Errors, Main, Symtab +) +from Cython.Compiler.StringEncoding import EncodedString +from Cython.Compiler.Scanning import FileSourceDescriptor + + +def create_shared_library_pipeline(context, scope, options, result): + + parse = Pipeline.parse_stage_factory(context) + + def generate_tree_factory(context): + def generate_tree(compsrc): + tree = parse(compsrc) + + tree.scope.use_utility_code( + MemoryView.get_view_utility_code(options.shared_utility_qualified_name)) + + tree.scope.use_utility_code(MemoryView._get_memviewslice_declare_code()) + tree.scope.use_utility_code(MemoryView._get_typeinfo_to_format_code()) + context.include_directories.append(Code.get_utility_dir()) + return tree + + return generate_tree + + orig_cimport_from_pyx = Options.cimport_from_pyx + + def set_cimport_from_pyx(cimport_from_pyx): + def inner(node): + Options.cimport_from_pyx = cimport_from_pyx + return node + return inner + + return [ + # "cimport_from_pyx=True" to force generating __Pyx_ExportFunction + set_cimport_from_pyx(True), + generate_tree_factory(context), + *Pipeline.create_pipeline(context, 'pyx', exclude_classes=()), + Pipeline.inject_pxd_code_stage_factory(context), + Pipeline.inject_utility_code_stage_factory(context, internalise_c_class_entries=False), + Pipeline.inject_utility_pxd_code_stage_factory(context), + Pipeline.abort_on_errors, + Pipeline.generate_pyx_code_stage_factory(options, result), + set_cimport_from_pyx(orig_cimport_from_pyx), + ] + + +def generate_shared_module(options): + Errors.init_thread() + Errors.open_listing_file(None) + + dest_c_file = options.shared_c_file_path + module_name = os.path.splitext(os.path.basename(dest_c_file))[0] + + context = Main.Context.from_options(options) + scope = Symtab.ModuleScope('MemoryView', parent_module = None, context = context, is_package=False) + + with tempfile.TemporaryDirectory() as tmpdirname: + pyx_file = os.path.join(tmpdirname, f'{module_name}.pyx') + c_file = os.path.join(tmpdirname, f'{module_name}.c') + with open(pyx_file, 'w'): + pass + source_desc = FileSourceDescriptor(pyx_file) + comp_src = Main.CompilationSource(source_desc, EncodedString(module_name), os.getcwd()) + result = Main.create_default_resultobj(comp_src, options) + + pipeline = create_shared_library_pipeline(context, scope, options, result) + err, enddata = Pipeline.run_pipeline(pipeline, comp_src) + if err is None: + shutil.copy(c_file, dest_c_file) + + return err, enddata diff --git a/venv/lib/python3.10/site-packages/Cython/Build/Tests/TestCyCache.py b/venv/lib/python3.10/site-packages/Cython/Build/Tests/TestCyCache.py new file mode 100644 index 0000000000000000000000000000000000000000..82086e380628a5539c267a30f6a076a6ba099167 --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Build/Tests/TestCyCache.py @@ -0,0 +1,194 @@ +import difflib +import glob +import gzip +import os +import sys +import tempfile +import unittest + +import Cython.Build.Dependencies +import Cython.Compiler.Main +import Cython.Utils +from Cython.TestUtils import CythonTest + + +class TestCyCache(CythonTest): + + def setUp(self): + CythonTest.setUp(self) + self.temp_dir = tempfile.mkdtemp( + prefix='cycache-test', + dir='TEST_TMP' if os.path.isdir('TEST_TMP') else None) + self.src_dir = tempfile.mkdtemp(prefix='src', dir=self.temp_dir) + self.cache_dir = tempfile.mkdtemp(prefix='cache', dir=self.temp_dir) + + def cache_files(self, file_glob): + return glob.glob(os.path.join(self.cache_dir, file_glob)) + + def fresh_cythonize(self, *args, **kwargs): + Cython.Utils.clear_function_caches() + Cython.Build.Dependencies._dep_tree = None # discard method caches + Cython.Build.Dependencies.cythonize(*args, **kwargs) + + def fresh_compile(self, *args, **kwargs): + Cython.Utils.clear_function_caches() + Cython.Compiler.Main.compile(*args, **kwargs) + + + def _test_cycache_switch(self, compilation_method): + content1 = 'value = 1\n' + content2 = 'value = 2\n' + a_pyx = os.path.join(self.src_dir, 'a.pyx') + a_c = a_pyx[:-4] + '.c' + + with open(a_pyx, 'w') as f: + f.write(content1) + + compilation_method(a_pyx, cache=self.cache_dir) + compilation_method(a_pyx, cache=self.cache_dir) + + self.assertEqual(1, len(self.cache_files('a.c*'))) + with open(a_c) as f: + a_contents1 = f.read() + os.unlink(a_c) + + with open(a_pyx, 'w') as f: + f.write(content2) + + compilation_method(a_pyx, cache=self.cache_dir) + + with open(a_c) as f: + a_contents2 = f.read() + os.unlink(a_c) + + self.assertNotEqual(a_contents1, a_contents2, 'C file not changed!') + self.assertEqual(2, len(self.cache_files('a.c*'))) + + with open(a_pyx, 'w') as f: + f.write(content1) + + compilation_method(a_pyx, cache=self.cache_dir) + + self.assertEqual(2, len(self.cache_files('a.c*'))) + with open(a_c) as f: + a_contents = f.read() + self.assertEqual( + a_contents, a_contents1, + msg='\n'.join(list(difflib.unified_diff( + a_contents.split('\n'), a_contents1.split('\n')))[:10])) + + def test_cycache_switch_cythonize(self): + self._test_cycache_switch(self.fresh_cythonize) + + def test_cycache_switch_compile(self): + self._test_cycache_switch(self.fresh_compile) + + def _test_cycache_uses_cache(self, compilation_method): + a_pyx = os.path.join(self.src_dir, 'a.pyx') + a_c = a_pyx[:-4] + '.c' + with open(a_pyx, 'w') as f: + f.write('pass') + + compilation_method(a_pyx, cache=self.cache_dir) + + a_cache = os.path.join(self.cache_dir, os.listdir(self.cache_dir)[0]) + with gzip.GzipFile(a_cache, 'wb') as gzipfile: + gzipfile.write(b'fake stuff') + os.unlink(a_c) + + compilation_method(a_pyx, cache=self.cache_dir) + + with open(a_c) as f: + a_contents = f.read() + self.assertEqual(a_contents, 'fake stuff', + 'Unexpected contents: %s...' % a_contents[:100]) + + + def test_cycache_uses_cache_cythonize(self): + self._test_cycache_uses_cache(self.fresh_cythonize) + + def test_cycache_uses_cache_compile(self): + self._test_cycache_uses_cache(self.fresh_compile) + + def _test_cycache_annotation(self, compilation_method): + a_pyx = os.path.join(self.src_dir, 'a.pyx') + a_c = a_pyx[:-4] + '.c' + a_html = a_pyx[:-4] + '.html' + with open(a_pyx, 'w') as f: + f.write('pass') + + compilation_method(a_pyx, cache=self.cache_dir, annotate='default') + self.assertTrue(os.path.exists(a_html), a_html) + os.unlink(a_html) + os.unlink(a_c) + compilation_method(a_pyx, cache=self.cache_dir, annotate='default') + self.assertTrue(os.path.exists(a_html), a_html) + + def test_cycache_annotation_cythonize(self): + self._test_cycache_annotation(self.fresh_cythonize) + + def test_cycache_annotation_compile(self): + self._test_cycache_annotation(self.fresh_compile) + + def _test_multi_file_output(self, compilation_method): + a_pyx = os.path.join(self.src_dir, 'a.pyx') + a_c = a_pyx[:-4] + '.c' + a_h = a_pyx[:-4] + '.h' + a_api_h = a_pyx[:-4] + '_api.h' + with open(a_pyx, 'w') as f: + f.write('cdef public api int foo(int x): return x\n') + + compilation_method(a_pyx, cache=self.cache_dir) + + expected = [a_c, a_h, a_api_h] + for output in expected: + self.assertTrue(os.path.exists(output), output) + os.unlink(output) + + compilation_method(a_pyx, cache=self.cache_dir) + + for output in expected: + self.assertTrue(os.path.exists(output), output) + + def test_multi_file_output_cythonize(self): + self._test_multi_file_output(self.fresh_cythonize) + + def test_multi_file_output_compile(self): + self._test_multi_file_output(self.fresh_compile) + + def _test_options_invalidation(self, compilation_method): + hash_pyx = os.path.join(self.src_dir, 'options.pyx') + hash_c = hash_pyx[:-len('.pyx')] + '.c' + hash_cpp = hash_pyx[:-len('.pyx')] + '.cpp' + + with open(hash_pyx, 'w') as f: + f.write('pass') + compilation_method(hash_pyx, cache=self.cache_dir, cplus=False) + self.assertEqual(1, len(self.cache_files('options.c*'))) + + os.unlink(hash_c) + + compilation_method(hash_pyx, cache=self.cache_dir, cplus=True) + + self.assertEqual(2, len(self.cache_files('options.c*'))) + + try: + os.unlink(hash_c) + except FileNotFoundError: + # fresh_cythonize() produces .c file, fresh_compile produces .cpp file + os.unlink(hash_cpp) + + compilation_method(hash_pyx, cache=self.cache_dir, cplus=False, show_version=False) + + self.assertEqual(2, len(self.cache_files('options.c*'))) + + os.unlink(hash_c) + + compilation_method(hash_pyx, cache=self.cache_dir, cplus=False, show_version=True) + + self.assertEqual(2, len(self.cache_files('options.c*'))) + def test_options_invalidation_cythonize(self): + self._test_options_invalidation(self.fresh_cythonize) + + def test_options_invalidation_compile(self): + self._test_options_invalidation(self.fresh_compile) diff --git a/venv/lib/python3.10/site-packages/Cython/Build/Tests/TestCythonizeArgsParser.py b/venv/lib/python3.10/site-packages/Cython/Build/Tests/TestCythonizeArgsParser.py new file mode 100644 index 0000000000000000000000000000000000000000..c2769a00df864b004ce0bfeaffc837fa4bd0139d --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Build/Tests/TestCythonizeArgsParser.py @@ -0,0 +1,481 @@ +from Cython.Build.Cythonize import ( + create_args_parser, parse_args_raw, parse_args, + parallel_compiles +) + +from Cython.Compiler import Options +from Cython.Compiler.Tests.Utils import backup_Options, restore_Options, check_global_options + +from unittest import TestCase + +import sys +from io import StringIO + + +class TestCythonizeArgsParser(TestCase): + + def setUp(self): + TestCase.setUp(self) + self.parse_args = lambda x, parser=create_args_parser() : parse_args_raw(parser, x) + + + def are_default(self, options, skip): + # empty containers + empty_containers = ['directives', 'compile_time_env', 'options', 'excludes'] + are_none = ['language_level', 'annotate', 'build', 'build_inplace', 'force', 'quiet', 'lenient', 'keep_going', 'no_docstrings'] + for opt_name in empty_containers: + if len(getattr(options, opt_name))!=0 and (opt_name not in skip): + self.assertEqual(opt_name,"", msg="For option "+opt_name) + return False + for opt_name in are_none: + if (getattr(options, opt_name) is not None) and (opt_name not in skip): + self.assertEqual(opt_name,"", msg="For option "+opt_name) + return False + if options.parallel!=parallel_compiles and ('parallel' not in skip): + return False + return True + + # testing directives: + def test_directive_short(self): + options, args = self.parse_args(['-X', 'cdivision=True']) + self.assertFalse(args) + self.assertTrue(self.are_default(options, ['directives'])) + self.assertEqual(options.directives['cdivision'], True) + + def test_directive_long(self): + options, args = self.parse_args(['--directive', 'cdivision=True']) + self.assertFalse(args) + self.assertTrue(self.are_default(options, ['directives'])) + self.assertEqual(options.directives['cdivision'], True) + + def test_directive_multiple(self): + options, args = self.parse_args(['-X', 'cdivision=True', '-X', 'c_string_type=bytes']) + self.assertFalse(args) + self.assertTrue(self.are_default(options, ['directives'])) + self.assertEqual(options.directives['cdivision'], True) + self.assertEqual(options.directives['c_string_type'], 'bytes') + + def test_directive_multiple_v2(self): + options, args = self.parse_args(['-X', 'cdivision=True,c_string_type=bytes']) + self.assertFalse(args) + self.assertTrue(self.are_default(options, ['directives'])) + self.assertEqual(options.directives['cdivision'], True) + self.assertEqual(options.directives['c_string_type'], 'bytes') + + def test_directive_value_yes(self): + options, args = self.parse_args(['-X', 'cdivision=YeS']) + self.assertFalse(args) + self.assertTrue(self.are_default(options, ['directives'])) + self.assertEqual(options.directives['cdivision'], True) + + def test_directive_value_no(self): + options, args = self.parse_args(['-X', 'cdivision=no']) + self.assertFalse(args) + self.assertTrue(self.are_default(options, ['directives'])) + self.assertEqual(options.directives['cdivision'], False) + + def test_directive_value_invalid(self): + with self.assertRaises(ValueError) as context: + options, args = self.parse_args(['-X', 'cdivision=sadfasd']) + + def test_directive_key_invalid(self): + with self.assertRaises(ValueError) as context: + options, args = self.parse_args(['-X', 'abracadabra']) + + def test_directive_no_value(self): + with self.assertRaises(ValueError) as context: + options, args = self.parse_args(['-X', 'cdivision']) + + def test_directives_types(self): + directives = [ + ('auto_pickle', True), + ('c_string_type', 'bytearray'), + ('c_string_type', 'bytes'), + ('c_string_type', 'str'), + ('c_string_type', 'bytearray'), + ('c_string_type', 'unicode'), + ('c_string_encoding', 'ascii'), + ('language_level', '2'), + ('language_level', '3'), + #('language_level', '3str'), + ('set_initial_path', 'my_initial_path'), + ] + for key, value in directives: + cmd = '{key}={value}'.format(key=key, value=str(value)) + options, args = self.parse_args(['-X', cmd]) + self.assertFalse(args) + self.assertTrue(self.are_default(options, ['directives']), msg = "Error for option: "+cmd) + if value == 'unicode': + value = 'str' + self.assertEqual(options.directives[key], value, msg = "Error for option: "+cmd) + + def test_directives_wrong(self): + directives = [ + ('auto_pickle', 42), # for bool type + ('auto_pickle', 'NONONO'), # for bool type + ('c_string_type', 'bites'), + #('c_string_encoding', 'a'), + #('language_level', 4), + ] + for key, value in directives: + cmd = '{key}={value}'.format(key=key, value=str(value)) + with self.assertRaises(ValueError, msg = "Error for option: "+cmd) as context: + options, args = self.parse_args(['-X', cmd]) + + def test_compile_time_env_short(self): + options, args = self.parse_args(['-E', 'MYSIZE=10']) + self.assertFalse(args) + self.assertTrue(self.are_default(options, ['compile_time_env'])) + self.assertEqual(options.compile_time_env['MYSIZE'], 10) + + def test_compile_time_env_long(self): + options, args = self.parse_args(['--compile-time-env', 'MYSIZE=10']) + self.assertFalse(args) + self.assertTrue(self.are_default(options, ['compile_time_env'])) + self.assertEqual(options.compile_time_env['MYSIZE'], 10) + + def test_compile_time_env_multiple(self): + options, args = self.parse_args(['-E', 'MYSIZE=10', '-E', 'ARRSIZE=11']) + self.assertFalse(args) + self.assertTrue(self.are_default(options, ['compile_time_env'])) + self.assertEqual(options.compile_time_env['MYSIZE'], 10) + self.assertEqual(options.compile_time_env['ARRSIZE'], 11) + + def test_compile_time_env_multiple_v2(self): + options, args = self.parse_args(['-E', 'MYSIZE=10,ARRSIZE=11']) + self.assertFalse(args) + self.assertTrue(self.are_default(options, ['compile_time_env'])) + self.assertEqual(options.compile_time_env['MYSIZE'], 10) + self.assertEqual(options.compile_time_env['ARRSIZE'], 11) + + #testing options + def test_option_short(self): + options, args = self.parse_args(['-s', 'docstrings=True']) + self.assertFalse(args) + self.assertTrue(self.are_default(options, ['options'])) + self.assertEqual(options.options['docstrings'], True) + + def test_option_long(self): + options, args = self.parse_args(['--option', 'docstrings=True']) + self.assertFalse(args) + self.assertTrue(self.are_default(options, ['options'])) + self.assertEqual(options.options['docstrings'], True) + + def test_option_multiple(self): + options, args = self.parse_args(['-s', 'docstrings=True', '-s', 'buffer_max_dims=8']) + self.assertFalse(args) + self.assertTrue(self.are_default(options, ['options'])) + self.assertEqual(options.options['docstrings'], True) + self.assertEqual(options.options['buffer_max_dims'], True) # really? + + def test_option_multiple_v2(self): + options, args = self.parse_args(['-s', 'docstrings=True,buffer_max_dims=8']) + self.assertFalse(args) + self.assertTrue(self.are_default(options, ['options'])) + self.assertEqual(options.options['docstrings'], True) + self.assertEqual(options.options['buffer_max_dims'], True) # really? + + def test_option_value_yes(self): + options, args = self.parse_args(['-s', 'docstrings=YeS']) + self.assertFalse(args) + self.assertTrue(self.are_default(options, ['options'])) + self.assertEqual(options.options['docstrings'], True) + + def test_option_value_4242(self): + options, args = self.parse_args(['-s', 'docstrings=4242']) + self.assertFalse(args) + self.assertTrue(self.are_default(options, ['options'])) + self.assertEqual(options.options['docstrings'], True) + + def test_option_value_0(self): + options, args = self.parse_args(['-s', 'docstrings=0']) + self.assertFalse(args) + self.assertTrue(self.are_default(options, ['options'])) + self.assertEqual(options.options['docstrings'], False) + + def test_option_value_emptystr(self): + options, args = self.parse_args(['-s', 'docstrings=']) + self.assertFalse(args) + self.assertTrue(self.are_default(options, ['options'])) + self.assertEqual(options.options['docstrings'], True) + + def test_option_value_a_str(self): + options, args = self.parse_args(['-s', 'docstrings=BB']) + self.assertFalse(args) + self.assertTrue(self.are_default(options, ['options'])) + self.assertEqual(options.options['docstrings'], True) + + def test_option_value_no(self): + options, args = self.parse_args(['-s', 'docstrings=nO']) + self.assertFalse(args) + self.assertTrue(self.are_default(options, ['options'])) + self.assertEqual(options.options['docstrings'], False) + + def test_option_no_value(self): + options, args = self.parse_args(['-s', 'docstrings']) + self.assertFalse(args) + self.assertTrue(self.are_default(options, ['options'])) + self.assertEqual(options.options['docstrings'], True) + + def test_option_any_key(self): + options, args = self.parse_args(['-s', 'abracadabra']) + self.assertFalse(args) + self.assertTrue(self.are_default(options, ['options'])) + self.assertEqual(options.options['abracadabra'], True) + + def test_language_level_2(self): + options, args = self.parse_args(['-2']) + self.assertFalse(args) + self.assertTrue(self.are_default(options, ['language_level'])) + self.assertEqual(options.language_level, 2) + + def test_language_level_3(self): + options, args = self.parse_args(['-3']) + self.assertFalse(args) + self.assertTrue(self.are_default(options, ['language_level'])) + self.assertEqual(options.language_level, 3) + + def test_language_level_3str(self): + options, args = self.parse_args(['--3str']) + self.assertFalse(args) + self.assertTrue(self.are_default(options, ['language_level'])) + self.assertEqual(options.language_level, 3) + + def test_annotate_short(self): + options, args = self.parse_args(['-a']) + self.assertFalse(args) + self.assertTrue(self.are_default(options, ['annotate'])) + self.assertEqual(options.annotate, 'default') + + def test_annotate_long(self): + options, args = self.parse_args(['--annotate']) + self.assertFalse(args) + self.assertTrue(self.are_default(options, ['annotate'])) + self.assertEqual(options.annotate, 'default') + + def test_annotate_fullc(self): + options, args = self.parse_args(['--annotate-fullc']) + self.assertFalse(args) + self.assertTrue(self.are_default(options, ['annotate'])) + self.assertEqual(options.annotate, 'fullc') + + def test_annotate_and_positional(self): + options, args = self.parse_args(['-a', 'foo.pyx']) + self.assertEqual(args, ['foo.pyx']) + self.assertTrue(self.are_default(options, ['annotate'])) + self.assertEqual(options.annotate, 'default') + + def test_annotate_and_optional(self): + options, args = self.parse_args(['-a', '--3str']) + self.assertFalse(args) + self.assertTrue(self.are_default(options, ['annotate', 'language_level'])) + self.assertEqual(options.annotate, 'default') + self.assertEqual(options.language_level, 3) + + def test_exclude_short(self): + options, args = self.parse_args(['-x', '*.pyx']) + self.assertFalse(args) + self.assertTrue(self.are_default(options, ['excludes'])) + self.assertTrue('*.pyx' in options.excludes) + + def test_exclude_long(self): + options, args = self.parse_args(['--exclude', '*.pyx']) + self.assertFalse(args) + self.assertTrue(self.are_default(options, ['excludes'])) + self.assertTrue('*.pyx' in options.excludes) + + def test_exclude_multiple(self): + options, args = self.parse_args(['--exclude', '*.pyx', '--exclude', '*.py', ]) + self.assertFalse(args) + self.assertTrue(self.are_default(options, ['excludes'])) + self.assertEqual(options.excludes, ['*.pyx', '*.py']) + + def test_build_short(self): + options, args = self.parse_args(['-b']) + self.assertFalse(args) + self.assertTrue(self.are_default(options, ['build'])) + self.assertEqual(options.build, True) + + def test_build_long(self): + options, args = self.parse_args(['--build']) + self.assertFalse(args) + self.assertTrue(self.are_default(options, ['build'])) + self.assertEqual(options.build, True) + + def test_inplace_short(self): + options, args = self.parse_args(['-i']) + self.assertFalse(args) + self.assertTrue(self.are_default(options, ['build_inplace'])) + self.assertEqual(options.build_inplace, True) + + def test_inplace_long(self): + options, args = self.parse_args(['--inplace']) + self.assertFalse(args) + self.assertTrue(self.are_default(options, ['build_inplace'])) + self.assertEqual(options.build_inplace, True) + + def test_parallel_short(self): + options, args = self.parse_args(['-j', '42']) + self.assertFalse(args) + self.assertTrue(self.are_default(options, ['parallel'])) + self.assertEqual(options.parallel, 42) + + def test_parallel_long(self): + options, args = self.parse_args(['--parallel', '42']) + self.assertFalse(args) + self.assertTrue(self.are_default(options, ['parallel'])) + self.assertEqual(options.parallel, 42) + + def test_force_short(self): + options, args = self.parse_args(['-f']) + self.assertFalse(args) + self.assertTrue(self.are_default(options, ['force'])) + self.assertEqual(options.force, True) + + def test_force_long(self): + options, args = self.parse_args(['--force']) + self.assertFalse(args) + self.assertTrue(self.are_default(options, ['force'])) + self.assertEqual(options.force, True) + + def test_quite_short(self): + options, args = self.parse_args(['-q']) + self.assertFalse(args) + self.assertTrue(self.are_default(options, ['quiet'])) + self.assertEqual(options.quiet, True) + + def test_quite_long(self): + options, args = self.parse_args(['--quiet']) + self.assertFalse(args) + self.assertTrue(self.are_default(options, ['quiet'])) + self.assertEqual(options.quiet, True) + + def test_lenient_long(self): + options, args = self.parse_args(['--lenient']) + self.assertTrue(self.are_default(options, ['lenient'])) + self.assertFalse(args) + self.assertEqual(options.lenient, True) + + def test_keep_going_short(self): + options, args = self.parse_args(['-k']) + self.assertFalse(args) + self.assertTrue(self.are_default(options, ['keep_going'])) + self.assertEqual(options.keep_going, True) + + def test_keep_going_long(self): + options, args = self.parse_args(['--keep-going']) + self.assertFalse(args) + self.assertTrue(self.are_default(options, ['keep_going'])) + self.assertEqual(options.keep_going, True) + + def test_no_docstrings_long(self): + options, args = self.parse_args(['--no-docstrings']) + self.assertFalse(args) + self.assertTrue(self.are_default(options, ['no_docstrings'])) + self.assertEqual(options.no_docstrings, True) + + def test_file_name(self): + options, args = self.parse_args(['file1.pyx', 'file2.pyx']) + self.assertEqual(len(args), 2) + self.assertEqual(args[0], 'file1.pyx') + self.assertEqual(args[1], 'file2.pyx') + self.assertTrue(self.are_default(options, [])) + + def test_option_first(self): + options, args = self.parse_args(['-i', 'file.pyx']) + self.assertEqual(args, ['file.pyx']) + self.assertEqual(options.build_inplace, True) + self.assertTrue(self.are_default(options, ['build_inplace'])) + + def test_file_inbetween(self): + options, args = self.parse_args(['-i', 'file.pyx', '-a']) + self.assertEqual(args, ['file.pyx']) + self.assertEqual(options.build_inplace, True) + self.assertEqual(options.annotate, 'default') + self.assertTrue(self.are_default(options, ['build_inplace', 'annotate'])) + + def test_option_trailing(self): + options, args = self.parse_args(['file.pyx', '-i']) + self.assertEqual(args, ['file.pyx']) + self.assertEqual(options.build_inplace, True) + self.assertTrue(self.are_default(options, ['build_inplace'])) + + def test_interspersed_positional(self): + options, sources = self.parse_args([ + 'file1.pyx', '-a', + 'file2.pyx' + ]) + self.assertEqual(sources, ['file1.pyx', 'file2.pyx']) + self.assertEqual(options.annotate, 'default') + self.assertTrue(self.are_default(options, ['annotate'])) + + def test_interspersed_positional2(self): + options, sources = self.parse_args([ + 'file1.pyx', '-a', + 'file2.pyx', '-a', 'file3.pyx' + ]) + self.assertEqual(sources, ['file1.pyx', 'file2.pyx', 'file3.pyx']) + self.assertEqual(options.annotate, 'default') + self.assertTrue(self.are_default(options, ['annotate'])) + + def test_interspersed_positional3(self): + options, sources = self.parse_args([ + '-f', 'f1', 'f2', '-a', + 'f3', 'f4', '-a', 'f5' + ]) + self.assertEqual(sources, ['f1', 'f2', 'f3', 'f4', 'f5']) + self.assertEqual(options.annotate, 'default') + self.assertEqual(options.force, True) + self.assertTrue(self.are_default(options, ['annotate', 'force'])) + + def test_wrong_option(self): + old_stderr = sys.stderr + stderr = sys.stderr = StringIO() + try: + self.assertRaises(SystemExit, self.parse_args, + ['--unknown-option'] + ) + finally: + sys.stderr = old_stderr + self.assertTrue(stderr.getvalue()) + + +class TestParseArgs(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 test_build_set_for_inplace(self): + options, args = parse_args(['foo.pyx', '-i']) + self.assertEqual(options.build, True) + self.check_default_global_options() + + def test_lenient(self): + options, sources = parse_args(['foo.pyx', '--lenient']) + self.assertEqual(sources, ['foo.pyx']) + self.assertEqual(Options.error_on_unknown_names, False) + self.assertEqual(Options.error_on_uninitialized, False) + self.check_default_global_options(['error_on_unknown_names', 'error_on_uninitialized']) + + def test_annotate(self): + options, sources = parse_args(['foo.pyx', '--annotate']) + self.assertEqual(sources, ['foo.pyx']) + self.assertEqual(Options.annotate, 'default') + self.check_default_global_options(['annotate']) + + def test_annotate_fullc(self): + options, sources = parse_args(['foo.pyx', '--annotate-fullc']) + self.assertEqual(sources, ['foo.pyx']) + self.assertEqual(Options.annotate, 'fullc') + self.check_default_global_options(['annotate']) + + def test_no_docstrings(self): + options, sources = parse_args(['foo.pyx', '--no-docstrings']) + self.assertEqual(sources, ['foo.pyx']) + self.assertEqual(Options.docstrings, False) + self.check_default_global_options(['docstrings']) diff --git a/venv/lib/python3.10/site-packages/Cython/Build/Tests/TestDependencies.py b/venv/lib/python3.10/site-packages/Cython/Build/Tests/TestDependencies.py new file mode 100644 index 0000000000000000000000000000000000000000..bc6b99bab45d00f5a1ba04fb47e425632386f7f2 --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Build/Tests/TestDependencies.py @@ -0,0 +1,133 @@ +import contextlib +import os.path +import tempfile +import unittest +from os.path import join as pjoin + +from ..Dependencies import extended_iglob + + +@contextlib.contextmanager +def writable_file(dir_path, filename): + with open(pjoin(dir_path, filename), "w", encoding="utf8") as f: + yield f + + +class TestGlobbing(unittest.TestCase): + @classmethod + def setUpClass(cls): + cls._orig_dir = os.getcwd() + cls._tmpdir = tempfile.TemporaryDirectory() + temp_path = cls._tmpdir.name + os.chdir(temp_path) + + for dir1 in "abcd": + for dir1x in [dir1, dir1 + 'x']: + for dir2 in "xyz": + dir_path = pjoin(dir1x, dir2) + os.makedirs(dir_path) + with writable_file(dir_path, "file2_pyx.pyx") as f: + f.write('""" PYX """') + with writable_file(dir_path, "file2_py.py") as f: + f.write('""" PY """') + + with writable_file(dir1x, "file1_pyx.pyx") as f: + f.write('""" PYX """') + with writable_file(dir1x, "file1_py.py") as f: + f.write('""" PY """') + + @classmethod + def tearDownClass(cls): + os.chdir(cls._orig_dir) + cls._tmpdir.cleanup() + + def files_equal(self, pattern, expected_files): + expected_files = sorted(expected_files) + # It's the users's choice whether '/' will appear on Windows. + matched_files = sorted(path.replace('/', os.sep) for path in extended_iglob(pattern)) + self.assertListEqual(matched_files, expected_files) # / + + # Special case for Windows: also support '\' in patterns. + if os.sep == '\\' and '/' in pattern: + matched_files = sorted(extended_iglob(pattern.replace('/', '\\'))) + self.assertListEqual(matched_files, expected_files) # \ + + def test_extended_iglob_simple(self): + ax_files = [pjoin("a", "x", "file2_pyx.pyx"), pjoin("a", "x", "file2_py.py")] + self.files_equal("a/x/*", ax_files) + self.files_equal("a/x/*.c12", []) + self.files_equal("a/x/*.{py,pyx,c12}", ax_files) + self.files_equal("a/x/*.{py,pyx}", ax_files) + self.files_equal("a/x/*.{pyx}", ax_files[:1]) + self.files_equal("a/x/*.pyx", ax_files[:1]) + self.files_equal("a/x/*.{py}", ax_files[1:]) + self.files_equal("a/x/*.py", ax_files[1:]) + + def test_extended_iglob_simple_star(self): + for basedir in "ad": + files = [ + pjoin(basedir, dirname, filename) + for dirname in "xyz" + for filename in ["file2_pyx.pyx", "file2_py.py"] + ] + self.files_equal(basedir + "/*/*", files) + self.files_equal(basedir + "/*/*.c12", []) + self.files_equal(basedir + "/*/*.{py,pyx,c12}", files) + self.files_equal(basedir + "/*/*.{py,pyx}", files) + self.files_equal(basedir + "/*/*.{pyx}", files[::2]) + self.files_equal(basedir + "/*/*.pyx", files[::2]) + self.files_equal(basedir + "/*/*.{py}", files[1::2]) + self.files_equal(basedir + "/*/*.py", files[1::2]) + + for subdir in "xy*": + files = [ + pjoin(basedir, dirname, filename) + for dirname in "xyz" + if subdir in ('*', dirname) + for filename in ["file2_pyx.pyx", "file2_py.py"] + ] + path = basedir + '/' + subdir + '/' + self.files_equal(path + "*", files) + self.files_equal(path + "*.{py,pyx}", files) + self.files_equal(path + "*.{pyx}", files[::2]) + self.files_equal(path + "*.pyx", files[::2]) + self.files_equal(path + "*.{py}", files[1::2]) + self.files_equal(path + "*.py", files[1::2]) + + def test_extended_iglob_double_star(self): + basedirs = os.listdir(".") + files = [ + pjoin(basedir, dirname, filename) + for basedir in basedirs + for dirname in "xyz" + for filename in ["file2_pyx.pyx", "file2_py.py"] + ] + all_files = [ + pjoin(basedir, filename) + for basedir in basedirs + for filename in ["file1_pyx.pyx", "file1_py.py"] + ] + files + self.files_equal("*/*/*", files) + self.files_equal("*/*/**/*", files) + self.files_equal("*/**/*.*", all_files) + self.files_equal("**/*.*", all_files) + self.files_equal("*/**/*.c12", []) + self.files_equal("**/*.c12", []) + self.files_equal("*/*/*.{py,pyx,c12}", files) + self.files_equal("*/*/**/*.{py,pyx,c12}", files) + self.files_equal("*/**/*/*.{py,pyx,c12}", files) + self.files_equal("**/*/*/*.{py,pyx,c12}", files) + self.files_equal("**/*.{py,pyx,c12}", all_files) + self.files_equal("*/*/*.{py,pyx}", files) + self.files_equal("**/*/*/*.{py,pyx}", files) + self.files_equal("*/**/*/*.{py,pyx}", files) + self.files_equal("**/*.{py,pyx}", all_files) + self.files_equal("*/*/*.{pyx}", files[::2]) + self.files_equal("**/*.{pyx}", all_files[::2]) + self.files_equal("*/**/*/*.pyx", files[::2]) + self.files_equal("*/*/*.pyx", files[::2]) + self.files_equal("**/*.pyx", all_files[::2]) + self.files_equal("*/*/*.{py}", files[1::2]) + self.files_equal("**/*.{py}", all_files[1::2]) + self.files_equal("*/*/*.py", files[1::2]) + self.files_equal("**/*.py", all_files[1::2]) diff --git a/venv/lib/python3.10/site-packages/Cython/Build/Tests/TestInline.py b/venv/lib/python3.10/site-packages/Cython/Build/Tests/TestInline.py new file mode 100644 index 0000000000000000000000000000000000000000..baf31811d8bb461419515cef0d9f8158b93444e1 --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Build/Tests/TestInline.py @@ -0,0 +1,177 @@ +import os +import tempfile +import unittest +from Cython.Shadow import inline +from Cython.Build.Inline import safe_type, cymeit +from Cython.TestUtils import CythonTest + +try: + import numpy + has_numpy = True +except: + has_numpy = False + +test_kwds = dict(force=True, quiet=True) + +global_value = 100 + +class TestInline(CythonTest): + def setUp(self): + CythonTest.setUp(self) + self._call_kwds = dict(test_kwds) + if os.path.isdir('TEST_TMP'): + lib_dir = os.path.join('TEST_TMP','inline') + else: + lib_dir = tempfile.mkdtemp(prefix='cython_inline_') + self._call_kwds['lib_dir'] = lib_dir + + def test_simple(self): + self.assertEqual(inline("return 1+2", **self._call_kwds), 3) + + def test_types(self): + self.assertEqual(inline(""" + cimport cython + return cython.typeof(a), cython.typeof(b) + """, a=1.0, b=[], **self._call_kwds), ('double', 'list object')) + + def test_locals(self): + a = 1 + b = 2 + self.assertEqual(inline("return a+b", **self._call_kwds), 3) + + def test_globals(self): + self.assertEqual(inline("return global_value + 1", **self._call_kwds), global_value + 1) + + def test_no_return(self): + self.assertEqual(inline(""" + a = 1 + cdef double b = 2 + cdef c = [] + """, **self._call_kwds), dict(a=1, b=2.0, c=[])) + + def test_def_node(self): + foo = inline("def foo(x): return x * x", **self._call_kwds)['foo'] + self.assertEqual(foo(7), 49) + + def test_class_ref(self): + class Type: + pass + tp = inline("Type")['Type'] + self.assertEqual(tp, Type) + + def test_pure(self): + import cython as cy + b = inline(""" + b = cy.declare(float, a) + c = cy.declare(cy.pointer(cy.float), &b) + return b + """, a=3, **self._call_kwds) + self.assertEqual(type(b), float) + + def test_compiler_directives(self): + self.assertEqual( + inline('return sum(x)', + x=[1, 2, 3], + cython_compiler_directives={'boundscheck': False}), + 6 + ) + + def test_lang_version(self): + # GH-3419. Caching for inline code didn't always respect compiler directives. + inline_divcode = "def f(int a, int b): return a/b" + self.assertEqual( + inline(inline_divcode, language_level=2)['f'](5,2), + 2 + ) + self.assertEqual( + inline(inline_divcode, language_level=3)['f'](5,2), + 2.5 + ) + self.assertEqual( + inline(inline_divcode, language_level=2)['f'](5,2), + 2 + ) + + def test_repeated_use(self): + inline_mulcode = "def f(int a, int b): return a * b" + self.assertEqual(inline(inline_mulcode)['f'](5, 2), 10) + self.assertEqual(inline(inline_mulcode)['f'](5, 3), 15) + self.assertEqual(inline(inline_mulcode)['f'](6, 2), 12) + self.assertEqual(inline(inline_mulcode)['f'](5, 2), 10) + + f = inline(inline_mulcode)['f'] + self.assertEqual(f(5, 2), 10) + self.assertEqual(f(5, 3), 15) + + @unittest.skipIf(not has_numpy, "NumPy is not available") + def test_numpy(self): + import numpy + a = numpy.ndarray((10, 20)) + a[0,0] = 10 + self.assertEqual(safe_type(a), 'numpy.ndarray[numpy.float64_t, ndim=2]') + self.assertEqual(inline("return a[0,0]", a=a, **self._call_kwds), 10.0) + + +class TestCymeit(unittest.TestCase): + def _run(self, code, setup_code=None, **kwargs): + timings, number = cymeit(code, setup_code=setup_code, **kwargs) + + self.assertGreater(min(timings), 0) + + # Guard that autoscaling leads to reasonable timings. + # Note: we cannot compare against the expected 0.2 due to large timing variations on CI. + max_time = max(timing * number for timing in timings) + if isinstance(max_time, int): + self.assertGreaterEqual(max_time, 100_000) + else: + self.assertGreaterEqual(max_time, 0.0001) + self.assertGreater(number, 10) # arbitrary lower bound for our very quick benchmarks + + return timings + + def test_benchmark_simple(self): + setup_code = "numbers = list(range(0, 1000, 3))" + self._run("sum([num for num in numbers])", setup_code, repeat=3) + + def test_benchmark_timer(self): + import time + setup_code = "numbers = list(range(0, 1000, 3))" + timings = self._run("sum([num for num in numbers])", setup_code, timer=time.perf_counter, repeat=3) + + for timing in timings: + self.assertIsInstance(timing, float) + + def test_benchmark_timer_ns(self): + import time + setup_code = "numbers = list(range(0, 1000, 3))" + timings = self._run("sum([num for num in numbers])", setup_code, timer=time.perf_counter_ns, repeat=3) + + for timing in timings: + self.assertIsInstance(timing, int) + + def test_benchmark_multiline_setup(self): + setup_code = """ + numbers = list(range(0, 100, 3)) + + def csum(numbers): + result = 0 + for number in numbers: + result += number + return result + """ + self._run("csum(numbers)", setup_code) + + def test_benchmark_multiline_code(self): + setup_code = "numbers = list(range(0, 100, 3))" + self._run(""" + sum([ + num + for num in numbers + ]) + """, + setup_code, + repeat=3 + ) + + def test_benchmark_in_module(self): + self._run("fsum(range(100))", import_module='math', repeat=2) diff --git a/venv/lib/python3.10/site-packages/Cython/Build/Tests/TestIpythonMagic.py b/venv/lib/python3.10/site-packages/Cython/Build/Tests/TestIpythonMagic.py new file mode 100644 index 0000000000000000000000000000000000000000..86f5c1a059b8261a82fc60a23d82a1182bb7053c --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Build/Tests/TestIpythonMagic.py @@ -0,0 +1,287 @@ +# tag: ipython + +"""Tests for the Cython magics extension.""" + + +import os +import io +import sys +from contextlib import contextmanager +from unittest import skipIf + +from Cython.Build import IpythonMagic +from Cython.TestUtils import CythonTest +from Cython.Compiler.Annotate import AnnotationCCodeWriter + +try: + import IPython.testing.globalipapp +except ImportError: + # Disable tests and fake helpers for initialisation below. + def skip_if_not_installed(_): + return None +else: + def skip_if_not_installed(c): + return c + +# not using IPython's decorators here because they depend on "nose" +skip_win32 = skipIf(sys.platform == 'win32', "Skip on Windows") + +try: + # disable IPython history thread before it gets started to avoid having to clean it up + from IPython.core.history import HistoryManager + HistoryManager.enabled = False +except ImportError: + pass + + +@contextmanager +def capture_output(): + backup = sys.stdout, sys.stderr + try: + replacement = [ + io.TextIOWrapper(io.BytesIO(), encoding=sys.stdout.encoding), + io.TextIOWrapper(io.BytesIO(), encoding=sys.stderr.encoding), + ] + sys.stdout, sys.stderr = replacement + output = [] + yield output + finally: + sys.stdout, sys.stderr = backup + for wrapper in replacement: + wrapper.seek(0) # rewind + output.append(wrapper.read()) + wrapper.close() + + +code = """\ +def f(x): + return 2*x +""" + +cython3_code = """\ +def f(int x): + return 2 / x + +def call(x): + return f(*(x,)) +""" + +pgo_cython3_code = cython3_code + """\ +def main(): + for _ in range(100): call(5) +main() +""" + +compile_error_code = '''\ +cdef extern from *: + """ + xxx a=1; + """ + int a; +def doit(): + return a +''' + +compile_warning_code = '''\ +cdef extern from *: + """ + #pragma message ( "CWarning" ) + int a = 42; + """ + int a; +def doit(): + return a +''' + + +@skip_if_not_installed +class TestIPythonMagic(CythonTest): + + @classmethod + def setUpClass(cls): + CythonTest.setUpClass() + cls._ip = IPython.testing.globalipapp.get_ipython() + + def setUp(self): + CythonTest.setUp(self) + self._ip.extension_manager.load_extension('cython') + + def test_cython_inline(self): + ip = self._ip + ip.ex('a=10; b=20') + result = ip.run_cell_magic('cython_inline', '', 'return a+b') + self.assertEqual(result, 30) + + @skip_win32 + def test_cython_pyximport(self): + ip = self._ip + module_name = '_test_cython_pyximport' + ip.run_cell_magic('cython_pyximport', module_name, code) + ip.ex('g = f(10)') + self.assertEqual(ip.user_ns['g'], 20.0) + ip.run_cell_magic('cython_pyximport', module_name, code) + ip.ex('h = f(-10)') + self.assertEqual(ip.user_ns['h'], -20.0) + try: + os.remove(module_name + '.pyx') + except OSError: + pass + + def test_cython(self): + ip = self._ip + ip.run_cell_magic('cython', '', code) + ip.ex('g = f(10)') + self.assertEqual(ip.user_ns['g'], 20.0) + + def test_cython_name(self): + # The Cython module named 'mymodule' defines the function f. + ip = self._ip + ip.run_cell_magic('cython', '--name=mymodule', code) + # This module can now be imported in the interactive namespace. + ip.ex('import mymodule; g = mymodule.f(10)') + self.assertEqual(ip.user_ns['g'], 20.0) + + def test_cython_language_level(self): + # The Cython cell defines the functions f() and call(). + ip = self._ip + ip.run_cell_magic('cython', '', cython3_code) + ip.ex('g = f(10); h = call(10)') + self.assertEqual(ip.user_ns['g'], 2.0 / 10.0) + self.assertEqual(ip.user_ns['h'], 2.0 / 10.0) + + def test_cython3(self): + # The Cython cell defines the functions f() and call(). + ip = self._ip + ip.run_cell_magic('cython', '-3', cython3_code) + ip.ex('g = f(10); h = call(10)') + self.assertEqual(ip.user_ns['g'], 2.0 / 10.0) + self.assertEqual(ip.user_ns['h'], 2.0 / 10.0) + + def test_cython2(self): + # The Cython cell defines the functions f() and call(). + ip = self._ip + ip.run_cell_magic('cython', '-2', cython3_code) + ip.ex('g = f(10); h = call(10)') + self.assertEqual(ip.user_ns['g'], 2 // 10) + self.assertEqual(ip.user_ns['h'], 2 // 10) + + def test_cython_compile_error_shown(self): + ip = self._ip + with capture_output() as out: + ip.run_cell_magic('cython', '-3', compile_error_code) + captured_out, captured_err = out + + # it could be that c-level output is captured by distutil-extension + # (and not by us) and is printed to stdout: + captured_all = captured_out + "\n" + captured_err + self.assertTrue("error" in captured_all, msg="error in " + captured_all) + + def test_cython_link_error_shown(self): + ip = self._ip + with capture_output() as out: + ip.run_cell_magic('cython', '-3 -l=xxxxxxxx', code) + captured_out, captured_err = out + + # it could be that c-level output is captured by distutil-extension + # (and not by us) and is printed to stdout: + captured_all = captured_out + "\n!" + captured_err + self.assertTrue("error" in captured_all, msg="error in " + captured_all) + + def test_cython_warning_shown(self): + ip = self._ip + with capture_output() as out: + # force rebuild, otherwise no warning as after the first success + # no build step is performed + ip.run_cell_magic('cython', '-3 -f', compile_warning_code) + captured_out, captured_err = out + + # check that warning was printed to stdout even if build hasn't failed + self.assertTrue("CWarning" in captured_out) + + @skip_win32 + def test_cython3_pgo(self): + # The Cython cell defines the functions f() and call(). + ip = self._ip + ip.run_cell_magic('cython', '-3 --pgo', pgo_cython3_code) + ip.ex('g = f(10); h = call(10); main()') + self.assertEqual(ip.user_ns['g'], 2.0 / 10.0) + self.assertEqual(ip.user_ns['h'], 2.0 / 10.0) + + @skip_win32 + def test_extlibs(self): + ip = self._ip + code = """ +from libc.math cimport sin +x = sin(0.0) + """ + ip.user_ns['x'] = 1 + ip.run_cell_magic('cython', '-l m', code) + self.assertEqual(ip.user_ns['x'], 0) + + + def test_cython_verbose(self): + ip = self._ip + ip.run_cell_magic('cython', '--verbose', code) + ip.ex('g = f(10)') + self.assertEqual(ip.user_ns['g'], 20.0) + + def test_cython_verbose_thresholds(self): + @contextmanager + def mock_distutils(): + class MockLog: + DEBUG = 1 + INFO = 2 + thresholds = [INFO] + + def set_threshold(self, val): + self.thresholds.append(val) + return self.thresholds[-2] + + + new_log = MockLog() + old_log = IpythonMagic.distutils.log + try: + IpythonMagic.distutils.log = new_log + yield new_log + finally: + IpythonMagic.distutils.log = old_log + + ip = self._ip + with mock_distutils() as verbose_log: + ip.run_cell_magic('cython', '--verbose', code) + ip.ex('g = f(10)') + self.assertEqual(ip.user_ns['g'], 20.0) + self.assertEqual([verbose_log.INFO, verbose_log.DEBUG, verbose_log.INFO], + verbose_log.thresholds) + + with mock_distutils() as normal_log: + ip.run_cell_magic('cython', '', code) + ip.ex('g = f(10)') + self.assertEqual(ip.user_ns['g'], 20.0) + self.assertEqual([normal_log.INFO], normal_log.thresholds) + + def test_cython_no_annotate(self): + ip = self._ip + html = ip.run_cell_magic('cython', '', code) + self.assertTrue(html is None) + + def test_cython_annotate(self): + ip = self._ip + html = ip.run_cell_magic('cython', '--annotate', code) + # somewhat brittle way to differentiate between annotated htmls + # with/without complete source code: + self.assertTrue(AnnotationCCodeWriter.COMPLETE_CODE_TITLE not in html.data) + + def test_cython_annotate_default(self): + ip = self._ip + html = ip.run_cell_magic('cython', '-a', code) + # somewhat brittle way to differentiate between annotated htmls + # with/without complete source code: + self.assertTrue(AnnotationCCodeWriter.COMPLETE_CODE_TITLE not in html.data) + + def test_cython_annotate_complete_c_code(self): + ip = self._ip + html = ip.run_cell_magic('cython', '--annotate-fullc', code) + # somewhat brittle way to differentiate between annotated htmls + # with/without complete source code: + self.assertTrue(AnnotationCCodeWriter.COMPLETE_CODE_TITLE in html.data) diff --git a/venv/lib/python3.10/site-packages/Cython/Build/Tests/TestRecythonize.py b/venv/lib/python3.10/site-packages/Cython/Build/Tests/TestRecythonize.py new file mode 100644 index 0000000000000000000000000000000000000000..eb87018cb8770832852d50a210afbdec45d2fd36 --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Build/Tests/TestRecythonize.py @@ -0,0 +1,212 @@ +import shutil +import os +import tempfile +import time + +import Cython.Build.Dependencies +import Cython.Utils +from Cython.TestUtils import CythonTest + + +def fresh_cythonize(*args, **kwargs): + Cython.Utils.clear_function_caches() + Cython.Build.Dependencies._dep_tree = None # discard method caches + Cython.Build.Dependencies.cythonize(*args, **kwargs) + +class TestRecythonize(CythonTest): + + def setUp(self): + CythonTest.setUp(self) + self.temp_dir = ( + tempfile.mkdtemp( + prefix='recythonize-test', + dir='TEST_TMP' if os.path.isdir('TEST_TMP') else None + ) + ) + + def tearDown(self): + CythonTest.tearDown(self) + shutil.rmtree(self.temp_dir) + + def test_recythonize_pyx_on_pxd_change(self): + + src_dir = tempfile.mkdtemp(prefix='src', dir=self.temp_dir) + + a_pxd = os.path.join(src_dir, 'a.pxd') + a_pyx = os.path.join(src_dir, 'a.pyx') + a_c = os.path.join(src_dir, 'a.c') + dep_tree = Cython.Build.Dependencies.create_dependency_tree() + + with open(a_pxd, 'w') as f: + f.write('cdef int value\n') + + with open(a_pyx, 'w') as f: + f.write('value = 1\n') + + + # The dependencies for "a.pyx" are "a.pxd" and "a.pyx". + self.assertEqual({a_pxd, a_pyx}, dep_tree.all_dependencies(a_pyx)) + + # Cythonize to create a.c + fresh_cythonize(a_pyx) + + # Sleep to address coarse time-stamp precision. + time.sleep(1) + + with open(a_c) as f: + a_c_contents1 = f.read() + + with open(a_pxd, 'w') as f: + f.write('cdef double value\n') + + fresh_cythonize(a_pyx) + + with open(a_c) as f: + a_c_contents2 = f.read() + + self.assertTrue("__pyx_v_1a_value = 1;" in a_c_contents1) + self.assertFalse("__pyx_v_1a_value = 1;" in a_c_contents2) + self.assertTrue("__pyx_v_1a_value = 1.0;" in a_c_contents2) + self.assertFalse("__pyx_v_1a_value = 1.0;" in a_c_contents1) + + + def test_recythonize_py_on_pxd_change(self): + + src_dir = tempfile.mkdtemp(prefix='src', dir=self.temp_dir) + + a_pxd = os.path.join(src_dir, 'a.pxd') + a_py = os.path.join(src_dir, 'a.py') + a_c = os.path.join(src_dir, 'a.c') + dep_tree = Cython.Build.Dependencies.create_dependency_tree() + + with open(a_pxd, 'w') as f: + f.write('cdef int value\n') + + with open(a_py, 'w') as f: + f.write('value = 1\n') + + + # The dependencies for "a.py" are "a.pxd" and "a.py". + self.assertEqual({a_pxd, a_py}, dep_tree.all_dependencies(a_py)) + + # Cythonize to create a.c + fresh_cythonize(a_py) + + # Sleep to address coarse time-stamp precision. + time.sleep(1) + + with open(a_c) as f: + a_c_contents1 = f.read() + + with open(a_pxd, 'w') as f: + f.write('cdef double value\n') + + fresh_cythonize(a_py) + + with open(a_c) as f: + a_c_contents2 = f.read() + + + self.assertTrue("__pyx_v_1a_value = 1;" in a_c_contents1) + self.assertFalse("__pyx_v_1a_value = 1;" in a_c_contents2) + self.assertTrue("__pyx_v_1a_value = 1.0;" in a_c_contents2) + self.assertFalse("__pyx_v_1a_value = 1.0;" in a_c_contents1) + + def test_recythonize_pyx_on_dep_pxd_change(self): + src_dir = tempfile.mkdtemp(prefix='src', dir=self.temp_dir) + + a_pxd = os.path.join(src_dir, 'a.pxd') + a_pyx = os.path.join(src_dir, 'a.pyx') + b_pyx = os.path.join(src_dir, 'b.pyx') + b_c = os.path.join(src_dir, 'b.c') + dep_tree = Cython.Build.Dependencies.create_dependency_tree() + + with open(a_pxd, 'w') as f: + f.write('cdef int value\n') + + with open(a_pyx, 'w') as f: + f.write('value = 1\n') + + with open(b_pyx, 'w') as f: + f.write('cimport a\n' + 'a.value = 2\n') + + + # The dependencies for "b.pyx" are "a.pxd" and "b.pyx". + self.assertEqual({a_pxd, b_pyx}, dep_tree.all_dependencies(b_pyx)) + + + # Cythonize to create b.c + fresh_cythonize([a_pyx, b_pyx]) + + # Sleep to address coarse time-stamp precision. + time.sleep(1) + + with open(b_c) as f: + b_c_contents1 = f.read() + + with open(a_pxd, 'w') as f: + f.write('cdef double value\n') + + fresh_cythonize([a_pyx, b_pyx]) + + with open(b_c) as f: + b_c_contents2 = f.read() + + + + self.assertTrue("__pyx_v_1a_value = 2;" in b_c_contents1) + self.assertFalse("__pyx_v_1a_value = 2;" in b_c_contents2) + self.assertTrue("__pyx_v_1a_value = 2.0;" in b_c_contents2) + self.assertFalse("__pyx_v_1a_value = 2.0;" in b_c_contents1) + + + + def test_recythonize_py_on_dep_pxd_change(self): + + src_dir = tempfile.mkdtemp(prefix='src', dir=self.temp_dir) + + a_pxd = os.path.join(src_dir, 'a.pxd') + a_pyx = os.path.join(src_dir, 'a.pyx') + b_pxd = os.path.join(src_dir, 'b.pxd') + b_py = os.path.join(src_dir, 'b.py') + b_c = os.path.join(src_dir, 'b.c') + dep_tree = Cython.Build.Dependencies.create_dependency_tree() + + with open(a_pxd, 'w') as f: + f.write('cdef int value\n') + + with open(a_pyx, 'w') as f: + f.write('value = 1\n') + + with open(b_pxd, 'w') as f: + f.write('cimport a\n') + + with open(b_py, 'w') as f: + f.write('a.value = 2\n') + + + # The dependencies for b.py are "a.pxd", "b.pxd" and "b.py". + self.assertEqual({a_pxd, b_pxd, b_py}, dep_tree.all_dependencies(b_py)) + + + # Cythonize to create b.c + fresh_cythonize([a_pyx, b_py]) + + # Sleep to address coarse time-stamp precision. + time.sleep(1) + + with open(b_c) as f: + b_c_contents1 = f.read() + + with open(a_pxd, 'w') as f: + f.write('cdef double value\n') + + fresh_cythonize([a_pyx, b_py]) + + with open(b_c) as f: + b_c_contents2 = f.read() + + self.assertTrue("__pyx_v_1a_value = 2;" in b_c_contents1) + self.assertFalse("__pyx_v_1a_value = 2;" in b_c_contents2) + self.assertTrue("__pyx_v_1a_value = 2.0;" in b_c_contents2) + self.assertFalse("__pyx_v_1a_value = 2.0;" in b_c_contents1) diff --git a/venv/lib/python3.10/site-packages/Cython/Build/Tests/TestStripLiterals.py b/venv/lib/python3.10/site-packages/Cython/Build/Tests/TestStripLiterals.py new file mode 100644 index 0000000000000000000000000000000000000000..89e2db6bd2f1b86325c5507fcb5f1dcf494e5f55 --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Build/Tests/TestStripLiterals.py @@ -0,0 +1,155 @@ +import pathlib +import re +import unittest + +from ...Utils import open_source_file +from ..Dependencies import strip_string_literals + + +class TestStripLiterals(unittest.TestCase): + maxDiff = None + + @staticmethod + def _rebuild_string(stripped, literals): + def lookup(match): + return literals[match.group()] + + return re.sub("__Pyx_L[0-9]+_", lookup, stripped) + + def test_strip_string_literals(self): + def strip_equals(s, expected): + stripped, literals = strip_string_literals(s) + self.assertEqual(expected, stripped) + + recovered = self._rebuild_string(stripped, literals) + self.assertEqual(s, recovered) + + unchanged = [ + "", + """abc""", + """123""", + """func(123)""", + """ '' """, + """ '''''''''''' """, + """ '''''''''''''' """, + ] + + tests = [(code, code) for code in unchanged] + [ + # strings and quotes + ('"x"', + '"__Pyx_L1_"'), + ("'x'", + "'__Pyx_L1_'"), + (""" '"' "'" """, + """ '__Pyx_L1_' "__Pyx_L2_" """), + (""" '''' ''' """, + """ '''__Pyx_L1_''' """), + (''' """" """ ''', + ''' """__Pyx_L1_""" '''), + (" '''a\n''' ", + " '''__Pyx_L1_''' "), + + # escapes + (r"'a\'b'", + "'__Pyx_L1_'"), + (r"'a\\'", + "'__Pyx_L1_'"), + (r"'a\\\'b'", + "'__Pyx_L1_'"), + + # string prefixes + ("u'abc'", + "u'__Pyx_L1_'"), + (r"r'abc\\'", + "r'__Pyx_L1_'"), + (r"ru'abc\\'", + "ru'__Pyx_L1_'"), + + # comments + ("abc # foo", + "abc #__Pyx_L1_"), + ("abc # 'x'", + "abc #__Pyx_L1_"), + ("'abc#'", + "'__Pyx_L1_'"), + + # special commands + ("include 'a.pxi' # something here", + "include '__Pyx_L1_' #__Pyx_L2_"), + ("cdef extern from 'a.h': # comment", + "cdef extern from '__Pyx_L1_': #__Pyx_L2_"), + + # mixed strings + (""" func('xyz') + " " + "" '' # '' | "" "123" 'xyz' "' """, + """ func('__Pyx_L1_') + "__Pyx_L2_" + "" '' #__Pyx_L3_"""), + + (""" f'f' """, + """ f'__Pyx_L1_' """), + + (""" f'a{123}b' """, + """ f'__Pyx_L1_{123}__Pyx_L2_' """), + + (""" f'{1}{f'xyz'}' """, + """ f'{1}{f'__Pyx_L1_'}' """), + + (""" f'{f'''xyz{f\"""abc\"""}'''}' """, + """ f'{f'''__Pyx_L1_{f\"""__Pyx_L2_\"""}'''}' """), + + (""" f'{{{{{"abc"}}}}}{{}}{{' == '{{abc}}{}{' """, + """ f'__Pyx_L1_{"__Pyx_L2_"}__Pyx_L3_' == '__Pyx_L4_' """), + + ("f'" + ('{x} ' * 250) + "{x:{width}} '", + "f'" + ''.join([f'{{x}}__Pyx_L{n}_' for n in range(1, 251)]) + "{x:{width}}__Pyx_L251_'") + ] + + for code, expected in tests: + with self.subTest(code=code): + strip_equals(code, expected) # plain + code = code.strip() + expected = expected.strip() + with self.subTest(code=code): + strip_equals(code, expected) # stripped + code += "\n" + expected += "\n" + with self.subTest(code=code): + strip_equals(code, expected) # +EOL + + # GH-5977: unclosed string literal + strip_equals( + """ print("Say something: %s' % something) """, + """ print("__Pyx_L1_""" + ) + + def _test_all_files(self, base_dir, file_paths): + _find_leftover_string = re.compile(r"""[^_'"}](['"]+)[^_'"{]""").search + for file_path in sorted(file_paths): + with self.subTest(file=str(file_path.relative_to(base_dir))): + with open_source_file(str(file_path)) as f: + code = f.read() + stripped, literals = strip_string_literals(code) + + match = _find_leftover_string(stripped) + if match and len(match.group(1)) != 2: + match_pos = match.start() + 1 + self.fail(f"Leftover string found: {stripped[match_pos - 12 : match_pos + 12]!r}") + + recovered = self._rebuild_string(stripped, literals) + self.assertEqual(code, recovered) + + def test_strip_string_literals_py_files(self): + # process all .py files in the Cython package + package_dir = pathlib.Path(__file__).absolute().parents[2] + assert package_dir.name == 'Cython' + base_dir = package_dir.parent + self._test_all_files(base_dir, package_dir.rglob("*.py")) + + def test_strip_string_literals_test_files(self): + # process all .py[x] files in the tests package + base_dir = pathlib.Path(__file__).absolute().parents[3] + tests_dir = base_dir / 'tests' + test_files = [] + for test_subdir in tests_dir.iterdir(): + if test_subdir.is_dir() and test_subdir.name != 'errors': + test_files.extend(test_subdir.rglob("*.py")) + test_files.extend(test_subdir.rglob("*.pyx")) + self._test_all_files(base_dir, test_files) diff --git a/venv/lib/python3.10/site-packages/Cython/Build/Tests/__init__.py b/venv/lib/python3.10/site-packages/Cython/Build/Tests/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..fa81adaff68e06d8e915a6afa375f62f7e5a8fad --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Build/Tests/__init__.py @@ -0,0 +1 @@ +# empty file diff --git a/venv/lib/python3.10/site-packages/Cython/Build/Tests/__pycache__/TestCyCache.cpython-310.pyc b/venv/lib/python3.10/site-packages/Cython/Build/Tests/__pycache__/TestCyCache.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..be483e208aae490df1035ee35758749263a95e19 Binary files /dev/null and b/venv/lib/python3.10/site-packages/Cython/Build/Tests/__pycache__/TestCyCache.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/Cython/Build/Tests/__pycache__/TestCythonizeArgsParser.cpython-310.pyc b/venv/lib/python3.10/site-packages/Cython/Build/Tests/__pycache__/TestCythonizeArgsParser.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2a3e1211c8b3f90bd99d26f3cafc502c0c293fd1 Binary files /dev/null and b/venv/lib/python3.10/site-packages/Cython/Build/Tests/__pycache__/TestCythonizeArgsParser.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/Cython/Build/Tests/__pycache__/TestDependencies.cpython-310.pyc b/venv/lib/python3.10/site-packages/Cython/Build/Tests/__pycache__/TestDependencies.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7ce5bdf27c1af4f658396185aed527c7a3a7072e Binary files /dev/null and b/venv/lib/python3.10/site-packages/Cython/Build/Tests/__pycache__/TestDependencies.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/Cython/Build/Tests/__pycache__/TestInline.cpython-310.pyc b/venv/lib/python3.10/site-packages/Cython/Build/Tests/__pycache__/TestInline.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e4d1293f3fcb33b0fb46133fa29e70cba2682eeb Binary files /dev/null and b/venv/lib/python3.10/site-packages/Cython/Build/Tests/__pycache__/TestInline.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/Cython/Build/Tests/__pycache__/TestIpythonMagic.cpython-310.pyc b/venv/lib/python3.10/site-packages/Cython/Build/Tests/__pycache__/TestIpythonMagic.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..73620f7d312dbbf34b947508e6a3d5886a1a2b21 Binary files /dev/null and b/venv/lib/python3.10/site-packages/Cython/Build/Tests/__pycache__/TestIpythonMagic.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/Cython/Build/Tests/__pycache__/TestRecythonize.cpython-310.pyc b/venv/lib/python3.10/site-packages/Cython/Build/Tests/__pycache__/TestRecythonize.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0a86dd7f48a7608e7e4959d54c2cc6994d19772f Binary files /dev/null and b/venv/lib/python3.10/site-packages/Cython/Build/Tests/__pycache__/TestRecythonize.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/Cython/Build/Tests/__pycache__/TestStripLiterals.cpython-310.pyc b/venv/lib/python3.10/site-packages/Cython/Build/Tests/__pycache__/TestStripLiterals.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..42a6c7f41d23d64d8aef43e41eef456d292f1df1 Binary files /dev/null and b/venv/lib/python3.10/site-packages/Cython/Build/Tests/__pycache__/TestStripLiterals.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/Cython/Build/Tests/__pycache__/__init__.cpython-310.pyc b/venv/lib/python3.10/site-packages/Cython/Build/Tests/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6b12b02eea33d6adfee1b1edb928d4867a835040 Binary files /dev/null and b/venv/lib/python3.10/site-packages/Cython/Build/Tests/__pycache__/__init__.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/Cython/Build/__init__.py b/venv/lib/python3.10/site-packages/Cython/Build/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e6202f5108789341ee597270af4318c88f575b7a --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Build/__init__.py @@ -0,0 +1,11 @@ +from .Dependencies import cythonize + +__all__ = ["cythonize"] + + +def __getattr__(name): + if name == 'build_ext': + # Lazy import, fails if distutils is not available (in Python 3.12+). + from .Distutils import build_ext + return build_ext + raise AttributeError("module '%s' has no attribute '%s'" % (__name__, name)) diff --git a/venv/lib/python3.10/site-packages/Cython/Build/__pycache__/BuildExecutable.cpython-310.pyc b/venv/lib/python3.10/site-packages/Cython/Build/__pycache__/BuildExecutable.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..69c274478853843caa1933b27d8c4a9e75b16517 Binary files /dev/null and b/venv/lib/python3.10/site-packages/Cython/Build/__pycache__/BuildExecutable.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/Cython/Build/__pycache__/Cache.cpython-310.pyc b/venv/lib/python3.10/site-packages/Cython/Build/__pycache__/Cache.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..84cf66dc91f7c4576cbf3e3c68d2e01d2f3e8cc1 Binary files /dev/null and b/venv/lib/python3.10/site-packages/Cython/Build/__pycache__/Cache.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/Cython/Build/__pycache__/Cythonize.cpython-310.pyc b/venv/lib/python3.10/site-packages/Cython/Build/__pycache__/Cythonize.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6db4d8e6c4bc0fcf7c4426755b06e053f7880e7d Binary files /dev/null and b/venv/lib/python3.10/site-packages/Cython/Build/__pycache__/Cythonize.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/Cython/Build/__pycache__/Dependencies.cpython-310.pyc b/venv/lib/python3.10/site-packages/Cython/Build/__pycache__/Dependencies.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a700173864a838167b7ed1344d0d7a27c0413638 Binary files /dev/null and b/venv/lib/python3.10/site-packages/Cython/Build/__pycache__/Dependencies.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/Cython/Build/__pycache__/Distutils.cpython-310.pyc b/venv/lib/python3.10/site-packages/Cython/Build/__pycache__/Distutils.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6cca1734b1bf84e4be5ba244ab06beafe3bf358e Binary files /dev/null and b/venv/lib/python3.10/site-packages/Cython/Build/__pycache__/Distutils.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/Cython/Build/__pycache__/Inline.cpython-310.pyc b/venv/lib/python3.10/site-packages/Cython/Build/__pycache__/Inline.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b34a00756a8ad45dc9b3990efc752da0074586ee Binary files /dev/null and b/venv/lib/python3.10/site-packages/Cython/Build/__pycache__/Inline.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/Cython/Build/__pycache__/IpythonMagic.cpython-310.pyc b/venv/lib/python3.10/site-packages/Cython/Build/__pycache__/IpythonMagic.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8e5d87b26841b6d9d929ae574b591d7ab854bf4d Binary files /dev/null and b/venv/lib/python3.10/site-packages/Cython/Build/__pycache__/IpythonMagic.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/Cython/Build/__pycache__/SharedModule.cpython-310.pyc b/venv/lib/python3.10/site-packages/Cython/Build/__pycache__/SharedModule.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c32ad135efd857af9db6214271a4257f649acd59 Binary files /dev/null and b/venv/lib/python3.10/site-packages/Cython/Build/__pycache__/SharedModule.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/Cython/Build/__pycache__/__init__.cpython-310.pyc b/venv/lib/python3.10/site-packages/Cython/Build/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fc5772ed14dc1ac099bfdeb04bcc406e283ef144 Binary files /dev/null and b/venv/lib/python3.10/site-packages/Cython/Build/__pycache__/__init__.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/Cython/CodeWriter.py b/venv/lib/python3.10/site-packages/Cython/CodeWriter.py new file mode 100644 index 0000000000000000000000000000000000000000..4b5d9fdea7d73b58d7593ace68d5622e668d6cac --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/CodeWriter.py @@ -0,0 +1,811 @@ +""" +Serializes a Cython code tree to Cython code. This is primarily useful for +debugging and testing purposes. +The output is in a strict format, no whitespace or comments from the input +is preserved (and it could not be as it is not present in the code tree). +""" + + +from .Compiler.Visitor import TreeVisitor +from .Compiler.ExprNodes import * +from .Compiler.Nodes import CSimpleBaseTypeNode + + +class LinesResult: + def __init__(self): + self.lines = [] + self.s = "" + + def put(self, s): + self.s += s + + def newline(self): + self.lines.append(self.s) + self.s = "" + + def putline(self, s): + self.put(s) + self.newline() + + +class DeclarationWriter(TreeVisitor): + """ + A Cython code writer that is limited to declarations nodes. + """ + + indent_string = " " + + def __init__(self, result=None): + super().__init__() + if result is None: + result = LinesResult() + self.result = result + self.numindents = 0 + self.tempnames = {} + self.tempblockindex = 0 + + def write(self, tree): + self.visit(tree) + return self.result + + def indent(self): + self.numindents += 1 + + def dedent(self): + self.numindents -= 1 + + def startline(self, s=""): + self.result.put(self.indent_string * self.numindents + s) + + def put(self, s): + self.result.put(s) + + def putline(self, s): + self.result.putline(self.indent_string * self.numindents + s) + + def endline(self, s=""): + self.result.putline(s) + + def line(self, s): + self.startline(s) + self.endline() + + def comma_separated_list(self, items, output_rhs=False): + if len(items) > 0: + for item in items[:-1]: + self.visit(item) + if output_rhs and item.default is not None: + self.put(" = ") + self.visit(item.default) + self.put(", ") + self.visit(items[-1]) + if output_rhs and items[-1].default is not None: + self.put(" = ") + self.visit(items[-1].default) + + def _visit_indented(self, node): + self.indent() + self.visit(node) + self.dedent() + + def visit_Node(self, node): + raise AssertionError("Node not handled by serializer: %r" % node) + + def visit_ModuleNode(self, node): + self.visitchildren(node) + + def visit_StatListNode(self, node): + self.visitchildren(node) + + def visit_CDefExternNode(self, node): + if node.include_file is None: + file = '*' + else: + file = '"%s"' % node.include_file + self.putline("cdef extern from %s:" % file) + self._visit_indented(node.body) + + def visit_CPtrDeclaratorNode(self, node): + self.put('*') + self.visit(node.base) + + def visit_CReferenceDeclaratorNode(self, node): + self.put('&') + self.visit(node.base) + + def visit_CArrayDeclaratorNode(self, node): + self.visit(node.base) + self.put('[') + if node.dimension is not None: + self.visit(node.dimension) + self.put(']') + + def visit_CFuncDeclaratorNode(self, node): + # TODO: except, gil, etc. + self.visit(node.base) + self.put('(') + self.comma_separated_list(node.args) + self.endline(')') + + def visit_CNameDeclaratorNode(self, node): + self.put(node.name) + + def visit_CSimpleBaseTypeNode(self, node): + # See Parsing.p_sign_and_longness + if node.is_basic_c_type: + self.put(("unsigned ", "", "signed ")[node.signed]) + if node.longness < 0: + self.put("short " * -node.longness) + elif node.longness > 0: + self.put("long " * node.longness) + if node.name is not None: + self.put(node.name) + + def visit_CComplexBaseTypeNode(self, node): + self.visit(node.base_type) + self.visit(node.declarator) + + def visit_CNestedBaseTypeNode(self, node): + self.visit(node.base_type) + self.put('.') + self.put(node.name) + + def visit_TemplatedTypeNode(self, node): + self.visit(node.base_type_node) + self.put('[') + self.comma_separated_list(node.positional_args + node.keyword_args.key_value_pairs) + self.put(']') + + def visit_CVarDefNode(self, node): + self.startline("cdef ") + self.visit(node.base_type) + self.put(" ") + self.comma_separated_list(node.declarators, output_rhs=True) + self.endline() + + def _visit_container_node(self, node, decl, extras, attributes): + # TODO: visibility + self.startline(decl) + if node.name: + self.put(' ') + self.put(node.name) + if node.cname is not None: + self.put(' "%s"' % node.cname) + if extras: + self.put(extras) + self.endline(':') + self.indent() + if not attributes: + self.putline('pass') + else: + for attribute in attributes: + self.visit(attribute) + self.dedent() + + def visit_CStructOrUnionDefNode(self, node): + if node.typedef_flag: + decl = 'ctypedef ' + else: + decl = 'cdef ' + if node.visibility == 'public': + decl += 'public ' + if node.packed: + decl += 'packed ' + decl += node.kind + self._visit_container_node(node, decl, None, node.attributes) + + def visit_CppClassNode(self, node): + extras = "" + if node.templates: + extras = "[%s]" % ", ".join(node.templates) + if node.base_classes: + extras += "(%s)" % ", ".join(node.base_classes) + self._visit_container_node(node, "cdef cppclass", extras, node.attributes) + + def visit_CEnumDefNode(self, node): + self._visit_container_node(node, "cdef enum", None, node.items) + + def visit_CEnumDefItemNode(self, node): + self.startline(node.name) + if node.cname: + self.put(' "%s"' % node.cname) + if node.value: + self.put(" = ") + self.visit(node.value) + self.endline() + + def visit_CClassDefNode(self, node): + assert not node.module_name + if node.decorators: + for decorator in node.decorators: + self.visit(decorator) + self.startline("cdef class ") + self.put(node.class_name) + if node.base_class_name: + self.put("(") + if node.base_class_module: + self.put(node.base_class_module) + self.put(".") + self.put(node.base_class_name) + self.put(")") + self.endline(":") + self._visit_indented(node.body) + + def visit_CTypeDefNode(self, node): + self.startline("ctypedef ") + self.visit(node.base_type) + self.put(" ") + self.visit(node.declarator) + self.endline() + + def visit_FuncDefNode(self, node): + # TODO: support cdef + cpdef functions + self.startline("def %s(" % node.name) + self.comma_separated_list(node.args) + self.endline("):") + self._visit_indented(node.body) + + def visit_CFuncDefNode(self, node): + self.startline('cpdef ' if node.overridable else 'cdef ') + if node.modifiers: + self.put(' '.join(node.modifiers)) + self.put(' ') + if node.visibility != 'private': + self.put(node.visibility) + self.put(' ') + if node.api: + self.put('api ') + + if node.base_type: + self.visit(node.base_type) + if node.base_type.name is not None: + self.put(' ') + + # visit the CFuncDeclaratorNode, but put a `:` at the end of line + self.visit(node.declarator.base) + self.put('(') + self.comma_separated_list(node.declarator.args) + self.endline('):') + + self._visit_indented(node.body) + + def visit_CArgDeclNode(self, node): + # For "CSimpleBaseTypeNode", the variable type may have been parsed as type. + # For other node types, the "name" is always None. + if not isinstance(node.base_type, CSimpleBaseTypeNode) or \ + node.base_type.name is not None: + self.visit(node.base_type) + + # If we printed something for "node.base_type", we may need to print an extra ' '. + # + # Special case: if "node.declarator" is a "CNameDeclaratorNode", + # its "name" might be an empty string, for example, for "cdef f(x)". + if node.declarator.declared_name(): + self.put(" ") + self.visit(node.declarator) + if node.default is not None: + self.put(" = ") + self.visit(node.default) + + def visit_CImportStatNode(self, node): + self.startline("cimport ") + self.put(node.module_name) + if node.as_name: + self.put(" as ") + self.put(node.as_name) + self.endline() + + def visit_FromCImportStatNode(self, node): + self.startline("from ") + self.put(node.module_name) + self.put(" cimport ") + first = True + for pos, name, as_name, kind in node.imported_names: + assert kind is None + if first: + first = False + else: + self.put(", ") + self.put(name) + if as_name: + self.put(" as ") + self.put(as_name) + self.endline() + + def visit_NameNode(self, node): + self.put(node.name) + + def visit_DecoratorNode(self, node): + self.startline("@") + self.visit(node.decorator) + self.endline() + + def visit_PassStatNode(self, node): + self.startline("pass") + self.endline() + + +class StatementWriter(DeclarationWriter): + """ + A Cython code writer for most language statement features. + """ + + def visit_SingleAssignmentNode(self, node): + self.startline() + self.visit(node.lhs) + self.put(" = ") + self.visit(node.rhs) + self.endline() + + def visit_CascadedAssignmentNode(self, node): + self.startline() + for lhs in node.lhs_list: + self.visit(lhs) + self.put(" = ") + self.visit(node.rhs) + self.endline() + + def visit_PrintStatNode(self, node): + self.startline("print ") + self.comma_separated_list(node.arg_tuple.args) + if not node.append_newline: + self.put(",") + self.endline() + + def visit_ForInStatNode(self, node): + self.startline("for ") + if node.target.is_sequence_constructor: + self.comma_separated_list(node.target.args) + else: + self.visit(node.target) + self.put(" in ") + self.visit(node.iterator.sequence) + self.endline(":") + self._visit_indented(node.body) + if node.else_clause is not None: + self.line("else:") + self._visit_indented(node.else_clause) + + def visit_IfStatNode(self, node): + # The IfClauseNode is handled directly without a separate match + # for clariy. + self.startline("if ") + self.visit(node.if_clauses[0].condition) + self.endline(":") + self._visit_indented(node.if_clauses[0].body) + for clause in node.if_clauses[1:]: + self.startline("elif ") + self.visit(clause.condition) + self.endline(":") + self._visit_indented(clause.body) + if node.else_clause is not None: + self.line("else:") + self._visit_indented(node.else_clause) + + def visit_WhileStatNode(self, node): + self.startline("while ") + self.visit(node.condition) + self.endline(":") + self._visit_indented(node.body) + if node.else_clause is not None: + self.line("else:") + self._visit_indented(node.else_clause) + + def visit_ContinueStatNode(self, node): + self.line("continue") + + def visit_BreakStatNode(self, node): + self.line("break") + + def visit_SequenceNode(self, node): + self.comma_separated_list(node.args) # Might need to discover whether we need () around tuples...hmm... + + def visit_ExprStatNode(self, node): + self.startline() + self.visit(node.expr) + self.endline() + + def visit_InPlaceAssignmentNode(self, node): + self.startline() + self.visit(node.lhs) + self.put(" %s= " % node.operator) + self.visit(node.rhs) + self.endline() + + def visit_WithStatNode(self, node): + self.startline() + self.put("with ") + self.visit(node.manager) + if node.target is not None: + self.put(" as ") + self.visit(node.target) + self.endline(":") + self._visit_indented(node.body) + + def visit_TryFinallyStatNode(self, node): + self.line("try:") + self._visit_indented(node.body) + self.line("finally:") + self._visit_indented(node.finally_clause) + + def visit_TryExceptStatNode(self, node): + self.line("try:") + self._visit_indented(node.body) + for x in node.except_clauses: + self.visit(x) + if node.else_clause is not None: + self.visit(node.else_clause) + + def visit_ExceptClauseNode(self, node): + self.startline("except") + if node.pattern is not None: + self.put(" ") + self.visit(node.pattern) + if node.target is not None: + self.put(", ") + self.visit(node.target) + self.endline(":") + self._visit_indented(node.body) + + def visit_ReturnStatNode(self, node): + self.startline("return") + if node.value is not None: + self.put(" ") + self.visit(node.value) + self.endline() + + def visit_ReraiseStatNode(self, node): + self.line("raise") + + def visit_ImportNode(self, node): + self.put("(import %s)" % node.module_name.value) + + def visit_TempsBlockNode(self, node): + """ + Temporaries are output like $1_1', where the first number is + an index of the TempsBlockNode and the second number is an index + of the temporary which that block allocates. + """ + idx = 0 + for handle in node.temps: + self.tempnames[handle] = "$%d_%d" % (self.tempblockindex, idx) + idx += 1 + self.tempblockindex += 1 + self.visit(node.body) + + def visit_TempRefNode(self, node): + self.put(self.tempnames[node.handle]) + + +class ExpressionWriter(TreeVisitor): + """ + A Cython code writer that is intentionally limited to expressions. + """ + + def __init__(self, result=None): + super().__init__() + if result is None: + result = "" + self.result = result + self.precedence = [0] + + def write(self, tree): + self.visit(tree) + return self.result + + def put(self, s): + self.result += s + + def remove(self, s): + if self.result.endswith(s): + self.result = self.result[:-len(s)] + + def comma_separated_list(self, items): + if len(items) > 0: + for item in items[:-1]: + self.visit(item) + self.put(", ") + self.visit(items[-1]) + + def visit_Node(self, node): + raise AssertionError("Node not handled by serializer: %r" % node) + + # TODO: Remove redundancy below. Most constants serialise fine as just "repr(node.value)". + + def visit_IntNode(self, node): + self.put(node.value) + + def visit_FloatNode(self, node): + self.put(node.value) + + def visit_NoneNode(self, node): + self.put("None") + + def visit_NameNode(self, node): + self.put(node.name) + + def visit_EllipsisNode(self, node): + self.put("...") + + def visit_BoolNode(self, node): + self.put(str(node.value)) + + def visit_ConstNode(self, node): + self.put(str(node.value)) + + def visit_ImagNode(self, node): + self.put(f"{node.value}j") + + def visit_BytesNode(self, node): + self.put(repr(node.value)) + + def visit_UnicodeNode(self, node): + self.put(repr(node.value)) + + def emit_sequence(self, node, parens=("", "")): + open_paren, close_paren = parens + items = node.subexpr_nodes() + self.put(open_paren) + self.comma_separated_list(items) + self.put(close_paren) + + def visit_ListNode(self, node): + self.emit_sequence(node, "[]") + + def visit_TupleNode(self, node): + self.emit_sequence(node, "()") + + def visit_SetNode(self, node): + if len(node.subexpr_nodes()) > 0: + self.emit_sequence(node, "{}") + else: + self.put("set()") + + def visit_DictNode(self, node): + self.emit_sequence(node, "{}") + + def visit_DictItemNode(self, node): + self.visit(node.key) + self.put(": ") + self.visit(node.value) + + unop_precedence = { + 'not': 3, '!': 3, + '+': 11, '-': 11, '~': 11, + } + binop_precedence = { + 'or': 1, + 'and': 2, + # unary: 'not': 3, '!': 3, + 'in': 4, 'not_in': 4, 'is': 4, 'is_not': 4, '<': 4, '<=': 4, '>': 4, '>=': 4, '!=': 4, '==': 4, + '|': 5, + '^': 6, + '&': 7, + '<<': 8, '>>': 8, + '+': 9, '-': 9, + '*': 10, '@': 10, '/': 10, '//': 10, '%': 10, + # unary: '+': 11, '-': 11, '~': 11 + '**': 12, + } + + def operator_enter(self, new_prec): + old_prec = self.precedence[-1] + if old_prec > new_prec: + self.put("(") + self.precedence.append(new_prec) + + def operator_exit(self): + old_prec, new_prec = self.precedence[-2:] + if old_prec > new_prec: + self.put(")") + self.precedence.pop() + + def visit_NotNode(self, node): + op = 'not' + prec = self.unop_precedence[op] + self.operator_enter(prec) + self.put("not ") + self.visit(node.operand) + self.operator_exit() + + def visit_UnopNode(self, node): + op = node.operator + prec = self.unop_precedence[op] + self.operator_enter(prec) + self.put("%s" % node.operator) + self.visit(node.operand) + self.operator_exit() + + def visit_BinopNode(self, node): + op = node.operator + prec = self.binop_precedence.get(op, 0) + self.operator_enter(prec) + self.visit(node.operand1) + self.put(" %s " % op.replace('_', ' ')) + self.visit(node.operand2) + self.operator_exit() + + def visit_BoolBinopNode(self, node): + self.visit_BinopNode(node) + + def visit_PrimaryCmpNode(self, node): + self.visit_BinopNode(node) + + def visit_IndexNode(self, node): + self.visit(node.base) + self.put("[") + if isinstance(node.index, TupleNode): + if node.index.subexpr_nodes(): + self.emit_sequence(node.index) + else: + self.put("()") + else: + self.visit(node.index) + self.put("]") + + def visit_SliceIndexNode(self, node): + self.visit(node.base) + self.put("[") + if node.start: + self.visit(node.start) + self.put(":") + if node.stop: + self.visit(node.stop) + if node.slice: + self.put(":") + self.visit(node.slice) + self.put("]") + + def visit_SliceNode(self, node): + if not node.start.is_none: + self.visit(node.start) + self.put(":") + if not node.stop.is_none: + self.visit(node.stop) + if not node.step.is_none: + self.put(":") + self.visit(node.step) + + def visit_CondExprNode(self, node): + self.visit(node.true_val) + self.put(" if ") + self.visit(node.test) + self.put(" else ") + self.visit(node.false_val) + + def visit_AttributeNode(self, node): + self.visit(node.obj) + self.put(".%s" % node.attribute) + + def visit_SimpleCallNode(self, node): + self.visit(node.function) + self.put("(") + self.comma_separated_list(node.args) + self.put(")") + + def emit_pos_args(self, node): + if node is None: + return + if isinstance(node, AddNode): + self.emit_pos_args(node.operand1) + self.emit_pos_args(node.operand2) + elif isinstance(node, TupleNode): + for expr in node.subexpr_nodes(): + self.visit(expr) + self.put(", ") + elif isinstance(node, AsTupleNode): + self.put("*") + self.visit(node.arg) + self.put(", ") + else: + self.visit(node) + self.put(", ") + + def emit_kwd_args(self, node): + if node is None: + return + if isinstance(node, MergedDictNode): + for expr in node.subexpr_nodes(): + self.emit_kwd_args(expr) + elif isinstance(node, DictNode): + for expr in node.subexpr_nodes(): + self.put("%s=" % expr.key.value) + self.visit(expr.value) + self.put(", ") + else: + self.put("**") + self.visit(node) + self.put(", ") + + def visit_GeneralCallNode(self, node): + self.visit(node.function) + self.put("(") + self.emit_pos_args(node.positional_args) + self.emit_kwd_args(node.keyword_args) + self.remove(", ") + self.put(")") + + def emit_comprehension(self, body, target, + sequence, condition, + parens=("", "")): + open_paren, close_paren = parens + self.put(open_paren) + self.visit(body) + self.put(" for ") + self.visit(target) + self.put(" in ") + self.visit(sequence) + if condition: + self.put(" if ") + self.visit(condition) + self.put(close_paren) + + def visit_ComprehensionAppendNode(self, node): + self.visit(node.expr) + + def visit_DictComprehensionAppendNode(self, node): + self.visit(node.key_expr) + self.put(": ") + self.visit(node.value_expr) + + def visit_ComprehensionNode(self, node): + tpmap = {'list': "[]", 'dict': "{}", 'set': "{}"} + parens = tpmap[node.type.py_type_name()] + body = node.loop.body + target = node.loop.target + sequence = node.loop.iterator.sequence + condition = None + if hasattr(body, 'if_clauses'): + # type(body) is Nodes.IfStatNode + condition = body.if_clauses[0].condition + body = body.if_clauses[0].body + self.emit_comprehension(body, target, sequence, condition, parens) + + def visit_GeneratorExpressionNode(self, node): + body = node.loop.body + target = node.loop.target + sequence = node.loop.iterator.sequence + condition = None + if hasattr(body, 'if_clauses'): + # type(body) is Nodes.IfStatNode + condition = body.if_clauses[0].condition + body = body.if_clauses[0].body.expr.arg + elif hasattr(body, 'expr'): + # type(body) is Nodes.ExprStatNode + body = body.expr.arg + self.emit_comprehension(body, target, sequence, condition, "()") + + +class PxdWriter(DeclarationWriter, ExpressionWriter): + """ + A Cython code writer for everything supported in pxd files. + (currently unused) + """ + + def __call__(self, node): + print('\n'.join(self.write(node).lines)) + return node + + def visit_CFuncDefNode(self, node): + if node.overridable: + self.startline('cpdef ') + else: + self.startline('cdef ') + if node.modifiers: + self.put(' '.join(node.modifiers)) + self.put(' ') + if node.visibility != 'private': + self.put(node.visibility) + self.put(' ') + if node.api: + self.put('api ') + self.visit(node.declarator) + + def visit_StatNode(self, node): + pass + + +class CodeWriter(StatementWriter, ExpressionWriter): + """ + A complete Cython code writer. + """ diff --git a/venv/lib/python3.10/site-packages/Cython/Compiler/AnalysedTreeTransforms.py b/venv/lib/python3.10/site-packages/Cython/Compiler/AnalysedTreeTransforms.py new file mode 100644 index 0000000000000000000000000000000000000000..7ab54d7ff638da2d263ad202a5de93eb183586b5 --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Compiler/AnalysedTreeTransforms.py @@ -0,0 +1,97 @@ +from .Visitor import ScopeTrackingTransform +from .Nodes import StatListNode, SingleAssignmentNode, CFuncDefNode, DefNode +from .ExprNodes import DictNode, DictItemNode, NameNode, UnicodeNode +from .PyrexTypes import py_object_type +from .StringEncoding import EncodedString +from . import Symtab + +class AutoTestDictTransform(ScopeTrackingTransform): + # Handles autotestdict directive + + excludelist = ['__cinit__', '__dealloc__', '__richcmp__', + '__nonzero__', '__bool__', + '__len__', '__contains__'] + + def visit_ModuleNode(self, node): + if node.is_pxd: + return node + self.scope_type = 'module' + self.scope_node = node + + if not self.current_directives['autotestdict']: + return node + self.all_docstrings = self.current_directives['autotestdict.all'] + self.cdef_docstrings = self.all_docstrings or self.current_directives['autotestdict.cdef'] + + assert isinstance(node.body, StatListNode) + + # First see if __test__ is already created + if '__test__' in node.scope.entries: + # Do nothing + return node + + pos = node.pos + + self.tests = [] + self.testspos = node.pos + + test_dict_entry = node.scope.declare_var(EncodedString('__test__'), + py_object_type, + pos, + visibility='public') + create_test_dict_assignment = SingleAssignmentNode(pos, + lhs=NameNode(pos, name=EncodedString('__test__'), + entry=test_dict_entry), + rhs=DictNode(pos, key_value_pairs=self.tests)) + self.visitchildren(node) + node.body.stats.append(create_test_dict_assignment) + return node + + def add_test(self, testpos, path, doctest): + pos = self.testspos + keystr = EncodedString(f'{path} (line {testpos[1]:d})') + key = UnicodeNode(pos, value=keystr) + value = UnicodeNode(pos, value=doctest) + self.tests.append(DictItemNode(pos, key=key, value=value)) + + def visit_ExprNode(self, node): + # expressions cannot contain functions and lambda expressions + # do not have a docstring + return node + + def visit_FuncDefNode(self, node): + if not node.doc or (isinstance(node, DefNode) and node.fused_py_func): + return node + if not self.cdef_docstrings: + if isinstance(node, CFuncDefNode) and not node.py_func: + return node + if not self.all_docstrings and '>>>' not in node.doc: + return node + + pos = self.testspos + if self.scope_type == 'module': + path = node.entry.name + elif self.scope_type in ('pyclass', 'cclass'): + if isinstance(node, CFuncDefNode): + if node.py_func is not None: + name = node.py_func.name + else: + name = node.entry.name + else: + name = node.name + if self.scope_type == 'cclass' and name in self.excludelist: + return node + if self.scope_type == 'pyclass': + class_name = self.scope_node.name + else: + class_name = self.scope_node.class_name + if isinstance(node.entry.scope, Symtab.PropertyScope): + property_method_name = node.entry.scope.name + path = "%s.%s.%s" % (class_name, node.entry.scope.name, + node.entry.name) + else: + path = "%s.%s" % (class_name, node.entry.name) + else: + assert False + self.add_test(node.pos, path, node.doc) + return node diff --git a/venv/lib/python3.10/site-packages/Cython/Compiler/Annotate.py b/venv/lib/python3.10/site-packages/Cython/Compiler/Annotate.py new file mode 100644 index 0000000000000000000000000000000000000000..5cc04f3098e2419661b311c4e3a7c921ea11aa63 --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Compiler/Annotate.py @@ -0,0 +1,325 @@ +# Note: Work in progress + + +import os +import os.path +import re +import textwrap +from datetime import datetime +from functools import partial +from collections import defaultdict +from xml.sax.saxutils import escape as html_escape +from io import StringIO + +from . import Version +from .Code import CCodeWriter +from .. import Utils + + +class AnnotationCCodeWriter(CCodeWriter): + + # also used as marker for detection of complete code emission in tests + COMPLETE_CODE_TITLE = "Complete cythonized code" + + def __init__(self, create_from=None, buffer=None, copy_formatting=True, show_entire_c_code=False, source_desc=None): + CCodeWriter.__init__(self, create_from, buffer, copy_formatting=copy_formatting) + self.show_entire_c_code = show_entire_c_code + if create_from is None: + self.annotation_buffer = StringIO() + self.last_annotated_pos = None + # annotations[filename][line] -> [(column, AnnotationItem)*] + self.annotations = defaultdict(partial(defaultdict, list)) + # code[filename][line] -> str + self.code = defaultdict(partial(defaultdict, str)) + # scopes[filename][line] -> set(scopes) + self.scopes = defaultdict(partial(defaultdict, set)) + else: + # When creating an insertion point, keep references to the same database + self.annotation_buffer = create_from.annotation_buffer + self.annotations = create_from.annotations + self.code = create_from.code + self.scopes = create_from.scopes + self.last_annotated_pos = create_from.last_annotated_pos + + def create_new(self, create_from, buffer, copy_formatting): + return AnnotationCCodeWriter(create_from, buffer, copy_formatting) + + def _write_to_buffer(self, s): + self.buffer.write(s) + self.annotation_buffer.write(s) + + def mark_pos(self, pos, trace=True): + if pos is not None: + CCodeWriter.mark_pos(self, pos, trace) + if self.funcstate and self.funcstate.scope: + # lambdas and genexprs can result in multiple scopes per line => keep them in a set + self.scopes[pos[0].filename][pos[1]].add(self.funcstate.scope) + if self.last_annotated_pos: + source_desc, line, _ = self.last_annotated_pos + pos_code = self.code[source_desc.filename] + pos_code[line] += self.annotation_buffer.getvalue() + self.annotation_buffer = StringIO() + self.last_annotated_pos = pos + + def annotate(self, pos, item): + self.annotations[pos[0].filename][pos[1]].append((pos[2], item)) + + def _css(self): + """css template will later allow to choose a colormap""" + css = [self._css_template] + for i in range(255): + color_shade = int(255.0 // (1.0 + i/10.0)) + css.append(f'.cython.score-{i:d} {{background-color: #FFFF{color_shade:02x};}}') + try: + from pygments.formatters import HtmlFormatter + except ImportError: + pass + else: + css.append(HtmlFormatter().get_style_defs('.cython')) + return '\n'.join(css) + + _css_template = textwrap.dedent(""" + body.cython { font-family: courier; font-size: 12; } + + .cython.tag { } + .cython.line { color: #000000; margin: 0em } + .cython.code { font-size: 9; color: #444444; display: none; margin: 0px 0px 0px 8px; border-left: 8px none; } + + .cython.line .run { background-color: #B0FFB0; } + .cython.line .mis { background-color: #FFB0B0; } + .cython.code.run { border-left: 8px solid #B0FFB0; } + .cython.code.mis { border-left: 8px solid #FFB0B0; } + + .cython.code .py_c_api { color: red; } + .cython.code .py_macro_api { color: #FF7000; } + .cython.code .pyx_c_api { color: #FF3000; } + .cython.code .pyx_macro_api { color: #FF7000; } + .cython.code .refnanny { color: #FFA000; } + .cython.code .trace { color: #FFA000; } + .cython.code .error_goto { color: #FFA000; } + + .cython.code .coerce { color: #008000; border: 1px dotted #008000 } + .cython.code .py_attr { color: #FF0000; font-weight: bold; } + .cython.code .c_attr { color: #0000FF; } + .cython.code .py_call { color: #FF0000; font-weight: bold; } + .cython.code .c_call { color: #0000FF; } + """) + + # on-click toggle function to show/hide C source code + _onclick_attr = ' onclick="{}"'.format(( + "(function(s){" + " s.display = s.display === 'block' ? 'none' : 'block'" + "})(this.nextElementSibling.style)" + ).replace(' ', '') # poor dev's JS minification + ) + + def save_annotation(self, source_filename, target_filename, coverage_xml=None): + with Utils.open_source_file(source_filename) as f: + code = f.read() + generated_code = self.code.get(source_filename, {}) + c_file = Utils.decode_filename(os.path.basename(target_filename)) + html_filename = os.path.splitext(target_filename)[0] + ".html" + + with open(html_filename, "w", encoding="UTF-8") as out_buffer: + out_buffer.write(self._save_annotation(code, generated_code, c_file, source_filename, coverage_xml)) + + def _save_annotation_header(self, c_file, source_filename, coverage_timestamp=None): + coverage_info = '' + if coverage_timestamp: + coverage_info = ' with coverage data from {timestamp}'.format( + timestamp=datetime.fromtimestamp(int(coverage_timestamp) // 1000)) + + outlist = [ + textwrap.dedent('''\ + + + + + + Cython: {filename} + + + +

Generated by Cython {watermark}{more_info}

+

+ Yellow lines hint at Python interaction.
+ Click on a line that starts with a "+" to see the C code that Cython generated for it. +

+ ''').format(css=self._css(), watermark=Version.watermark, + filename=os.path.basename(source_filename) if source_filename else '', + more_info=coverage_info) + ] + if c_file: + outlist.append('

Raw output: %s

\n' % (c_file, c_file)) + return outlist + + def _save_annotation_footer(self): + return ('\n',) + + def _save_annotation(self, code, generated_code, c_file=None, source_filename=None, coverage_xml=None): + """ + lines : original cython source code split by lines + generated_code : generated c code keyed by line number in original file + target filename : name of the file in which to store the generated html + c_file : filename in which the c_code has been written + """ + if coverage_xml is not None and source_filename: + coverage_timestamp = coverage_xml.get('timestamp', '').strip() + covered_lines = self._get_line_coverage(coverage_xml, source_filename) + else: + coverage_timestamp = covered_lines = None + annotation_items = dict(self.annotations[source_filename]) + scopes = dict(self.scopes[source_filename]) + + outlist = [] + outlist.extend(self._save_annotation_header(c_file, source_filename, coverage_timestamp)) + outlist.extend(self._save_annotation_body(code, generated_code, annotation_items, scopes, covered_lines)) + outlist.extend(self._save_annotation_footer()) + return ''.join(outlist) + + def _get_line_coverage(self, coverage_xml, source_filename): + coverage_data = None + for entry in coverage_xml.iterfind('.//class'): + if not entry.get('filename'): + continue + if (entry.get('filename') == source_filename or + os.path.abspath(entry.get('filename')) == source_filename): + coverage_data = entry + break + elif source_filename.endswith(entry.get('filename')): + coverage_data = entry # but we might still find a better match... + if coverage_data is None: + return None + return { + int(line.get('number')): int(line.get('hits')) + for line in coverage_data.iterfind('lines/line') + } + + def _htmlify_code(self, code, language): + try: + from pygments import highlight + from pygments.lexers import CythonLexer, CppLexer + from pygments.formatters import HtmlFormatter + except ImportError: + # no Pygments, just escape the code + return html_escape(code) + + if language == "cython": + lexer = CythonLexer(stripnl=False, stripall=False) + elif language == "c/cpp": + lexer = CppLexer(stripnl=False, stripall=False) + else: + # unknown language, use fallback + return html_escape(code) + html_code = highlight( + code, lexer, + HtmlFormatter(nowrap=True)) + return html_code + + def _save_annotation_body(self, cython_code, generated_code, annotation_items, scopes, covered_lines=None): + outlist = ['
'] + pos_comment_marker = '/* \N{HORIZONTAL ELLIPSIS} */\n' + new_calls_map = { + name: 0 for name in + 'refnanny trace py_macro_api py_c_api pyx_macro_api pyx_c_api error_goto'.split() + }.copy + + self.mark_pos(None) + + def annotate(match): + group_name = match.lastgroup + calls[group_name] += 1 + return f"{match.group(group_name)}" + + lines = self._htmlify_code(cython_code, "cython").splitlines() + lineno_width = len(str(len(lines))) + if not covered_lines: + covered_lines = None + + for k, line in enumerate(lines, 1): + try: + c_code = generated_code[k] + except KeyError: + c_code = '' + else: + c_code = _replace_pos_comment(pos_comment_marker, c_code) + if c_code.startswith(pos_comment_marker): + c_code = c_code[len(pos_comment_marker):] + c_code = html_escape(c_code) + + calls = new_calls_map() + c_code = _parse_code(annotate, c_code) + score = (5 * calls['py_c_api'] + 2 * calls['pyx_c_api'] + + calls['py_macro_api'] + calls['pyx_macro_api']) + + if c_code: + onclick = self._onclick_attr + expandsymbol = '+' + else: + onclick = '' + expandsymbol = ' ' + + covered = '' + if covered_lines is not None and k in covered_lines: + hits = covered_lines[k] + if hits is not None: + covered = 'run' if hits else 'mis' + + outlist.append( + f'
'
+                # generate line number with expand symbol in front,
+                # and the right  number of digit
+                f'{expandsymbol}{k:0{lineno_width}d}: {line.rstrip()}
\n' + ) + if c_code: + outlist.append(f"
{c_code}
") + outlist.append("
") + + # now the whole c-code if needed: + if self.show_entire_c_code: + complete_code_as_html = self._htmlify_code(self.buffer.getvalue(), "c/cpp") + outlist.append( + '

' + f"
+ {AnnotationCCodeWriter.COMPLETE_CODE_TITLE}
\n" + f"
{complete_code_as_html}
" + "

" + ) + + return outlist + + +_parse_code = re.compile(( + br'(?P__Pyx_X?(?:GOT|GIVE)REF|__Pyx_RefNanny[A-Za-z]+)|' + br'(?P__Pyx_Trace[A-Za-z]+)|' + br'(?:' + br'(?P__Pyx_[A-Z][A-Z_]+)|' + br'(?P(?:__Pyx_[A-Z][a-z_][A-Za-z_]*)|__pyx_convert_[A-Za-z_]*)|' + br'(?PPy[A-Z][a-z]+_[A-Z][A-Z_]+)|' + br'(?PPy[A-Z][a-z]+_[A-Z][a-z][A-Za-z_]*)' + br')(?=\()|' # look-ahead to exclude subsequent '(' from replacement + br'(?P(?:(?<=;) *if [^;]* +)?__PYX_ERR\([^)]+\))' +).decode('ascii')).sub + + +_replace_pos_comment = re.compile( + # this matches what Cython generates as code line marker comment + br'^\s*/\*(?:(?:[^*]|\*[^/])*\n)+\s*\*/\s*\n'.decode('ascii'), + re.M +).sub + + +class AnnotationItem: + + def __init__(self, style, text, tag="", size=0): + self.style = style + self.text = text + self.tag = tag + self.size = size + + def start(self): + return "%s" % (self.style, self.text, self.tag) + + def end(self): + return self.size, "" diff --git a/venv/lib/python3.10/site-packages/Cython/Compiler/AutoDocTransforms.py b/venv/lib/python3.10/site-packages/Cython/Compiler/AutoDocTransforms.py new file mode 100644 index 0000000000000000000000000000000000000000..ad1633c27bc177e66fe07437933e50c237f28d74 --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Compiler/AutoDocTransforms.py @@ -0,0 +1,320 @@ +import inspect + +from .Visitor import CythonTransform +from .StringEncoding import EncodedString +from . import Options +from . import PyrexTypes +from ..CodeWriter import ExpressionWriter +from .Errors import warning + + +class AnnotationWriter(ExpressionWriter): + """ + A Cython code writer for Python expressions in argument/variable annotations. + """ + def __init__(self, description=None): + """description is optional. If specified it is used in + warning messages for the nodes that don't convert to string properly. + If not specified then no messages are generated. + """ + ExpressionWriter.__init__(self) + self.description = description + self.incomplete = False + + def visit_Node(self, node): + self.put("") + self.incomplete = True + if self.description: + warning(node.pos, + "Failed to convert code to string representation in {}".format( + self.description), level=1) + + def visit_LambdaNode(self, node): + # XXX Should we do better? + self.put("") + self.incomplete = True + if self.description: + warning(node.pos, + "Failed to convert lambda to string representation in {}".format( + self.description), level=1) + + def visit_AnnotationNode(self, node): + self.put(node.string.value) + + +class EmbedSignature(CythonTransform): + + def __init__(self, context): + super().__init__(context) + self.class_name = None + self.class_node = None + + def _fmt_expr(self, node): + writer = ExpressionWriter() + result = writer.write(node) + # print(type(node).__name__, '-->', result) + return result + + def _fmt_annotation(self, node): + writer = AnnotationWriter() + result = writer.write(node) + # print(type(node).__name__, '-->', result) + return result + + def _setup_format(self): + signature_format = self.current_directives['embedsignature.format'] + self.is_format_c = signature_format == 'c' + self.is_format_python = signature_format == 'python' + self.is_format_clinic = signature_format == 'clinic' + + def _fmt_arg(self, arg): + arg_doc = arg.name + annotation = None + defaultval = None + if arg.is_self_arg: + if self.is_format_clinic: + arg_doc = '$self' + elif arg.is_type_arg: + if self.is_format_clinic: + arg_doc = '$type' + elif self.is_format_c: + if arg.type is not PyrexTypes.py_object_type: + arg_doc = arg.type.declaration_code(arg.name, for_display=1) + elif self.is_format_python: + if not arg.annotation: + annotation = self._fmt_type(arg.type) + if arg.annotation: + if not self.is_format_clinic: + annotation = self._fmt_annotation(arg.annotation) + if arg.default: + defaultval = self._fmt_expr(arg.default) + if annotation: + arg_doc = arg_doc + (': %s' % annotation) + if defaultval: + arg_doc = arg_doc + (' = %s' % defaultval) + elif defaultval: + arg_doc = arg_doc + ('=%s' % defaultval) + return arg_doc + + def _fmt_star_arg(self, arg): + arg_doc = arg.name + if arg.annotation: + if not self.is_format_clinic: + annotation = self._fmt_annotation(arg.annotation) + arg_doc = arg_doc + (': %s' % annotation) + return arg_doc + + def _fmt_arglist(self, args, + npoargs=0, npargs=0, pargs=None, + nkargs=0, kargs=None, + hide_self=False): + arglist = [] + for arg in args: + if not hide_self or not arg.entry.is_self_arg: + arg_doc = self._fmt_arg(arg) + arglist.append(arg_doc) + if pargs: + arg_doc = self._fmt_star_arg(pargs) + arglist.insert(npargs + npoargs, '*%s' % arg_doc) + elif nkargs: + arglist.insert(npargs + npoargs, '*') + if npoargs: + arglist.insert(npoargs, '/') + if kargs: + arg_doc = self._fmt_star_arg(kargs) + arglist.append('**%s' % arg_doc) + return arglist + + def _fmt_type(self, type): + if type is PyrexTypes.py_object_type: + return None + elif self.is_format_c: + code = type.declaration_code("", for_display=1) + return code + elif self.is_format_python: + annotation = None + if type.is_string: + annotation = self.current_directives['c_string_type'] + elif type.is_numeric: + annotation = type.py_type_name() + if annotation is None: + code = type.declaration_code('', for_display=1) + annotation = code.replace(' ', '_').replace('*', 'p') + return annotation + return None + + def _fmt_signature(self, cls_name, func_name, args, + npoargs=0, npargs=0, pargs=None, + nkargs=0, kargs=None, + return_expr=None, return_type=None, + hide_self=False): + arglist = self._fmt_arglist( + args, npoargs, npargs, pargs, nkargs, kargs, + hide_self=hide_self, + ) + arglist_doc = ', '.join(arglist) + func_doc = '%s(%s)' % (func_name, arglist_doc) + if self.is_format_c and cls_name: + func_doc = '%s.%s' % (cls_name, func_doc) + if not self.is_format_clinic: + ret_doc = None + if return_expr: + ret_doc = self._fmt_annotation(return_expr) + elif return_type: + ret_doc = self._fmt_type(return_type) + if ret_doc: + func_doc = '%s -> %s' % (func_doc, ret_doc) + return func_doc + + def _embed_signature(self, signature, node_doc): + if self.is_format_clinic and self.current_directives['binding']: + return node_doc + if node_doc: + if self.is_format_clinic: + docfmt = "%s\n--\n\n%s" + else: + docfmt = "%s\n\n%s" + node_doc = inspect.cleandoc(node_doc) + return docfmt % (signature, node_doc) + else: + if self.is_format_clinic: + docfmt = "%s\n--\n\n" + else: + docfmt = "%s" + return docfmt % signature + + def __call__(self, node): + if not Options.docstrings: + return node + else: + return super().__call__(node) + + def visit_ClassDefNode(self, node): + oldname = self.class_name + oldclass = self.class_node + self.class_node = node + try: + # PyClassDefNode + self.class_name = node.name + except AttributeError: + # CClassDefNode + self.class_name = node.class_name + self.visitchildren(node) + self.class_name = oldname + self.class_node = oldclass + return node + + def visit_LambdaNode(self, node): + # lambda expressions so not have signature or inner functions + return node + + def visit_DefNode(self, node): + if not self.current_directives['embedsignature']: + return node + self._setup_format() + + is_constructor = False + hide_self = False + if node.entry.is_special: + is_constructor = self.class_node and node.name == '__init__' + if is_constructor: + class_name = None + func_name = node.name + if self.is_format_c: + func_name = self.class_name + hide_self = True + else: + class_name, func_name = self.class_name, node.name + else: + class_name, func_name = self.class_name, node.name + + npoargs = getattr(node, 'num_posonly_args', 0) + nkargs = getattr(node, 'num_kwonly_args', 0) + npargs = len(node.args) - nkargs - npoargs + signature = self._fmt_signature( + class_name, func_name, node.args, + npoargs, npargs, node.star_arg, + nkargs, node.starstar_arg, + return_expr=node.return_type_annotation, + return_type=None, hide_self=hide_self) + if signature: + if is_constructor and self.is_format_c: + doc_holder = self.class_node.entry.type.scope + else: + doc_holder = node.entry + if doc_holder.doc is not None: + old_doc = doc_holder.doc + elif not is_constructor and getattr(node, 'py_func', None) is not None: + old_doc = node.py_func.entry.doc + else: + old_doc = None + new_doc = self._embed_signature(signature, old_doc) + if not node.entry.is_special or is_constructor or node.entry.wrapperbase_cname is not None: + # TODO: the wrapperbase must be generated for __doc__ to exist; + # however this phase is run later in the pipeline than + # Compiler/Nodes.py:declare_pyfunction, so wrapperbase_cname + # may already be set to None + doc_holder.doc = EncodedString(new_doc) + if not is_constructor and getattr(node, 'py_func', None) is not None: + node.py_func.entry.doc = EncodedString(new_doc) + return node + + def visit_CFuncDefNode(self, node): + if not node.overridable: # not cpdef FOO(...): + return node + if not self.current_directives['embedsignature']: + return node + self._setup_format() + + signature = self._fmt_signature( + self.class_name, node.declarator.base.name, + node.declarator.args, + return_type=node.return_type) + if signature: + if node.entry.doc is not None: + old_doc = node.entry.doc + elif getattr(node, 'py_func', None) is not None: + old_doc = node.py_func.entry.doc + else: + old_doc = None + new_doc = self._embed_signature(signature, old_doc) + node.entry.doc = EncodedString(new_doc) + py_func = getattr(node, 'py_func', None) + if py_func is not None: + py_func.entry.doc = EncodedString(new_doc) + return node + + def visit_PropertyNode(self, node): + if not self.current_directives['embedsignature']: + return node + self._setup_format() + + entry = node.entry + body = node.body + prop_name = entry.name + type_name = None + if entry.visibility == 'public': + if self.is_format_c: + # property synthesised from a cdef public attribute + type_name = entry.type.declaration_code("", for_display=1) + if not entry.type.is_pyobject: + type_name = "'%s'" % type_name + elif entry.type.is_extension_type: + type_name = entry.type.module_name + '.' + type_name + elif self.is_format_python: + type_name = self._fmt_type(entry.type) + if type_name is None: + for stat in body.stats: + if stat.name != '__get__': + continue + if self.is_format_c: + prop_name = '%s.%s' % (self.class_name, prop_name) + ret_annotation = stat.return_type_annotation + if ret_annotation: + type_name = self._fmt_annotation(ret_annotation) + if type_name is not None : + signature = '%s: %s' % (prop_name, type_name) + new_doc = self._embed_signature(signature, entry.doc) + if not self.is_format_clinic: + entry.doc = EncodedString(new_doc) + return node diff --git a/venv/lib/python3.10/site-packages/Cython/Compiler/Buffer.py b/venv/lib/python3.10/site-packages/Cython/Compiler/Buffer.py new file mode 100644 index 0000000000000000000000000000000000000000..5de41d3401fdca66c006ca2782c3ea1c8157b658 --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Compiler/Buffer.py @@ -0,0 +1,680 @@ +from .Visitor import CythonTransform +from .ModuleNode import ModuleNode +from .Errors import CompileError +from .UtilityCode import CythonUtilityCode +from .Code import UtilityCode, TempitaUtilityCode + +from . import Options +from . import Interpreter +from . import PyrexTypes +from . import Naming +from . import Symtab + +def dedent(text, reindent=0): + from textwrap import dedent + text = dedent(text) + if reindent > 0: + indent = " " * reindent + text = '\n'.join([indent + x for x in text.split('\n')]) + return text + +class IntroduceBufferAuxiliaryVars(CythonTransform): + + # + # Entry point + # + + buffers_exists = False + using_memoryview = False + + def __call__(self, node): + assert isinstance(node, ModuleNode) + self.max_ndim = 0 + result = super().__call__(node) + if self.buffers_exists: + use_bufstruct_declare_code(node.scope) + + return result + + + # + # Basic operations for transforms + # + def handle_scope(self, node, scope): + # For all buffers, insert extra variables in the scope. + # The variables are also accessible from the buffer_info + # on the buffer entry + scope_items = scope.entries.items() + bufvars = [entry for name, entry in scope_items if entry.type.is_buffer] + if len(bufvars) > 0: + bufvars.sort(key=lambda entry: entry.name) + self.buffers_exists = True + + memviewslicevars = [entry for name, entry in scope_items if entry.type.is_memoryviewslice] + if len(memviewslicevars) > 0: + self.buffers_exists = True + + + for (name, entry) in scope_items: + if name == 'memoryview' and isinstance(entry.utility_code_definition, CythonUtilityCode): + self.using_memoryview = True + break + del scope_items + + if isinstance(node, ModuleNode) and len(bufvars) > 0: + # for now...note that pos is wrong + raise CompileError(node.pos, "Buffer vars not allowed in module scope") + for entry in bufvars: + if entry.type.dtype.is_ptr: + raise CompileError(node.pos, "Buffers with pointer types not yet supported.") + + name = entry.name + buftype = entry.type + if buftype.ndim > Options.buffer_max_dims: + raise CompileError(node.pos, + "Buffer ndims exceeds Options.buffer_max_dims = %d" % Options.buffer_max_dims) + if buftype.ndim > self.max_ndim: + self.max_ndim = buftype.ndim + + # Declare auxiliary vars + def decvar(type, prefix): + cname = scope.mangle(prefix, name) + aux_var = scope.declare_var(name=None, cname=cname, + type=type, pos=node.pos) + if entry.is_arg: + aux_var.used = True # otherwise, NameNode will mark whether it is used + + return aux_var + + auxvars = ((PyrexTypes.c_pyx_buffer_nd_type, Naming.pybuffernd_prefix), + (PyrexTypes.c_pyx_buffer_type, Naming.pybufferstruct_prefix)) + pybuffernd, rcbuffer = [decvar(type, prefix) for (type, prefix) in auxvars] + + entry.buffer_aux = Symtab.BufferAux(pybuffernd, rcbuffer) + + scope.buffer_entries = bufvars + self.scope = scope + + def visit_ModuleNode(self, node): + self.handle_scope(node, node.scope) + self.visitchildren(node) + return node + + def visit_FuncDefNode(self, node): + self.handle_scope(node, node.local_scope) + self.visitchildren(node) + return node + +# +# Analysis +# +buffer_options = ("dtype", "ndim", "mode", "negative_indices", "cast") # ordered! +buffer_defaults = {"ndim": 1, "mode": "full", "negative_indices": True, "cast": False} +buffer_positional_options_count = 1 # anything beyond this needs keyword argument + +ERR_BUF_OPTION_UNKNOWN = '"%s" is not a buffer option' +ERR_BUF_TOO_MANY = 'Too many buffer options' +ERR_BUF_DUP = '"%s" buffer option already supplied' +ERR_BUF_MISSING = '"%s" missing' +ERR_BUF_MODE = 'Only allowed buffer modes are: "c", "fortran", "full", "strided" (as a compile-time string)' +ERR_BUF_NDIM = 'ndim must be a non-negative integer' +ERR_BUF_DTYPE = 'dtype must be "object", numeric type or a struct' +ERR_BUF_BOOL = '"%s" must be a boolean' + +def analyse_buffer_options(globalpos, env, posargs, dictargs, defaults=None, need_complete=True): + """ + Must be called during type analysis, as analyse is called + on the dtype argument. + + posargs and dictargs should consist of a list and a dict + of tuples (value, pos). Defaults should be a dict of values. + + Returns a dict containing all the options a buffer can have and + its value (with the positions stripped). + """ + if defaults is None: + defaults = buffer_defaults + + posargs, dictargs = Interpreter.interpret_compiletime_options( + posargs, dictargs, type_env=env, type_args=(0, 'dtype')) + + if len(posargs) > buffer_positional_options_count: + raise CompileError(posargs[-1][1], ERR_BUF_TOO_MANY) + + options = {} + for name, (value, pos) in dictargs.items(): + if name not in buffer_options: + raise CompileError(pos, ERR_BUF_OPTION_UNKNOWN % name) + options[name] = value + + for name, (value, pos) in zip(buffer_options, posargs): + if name not in buffer_options: + raise CompileError(pos, ERR_BUF_OPTION_UNKNOWN % name) + if name in options: + raise CompileError(pos, ERR_BUF_DUP % name) + options[name] = value + + # Check that they are all there and copy defaults + for name in buffer_options: + if name not in options: + try: + options[name] = defaults[name] + except KeyError: + if need_complete: + raise CompileError(globalpos, ERR_BUF_MISSING % name) + + dtype = options.get("dtype") + if dtype and dtype.is_extension_type: + raise CompileError(globalpos, ERR_BUF_DTYPE) + + ndim = options.get("ndim") + if ndim and (not isinstance(ndim, int) or ndim < 0): + raise CompileError(globalpos, ERR_BUF_NDIM) + + mode = options.get("mode") + if mode and not (mode in ('full', 'strided', 'c', 'fortran')): + raise CompileError(globalpos, ERR_BUF_MODE) + + def assert_bool(name): + x = options.get(name) + if not isinstance(x, bool): + raise CompileError(globalpos, ERR_BUF_BOOL % name) + + assert_bool('negative_indices') + assert_bool('cast') + + return options + + +# +# Code generation +# + +class BufferEntry: + def __init__(self, entry): + self.entry = entry + self.type = entry.type + self.cname = entry.buffer_aux.buflocal_nd_var.cname + self.buf_ptr = "%s.rcbuffer->pybuffer.buf" % self.cname + self.buf_ptr_type = entry.type.buffer_ptr_type + self.init_attributes() + + def init_attributes(self): + self.shape = self.get_buf_shapevars() + self.strides = self.get_buf_stridevars() + self.suboffsets = self.get_buf_suboffsetvars() + + def get_buf_suboffsetvars(self): + return self._for_all_ndim("%s.diminfo[%d].suboffsets") + + def get_buf_stridevars(self): + return self._for_all_ndim("%s.diminfo[%d].strides") + + def get_buf_shapevars(self): + return self._for_all_ndim("%s.diminfo[%d].shape") + + def _for_all_ndim(self, s): + return [s % (self.cname, i) for i in range(self.type.ndim)] + + def generate_buffer_lookup_code(self, code, index_cnames): + # Create buffer lookup and return it + # This is done via utility macros/inline functions, which vary + # according to the access mode used. + params = [] + nd = self.type.ndim + mode = self.type.mode + if mode == 'full': + for i, s, o in zip(index_cnames, + self.get_buf_stridevars(), + self.get_buf_suboffsetvars()): + params.append(i) + params.append(s) + params.append(o) + funcname = "__Pyx_BufPtrFull%dd" % nd + funcgen = buf_lookup_full_code + else: + if mode == 'strided': + funcname = "__Pyx_BufPtrStrided%dd" % nd + funcgen = buf_lookup_strided_code + elif mode == 'c': + funcname = "__Pyx_BufPtrCContig%dd" % nd + funcgen = buf_lookup_c_code + elif mode == 'fortran': + funcname = "__Pyx_BufPtrFortranContig%dd" % nd + funcgen = buf_lookup_fortran_code + else: + assert False + for i, s in zip(index_cnames, self.get_buf_stridevars()): + params.append(i) + params.append(s) + + # Make sure the utility code is available + if funcname not in code.globalstate.utility_codes: + code.globalstate.utility_codes.add(funcname) + protocode = code.globalstate['utility_code_proto'] + defcode = code.globalstate['utility_code_def'] + funcgen(protocode, defcode, name=funcname, nd=nd) + + buf_ptr_type_code = self.buf_ptr_type.empty_declaration_code() + ptrcode = "%s(%s, %s, %s)" % (funcname, buf_ptr_type_code, self.buf_ptr, + ", ".join(params)) + return ptrcode + + +def get_flags(buffer_aux, buffer_type): + flags = 'PyBUF_FORMAT' + mode = buffer_type.mode + if mode == 'full': + flags += '| PyBUF_INDIRECT' + elif mode == 'strided': + flags += '| PyBUF_STRIDES' + elif mode == 'c': + flags += '| PyBUF_C_CONTIGUOUS' + elif mode == 'fortran': + flags += '| PyBUF_F_CONTIGUOUS' + else: + assert False + if buffer_aux.writable_needed: flags += "| PyBUF_WRITABLE" + return flags + +def used_buffer_aux_vars(entry): + buffer_aux = entry.buffer_aux + buffer_aux.buflocal_nd_var.used = True + buffer_aux.rcbuf_var.used = True + +def put_unpack_buffer_aux_into_scope(buf_entry, code): + # Generate code to copy the needed struct info into local + # variables. + buffer_aux, mode = buf_entry.buffer_aux, buf_entry.type.mode + pybuffernd_struct = buffer_aux.buflocal_nd_var.cname + + fldnames = ['strides', 'shape'] + if mode == 'full': + fldnames.append('suboffsets') + + ln = [] + for i in range(buf_entry.type.ndim): + for fldname in fldnames: + ln.append("%s.diminfo[%d].%s = %s.rcbuffer->pybuffer.%s[%d];" % ( + pybuffernd_struct, i, fldname, + pybuffernd_struct, fldname, i, + )) + code.putln(' '.join(ln)) + +def put_init_vars(entry, code): + bufaux = entry.buffer_aux + pybuffernd_struct = bufaux.buflocal_nd_var.cname + pybuffer_struct = bufaux.rcbuf_var.cname + # init pybuffer_struct + code.putln("%s.pybuffer.buf = NULL;" % pybuffer_struct) + code.putln("%s.refcount = 0;" % pybuffer_struct) + # init the buffer object + # code.put_init_var_to_py_none(entry) + # init the pybuffernd_struct + code.putln("%s.data = NULL;" % pybuffernd_struct) + code.putln("%s.rcbuffer = &%s;" % (pybuffernd_struct, pybuffer_struct)) + + +def put_acquire_arg_buffer(entry, code, pos): + buffer_aux = entry.buffer_aux + getbuffer = get_getbuffer_call(code, entry.cname, buffer_aux, entry.type) + + # Acquire any new buffer + code.putln("{") + code.putln("__Pyx_BufFmt_StackElem __pyx_stack[%d];" % entry.type.dtype.struct_nesting_depth()) + code.putln(code.error_goto_if("%s == -1" % getbuffer, pos)) + code.putln("}") + # An exception raised in arg parsing cannot be caught, so no + # need to care about the buffer then. + put_unpack_buffer_aux_into_scope(entry, code) + + +def put_release_buffer_code(code, entry): + code.globalstate.use_utility_code(acquire_utility_code) + code.putln("__Pyx_SafeReleaseBuffer(&%s.rcbuffer->pybuffer);" % entry.buffer_aux.buflocal_nd_var.cname) + + +def get_getbuffer_call(code, obj_cname, buffer_aux, buffer_type): + ndim = buffer_type.ndim + cast = int(buffer_type.cast) + flags = get_flags(buffer_aux, buffer_type) + pybuffernd_struct = buffer_aux.buflocal_nd_var.cname + + dtype_typeinfo = get_type_information_cname(code, buffer_type.dtype) + + code.globalstate.use_utility_code(acquire_utility_code) + return ("__Pyx_GetBufferAndValidate(&%(pybuffernd_struct)s.rcbuffer->pybuffer, " + "(PyObject*)%(obj_cname)s, &%(dtype_typeinfo)s, %(flags)s, %(ndim)d, " + "%(cast)d, __pyx_stack)" % locals()) + + +def put_assign_to_buffer(lhs_cname, rhs_cname, buf_entry, + is_initialized, pos, code): + """ + Generate code for reassigning a buffer variables. This only deals with getting + the buffer auxiliary structure and variables set up correctly, the assignment + itself and refcounting is the responsibility of the caller. + + However, the assignment operation may throw an exception so that the reassignment + never happens. + + Depending on the circumstances there are two possible outcomes: + - Old buffer released, new acquired, rhs assigned to lhs + - Old buffer released, new acquired which fails, reaqcuire old lhs buffer + (which may or may not succeed). + """ + + buffer_aux, buffer_type = buf_entry.buffer_aux, buf_entry.type + pybuffernd_struct = buffer_aux.buflocal_nd_var.cname + flags = get_flags(buffer_aux, buffer_type) + + code.putln("{") # Set up necessary stack for getbuffer + code.putln("__Pyx_BufFmt_StackElem __pyx_stack[%d];" % buffer_type.dtype.struct_nesting_depth()) + + getbuffer = get_getbuffer_call(code, "%s", buffer_aux, buffer_type) # fill in object below + + if is_initialized: + # Release any existing buffer + code.putln('__Pyx_SafeReleaseBuffer(&%s.rcbuffer->pybuffer);' % pybuffernd_struct) + # Acquire + retcode_cname = code.funcstate.allocate_temp(PyrexTypes.c_int_type, manage_ref=False) + code.putln("%s = %s;" % (retcode_cname, getbuffer % rhs_cname)) + code.putln('if (%s) {' % (code.unlikely("%s < 0" % retcode_cname))) + # If acquisition failed, attempt to reacquire the old buffer + # before raising the exception. A failure of reacquisition + # will cause the reacquisition exception to be reported, one + # can consider working around this later. + exc_temps = tuple(code.funcstate.allocate_temp(PyrexTypes.py_object_type, manage_ref=False) + for _ in range(3)) + code.putln('PyErr_Fetch(&%s, &%s, &%s);' % exc_temps) + code.putln('if (%s) {' % code.unlikely("%s == -1" % (getbuffer % lhs_cname))) + code.putln('Py_XDECREF(%s); Py_XDECREF(%s); Py_XDECREF(%s);' % exc_temps) # Do not refnanny these! + code.globalstate.use_utility_code(raise_buffer_fallback_code) + code.putln('__Pyx_RaiseBufferFallbackError();') + code.putln('} else {') + code.putln('PyErr_Restore(%s, %s, %s);' % exc_temps) + code.putln('}') + code.putln('%s = %s = %s = 0;' % exc_temps) + for t in exc_temps: + code.funcstate.release_temp(t) + code.putln('}') + # Unpack indices + put_unpack_buffer_aux_into_scope(buf_entry, code) + code.putln(code.error_goto_if_neg(retcode_cname, pos)) + code.funcstate.release_temp(retcode_cname) + else: + # Our entry had no previous value, so set to None when acquisition fails. + # In this case, auxiliary vars should be set up right in initialization to a zero-buffer, + # so it suffices to set the buf field to NULL. + code.putln('if (%s) {' % code.unlikely("%s == -1" % (getbuffer % rhs_cname))) + code.putln('%s = %s; __Pyx_INCREF(Py_None); %s.rcbuffer->pybuffer.buf = NULL;' % + (lhs_cname, + PyrexTypes.typecast(buffer_type, PyrexTypes.py_object_type, "Py_None"), + pybuffernd_struct)) + code.putln(code.error_goto(pos)) + code.put('} else {') + # Unpack indices + put_unpack_buffer_aux_into_scope(buf_entry, code) + code.putln('}') + + code.putln("}") # Release stack + + +def put_buffer_lookup_code(entry, index_signeds, index_cnames, directives, + pos, code, negative_indices, in_nogil_context): + """ + Generates code to process indices and calculate an offset into + a buffer. Returns a C string which gives a pointer which can be + read from or written to at will (it is an expression so caller should + store it in a temporary if it is used more than once). + + As the bounds checking can have any number of combinations of unsigned + arguments, smart optimizations etc. we insert it directly in the function + body. The lookup however is delegated to a inline function that is instantiated + once per ndim (lookup with suboffsets tend to get quite complicated). + + entry is a BufferEntry + """ + negative_indices = directives['wraparound'] and negative_indices + + if directives['boundscheck']: + # Check bounds and fix negative indices. + # We allocate a temporary which is initialized to -1, meaning OK (!). + # If an error occurs, the temp is set to the index dimension the + # error is occurring at. + failed_dim_temp = code.funcstate.allocate_temp(PyrexTypes.c_int_type, manage_ref=False) + code.putln("%s = -1;" % failed_dim_temp) + for dim, (signed, cname, shape) in enumerate(zip(index_signeds, index_cnames, entry.get_buf_shapevars())): + if signed != 0: + # not unsigned, deal with negative index + code.putln("if (%s < 0) {" % cname) + if negative_indices: + code.putln("%s += %s;" % (cname, shape)) + code.putln("if (%s) %s = %d;" % ( + code.unlikely("%s < 0" % cname), + failed_dim_temp, dim)) + else: + code.putln("%s = %d;" % (failed_dim_temp, dim)) + code.put("} else ") + # check bounds in positive direction + if signed != 0: + cast = "" + else: + cast = "(size_t)" + code.putln("if (%s) %s = %d;" % ( + code.unlikely("%s >= %s%s" % (cname, cast, shape)), + failed_dim_temp, dim)) + + if in_nogil_context: + code.globalstate.use_utility_code(raise_indexerror_nogil) + func = '__Pyx_RaiseBufferIndexErrorNogil' + else: + code.globalstate.use_utility_code(raise_indexerror_code) + func = '__Pyx_RaiseBufferIndexError' + + code.putln("if (%s) {" % code.unlikely("%s != -1" % failed_dim_temp)) + code.putln('%s(%s);' % (func, failed_dim_temp)) + code.putln(code.error_goto(pos)) + code.putln('}') + code.funcstate.release_temp(failed_dim_temp) + elif negative_indices: + # Only fix negative indices. + for signed, cname, shape in zip(index_signeds, index_cnames, entry.get_buf_shapevars()): + if signed != 0: + code.putln("if (%s < 0) %s += %s;" % (cname, cname, shape)) + + return entry.generate_buffer_lookup_code(code, index_cnames) + + +def use_bufstruct_declare_code(env): + env.use_utility_code(buffer_struct_declare_code) + + +def buf_lookup_full_code(proto, defin, name, nd): + """ + Generates a buffer lookup function for the right number + of dimensions. The function gives back a void* at the right location. + """ + # _i_ndex, _s_tride, sub_o_ffset + macroargs = ", ".join(["i%d, s%d, o%d" % (i, i, i) for i in range(nd)]) + proto.putln("#define %s(type, buf, %s) (type)(%s_imp(buf, %s))" % (name, macroargs, name, macroargs)) + + funcargs = ", ".join(["Py_ssize_t i%d, Py_ssize_t s%d, Py_ssize_t o%d" % (i, i, i) for i in range(nd)]) + proto.putln("static CYTHON_INLINE void* %s_imp(void* buf, %s);" % (name, funcargs)) + defin.putln(dedent(""" + static CYTHON_INLINE void* %s_imp(void* buf, %s) { + char* ptr = (char*)buf; + """) % (name, funcargs) + "".join([dedent("""\ + ptr += s%d * i%d; + if (o%d >= 0) ptr = *((char**)ptr) + o%d; + """) % (i, i, i, i) for i in range(nd)] + ) + "\nreturn ptr;\n}") + + +def buf_lookup_strided_code(proto, defin, name, nd): + """ + Generates a buffer lookup function for the right number + of dimensions. The function gives back a void* at the right location. + """ + # _i_ndex, _s_tride + args = ", ".join(["i%d, s%d" % (i, i) for i in range(nd)]) + offset = " + ".join(["i%d * s%d" % (i, i) for i in range(nd)]) + proto.putln("#define %s(type, buf, %s) (type)((char*)buf + %s)" % (name, args, offset)) + + +def buf_lookup_c_code(proto, defin, name, nd): + """ + Similar to strided lookup, but can assume that the last dimension + doesn't need a multiplication as long as. + Still we keep the same signature for now. + """ + if nd == 1: + proto.putln("#define %s(type, buf, i0, s0) ((type)buf + i0)" % name) + else: + args = ", ".join(["i%d, s%d" % (i, i) for i in range(nd)]) + offset = " + ".join(["i%d * s%d" % (i, i) for i in range(nd - 1)]) + proto.putln("#define %s(type, buf, %s) ((type)((char*)buf + %s) + i%d)" % (name, args, offset, nd - 1)) + + +def buf_lookup_fortran_code(proto, defin, name, nd): + """ + Like C lookup, but the first index is optimized instead. + """ + if nd == 1: + proto.putln("#define %s(type, buf, i0, s0) ((type)buf + i0)" % name) + else: + args = ", ".join(["i%d, s%d" % (i, i) for i in range(nd)]) + offset = " + ".join(["i%d * s%d" % (i, i) for i in range(1, nd)]) + proto.putln("#define %s(type, buf, %s) ((type)((char*)buf + %s) + i%d)" % (name, args, offset, 0)) + + +def mangle_dtype_name(dtype): + # Use prefixes to separate user defined types from builtins + # (consider "typedef float unsigned_int") + if dtype.is_pyobject: + return "object" + elif dtype.is_ptr: + return "ptr" + else: + if dtype.is_typedef or dtype.is_struct_or_union: + prefix = "nn_" + else: + prefix = "" + return prefix + dtype.specialization_name() + +def get_type_information_cname(code, dtype, maxdepth=None): + """ + Output the run-time type information (__Pyx_TypeInfo) for given dtype, + and return the name of the type info struct. + + Structs with two floats of the same size are encoded as complex numbers. + One can separate between complex numbers declared as struct or with native + encoding by inspecting to see if the fields field of the type is + filled in. + """ + namesuffix = mangle_dtype_name(dtype) + name = "__Pyx_TypeInfo_%s" % namesuffix + structinfo_name = "__Pyx_StructFields_%s" % namesuffix + + if dtype.is_error: return "" + + # It's critical that walking the type info doesn't use more stack + # depth than dtype.struct_nesting_depth() returns, so use an assertion for this + if maxdepth is None: maxdepth = dtype.struct_nesting_depth() + if maxdepth <= 0: + assert False + + if name not in code.globalstate.utility_codes: + code.globalstate.utility_codes.add(name) + typecode = code.globalstate['typeinfo'] + + arraysizes = [] + if dtype.is_array: + while dtype.is_array: + arraysizes.append(dtype.size) + dtype = dtype.base_type + + complex_possible = dtype.is_struct_or_union and dtype.can_be_complex() + + declcode = dtype.empty_declaration_code() + if dtype.is_simple_buffer_dtype(): + structinfo_name = "NULL" + elif dtype.is_struct: + struct_scope = dtype.scope + if dtype.is_cv_qualified: + struct_scope = struct_scope.base_type_scope + # Must pre-call all used types in order not to recurse during utility code writing. + fields = struct_scope.var_entries + assert len(fields) > 0 + types = [get_type_information_cname(code, f.type, maxdepth - 1) + for f in fields] + typecode.putln("static const __Pyx_StructField %s[] = {" % structinfo_name, safe=True) + + if dtype.is_cv_qualified: + # roughly speaking, remove "const" from struct_type + struct_type = dtype.cv_base_type.empty_declaration_code() + else: + struct_type = dtype.empty_declaration_code() + + for f, typeinfo in zip(fields, types): + typecode.putln(' {&%s, "%s", offsetof(%s, %s)},' % + (typeinfo, f.name, struct_type, f.cname), safe=True) + + typecode.putln(' {NULL, NULL, 0}', safe=True) + typecode.putln("};", safe=True) + else: + assert False + + rep = str(dtype) + + flags = "0" + is_unsigned = "0" + if dtype is PyrexTypes.c_char_type: + is_unsigned = "__PYX_IS_UNSIGNED(%s)" % declcode + typegroup = "'H'" + elif dtype.is_int: + is_unsigned = "__PYX_IS_UNSIGNED(%s)" % declcode + typegroup = "%s ? 'U' : 'I'" % is_unsigned + elif complex_possible or dtype.is_complex: + typegroup = "'C'" + elif dtype.is_float: + typegroup = "'R'" + elif dtype.is_struct: + typegroup = "'S'" + if dtype.packed: + flags = "__PYX_BUF_FLAGS_PACKED_STRUCT" + elif dtype.is_pyobject: + typegroup = "'O'" + else: + assert False, dtype + + typeinfo = ('static const __Pyx_TypeInfo %s = ' + '{ "%s", %s, sizeof(%s), { %s }, %s, %s, %s, %s };') + tup = (name, rep, structinfo_name, declcode, + ', '.join([str(x) for x in arraysizes]) or '0', len(arraysizes), + typegroup, is_unsigned, flags) + typecode.putln(typeinfo % tup, safe=True) + + return name + +def load_buffer_utility(util_code_name, context=None, **kwargs): + if context is None: + return UtilityCode.load(util_code_name, "Buffer.c", **kwargs) + else: + return TempitaUtilityCode.load(util_code_name, "Buffer.c", context=context, **kwargs) + +context = dict(max_dims=Options.buffer_max_dims) +buffer_struct_declare_code = load_buffer_utility("BufferStructDeclare", context=context) +buffer_formats_declare_code = load_buffer_utility("BufferFormatStructs") + +# Utility function to set the right exception +# The caller should immediately goto_error +raise_indexerror_code = load_buffer_utility("BufferIndexError") +raise_indexerror_nogil = load_buffer_utility("BufferIndexErrorNogil") +raise_buffer_fallback_code = load_buffer_utility("BufferFallbackError") + +acquire_utility_code = load_buffer_utility("BufferGetAndValidate", context=context) +buffer_format_check_code = load_buffer_utility("BufferFormatCheck", context=context) + +# See utility code BufferFormatFromTypeInfo +_typeinfo_to_format_code = load_buffer_utility("TypeInfoToFormat") diff --git a/venv/lib/python3.10/site-packages/Cython/Compiler/Builtin.py b/venv/lib/python3.10/site-packages/Cython/Compiler/Builtin.py new file mode 100644 index 0000000000000000000000000000000000000000..4f4a4d4994fff40fe10bebd539f009a277b0b80f --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Compiler/Builtin.py @@ -0,0 +1,948 @@ +# +# Builtin Definitions +# + + +from .StringEncoding import EncodedString +from .Symtab import BuiltinScope, CClassScope, StructOrUnionScope, ModuleScope, Entry +from .Code import UtilityCode, TempitaUtilityCode +from .TypeSlots import Signature +from . import PyrexTypes + + +# C-level implementations of builtin types, functions and methods + +iter_next_utility_code = UtilityCode.load("IterNext", "ObjectHandling.c") +getattr_utility_code = UtilityCode.load("GetAttr", "ObjectHandling.c") +getattr3_utility_code = UtilityCode.load("GetAttr3", "Builtins.c") +pyexec_utility_code = UtilityCode.load("PyExec", "Builtins.c") +pyexec_globals_utility_code = UtilityCode.load("PyExecGlobals", "Builtins.c") +globals_utility_code = UtilityCode.load("Globals", "Builtins.c") +include_std_lib_h_utility_code = UtilityCode.load("IncludeStdlibH", "ModuleSetupCode.c") +pysequence_multiply_utility_code = UtilityCode.load("PySequenceMultiply", "ObjectHandling.c") +slice_accessor_utility_code = UtilityCode.load("PySliceAccessors", "Builtins.c") + +# mapping from builtins to their C-level equivalents + +class _BuiltinOverride: + def __init__(self, py_name, args, ret_type, cname, py_equiv="*", + utility_code=None, sig=None, func_type=None, + is_strict_signature=False, builtin_return_type=None, + nogil=None, specialiser=None): + self.py_name, self.cname, self.py_equiv = py_name, cname, py_equiv + self.args, self.ret_type = args, ret_type + self.func_type, self.sig = func_type, sig + self.builtin_return_type = builtin_return_type + self.is_strict_signature = is_strict_signature + self.utility_code = utility_code + self.nogil = nogil + self.specialiser = specialiser + + def build_func_type(self, sig=None, self_arg=None): + if sig is None: + sig = Signature(self.args, self.ret_type, nogil=self.nogil) + sig.exception_check = False # not needed for the current builtins + func_type = sig.function_type(self_arg) + if self.is_strict_signature: + func_type.is_strict_signature = True + if self.builtin_return_type: + func_type.return_type = builtin_types[self.builtin_return_type] + return func_type + + +class BuiltinAttribute: + def __init__(self, py_name, cname=None, field_type=None, field_type_name=None): + self.py_name = py_name + self.cname = cname or py_name + self.field_type_name = field_type_name # can't do the lookup before the type is declared! + self.field_type = field_type + + def declare_in_type(self, self_type): + if self.field_type_name is not None: + # lazy type lookup + field_type = builtin_scope.lookup(self.field_type_name).type + else: + field_type = self.field_type or PyrexTypes.py_object_type + entry = self_type.scope.declare(self.py_name, self.cname, field_type, None, 'private') + entry.is_variable = True + + +class BuiltinFunction(_BuiltinOverride): + def declare_in_scope(self, scope): + func_type, sig = self.func_type, self.sig + if func_type is None: + func_type = self.build_func_type(sig) + scope.declare_builtin_cfunction( + self.py_name, func_type, self.cname, self.py_equiv, self.utility_code, + specialiser=self.specialiser, + ) + + +class BuiltinMethod(_BuiltinOverride): + def declare_in_type(self, self_type): + method_type, sig = self.func_type, self.sig + if method_type is None: + # override 'self' type (first argument) + self_arg = PyrexTypes.CFuncTypeArg("", self_type, None) + self_arg.not_none = True + self_arg.accept_builtin_subtypes = True + method_type = self.build_func_type(sig, self_arg) + self_type.scope.declare_builtin_cfunction( + self.py_name, method_type, self.cname, utility_code=self.utility_code) + + +class BuiltinProperty: + # read only for now + def __init__(self, py_name, property_type, call_cname, + exception_value=None, exception_check=None, utility_code=None): + self.py_name = py_name + self.property_type = property_type + self.call_cname = call_cname + self.utility_code = utility_code + self.exception_value = exception_value + self.exception_check = exception_check + + def declare_in_type(self, self_type): + self_type.scope.declare_cproperty( + self.py_name, + self.property_type, + self.call_cname, + exception_value=self.exception_value, + exception_check=self.exception_check, + utility_code=self.utility_code + ) + + +### Special builtin implementations generated at runtime. + +def _generate_divmod_function(scope, argument_types): + if len(argument_types) != 2: + return None + type_op1, type_op2 = argument_types + + # Resolve internal typedefs to avoid useless code duplication. + if type_op1.is_typedef: + type_op1 = type_op1.resolve_known_type() + if type_op2.is_typedef: + type_op2 = type_op2.resolve_known_type() + + if type_op1.is_float or type_op1 is float_type or type_op2.is_float and (type_op1.is_int or type_op1 is int_type): + impl = "float" + # TODO: support 'long double'? Currently fails to handle the error return value. + number_type = PyrexTypes.c_double_type + elif type_op1.is_int and type_op2.is_int: + impl = "int" + number_type = type_op1 if type_op1.rank >= type_op2.rank else type_op2 + else: + return None + + nogil = scope.nogil + cfunc_suffix = f"{'nogil_' if nogil else ''}{impl}_{'td_' if number_type.is_typedef else ''}{number_type.specialization_name()}" + function_cname = f"__Pyx_divmod_{cfunc_suffix}" + + # Reuse an existing specialisation, if available. + builtin_scope = scope.builtin_scope() + existing_entry = builtin_scope.lookup_here("divmod") + if existing_entry is not None: + for entry in existing_entry.all_alternatives(): + if entry.cname == function_cname: + return entry + + # Generate a new specialisation. + ctuple_entry = scope.declare_tuple_type(None, [number_type]*2) + ctuple_entry.used = True + return_type = ctuple_entry.type + + function_type = PyrexTypes.CFuncType( + return_type, [ + PyrexTypes.CFuncTypeArg("a", number_type, None), + PyrexTypes.CFuncTypeArg("b", number_type, None), + ], + exception_value=f"__Pyx_divmod_ERROR_VALUE_{cfunc_suffix}", + exception_check=True, + is_strict_signature=True, + nogil=nogil, + ) + + utility_code = TempitaUtilityCode.load( + f"divmod_{impl}", "Builtins.c", context={ + 'CFUNC_SUFFIX': cfunc_suffix, + 'MATH_SUFFIX': number_type.math_h_modifier if number_type.is_float else '', + 'TYPE': number_type.empty_declaration_code(), + 'RETURN_TYPE': return_type.empty_declaration_code(), + 'NOGIL': nogil, + }) + + entry = builtin_scope.declare_builtin_cfunction( + "divmod", function_type, function_cname, utility_code=utility_code) + + return entry + + +### List of builtin functions and their implementation. + +builtin_function_table = [ + # name, args, return, C API func, py equiv = "*" + BuiltinFunction('abs', "d", "d", "fabs", + is_strict_signature=True, nogil=True, + utility_code=include_std_lib_h_utility_code), + BuiltinFunction('abs', "f", "f", "fabsf", + is_strict_signature=True, nogil=True, + utility_code=include_std_lib_h_utility_code), + BuiltinFunction('abs', "i", "i", "abs", + is_strict_signature=True, nogil=True, + utility_code=include_std_lib_h_utility_code), + BuiltinFunction('abs', "l", "l", "labs", + is_strict_signature=True, nogil=True, + utility_code=include_std_lib_h_utility_code), + BuiltinFunction('abs', None, None, "__Pyx_abs_longlong", + utility_code = UtilityCode.load("abs_longlong", "Builtins.c"), + func_type = PyrexTypes.CFuncType( + PyrexTypes.c_longlong_type, [ + PyrexTypes.CFuncTypeArg("arg", PyrexTypes.c_longlong_type, None) + ], + is_strict_signature = True, nogil=True)), + ] + list( + BuiltinFunction('abs', None, None, "/*abs_{}*/".format(t.specialization_name()), + func_type = PyrexTypes.CFuncType( + t, + [PyrexTypes.CFuncTypeArg("arg", t, None)], + is_strict_signature = True, nogil=True)) + for t in (PyrexTypes.c_uint_type, PyrexTypes.c_ulong_type, PyrexTypes.c_ulonglong_type) + ) + list( + BuiltinFunction('abs', None, None, "__Pyx_c_abs{}".format(t.funcsuffix), + func_type = PyrexTypes.CFuncType( + t.real_type, [ + PyrexTypes.CFuncTypeArg("arg", t, None) + ], + is_strict_signature = True, nogil=True)) + for t in (PyrexTypes.c_float_complex_type, + PyrexTypes.c_double_complex_type, + PyrexTypes.c_longdouble_complex_type) + ) + [ + BuiltinFunction('abs', "O", "O", "__Pyx_PyNumber_Absolute", + utility_code=UtilityCode.load("py_abs", "Builtins.c")), + #('all', "", "", ""), + #('any', "", "", ""), + #('ascii', "", "", ""), + #('bin', "", "", ""), + BuiltinFunction('callable', "O", "b", "__Pyx_PyCallable_Check", + utility_code = UtilityCode.load("CallableCheck", "ObjectHandling.c")), + BuiltinFunction('chr', "i", "O", "PyUnicode_FromOrdinal", builtin_return_type='str'), + #('cmp', "", "", "", ""), # int PyObject_Cmp(PyObject *o1, PyObject *o2, int *result) + #('compile', "", "", ""), # PyObject* Py_CompileString( char *str, char *filename, int start) + BuiltinFunction('delattr', "OO", "r", "__Pyx_PyObject_DelAttr", + utility_code=UtilityCode.load("PyObjectDelAttr", "ObjectHandling.c")), + BuiltinFunction('dir', "O", "O", "PyObject_Dir"), + BuiltinFunction('divmod', "OO", "O", "PyNumber_Divmod", + specialiser=_generate_divmod_function), + BuiltinFunction('exec', "O", "O", "__Pyx_PyExecGlobals", + utility_code = pyexec_globals_utility_code), + BuiltinFunction('exec', "OO", "O", "__Pyx_PyExec2", + utility_code = pyexec_utility_code), + BuiltinFunction('exec', "OOO", "O", "__Pyx_PyExec3", + utility_code = pyexec_utility_code), + #('eval', "", "", ""), + #('execfile', "", "", ""), + #('filter', "", "", ""), + BuiltinFunction('getattr3', "OOO", "O", "__Pyx_GetAttr3", "getattr", + utility_code=getattr3_utility_code), # Pyrex legacy + BuiltinFunction('getattr', "OOO", "O", "__Pyx_GetAttr3", + utility_code=getattr3_utility_code), + BuiltinFunction('getattr', "OO", "O", "__Pyx_GetAttr", + utility_code=getattr_utility_code), + BuiltinFunction('hasattr', "OO", "b", "__Pyx_HasAttr", + utility_code = UtilityCode.load("HasAttr", "Builtins.c")), + BuiltinFunction('hash', "O", "h", "PyObject_Hash"), + #('hex', "", "", ""), + #('id', "", "", ""), + #('input', "", "", ""), + BuiltinFunction('intern', "O", "O", "__Pyx_Intern", + utility_code = UtilityCode.load("Intern", "Builtins.c")), + BuiltinFunction('isinstance', "OO", "b", "PyObject_IsInstance"), + BuiltinFunction('issubclass', "OO", "b", "PyObject_IsSubclass"), + BuiltinFunction('iter', "OO", "O", "PyCallIter_New"), + BuiltinFunction('iter', "O", "O", "PyObject_GetIter"), + BuiltinFunction('len', "O", "z", "PyObject_Length"), + BuiltinFunction('locals', "", "O", "__pyx_locals"), + #('map', "", "", ""), + #('max', "", "", ""), + #('min', "", "", ""), + BuiltinFunction('next', "O", "O", "__Pyx_PyIter_Next", + utility_code = iter_next_utility_code), # not available in Py2 => implemented here + BuiltinFunction('next', "OO", "O", "__Pyx_PyIter_Next2", + utility_code = iter_next_utility_code), # not available in Py2 => implemented here + #('oct', "", "", ""), + #('open', "ss", "O", "PyFile_FromString"), # not in Py3 +] + [ + BuiltinFunction('ord', None, None, "__Pyx_long_cast", + func_type=PyrexTypes.CFuncType( + PyrexTypes.c_long_type, [PyrexTypes.CFuncTypeArg("c", c_type, None)], + is_strict_signature=True)) + for c_type in [PyrexTypes.c_py_ucs4_type, PyrexTypes.c_py_unicode_type] +] + [ + BuiltinFunction('ord', None, None, "__Pyx_uchar_cast", + func_type=PyrexTypes.CFuncType( + PyrexTypes.c_uchar_type, [PyrexTypes.CFuncTypeArg("c", c_type, None)], + is_strict_signature=True)) + for c_type in [PyrexTypes.c_char_type, PyrexTypes.c_schar_type, PyrexTypes.c_uchar_type] +] + [ + BuiltinFunction('ord', None, None, "__Pyx_PyObject_Ord", + utility_code=UtilityCode.load_cached("object_ord", "Builtins.c"), + func_type=PyrexTypes.CFuncType( + PyrexTypes.c_long_type, [ + PyrexTypes.CFuncTypeArg("c", PyrexTypes.py_object_type, None) + ], + exception_value="(long)(Py_UCS4)-1")), + BuiltinFunction('pow', "OOO", "O", "PyNumber_Power"), + BuiltinFunction('pow', "OO", "O", "__Pyx_PyNumber_Power2", + utility_code = UtilityCode.load("pow2", "Builtins.c")), + #('range', "", "", ""), + #('raw_input', "", "", ""), + #('reduce', "", "", ""), + BuiltinFunction('reload', "O", "O", "PyImport_ReloadModule"), + BuiltinFunction('repr', "O", "O", "PyObject_Repr", builtin_return_type='str'), + #('round', "", "", ""), + BuiltinFunction('setattr', "OOO", "r", "PyObject_SetAttr"), + #('sum', "", "", ""), + #('sorted', "", "", ""), + #('type', "O", "O", "PyObject_Type"), + BuiltinFunction('unichr', "i", "O", "PyUnicode_FromOrdinal", builtin_return_type='str'), + #('vars', "", "", ""), + #('zip', "", "", ""), + # Can't do these easily until we have builtin type entries. + #('typecheck', "OO", "i", "PyObject_TypeCheck", False), + #('issubtype', "OO", "i", "PyType_IsSubtype", False), + + # Put in namespace append optimization. + BuiltinFunction('__Pyx_PyObject_Append', "OO", "O", "__Pyx_PyObject_Append"), + + # This is conditionally looked up based on a compiler directive. + BuiltinFunction('__Pyx_Globals', "", "O", "__Pyx_Globals", + utility_code=globals_utility_code), +] + + +# Builtin types +# bool +# buffer +# classmethod +# dict +# enumerate +# file +# float +# int +# list +# long +# object +# property +# slice +# staticmethod +# super +# str +# tuple +# type +# xrange + +builtin_types_table = [ + + ("type", "&PyType_Type", []), + +# This conflicts with the C++ bool type, and unfortunately +# C++ is too liberal about PyObject* <-> bool conversions, +# resulting in unintuitive runtime behavior and segfaults. +# ("bool", "&PyBool_Type", []), + + ("int", "&PyLong_Type", []), + ("float", "&PyFloat_Type", []), + + ("complex", "&PyComplex_Type", [BuiltinAttribute('cval', field_type_name = 'Py_complex'), + BuiltinAttribute('real', 'cval.real', field_type = PyrexTypes.c_double_type), + BuiltinAttribute('imag', 'cval.imag', field_type = PyrexTypes.c_double_type), + ]), + + ("bytearray", "&PyByteArray_Type", [ + BuiltinMethod("__mul__", "Tz", "T", "__Pyx_PySequence_Multiply", + utility_code=pysequence_multiply_utility_code), + ]), + ("bytes", "&PyBytes_Type", [BuiltinMethod("join", "TO", "O", "__Pyx_PyBytes_Join", + utility_code=UtilityCode.load("StringJoin", "StringTools.c")), + BuiltinMethod("__mul__", "Tz", "T", "__Pyx_PySequence_Multiply", + utility_code=pysequence_multiply_utility_code), + ]), + ("str", "&PyUnicode_Type", [BuiltinMethod("__contains__", "TO", "b", "PyUnicode_Contains"), + BuiltinMethod("join", "TO", "T", "PyUnicode_Join"), + BuiltinMethod("__mul__", "Tz", "T", "__Pyx_PySequence_Multiply", + utility_code=pysequence_multiply_utility_code), + ]), + + ("tuple", "&PyTuple_Type", [BuiltinMethod("__mul__", "Tz", "T", "__Pyx_PySequence_Multiply", + utility_code=pysequence_multiply_utility_code), + ]), + + ("list", "&PyList_Type", [BuiltinMethod("insert", "TzO", "r", "PyList_Insert"), + BuiltinMethod("reverse", "T", "r", "PyList_Reverse"), + BuiltinMethod("append", "TO", "r", "__Pyx_PyList_Append", + utility_code=UtilityCode.load("ListAppend", "Optimize.c")), + BuiltinMethod("extend", "TO", "r", "__Pyx_PyList_Extend", + utility_code=UtilityCode.load("ListExtend", "Optimize.c")), + BuiltinMethod("__mul__", "Tz", "T", "__Pyx_PySequence_Multiply", + utility_code=pysequence_multiply_utility_code), + ]), + + ("dict", "&PyDict_Type", [BuiltinMethod("__contains__", "TO", "b", "PyDict_Contains"), + BuiltinMethod("has_key", "TO", "b", "PyDict_Contains"), + BuiltinMethod("items", "T", "O", "__Pyx_PyDict_Items", + utility_code=UtilityCode.load("py_dict_items", "Builtins.c")), + BuiltinMethod("keys", "T", "O", "__Pyx_PyDict_Keys", + utility_code=UtilityCode.load("py_dict_keys", "Builtins.c")), + BuiltinMethod("values", "T", "O", "__Pyx_PyDict_Values", + utility_code=UtilityCode.load("py_dict_values", "Builtins.c")), + BuiltinMethod("iteritems", "T", "O", "__Pyx_PyDict_IterItems", + utility_code=UtilityCode.load("py_dict_iteritems", "Builtins.c")), + BuiltinMethod("iterkeys", "T", "O", "__Pyx_PyDict_IterKeys", + utility_code=UtilityCode.load("py_dict_iterkeys", "Builtins.c")), + BuiltinMethod("itervalues", "T", "O", "__Pyx_PyDict_IterValues", + utility_code=UtilityCode.load("py_dict_itervalues", "Builtins.c")), + BuiltinMethod("viewitems", "T", "O", "__Pyx_PyDict_ViewItems", + utility_code=UtilityCode.load("py_dict_viewitems", "Builtins.c")), + BuiltinMethod("viewkeys", "T", "O", "__Pyx_PyDict_ViewKeys", + utility_code=UtilityCode.load("py_dict_viewkeys", "Builtins.c")), + BuiltinMethod("viewvalues", "T", "O", "__Pyx_PyDict_ViewValues", + utility_code=UtilityCode.load("py_dict_viewvalues", "Builtins.c")), + BuiltinMethod("clear", "T", "r", "__Pyx_PyDict_Clear", + utility_code=UtilityCode.load("py_dict_clear", "Optimize.c")), + BuiltinMethod("copy", "T", "T", "PyDict_Copy")]), + + ("slice", "&PySlice_Type", [BuiltinProperty("start", PyrexTypes.py_object_type, '__Pyx_PySlice_Start', + utility_code=slice_accessor_utility_code), + BuiltinProperty("stop", PyrexTypes.py_object_type, '__Pyx_PySlice_Stop', + utility_code=slice_accessor_utility_code), + BuiltinProperty("step", PyrexTypes.py_object_type, '__Pyx_PySlice_Step', + utility_code=slice_accessor_utility_code), + ]), + + ("set", "&PySet_Type", [BuiltinMethod("clear", "T", "r", "PySet_Clear"), + # discard() and remove() have a special treatment for unhashable values + BuiltinMethod("discard", "TO", "r", "__Pyx_PySet_Discard", + utility_code=UtilityCode.load("py_set_discard", "Optimize.c")), + BuiltinMethod("remove", "TO", "r", "__Pyx_PySet_Remove", + utility_code=UtilityCode.load("py_set_remove", "Optimize.c")), + # update is actually variadic (see Github issue #1645) +# BuiltinMethod("update", "TO", "r", "__Pyx_PySet_Update", +# utility_code=UtilityCode.load_cached("PySet_Update", "Builtins.c")), + BuiltinMethod("add", "TO", "r", "PySet_Add"), + BuiltinMethod("pop", "T", "O", "PySet_Pop")]), + ("frozenset", "&PyFrozenSet_Type", []), + ("BaseException", "((PyTypeObject*)PyExc_BaseException)", []), + ("Exception", "((PyTypeObject*)PyExc_Exception)", []), + ("memoryview", "&PyMemoryView_Type", [ + # TODO - format would be nice, but hard to get + # __len__ can be accessed through a direct lookup of the buffer (but probably in Optimize.c) + # error checking would ideally be limited api only + BuiltinProperty("ndim", PyrexTypes.c_int_type, '__Pyx_PyMemoryView_Get_ndim', + exception_value=-1, exception_check=True, + utility_code=TempitaUtilityCode.load_cached( + "memoryview_get_from_buffer", "Builtins.c", + context=dict(name="ndim") + ) + ), + BuiltinProperty("readonly", PyrexTypes.c_bint_type, '__Pyx_PyMemoryView_Get_readonly', + exception_value=-1, exception_check=True, + utility_code=TempitaUtilityCode.load_cached( + "memoryview_get_from_buffer", "Builtins.c", + context=dict(name="readonly") + ) + ), + BuiltinProperty("itemsize", PyrexTypes.c_py_ssize_t_type, '__Pyx_PyMemoryView_Get_itemsize', + exception_value=-1, exception_check=True, + utility_code=TempitaUtilityCode.load_cached( + "memoryview_get_from_buffer", "Builtins.c", + context=dict(name="itemsize") + ) + )] + ) +] + + +types_that_construct_their_instance = frozenset({ + # some builtin types do not always return an instance of + # themselves - these do: + 'type', 'bool', 'int', 'float', 'complex', + 'bytes', 'unicode', 'bytearray', 'str', + 'tuple', 'list', 'dict', 'set', 'frozenset', + 'memoryview' +}) + + +# When updating this mapping, also update "unsafe_compile_time_methods" below +# if methods are added that are not safe to evaluate at compile time. +inferred_method_return_types = { + 'complex': dict( + conjugate='complex', + ), + 'int': dict( + as_integer_ratio='tuple[int,int]', + bit_count='T', + bit_length='T', + conjugate='T', + from_bytes='T', # classmethod + is_integer='bint', + to_bytes='bytes', + ), + 'float': dict( + as_integer_ratio='tuple[int,int]', + conjugate='T', + fromhex='T', # classmethod + hex='str', + is_integer='bint', + ), + 'list': dict( + copy='T', + count='Py_ssize_t', + index='Py_ssize_t', + ), + 'tuple': dict( + count='Py_ssize_t', + index='Py_ssize_t', + ), + 'str': dict( + capitalize='T', + casefold='T', + center='T', + count='Py_ssize_t', + encode='bytes', + endswith='bint', + expandtabs='T', + find='Py_ssize_t', + format='T', + format_map='T', + index='Py_ssize_t', + isalnum='bint', + isalpha='bint', + isascii='bint', + isdecimal='bint', + isdigit='bint', + isidentifier='bint', + islower='bint', + isnumeric='bint', + isprintable='bint', + isspace='bint', + istitle='bint', + isupper='bint', + join='T', + ljust='T', + lower='T', + lstrip='T', + maketrans='dict[int,object]', # staticmethod + partition='tuple[T,T,T]', + removeprefix='T', + removesuffix='T', + replace='T', + rfind='Py_ssize_t', + rindex='Py_ssize_t', + rjust='T', + rpartition='tuple[T,T,T]', + rsplit='list[T]', + rstrip='T', + split='list[T]', + splitlines='list[T]', + startswith='bint', + strip='T', + swapcase='T', + title='T', + translate='T', + upper='T', + zfill='T', + ), + 'bytes': dict( + capitalize='T', + center='T', + count='Py_ssize_t', + decode='str', + endswith='bint', + expandtabs='T', + find='Py_ssize_t', + fromhex='T', # classmethod + hex='str', + index='Py_ssize_t', + isalnum='bint', + isalpha='bint', + isascii='bint', + isdigit='bint', + islower='bint', + isspace='bint', + istitle='bint', + isupper='bint', + join='T', + ljust='T', + lower='T', + lstrip='T', + maketrans='bytes', # staticmethod + partition='tuple[T,T,T]', + removeprefix='T', + removesuffix='T', + replace='T', + rfind='Py_ssize_t', + rindex='Py_ssize_t', + rjust='T', + rpartition='tuple[T,T,T]', + rsplit='list[T]', + rstrip='T', + split='list[T]', + splitlines='list[T]', + startswith='bint', + strip='T', + swapcase='T', + title='T', + translate='T', + upper='T', + zfill='T', + ), + 'bytearray': dict( + # Inherited from 'bytes' below. + ), + 'memoryview': dict( + cast='T', + hex='str', + tobytes='bytes', + tolist='list', + toreadonly='T', + ), + 'set': dict( + copy='T', + difference='T', + intersection='T', + isdisjoint='bint', + issubset='bint', + issuperset='bint', + symmetric_difference='T', + union='T', + ), + 'frozenset': dict( + # Inherited from 'set' below. + ), + 'dict': dict( + copy='T', + fromkeys='T', # classmethod + popitem='tuple', + ), +} + +inferred_method_return_types['bytearray'].update(inferred_method_return_types['bytes']) +inferred_method_return_types['frozenset'].update(inferred_method_return_types['set']) + + +def find_return_type_of_builtin_method(builtin_type, method_name): + type_name = builtin_type.name + if type_name in inferred_method_return_types: + methods = inferred_method_return_types[type_name] + if method_name in methods: + return_type_name = methods[method_name] + if '[' in return_type_name: + # TODO: Keep the "[...]" part when we add support for generics. + return_type_name = return_type_name.partition('[')[0] + if return_type_name == 'T': + return builtin_type + if 'T' in return_type_name: + return_type_name = return_type_name.replace('T', builtin_type.name) + if return_type_name == 'bint': + return PyrexTypes.c_bint_type + elif return_type_name == 'Py_ssize_t': + return PyrexTypes.c_py_ssize_t_type + return builtin_scope.lookup(return_type_name).type + return PyrexTypes.py_object_type + + +unsafe_compile_time_methods = { + # We name here only unsafe and non-portable methods if: + # - the type has a literal representation, allowing for constant folding. + # - the return type is not None (thus excluding modifier methods) + # and is listed in 'inferred_method_return_types' above. + # + # See the consistency check in TestBuiltin.py. + # + 'complex': set(), + 'int': { + 'bit_count', # Py3.10+ + 'from_bytes', # classmethod + 'is_integer', # Py3.12+ + 'to_bytes', # changed in Py3.11 + }, + 'float': { + 'fromhex', # classmethod + }, + 'list': { + 'copy', + }, + 'tuple': set(), + 'str': { + 'replace', # changed in Py3.13+ + 'maketrans', # staticmethod + 'removeprefix', # Py3.9+ + 'removesuffix', # Py3.9+ + }, + 'bytes': { + 'fromhex', # classmethod + 'maketrans', # staticmethod + 'removeprefix', # Py3.9+ + 'removesuffix', # Py3.9+ + }, + 'set': set(), +} + + +def is_safe_compile_time_method(builtin_type_name: str, method_name: str): + unsafe_methods = unsafe_compile_time_methods.get(builtin_type_name) + if unsafe_methods is None: + # Not a literal type. + return False + if method_name in unsafe_methods: + # Not a safe method. + return False + known_methods = inferred_method_return_types.get(builtin_type_name) + if known_methods is None or method_name not in known_methods: + # Not a known method. + return False + return True + + +builtin_structs_table = [ + ('Py_buffer', 'Py_buffer', + [("buf", PyrexTypes.c_void_ptr_type), + ("obj", PyrexTypes.py_object_type), + ("len", PyrexTypes.c_py_ssize_t_type), + ("itemsize", PyrexTypes.c_py_ssize_t_type), + ("readonly", PyrexTypes.c_bint_type), + ("ndim", PyrexTypes.c_int_type), + ("format", PyrexTypes.c_char_ptr_type), + ("shape", PyrexTypes.c_py_ssize_t_ptr_type), + ("strides", PyrexTypes.c_py_ssize_t_ptr_type), + ("suboffsets", PyrexTypes.c_py_ssize_t_ptr_type), + ("smalltable", PyrexTypes.CArrayType(PyrexTypes.c_py_ssize_t_type, 2)), + ("internal", PyrexTypes.c_void_ptr_type), + ]), + ('Py_complex', 'Py_complex', + [('real', PyrexTypes.c_double_type), + ('imag', PyrexTypes.c_double_type), + ]) +] + +# set up builtin scope + +builtin_scope = BuiltinScope() + +def init_builtin_funcs(): + for bf in builtin_function_table: + bf.declare_in_scope(builtin_scope) + +builtin_types = {} + +def init_builtin_types(): + global builtin_types + for name, cname, methods in builtin_types_table: + if name == 'frozenset': + objstruct_cname = 'PySetObject' + elif name == 'bytearray': + objstruct_cname = 'PyByteArrayObject' + elif name == 'int': + objstruct_cname = 'PyLongObject' + elif name == 'str': + objstruct_cname = 'PyUnicodeObject' + elif name == 'bool': + objstruct_cname = 'PyLongObject' + elif name == 'BaseException': + objstruct_cname = "PyBaseExceptionObject" + elif name == 'Exception': + objstruct_cname = "PyBaseExceptionObject" + else: + objstruct_cname = 'Py%sObject' % name.capitalize() + type_class = PyrexTypes.BuiltinObjectType + if name in ['dict', 'list', 'set', 'frozenset']: + type_class = PyrexTypes.BuiltinTypeConstructorObjectType + elif name == 'tuple': + type_class = PyrexTypes.PythonTupleTypeConstructor + the_type = builtin_scope.declare_builtin_type( + name, cname, objstruct_cname=objstruct_cname, type_class=type_class) + builtin_types[name] = the_type + for method in methods: + method.declare_in_type(the_type) + + +def init_builtin_structs(): + for name, cname, attribute_types in builtin_structs_table: + scope = StructOrUnionScope(name) + for attribute_name, attribute_type in attribute_types: + scope.declare_var(attribute_name, attribute_type, None, + attribute_name, allow_pyobject=True) + builtin_scope.declare_struct_or_union( + name, "struct", scope, 1, None, cname = cname) + + +def init_builtins(): + #Errors.init_thread() # hopefully not needed - we should not emit warnings ourselves + init_builtin_structs() + init_builtin_types() + init_builtin_funcs() + + entry = builtin_scope.declare_var( + '__debug__', PyrexTypes.c_const_type(PyrexTypes.c_bint_type), + pos=None, cname='__pyx_assertions_enabled()', is_cdef=True) + entry.utility_code = UtilityCode.load_cached("AssertionsEnabled", "Exceptions.c") + + global type_type, list_type, tuple_type, dict_type, set_type, frozenset_type, slice_type + global bytes_type, unicode_type, bytearray_type + global float_type, int_type, bool_type, complex_type + global memoryview_type, py_buffer_type + global sequence_types + type_type = builtin_scope.lookup('type').type + list_type = builtin_scope.lookup('list').type + tuple_type = builtin_scope.lookup('tuple').type + dict_type = builtin_scope.lookup('dict').type + set_type = builtin_scope.lookup('set').type + frozenset_type = builtin_scope.lookup('frozenset').type + slice_type = builtin_scope.lookup('slice').type + + bytes_type = builtin_scope.lookup('bytes').type + unicode_type = builtin_scope.lookup('str').type + bytearray_type = builtin_scope.lookup('bytearray').type + memoryview_type = builtin_scope.lookup('memoryview').type + + float_type = builtin_scope.lookup('float').type + int_type = builtin_scope.lookup('int').type + #bool_type = builtin_scope.lookup('bool').type + complex_type = builtin_scope.lookup('complex').type + + # Most entries are initialized via "declare_builtin_type()"", except for "bool" + # which is apparently a special case because it conflicts with C++ bool. + # Here, we only declare it as builtin name, not as actual type. + bool_type = PyrexTypes.BuiltinObjectType(EncodedString('bool'), "((PyObject*)&PyBool_Type)", "PyLongObject") + scope = CClassScope('bool', outer_scope=None, visibility='extern', parent_type=bool_type) + bool_type.set_scope(scope) + bool_type.is_final_type = True + bool_type.entry = builtin_scope.declare_var(EncodedString('bool'), bool_type, pos=None, cname="((PyObject*)&PyBool_Type)") + builtin_types['bool'] = bool_type + + sequence_types = ( + list_type, + tuple_type, + bytes_type, + unicode_type, + bytearray_type, + memoryview_type, + ) + + # Set up type inference links between equivalent Python/C types + assert bool_type.name == 'bool', bool_type.name + bool_type.equivalent_type = PyrexTypes.c_bint_type + PyrexTypes.c_bint_type.equivalent_type = bool_type + + assert float_type.name == 'float', float_type.name + float_type.equivalent_type = PyrexTypes.c_double_type + PyrexTypes.c_double_type.equivalent_type = float_type + + assert complex_type.name == 'complex', complex_type.name + complex_type.equivalent_type = PyrexTypes.c_double_complex_type + PyrexTypes.c_double_complex_type.equivalent_type = complex_type + + py_buffer_type = builtin_scope.lookup('Py_buffer').type + + +init_builtins() + +############################## +# Support for a few standard library modules that Cython understands (currently typing and dataclasses) +############################## +_known_module_scopes = {} + +def get_known_standard_library_module_scope(module_name): + mod = _known_module_scopes.get(module_name) + if mod: + return mod + + if module_name == "typing": + mod = ModuleScope(module_name, None, None) + for name, tp in [ + ('Dict', dict_type), + ('List', list_type), + ('Tuple', tuple_type), + ('Set', set_type), + ('FrozenSet', frozenset_type), + ]: + name = EncodedString(name) + entry = mod.declare_type(name, tp, pos = None) + var_entry = Entry(name, None, PyrexTypes.py_object_type) + var_entry.is_pyglobal = True + var_entry.is_variable = True + var_entry.scope = mod + entry.as_variable = var_entry + entry.known_standard_library_import = "%s.%s" % (module_name, name) + + for name in ['ClassVar', 'Optional', 'Union']: + name = EncodedString(name) + indexed_type = PyrexTypes.SpecialPythonTypeConstructor(EncodedString("typing."+name)) + entry = mod.declare_type(name, indexed_type, pos = None) + var_entry = Entry(name, None, PyrexTypes.py_object_type) + var_entry.is_pyglobal = True + var_entry.is_variable = True + var_entry.scope = mod + entry.as_variable = var_entry + entry.known_standard_library_import = "%s.%s" % (module_name, name) + _known_module_scopes[module_name] = mod + elif module_name == "dataclasses": + mod = ModuleScope(module_name, None, None) + indexed_type = PyrexTypes.SpecialPythonTypeConstructor(EncodedString("dataclasses.InitVar")) + initvar_string = EncodedString("InitVar") + entry = mod.declare_type(initvar_string, indexed_type, pos = None) + var_entry = Entry(initvar_string, None, PyrexTypes.py_object_type) + var_entry.is_pyglobal = True + var_entry.scope = mod + entry.as_variable = var_entry + entry.known_standard_library_import = "%s.InitVar" % module_name + for name in ["dataclass", "field"]: + mod.declare_var(EncodedString(name), PyrexTypes.py_object_type, pos=None) + _known_module_scopes[module_name] = mod + elif module_name == "functools": + mod = ModuleScope(module_name, None, None) + for name in ["total_ordering"]: + mod.declare_var(EncodedString(name), PyrexTypes.py_object_type, pos=None) + _known_module_scopes[module_name] = mod + + return mod + + +def get_known_standard_library_entry(qualified_name): + name_parts = qualified_name.split(".") + module_name = EncodedString(name_parts[0]) + rest = name_parts[1:] + + if len(rest) > 1: # for now, we don't know how to deal with any nested modules + return None + + mod = get_known_standard_library_module_scope(module_name) + + # eventually handle more sophisticated multiple lookups if needed + if mod and rest: + return mod.lookup_here(rest[0]) + return None + + +def exprnode_to_known_standard_library_name(node, env): + qualified_name_parts = [] + known_name = None + while node.is_attribute: + qualified_name_parts.append(node.attribute) + node = node.obj + if node.is_name: + entry = env.lookup(node.name) + if entry and entry.known_standard_library_import: + if get_known_standard_library_entry( + entry.known_standard_library_import): + known_name = entry.known_standard_library_import + else: + standard_env = get_known_standard_library_module_scope( + entry.known_standard_library_import) + if standard_env: + qualified_name_parts.append(standard_env.name) + known_name = ".".join(reversed(qualified_name_parts)) + return known_name diff --git a/venv/lib/python3.10/site-packages/Cython/Compiler/CmdLine.py b/venv/lib/python3.10/site-packages/Cython/Compiler/CmdLine.py new file mode 100644 index 0000000000000000000000000000000000000000..5071320ceb37eef9a6f0264229b064c56ed1da9b --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Compiler/CmdLine.py @@ -0,0 +1,259 @@ +# +# Cython - Command Line Parsing +# + + +import os +from argparse import ArgumentParser, Action, SUPPRESS, RawDescriptionHelpFormatter +from . import Options + + +class ParseDirectivesAction(Action): + def __call__(self, parser, namespace, values, option_string=None): + old_directives = dict(getattr(namespace, self.dest, + Options.get_directive_defaults())) + directives = Options.parse_directive_list( + values, relaxed_bool=True, current_settings=old_directives) + setattr(namespace, self.dest, directives) + + +class ParseOptionsAction(Action): + def __call__(self, parser, namespace, values, option_string=None): + options = dict(getattr(namespace, self.dest, {})) + for opt in values.split(','): + if '=' in opt: + n, v = opt.split('=', 1) + v = v.lower() not in ('false', 'f', '0', 'no') + else: + n, v = opt, True + options[n] = v + setattr(namespace, self.dest, options) + + +class ParseCompileTimeEnvAction(Action): + def __call__(self, parser, namespace, values, option_string=None): + old_env = dict(getattr(namespace, self.dest, {})) + new_env = Options.parse_compile_time_env(values, current_settings=old_env) + setattr(namespace, self.dest, new_env) + + +class ActivateAllWarningsAction(Action): + def __call__(self, parser, namespace, values, option_string=None): + directives = getattr(namespace, 'compiler_directives', {}) + directives.update(Options.extra_warnings) + namespace.compiler_directives = directives + + +class SetLenientAction(Action): + def __call__(self, parser, namespace, values, option_string=None): + namespace.error_on_unknown_names = False + namespace.error_on_uninitialized = False + + +class SetGDBDebugAction(Action): + def __call__(self, parser, namespace, values, option_string=None): + namespace.gdb_debug = True + namespace.output_dir = os.curdir + + +class SetGDBDebugOutputAction(Action): + def __call__(self, parser, namespace, values, option_string=None): + namespace.gdb_debug = True + namespace.output_dir = values + + +class SetAnnotateCoverageAction(Action): + def __call__(self, parser, namespace, values, option_string=None): + namespace.annotate = True + namespace.annotate_coverage_xml = values + +def create_cython_argparser(): + description = "Cython (https://cython.org/) is a compiler for code written in the "\ + "Cython language. Cython is based on Pyrex by Greg Ewing." + + parser = ArgumentParser( + description=description, + argument_default=SUPPRESS, + formatter_class=RawDescriptionHelpFormatter, + epilog="""\ +Environment variables: + CYTHON_CACHE_DIR: the base directory containing Cython's caches.""" + ) + + parser.add_argument("-V", "--version", dest='show_version', action='store_const', const=1, + help='Display version number of cython compiler') + parser.add_argument("-l", "--create-listing", dest='use_listing_file', action='store_const', const=1, + help='Write error messages to a listing file') + parser.add_argument("-I", "--include-dir", dest='include_path', action='append', + help='Search for include files in named directory ' + '(multiple include directories are allowed).') + parser.add_argument("-o", "--output-file", dest='output_file', action='store', type=str, + help='Specify name of generated C file') + parser.add_argument("-t", "--timestamps", dest='timestamps', action='store_const', const=1, + help='Only compile newer source files') + parser.add_argument("-f", "--force", dest='timestamps', action='store_const', const=0, + help='Compile all source files (overrides implied -t)') + parser.add_argument("-v", "--verbose", dest='verbose', action='count', + help='Be verbose, print file names on multiple compilation') + parser.add_argument("-p", "--embed-positions", dest='embed_pos_in_docstring', action='store_const', const=1, + help='If specified, the positions in Cython files of each ' + 'function definition is embedded in its docstring.') + parser.add_argument("--cleanup", dest='generate_cleanup_code', action='store', type=int, + help='Release interned objects on python exit, for memory debugging. ' + 'Level indicates aggressiveness, default 0 releases nothing.') + parser.add_argument("--cache", dest='cache', action='store_true', + help='Enables Cython compilation cache.') + parser.add_argument("-w", "--working", dest='working_path', action='store', type=str, + help='Sets the working directory for Cython (the directory modules are searched from)') + parser.add_argument("--gdb", action=SetGDBDebugAction, nargs=0, + help='Output debug information for cygdb') + parser.add_argument("--gdb-outdir", action=SetGDBDebugOutputAction, type=str, + help='Specify gdb debug information output directory. Implies --gdb.') + parser.add_argument("-D", "--no-docstrings", dest='docstrings', action='store_false', + help='Strip docstrings from the compiled module.') + 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("--annotate-coverage", dest='annotate_coverage_xml', action=SetAnnotateCoverageAction, type=str, + help='Annotate and include coverage information from cov.xml.') + parser.add_argument("--line-directives", dest='emit_linenums', action='store_true', + help='Produce #line directives pointing to the .pyx source') + parser.add_argument("-+", "--cplus", dest='cplus', action='store_const', const=1, + help='Output a C++ rather than C file.') + parser.add_argument('--embed', action='store_const', const='main', + help='Generate a main() function that embeds the Python interpreter. ' + 'Pass --embed= for a name other than main().') + parser.add_argument('-2', dest='language_level', action='store_const', const=2, + help='Compile based on Python-2 syntax and code semantics.') + parser.add_argument('-3', dest='language_level', action='store_const', const=3, + help='Compile based on Python-3 syntax and code semantics.') + parser.add_argument('--3str', dest='language_level', action='store_const', const='3', + help='Compile based on Python-3 syntax and code semantics (same as -3 since Cython 3.1).') + parser.add_argument("--lenient", action=SetLenientAction, nargs=0, + help='Change some compile time errors to runtime errors to ' + 'improve Python compatibility') + parser.add_argument("--capi-reexport-cincludes", dest='capi_reexport_cincludes', action='store_true', + help='Add cincluded headers to any auto-generated header files.') + parser.add_argument("--fast-fail", dest='fast_fail', action='store_true', + help='Abort the compilation on the first error') + parser.add_argument("-Werror", "--warning-errors", dest='warning_errors', action='store_true', + help='Make all warnings into errors') + parser.add_argument("-Wextra", "--warning-extra", action=ActivateAllWarningsAction, nargs=0, + help='Enable extra warnings') + + parser.add_argument('-X', '--directive', metavar='NAME=VALUE,...', + dest='compiler_directives', type=str, + action=ParseDirectivesAction, + help='Overrides a compiler directive') + parser.add_argument('-E', '--compile-time-env', metavar='NAME=VALUE,...', + dest='compile_time_env', type=str, + action=ParseCompileTimeEnvAction, + help='Provides compile time env like DEF would do.') + parser.add_argument("--module-name", + dest='module_name', type=str, action='store', + help='Fully qualified module name. If not given, is ' + 'deduced from the import path if source file is in ' + 'a package, or equals the filename otherwise.') + parser.add_argument('-M', '--depfile', action='store_true', help='produce depfiles for the sources') + parser.add_argument("--generate-shared", dest='shared_c_file_path', action='store', type=str, + help='Generates shared module with specified name.') + parser.add_argument("--shared", dest='shared_utility_qualified_name', action='store', type=str, + help='Imports utility code from shared module specified by fully qualified module name.') + + parser.add_argument('sources', nargs='*', default=[]) + + # TODO: add help + parser.add_argument("-z", "--pre-import", dest='pre_import', action='store', type=str, help=SUPPRESS) + parser.add_argument("--convert-range", dest='convert_range', action='store_true', help=SUPPRESS) + parser.add_argument("--no-c-in-traceback", dest='c_line_in_traceback', action='store_false', help=SUPPRESS) + parser.add_argument("--cimport-from-pyx", dest='cimport_from_pyx', action='store_true', help=SUPPRESS) + parser.add_argument("--old-style-globals", dest='old_style_globals', action='store_true', help=SUPPRESS) + + # debug stuff: + from . import DebugFlags + for name in vars(DebugFlags): + if name.startswith("debug"): + option_name = name.replace('_', '-') + parser.add_argument("--" + option_name, action='store_true', help=SUPPRESS) + + return parser + + +def parse_command_line_raw(parser, args): + # special handling for --embed and --embed=xxxx as they aren't correctly parsed + def filter_out_embed_options(args): + with_embed, without_embed = [], [] + for x in args: + if x == '--embed' or x.startswith('--embed='): + with_embed.append(x) + else: + without_embed.append(x) + return with_embed, without_embed + + with_embed, args_without_embed = filter_out_embed_options(args) + + arguments, unknown = parser.parse_known_args(args_without_embed) + + sources = arguments.sources + del arguments.sources + + # unknown can be either debug, embed or input files or really unknown + for option in unknown: + if option.startswith('-'): + parser.error("unknown option " + option) + else: + sources.append(option) + + # embed-stuff must be handled extra: + for x in with_embed: + if x == '--embed': + name = 'main' # default value + else: + name = x[len('--embed='):] + setattr(arguments, 'embed', name) + + return arguments, sources + + +def parse_command_line(args): + parser = create_cython_argparser() + arguments, sources = parse_command_line_raw(parser, args) + + work_dir = getattr(arguments, 'working_path', '') + for source in sources: + if work_dir and not os.path.isabs(source): + source = os.path.join(work_dir, source) + if not os.path.exists(source): + import errno + raise FileNotFoundError(errno.ENOENT, os.strerror(errno.ENOENT), source) + + options = Options.CompilationOptions(Options.default_options) + for name, value in vars(arguments).items(): + if name.startswith('debug'): + from . import DebugFlags + if name in dir(DebugFlags): + setattr(DebugFlags, name, value) + else: + parser.error("Unknown debug flag: %s\n" % name) + elif hasattr(Options, name): + setattr(Options, name, value) + else: + setattr(options, name, value) + + if options.use_listing_file and len(sources) > 1: + parser.error("cython: Only one source file allowed when using -o\n") + if options.shared_c_file_path: + if len(sources) > 0: + parser.error("cython: Source file not allowed when using --generate-shared\n") + elif len(sources) == 0 and not options.show_version: + parser.error("cython: Need at least one source file\n") + if Options.embed and len(sources) > 1: + parser.error("cython: Only one source file allowed when using --embed\n") + if options.module_name: + if options.timestamps: + parser.error("cython: Cannot use --module-name with --timestamps\n") + if len(sources) > 1: + parser.error("cython: Only one source file allowed when using --module-name\n") + return options, sources diff --git a/venv/lib/python3.10/site-packages/Cython/Compiler/Code.pxd b/venv/lib/python3.10/site-packages/Cython/Compiler/Code.pxd new file mode 100644 index 0000000000000000000000000000000000000000..00d311cfeaa2ea93b4e1dffdf774040e389f9807 --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Compiler/Code.pxd @@ -0,0 +1,148 @@ +cimport cython +from ..StringIOTree cimport StringIOTree + + +cdef class AbstractUtilityCode: + pass + + +cdef class UtilityCodeBase(AbstractUtilityCode): + cpdef format_code(self, code_string, replace_empty_lines=*) + + +cdef class UtilityCode(UtilityCodeBase): + cdef public object name + cdef public object proto + cdef public object impl + cdef public object init + cdef public object cleanup + cdef public object proto_block + cdef public object module_state_decls + cdef public object requires + cdef public dict _cache + cdef public list specialize_list + cdef public object file + cdef public tuple _parts_tuple + + cpdef none_or_sub(self, s, context) + # TODO - Signature not compatible with previous declaration + #@cython.final + #cdef bint _put_code_section(self, writer, code_type: str) except -1 + + +cdef class FunctionState: + cdef public set names_taken + cdef public object owner + cdef public object scope + + cdef public object error_label + cdef public size_t label_counter + cdef public set labels_used + cdef public object return_label + cdef public object continue_label + cdef public object break_label + cdef public list yield_labels + + cdef public object return_from_error_cleanup_label # not used in __init__ ? + + cdef public object exc_vars + cdef public object current_except + cdef public bint can_trace + cdef public bint gil_owned + + cdef public list temps_allocated + cdef public dict temps_free + cdef public dict temps_used_type + cdef public set zombie_temps + cdef public size_t temp_counter + cdef public list collect_temps_stack + + cdef public object closure_temps + cdef public bint should_declare_error_indicator + cdef public bint uses_error_indicator + cdef public bint error_without_exception + + cdef public bint needs_refnanny + + cpdef new_label(self, name=*) + cpdef tuple get_loop_labels(self) + cpdef set_loop_labels(self, labels) + cpdef tuple get_all_labels(self) + cpdef set_all_labels(self, labels) + cpdef start_collecting_temps(self) + cpdef stop_collecting_temps(self) + + cpdef list temps_in_use(self) + +cdef class IntConst: + cdef public object cname + cdef public object value + cdef public bint is_long + +cdef class PyObjectConst: + cdef public object cname + cdef public object type + +cdef class StringConst: + cdef public object cname + cdef public object text + cdef public object escaped_value + cdef public dict py_strings + cdef public list py_versions + + cpdef get_py_string_const(self, encoding, identifier=*) + +## cdef class PyStringConst: +## cdef public object cname +## cdef public object encoding +## cdef public bint is_str +## cdef public bint is_unicode +## cdef public bint intern + +#class GlobalState(object): + +#def funccontext_property(name): + +cdef class CCodeWriter(object): + cdef readonly StringIOTree buffer + cdef readonly list pyclass_stack + cdef readonly object globalstate + cdef readonly object funcstate + cdef object code_config + cdef tuple last_pos + cdef tuple last_marked_pos + cdef Py_ssize_t level + cdef public Py_ssize_t call_level # debug-only, see Nodes.py + cdef bint bol + + cpdef write(self, s) + @cython.final + cdef _write_lines(self, s) + cpdef _write_to_buffer(self, s) + cpdef put(self, code) + cpdef put_safe(self, code) + cpdef putln(self, code=*, bint safe=*) + @cython.final + cdef emit_marker(self) + @cython.final + cdef _build_marker(self, tuple pos) + @cython.final + cdef increase_indent(self) + @cython.final + cdef decrease_indent(self) + @cython.final + cdef indent(self) + + +cdef class PyrexCodeWriter: + cdef public object f + cdef public Py_ssize_t level + + +cdef class PyxCodeWriter: + cdef public StringIOTree buffer + cdef public object context + cdef object encoding + cdef Py_ssize_t level + cdef Py_ssize_t original_level + cdef dict _insertion_points diff --git a/venv/lib/python3.10/site-packages/Cython/Compiler/Code.py b/venv/lib/python3.10/site-packages/Cython/Compiler/Code.py new file mode 100644 index 0000000000000000000000000000000000000000..4dca40ffdda137b0837d1481a51dd5f8ac6f1f34 --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Compiler/Code.py @@ -0,0 +1,3375 @@ +# +# Code output module +# + + +import cython +cython.declare(os=object, re=object, operator=object, textwrap=object, + Template=object, Naming=object, Options=object, StringEncoding=object, + Utils=object, SourceDescriptor=object, StringIOTree=object, + DebugFlags=object, defaultdict=object, + closing=object, partial=object, wraps=object) + +import hashlib +import operator +import os +import re +import shutil +import textwrap +from string import Template +from functools import partial, wraps +from contextlib import closing, contextmanager +from collections import defaultdict + +from . import Naming +from . import Options +from . import DebugFlags +from . import StringEncoding +from .. import Utils +from .Scanning import SourceDescriptor +from ..StringIOTree import StringIOTree + + +renamed_py2_builtins_map = { + # builtins that had different names in Py2 code + 'unicode' : 'str', + 'basestring' : 'str', + 'xrange' : 'range', + 'raw_input' : 'input', +} + +ctypedef_builtins_map = { + # types of builtins in "ctypedef class" statements which we don't + # import either because the names conflict with C types or because + # the type simply is not exposed. + 'py_int' : '&PyLong_Type', + 'py_long' : '&PyLong_Type', + 'py_float' : '&PyFloat_Type', + 'wrapper_descriptor' : '&PyWrapperDescr_Type', +} + +basicsize_builtins_map = { + # builtins whose type has a different tp_basicsize than sizeof(...) + 'PyTypeObject': 'PyHeapTypeObject', +} + +# Builtins as of Python version ... +KNOWN_PYTHON_BUILTINS_VERSION = (3, 13, 0, 'alpha', 5) +KNOWN_PYTHON_BUILTINS = frozenset([ + 'ArithmeticError', + 'AssertionError', + 'AttributeError', + 'BaseException', + 'BaseExceptionGroup', + 'BlockingIOError', + 'BrokenPipeError', + 'BufferError', + 'BytesWarning', + 'ChildProcessError', + 'ConnectionAbortedError', + 'ConnectionError', + 'ConnectionRefusedError', + 'ConnectionResetError', + 'DeprecationWarning', + 'EOFError', + 'Ellipsis', + 'EncodingWarning', + 'EnvironmentError', + 'Exception', + 'ExceptionGroup', + 'False', + 'FileExistsError', + 'FileNotFoundError', + 'FloatingPointError', + 'FutureWarning', + 'GeneratorExit', + 'IOError', + 'ImportError', + 'ImportWarning', + '_IncompleteInputError', + 'IndentationError', + 'IndexError', + 'InterruptedError', + 'IsADirectoryError', + 'KeyError', + 'KeyboardInterrupt', + 'LookupError', + 'MemoryError', + 'ModuleNotFoundError', + 'NameError', + 'None', + 'NotADirectoryError', + 'NotImplemented', + 'NotImplementedError', + 'OSError', + 'OverflowError', + 'PendingDeprecationWarning', + 'PermissionError', + 'ProcessLookupError', + 'PythonFinalizationError', + 'RecursionError', + 'ReferenceError', + 'ResourceWarning', + 'RuntimeError', + 'RuntimeWarning', + 'StopAsyncIteration', + 'StopIteration', + 'SyntaxError', + 'SyntaxWarning', + 'SystemError', + 'SystemExit', + 'TabError', + 'TimeoutError', + 'True', + 'TypeError', + 'UnboundLocalError', + 'UnicodeDecodeError', + 'UnicodeEncodeError', + 'UnicodeError', + 'UnicodeTranslateError', + 'UnicodeWarning', + 'UserWarning', + 'ValueError', + 'Warning', + 'WindowsError', + 'ZeroDivisionError', + '__build_class__', + '__debug__', + '__import__', + 'abs', + 'aiter', + 'all', + 'anext', + 'any', + 'ascii', + 'bin', + 'bool', + 'breakpoint', + 'bytearray', + 'bytes', + 'callable', + 'chr', + 'classmethod', + 'compile', + 'complex', + 'copyright', + 'credits', + 'delattr', + 'dict', + 'dir', + 'divmod', + 'enumerate', + 'eval', + 'exec', + 'exit', + 'filter', + 'float', + 'format', + 'frozenset', + 'getattr', + 'globals', + 'hasattr', + 'hash', + 'help', + 'hex', + 'id', + 'input', + 'int', + 'isinstance', + 'issubclass', + 'iter', + 'len', + 'license', + 'list', + 'locals', + 'map', + 'max', + 'memoryview', + 'min', + 'next', + 'object', + 'oct', + 'open', + 'ord', + 'pow', + 'print', + 'property', + 'quit', + 'range', + 'repr', + 'reversed', + 'round', + 'set', + 'setattr', + 'slice', + 'sorted', + 'staticmethod', + 'str', + 'sum', + 'super', + 'tuple', + 'type', + 'vars', + 'zip', +]) + +uncachable_builtins = [ + # Global/builtin names that cannot be cached because they may or may not + # be available at import time, for various reasons: + ## Python 3.13+ + '_IncompleteInputError', + 'PythonFinalizationError', + ## Python 3.11+ + 'BaseExceptionGroup', + 'ExceptionGroup', + ## - Py3.10+ + 'aiter', + 'anext', + 'EncodingWarning', + ## - Py3.7+ + 'breakpoint', # might deserve an implementation in Cython + ## - platform specific + 'WindowsError', + ## - others + '_', # e.g. used by gettext +] + +special_py_methods = cython.declare(frozenset, frozenset(( + '__cinit__', '__dealloc__', '__richcmp__', '__next__', + '__await__', '__aiter__', '__anext__', + '__getbuffer__', '__releasebuffer__', +))) + +modifier_output_mapper = { + 'inline': 'CYTHON_INLINE' +}.get + +cleanup_level_for_type_prefix = cython.declare(object, { + 'ustring': None, + 'tuple': 2, + 'slice': 2, +}.get) + + +class IncludeCode: + """ + An include file and/or verbatim C code to be included in the + generated sources. + """ + # attributes: + # + # pieces {order: unicode}: pieces of C code to be generated. + # For the included file, the key "order" is zero. + # For verbatim include code, the "order" is the "order" + # attribute of the original IncludeCode where this piece + # of C code was first added. This is needed to prevent + # duplication if the same include code is found through + # multiple cimports. + # location int: where to put this include in the C sources, one + # of the constants INITIAL, EARLY, LATE + # order int: sorting order (automatically set by increasing counter) + + # Constants for location. If the same include occurs with different + # locations, the earliest one takes precedence. + INITIAL = 0 + EARLY = 1 + LATE = 2 + + counter = 1 # Counter for "order" + + def __init__(self, include=None, verbatim=None, late=True, initial=False): + self.order = self.counter + type(self).counter += 1 + self.pieces = {} + + if include: + if include[0] == '<' and include[-1] == '>': + self.pieces[0] = '#include {}'.format(include) + late = False # system include is never late + else: + self.pieces[0] = '#include "{}"'.format(include) + + if verbatim: + self.pieces[self.order] = verbatim + + if initial: + self.location = self.INITIAL + elif late: + self.location = self.LATE + else: + self.location = self.EARLY + + def dict_update(self, d, key): + """ + Insert `self` in dict `d` with key `key`. If that key already + exists, update the attributes of the existing value with `self`. + """ + if key in d: + other = d[key] + other.location = min(self.location, other.location) + other.pieces.update(self.pieces) + else: + d[key] = self + + def sortkey(self): + return self.order + + def mainpiece(self): + """ + Return the main piece of C code, corresponding to the include + file. If there was no include file, return None. + """ + return self.pieces.get(0) + + def write(self, code): + # Write values of self.pieces dict, sorted by the keys + for k in sorted(self.pieces): + code.putln(self.pieces[k]) + + +def get_utility_dir(): + # make this a function and not global variables: + # http://trac.cython.org/cython_trac/ticket/475 + Cython_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) + return os.path.join(Cython_dir, "Utility") + +read_utilities_hook = None +""" +Override the hook for reading a utilities file that contains code fragments used +by the codegen. + +The hook functions takes the path of the utilities file, and returns a list +of strings, one per line. + +The default behavior is to open a file relative to get_utility_dir(). +""" + +def read_utilities_from_utility_dir(path): + """ + Read all lines of the file at the provided path from a path relative + to get_utility_dir(). + """ + filename = os.path.join(get_utility_dir(), path) + with closing(Utils.open_source_file(filename, encoding='UTF-8')) as f: + return f.readlines() + +# by default, read utilities from the utility directory. +read_utilities_hook = read_utilities_from_utility_dir + + +class AbstractUtilityCode: + + requires = None + + def put_code(self, output): + pass + + def get_tree(self, **kwargs): + return None + + def get_shared_library_scope(self, **kwargs): + return None + + +class UtilityCodeBase(AbstractUtilityCode): + """ + Support for loading utility code from a file. + + Code sections in the file can be specified as follows: + + ##### MyUtility.proto ##### + + [proto declarations] + + ##### MyUtility.init ##### + + [code run at module initialization] + + ##### MyUtility ##### + #@requires: MyOtherUtility + #@substitute: naming + + [definitions] + + ##### MyUtility ##### + #@substitute: tempita + + [requires tempita substitution + - context can't be specified here though so only + tempita utility that requires no external context + will benefit from this tag + - only necessary when @required from non-tempita code] + + for prototypes and implementation respectively. For non-python or + -cython files backslashes should be used instead. 5 to 30 comment + characters may be used on either side. + + If the @cname decorator is not used and this is a CythonUtilityCode, + one should pass in the 'name' keyword argument to be used for name + mangling of such entries. + """ + + is_cython_utility = False + _utility_cache = {} + + @classmethod + def _add_utility(cls, utility, name, type, lines, begin_lineno, tags=None): + if utility is None: + return + + code = '\n'.join(lines) + if tags and 'substitute' in tags and 'naming' in tags['substitute']: + try: + new_code = Template(code).substitute(vars(Naming)) + except (KeyError, ValueError) as e: + raise RuntimeError( + f"Error parsing templated utility code '{name}.{type}' at line {begin_lineno:d}: {e}") + if new_code == code: + raise RuntimeError( + f"Found useless 'substitute: naming' declaration without replacements. ({name}.{type}:{begin_lineno:d})") + code = new_code + + # remember correct line numbers at least until after templating + code = '\n' * begin_lineno + code + + if type == 'proto': + utility[0] = code + elif type == 'impl': + utility[1] = code + else: + all_tags = utility[2] + all_tags[type] = code + + if tags: + all_tags = utility[2] + for name, values in tags.items(): + all_tags.setdefault(name, set()).update(values) + + @classmethod + def load_utilities_from_file(cls, path): + utilities = cls._utility_cache.get(path) + if utilities: + return utilities + + _, ext = os.path.splitext(path) + if ext in ('.pyx', '.py', '.pxd', '.pxi'): + comment = '#' + strip_comments = partial(re.compile(r'^\s*#(?!\s*cython\s*:).*').sub, '') + rstrip = str.rstrip + else: + comment = '/' + strip_comments = partial(re.compile(r'^\s*//.*|/\*[^*]*\*/').sub, '') + rstrip = partial(re.compile(r'\s+(\\?)$').sub, r'\1') + match_special = re.compile( + (r'^%(C)s{5,30}\s*(?P(?:\w|\.)+)\s*%(C)s{5,30}|' + r'^%(C)s+@(?P\w+)\s*:\s*(?P(?:\w|[.:])+)') % + {'C': comment}).match + match_type = re.compile(r'(.+)[.](proto(?:[.]\S+)?|impl|init|cleanup|module_state_decls)$').match + + all_lines = read_utilities_hook(path) + + utilities = defaultdict(lambda: [None, None, {}]) + lines = [] + tags = defaultdict(set) + utility = name = type = None + begin_lineno = 0 + + for lineno, line in enumerate(all_lines): + m = match_special(line) + if m: + if m.group('name'): + cls._add_utility(utility, name, type, lines, begin_lineno, tags) + + begin_lineno = lineno + 1 + del lines[:] + tags.clear() + + name = m.group('name') + mtype = match_type(name) + if mtype: + name, type = mtype.groups() + else: + type = 'impl' + utility = utilities[name] + else: + tags[m.group('tag')].add(m.group('value')) + lines.append('') # keep line number correct + else: + lines.append(rstrip(strip_comments(line))) + + if utility is None: + raise ValueError("Empty utility code file") + + # Don't forget to add the last utility code + cls._add_utility(utility, name, type, lines, begin_lineno, tags) + + utilities = dict(utilities) # un-defaultdict-ify + cls._utility_cache[path] = utilities + return utilities + + @classmethod + def load(cls, util_code_name, from_file, **kwargs): + """ + Load utility code from a file specified by from_file (relative to + Cython/Utility) and name util_code_name. + """ + + if '::' in util_code_name: + from_file, util_code_name = util_code_name.rsplit('::', 1) + assert from_file + utilities = cls.load_utilities_from_file(from_file) + proto, impl, tags = utilities[util_code_name] + + if tags: + if "substitute" in tags and "tempita" in tags["substitute"]: + if not issubclass(cls, TempitaUtilityCode): + return TempitaUtilityCode.load(util_code_name, from_file, **kwargs) + orig_kwargs = kwargs.copy() + for name, values in tags.items(): + if name in kwargs: + continue + # only pass lists when we have to: most argument expect one value or None + if name == 'requires': + if orig_kwargs: + values = [cls.load(dep, from_file, **orig_kwargs) + for dep in sorted(values)] + else: + # dependencies are rarely unique, so use load_cached() when we can + values = [cls.load_cached(dep, from_file) + for dep in sorted(values)] + elif name == 'substitute': + # don't want to pass "naming" or "tempita" to the constructor + # since these will have been handled + values = values - {'naming', 'tempita'} + if not values: + continue + elif not values: + values = None + elif len(values) == 1: + values = list(values)[0] + kwargs[name] = values + + if proto is not None: + kwargs['proto'] = proto + if impl is not None: + kwargs['impl'] = impl + + if 'name' not in kwargs: + kwargs['name'] = util_code_name + + if 'file' not in kwargs and from_file: + kwargs['file'] = from_file + return cls(**kwargs) + + @classmethod + def load_cached(cls, utility_code_name, from_file, __cache={}): + """ + Calls .load(), but using a per-type cache based on utility name and file name. + """ + key = (utility_code_name, from_file, cls) + try: + return __cache[key] + except KeyError: + pass + code = __cache[key] = cls.load(utility_code_name, from_file) + return code + + @classmethod + def load_as_string(cls, util_code_name, from_file, include_requires=False, **kwargs): + """ + Load a utility code as a string. Returns (proto, implementation). + + If 'include_requires=True', concatenates all requirements before the actually + requested utility code, separately for proto and impl part. + + In a lot of cases it may be better to use regular "load" and "CCodeWriter.put_code_here" + since that is able to apply the code transformations to the code too. + """ + util = cls.load(util_code_name, from_file, **kwargs) + + if not include_requires: + return (util.format_code(util.proto), + util.format_code(util.impl)) + + protos, impls = [], [] + def prepend(util_code): + if util_code.requires: + for dep in util_code.requires: + prepend(dep) + if util_code.proto: + protos.append(util_code.format_code(util_code.proto)) + if util_code.impl: + impls.append(util_code.format_code(util_code.impl)) + + prepend(util) + return "".join(protos), "".join(impls) + + def format_code(self, code_string, replace_empty_lines=re.compile(r'\n\n+').sub): + """ + Format a code section for output. + """ + if code_string: + code_string = replace_empty_lines('\n', code_string.strip()) + '\n\n' + return code_string + + def __repr__(self): + return "<%s(%s)>" % (type(self).__name__, self.name) + + def get_tree(self, **kwargs): + return None + + def get_shared_library_scope(self, **kwargs): + return None + + def __deepcopy__(self, memodict=None): + # No need to deep-copy utility code since it's essentially immutable. + return self + + +class UtilityCode(UtilityCodeBase): + """ + Stores utility code to add during code generation. + + See GlobalState.put_utility_code. + + hashes/equals by instance + + proto C prototypes + impl implementation code + init code to call on module initialization + requires utility code dependencies + proto_block the place in the resulting file where the prototype should + end up + name name of the utility code (or None) + file filename of the utility code file this utility was loaded + from (or None) + """ + code_parts = ["proto", "impl", "init", "cleanup", "module_state_decls"] + + def __init__(self, proto=None, impl=None, init=None, cleanup=None, + module_state_decls=None, requires=None, + proto_block='utility_code_proto', name=None, file=None): + # proto_block: Which code block to dump prototype in. See GlobalState. + self.proto = proto + self.impl = impl + self.init = init + self.cleanup = cleanup + self.module_state_decls = module_state_decls + self.requires = requires + self._cache = {} + self.specialize_list = [] + self.proto_block = proto_block + self.name = name + self.file = file + + # cached for use in hash and eq + self._parts_tuple = tuple(getattr(self, part, None) for part in self.code_parts) + + def __hash__(self): + return hash(self._parts_tuple) + + def __eq__(self, other): + if self is other: + return True + self_type, other_type = type(self), type(other) + if self_type is not other_type and not (isinstance(other, self_type) or isinstance(self, other_type)): + return False + + return self._parts_tuple == other._parts_tuple + + def none_or_sub(self, s, context): + """ + Format a string in this utility code with context. If None, do nothing. + """ + if s is None: + return None + return s % context + + def specialize(self, pyrex_type=None, **data): + name = self.name + if pyrex_type is not None: + data['type'] = pyrex_type.empty_declaration_code() + data['type_name'] = pyrex_type.specialization_name() + name = "%s[%s]" % (name, data['type_name']) + # Dicts aren't hashable... + key = tuple(sorted(data.items())) + try: + return self._cache[key] + except KeyError: + if self.requires is None: + requires = None + else: + requires = [r.specialize(data) for r in self.requires] + + s = self._cache[key] = UtilityCode( + self.none_or_sub(self.proto, data), + self.none_or_sub(self.impl, data), + self.none_or_sub(self.init, data), + self.none_or_sub(self.cleanup, data), + self.none_or_sub(self.module_state_decls, data), + requires, + self.proto_block, + name, + ) + + self.specialize_list.append(s) + return s + + def _put_code_section(self, writer: "CCodeWriter", output: "GlobalState", code_type: str): + code_string = getattr(self, code_type) + if not code_string: + return + + can_be_reused = code_type in ('proto', 'impl') + + code_string, result_is_module_specific = process_utility_ccode(self, output, code_string) + + code_type_name = code_type if code_type != 'impl' else '' + writer.putln(f"/* {self.name}{'.' if code_type_name else ''}{code_type_name} */") + + if can_be_reused and not result_is_module_specific: + # can be reused across modules + writer.put_or_include(code_string, f'{self.name}_{code_type}') + else: + writer.put(code_string) + + def _put_init_code_section(self, output): + if not self.init: + return + writer = output['init_globals'] + self._put_code_section(writer, output, 'init') + # 'init' code can end with an 'if' statement for an error condition like: + # if (check_ok()) ; else + writer.putln(writer.error_goto_if_PyErr(output.module_pos)) + writer.putln() + + def put_code(self, output): + if self.requires: + for dependency in self.requires: + output.use_utility_code(dependency) + + if self.proto: + self._put_code_section(output[self.proto_block], output, 'proto') + if self.impl: + self._put_code_section(output['utility_code_def'], output, 'impl') + if self.cleanup and Options.generate_cleanup_code: + self._put_code_section(output['cleanup_globals'], output, 'cleanup') + if self.module_state_decls: + self._put_code_section(output['module_state_contents'], output, 'module_state_decls') + + if self.init: + self._put_init_code_section(output) + + +def add_macro_processor(*macro_names, regex=None, is_module_specific=False, _last_macro_processor = [None]): + """Decorator to chain the code macro processors below. + """ + last_processor = _last_macro_processor[0] + + def build_processor(func): + @wraps(func) + def process(utility_code: UtilityCode, output, code_string: str): + # First, call the processing chain in FIFO function definition order. + result_is_module_specific = False + if last_processor is not None: + code_string, result_is_module_specific = last_processor(utility_code, output, code_string) + + # Detect if we need to do something. + if macro_names: + for macro in macro_names: + if macro in code_string: + break + else: + return code_string, result_is_module_specific + + # Process the code. + if regex is None: + code_string = func(utility_code, output, code_string) + else: + code_string = re.sub(regex, partial(func, output), code_string) + + # Make sure we found and replaced all macro occurrences. + for macro in macro_names: + if macro in code_string: + raise RuntimeError(f"Left-over utility code macro '{macro}()' found in '{utility_code.name}'") + + result_is_module_specific |= is_module_specific + return code_string, result_is_module_specific + + _last_macro_processor[0] = process + return process + + return build_processor + + +@add_macro_processor( + 'CSTRING', + regex=r'CSTRING\(\s*"""([^"]*(?:"[^"]+)*)"""\s*\)', +) +def _wrap_c_string(_, matchobj): + """Replace CSTRING('''xyz''') by a C compatible string, taking care of line breaks. + """ + content = matchobj.group(1).replace('"', r'\042') + return ''.join( + f'"{line}\\n"\n' if not line.endswith('\\') or line.endswith('\\\\') else f'"{line[:-1]}"\n' + for line in content.splitlines()) + + +@add_macro_processor() +def _format_impl_code(utility_code: UtilityCode, _, impl): + return utility_code.format_code(impl) + + +@add_macro_processor( + 'CALL_UNBOUND_METHOD', + is_module_specific=True, + regex=( + r'CALL_UNBOUND_METHOD\(' + r'([a-zA-Z_]+),\s*' # type cname + r'"([^"]+)",\s*' # method name + r'([^),\s]+)' # object cname + r'((?:,[^),]+)*)' # args* + r'\)' + ), +) +def _inject_unbound_method(output, matchobj): + """Replace 'UNBOUND_METHOD(type, "name")' by a constant Python identifier cname. + """ + type_cname, method_name, obj_cname, args = matchobj.groups() + type_cname = '&%s' % type_cname + args = [arg.strip() for arg in args[1:].split(',')] if args else [] + assert len(args) < 3, f"CALL_UNBOUND_METHOD() does not support {len(args):d} call arguments" + return output.cached_unbound_method_call_code( + f"{Naming.modulestateglobal_cname}->", + obj_cname, type_cname, method_name, args) + + +@add_macro_processor( + 'PYIDENT', 'PYUNICODE', + is_module_specific=True, + regex=r'PY(IDENT|UNICODE)\("([^"]+)"\)', +) +def _inject_string_constant(output, matchobj): + """Replace 'PYIDENT("xyz")' by a constant Python identifier cname. + """ + str_type, name = matchobj.groups() + return "%s->%s" % ( + Naming.modulestateglobal_cname, + output.get_py_string_const( + StringEncoding.EncodedString(name), identifier=str_type == 'IDENT').cname) + + +@add_macro_processor( + 'EMPTY', + # As long as we use the same C access macros for these names, they are not module specific. + # is_module_specific=True, + regex=r'EMPTY\((bytes|unicode|tuple)\)', +) +def _inject_empty_collection_constant(output, matchobj): + """Replace 'EMPTY(bytes|tuple|...)' by a constant Python identifier cname. + """ + type_name = matchobj.group(1) + return "%s->%s" % ( + Naming.modulestateglobal_cname, + getattr(Naming, f'empty_{type_name}')) + + +@add_macro_processor( + 'CGLOBAL', # 'NAMED_CGLOBAL', # first is part of second and thus not needed + is_module_specific=False, + regex=r'(NAMED_)?CGLOBAL\(([^)]+)\)', +) +def _inject_cglobal(output, matchobj): + is_named, name = matchobj.groups() + if is_named: + name = getattr(Naming, name) + return f"{Naming.modulestateglobal_cname}->{name}" + + +@add_macro_processor() +def process_utility_ccode(utility_code, _, code_string): + """Entry point for code processors, must be defined last. + """ + return code_string + + +def sub_tempita(s, context, file=None, name=None, __cache={}): + "Run tempita on string s with given context." + if not s: + return None + + if file: + name = f"{file}:{name}" + if name: + context['__name'] = name + + try: + template = __cache[s] + except KeyError: + from ..Tempita import Template + template = __cache[s] = Template(s, name=name) + + return template.substitute(context) + + +class TempitaUtilityCode(UtilityCode): + def __init__(self, name=None, proto=None, impl=None, init=None, file=None, context=None, **kwargs): + if context is None: + context = {} + else: + # prevent changes propagating back if context is shared between multiple utility codes. + context = context.copy() + proto = sub_tempita(proto, context, file, name) + impl = sub_tempita(impl, context, file, name) + init = sub_tempita(init, context, file, name) + super().__init__( + proto, impl, init=init, name=name, file=file, **kwargs) + + @classmethod + def load_cached(cls, utility_code_name, from_file=None, context=None, __cache={}): + context_key = tuple(sorted(context.items())) if context else None + assert hash(context_key) is not None # raise TypeError if not hashable + key = (cls, from_file, utility_code_name, context_key) + try: + return __cache[key] + except KeyError: + pass + code = __cache[key] = cls.load(utility_code_name, from_file, context=context) + return code + + def none_or_sub(self, s, context): + """ + Format a string in this utility code with context. If None, do nothing. + """ + if s is None: + return None + return sub_tempita(s, context, self.file, self.name) + + +class LazyUtilityCode(UtilityCodeBase): + """ + Utility code that calls a callback with the root code writer when + available. Useful when you only have 'env' but not 'code'. + """ + __name__ = '' + requires = None + + def __init__(self, callback): + self.callback = callback + + def put_code(self, globalstate): + utility = self.callback(globalstate.rootwriter) + globalstate.use_utility_code(utility) + + +class FunctionState: + # return_label string function return point label + # error_label string error catch point label + # error_without_exception boolean Can go to the error label without an exception (e.g. __next__ can return NULL) + # continue_label string loop continue point label + # break_label string loop break point label + # return_from_error_cleanup_label string + # label_counter integer counter for naming labels + # exc_vars (string * 3) exception variables for reraise, or None + # can_trace boolean line tracing is supported in the current context + # scope Scope the scope object of the current function + + # Not used for now, perhaps later + def __init__(self, owner, names_taken=set(), scope=None): + self.names_taken = names_taken + self.owner = owner + self.scope = scope + + self.error_label = None + self.label_counter = 0 + self.labels_used = set() + self.return_label = self.new_label() + self.new_error_label() + self.continue_label = None + self.break_label = None + self.yield_labels = [] + + self.exc_vars = None + self.current_except = None + self.can_trace = False + self.gil_owned = True + + self.temps_allocated = [] # of (name, type, manage_ref, static) + self.temps_free = {} # (type, manage_ref) -> list of free vars with same type/managed status + self.temps_used_type = {} # name -> (type, manage_ref) + self.zombie_temps = set() # temps that must not be reused after release + self.temp_counter = 0 + self.closure_temps = None + + # This is used to collect temporaries, useful to find out which temps + # need to be privatized in parallel sections + self.collect_temps_stack = [] + + # This is used for the error indicator, which needs to be local to the + # function. It used to be global, which relies on the GIL being held. + # However, exceptions may need to be propagated through 'nogil' + # sections, in which case we introduce a race condition. + self.should_declare_error_indicator = False + self.uses_error_indicator = False + + self.error_without_exception = False + + self.needs_refnanny = False + + # safety checks + + def validate_exit(self): + # validate that all allocated temps have been freed + if self.temps_allocated: + leftovers = self.temps_in_use() + if leftovers: + msg = "TEMPGUARD: Temps left over at end of '%s': %s" % (self.scope.name, ', '.join([ + '%s [%s]' % (name, ctype) + for name, ctype, is_pytemp in sorted(leftovers)]), + ) + #print(msg) + raise RuntimeError(msg) + + # labels + + def new_label(self, name=None): + n: cython.size_t = self.label_counter + self.label_counter = n + 1 + label = "%s%d" % (Naming.label_prefix, n) + if name is not None: + label += '_' + name + return label + + def new_yield_label(self, expr_type='yield'): + label = self.new_label('resume_from_%s' % expr_type) + num_and_label = (len(self.yield_labels) + 1, label) + self.yield_labels.append(num_and_label) + return num_and_label + + def new_error_label(self, prefix=""): + old_err_lbl = self.error_label + self.error_label = self.new_label(prefix + 'error') + return old_err_lbl + + def get_loop_labels(self): + return ( + self.continue_label, + self.break_label) + + def set_loop_labels(self, labels): + (self.continue_label, + self.break_label) = labels + + def new_loop_labels(self, prefix=""): + old_labels = self.get_loop_labels() + self.set_loop_labels( + (self.new_label(prefix + "continue"), + self.new_label(prefix + "break"))) + return old_labels + + def get_all_labels(self): + return ( + self.continue_label, + self.break_label, + self.return_label, + self.error_label) + + def set_all_labels(self, labels): + (self.continue_label, + self.break_label, + self.return_label, + self.error_label) = labels + + def all_new_labels(self): + old_labels = self.get_all_labels() + new_labels = [] + for old_label, name in zip(old_labels, ['continue', 'break', 'return', 'error']): + if old_label: + new_labels.append(self.new_label(name)) + else: + new_labels.append(old_label) + self.set_all_labels(new_labels) + return old_labels + + def use_label(self, lbl): + self.labels_used.add(lbl) + + def label_used(self, lbl): + return lbl in self.labels_used + + # temp handling + + def allocate_temp(self, type, manage_ref, static=False, reusable=True): + """ + Allocates a temporary (which may create a new one or get a previously + allocated and released one of the same type). Type is simply registered + and handed back, but will usually be a PyrexType. + + If type.needs_refcounting, manage_ref comes into play. If manage_ref is set to + True, the temp will be decref-ed on return statements and in exception + handling clauses. Otherwise the caller has to deal with any reference + counting of the variable. + + If not type.needs_refcounting, then manage_ref will be ignored, but it + still has to be passed. It is recommended to pass False by convention + if it is known that type will never be a reference counted type. + + static=True marks the temporary declaration with "static". + This is only used when allocating backing store for a module-level + C array literals. + + if reusable=False, the temp will not be reused after release. + + A C string referring to the variable is returned. + """ + if type.is_cv_qualified and not type.is_reference: + type = type.cv_base_type + elif type.is_reference and not type.is_fake_reference: + type = type.ref_base_type + elif type.is_cfunction: + from . import PyrexTypes + type = PyrexTypes.c_ptr_type(type) # A function itself isn't an l-value + elif type.is_cpp_class and not type.is_fake_reference and self.scope.directives['cpp_locals']: + self.scope.use_utility_code(UtilityCode.load_cached("OptionalLocals", "CppSupport.cpp")) + if not type.needs_refcounting: + # Make manage_ref canonical, so that manage_ref will always mean + # a decref is needed. + manage_ref = False + + freelist = self.temps_free.get((type, manage_ref)) + if reusable and freelist is not None and freelist[0]: + result = freelist[0].pop() + freelist[1].remove(result) + else: + while True: + self.temp_counter += 1 + result = "%s%d" % (Naming.codewriter_temp_prefix, self.temp_counter) + if result not in self.names_taken: break + self.temps_allocated.append((result, type, manage_ref, static)) + if not reusable: + self.zombie_temps.add(result) + self.temps_used_type[result] = (type, manage_ref) + if DebugFlags.debug_temp_code_comments: + self.owner.putln("/* %s allocated (%s)%s */" % (result, type, "" if reusable else " - zombie")) + + if self.collect_temps_stack: + self.collect_temps_stack[-1].add((result, type)) + + return result + + def release_temp(self, name): + """ + Releases a temporary so that it can be reused by other code needing + a temp of the same type. + """ + type, manage_ref = self.temps_used_type[name] + freelist = self.temps_free.get((type, manage_ref)) + if freelist is None: + freelist = ([], set()) # keep order in list and make lookups in set fast + self.temps_free[(type, manage_ref)] = freelist + if name in freelist[1]: + raise RuntimeError("Temp %s freed twice!" % name) + if name not in self.zombie_temps: + freelist[0].append(name) + freelist[1].add(name) + if DebugFlags.debug_temp_code_comments: + self.owner.putln("/* %s released %s*/" % ( + name, " - zombie" if name in self.zombie_temps else "")) + + def temps_in_use(self): + """Return a list of (cname,type,manage_ref) tuples of temp names and their type + that are currently in use. + """ + used = [] + for name, type, manage_ref, static in self.temps_allocated: + freelist = self.temps_free.get((type, manage_ref)) + if freelist is None or name not in freelist[1]: + used.append((name, type, manage_ref and type.needs_refcounting)) + return used + + def temps_holding_reference(self): + """Return a list of (cname,type) tuples of temp names and their type + that are currently in use. This includes only temps + with a reference counted type which owns its reference. + """ + return [(name, type) + for name, type, manage_ref in self.temps_in_use() + if manage_ref and type.needs_refcounting] + + def all_managed_temps(self): + """Return a list of (cname, type) tuples of refcount-managed Python objects. + """ + return [(cname, type) + for cname, type, manage_ref, static in self.temps_allocated + if manage_ref] + + def all_free_managed_temps(self): + """Return a list of (cname, type) tuples of refcount-managed Python + objects that are not currently in use. This is used by + try-except and try-finally blocks to clean up temps in the + error case. + """ + return sorted([ # Enforce deterministic order. + (cname, type) + for (type, manage_ref), freelist in self.temps_free.items() if manage_ref + for cname in freelist[0] + ]) + + def start_collecting_temps(self): + """ + Useful to find out which temps were used in a code block + """ + self.collect_temps_stack.append(set()) + + def stop_collecting_temps(self): + return self.collect_temps_stack.pop() + + def init_closure_temps(self, scope): + self.closure_temps = ClosureTempAllocator(scope) + + +class NumConst: + """Global info about a Python number constant held by GlobalState. + + cname string + value string + py_type string int, long, float + value_code string evaluation code if different from value + """ + + def __init__(self, cname, value, py_type, value_code=None): + self.cname = cname + self.value = value + self.py_type = py_type + self.value_code = value_code or value + + +class PyObjectConst: + """Global info about a generic constant held by GlobalState. + """ + # cname string + # type PyrexType + + def __init__(self, cname, type): + self.cname = cname + self.type = type + + +cython.declare(possible_unicode_identifier=object, possible_bytes_identifier=object, + replace_identifier=object, find_alphanums=object) +possible_unicode_identifier = re.compile(r"(?![0-9])\w+$", re.U).match +possible_bytes_identifier = re.compile(br"(?![0-9])\w+$").match +replace_identifier = re.compile(r'[^a-zA-Z0-9_]+').sub +find_alphanums = re.compile('([a-zA-Z0-9]+)').findall + +class StringConst: + """Global info about a C string constant held by GlobalState. + """ + # cname string + # text EncodedString or BytesLiteral + # py_strings {(identifier, encoding) : PyStringConst} + + def __init__(self, cname, text, byte_string): + self.cname = cname + self.text = text + self.escaped_value = StringEncoding.escape_byte_string(byte_string) + self.py_strings = None + + def get_py_string_const(self, encoding, identifier=None): + text = self.text + intern: cython.bint + is_unicode: cython.bint + + if identifier or encoding is None: + # unicode string + encoding = encoding_key = None + is_unicode = True + else: + # bytes + is_unicode = False + encoding = encoding.lower() + if encoding in ('utf8', 'utf-8', 'ascii', 'usascii', 'us-ascii'): + encoding = None + encoding_key = None + else: + encoding_key = ''.join(find_alphanums(encoding)) + + if identifier: + intern = True + elif identifier is None: + if isinstance(text, bytes): + intern = bool(possible_bytes_identifier(text)) + else: + intern = bool(possible_unicode_identifier(text)) + else: + intern = False + + key = (intern, is_unicode, encoding_key) + if self.py_strings is None: + self.py_strings = {} + else: + try: + return self.py_strings[key] + except KeyError: + pass + + pystring_cname = ( + f"{Naming.interned_prefixes['str'] if intern else Naming.py_const_prefix}" + f"{'u' if is_unicode else 'b'}" + f"{'_' + encoding_key if encoding_key else ''}" + f"_{self.cname[len(Naming.const_prefix):]}" + ) + + py_string = PyStringConst(pystring_cname, encoding, intern, is_unicode) + self.py_strings[key] = py_string + return py_string + + +class PyStringConst: + """Global info about a Python string constant held by GlobalState. + """ + # cname string + # encoding string + # intern boolean + # is_unicode boolean + + def __init__(self, cname, encoding, intern=False, is_unicode=False): + self.cname = cname + self.encoding = encoding + self.is_unicode = is_unicode + self.intern = intern + + def __lt__(self, other): + return self.cname < other.cname + + +class GlobalState: + # filename_table {string : int} for finding filename table indexes + # filename_list [string] filenames in filename table order + # input_file_contents dict contents (=list of lines) of any file that was used as input + # to create this output C code. This is + # used to annotate the comments. + # + # utility_codes set IDs of used utility code (to avoid reinsertion) + # + # declared_cnames {string:Entry} used in a transition phase to merge pxd-declared + # constants etc. into the pyx-declared ones (i.e, + # check if constants are already added). + # In time, hopefully the literals etc. will be + # supplied directly instead. + # + # const_cnames_used dict global counter for unique constant identifiers + # + + # parts {string:CCodeWriter} + + + # interned_strings + # consts + # interned_nums + + # directives set Temporary variable used to track + # the current set of directives in the code generation + # process. + + directives = {} + + code_layout = [ + 'h_code', + 'filename_table', + 'utility_code_proto_before_types', + 'numeric_typedefs', # Let these detailed individual parts stay!, + 'complex_type_declarations', # as the proper solution is to make a full DAG... + 'type_declarations', # More coarse-grained blocks would simply hide + 'utility_code_proto', # the ugliness, not fix it + 'module_declarations', + 'typeinfo', + 'before_global_var', + 'global_var', + 'string_decls', + 'decls', + 'late_includes', + 'module_state', + 'module_state_contents', # can be used to inject declarations into the modulestate struct + 'module_state_end', + 'constant_name_defines', + 'module_state_clear', + 'module_state_traverse', + 'module_code', # user code goes here + 'module_exttypes', + 'initfunc_declarations', + 'init_module', + 'pystring_table', + 'cached_builtins', + 'cached_constants', + 'init_constants', + 'init_codeobjects', + 'init_globals', # (utility code called at init-time) + 'cleanup_globals', + 'cleanup_module', + 'main_method', + 'utility_code_pragmas', # silence some irrelevant warnings in utility code + 'utility_code_def', + 'utility_code_pragmas_end', # clean-up the utility_code_pragmas + 'end' + ] + + # h files can only have a much smaller list of sections + h_code_layout = [ + 'h_code', + 'utility_code_proto_before_types', + 'type_declarations', + 'utility_code_proto', + 'end' + ] + + def __init__(self, writer, module_node, code_config, common_utility_include_dir=None): + self.filename_table = {} + self.filename_list = [] + self.input_file_contents = {} + self.utility_codes = set() + self.declared_cnames = {} + self.in_utility_code_generation = False + self.code_config = code_config + self.common_utility_include_dir = common_utility_include_dir + self.parts = {} + self.module_node = module_node # because some utility code generation needs it + # (generating backwards-compatible Get/ReleaseBuffer + + self.const_cnames_used = {} + self.string_const_index = {} + self.dedup_const_index = {} + self.pyunicode_ptr_const_index = {} + self.codeobject_constants = [] + self.num_const_index = {} + self.arg_default_constants = [] + self.const_array_counters = {} # counts of differently prefixed arrays of constants + self.cached_cmethods = {} + self.initialised_constants = set() + + writer.set_global_state(self) + self.rootwriter = writer + + def initialize_main_c_code(self): + rootwriter = self.rootwriter + for i, part in enumerate(self.code_layout): + w = self.parts[part] = rootwriter.insertion_point() + if i > 0: + w.putln("/* #### Code section: %s ### */" % part) + + if not Options.cache_builtins: + del self.parts['cached_builtins'] + else: + w = self.parts['cached_builtins'] + w.start_initcfunc( + "int __Pyx_InitCachedBuiltins(" + f"{Naming.modulestatetype_cname} *{Naming.modulestatevalue_cname})") + w.putln(f"CYTHON_UNUSED_VAR({Naming.modulestatevalue_cname});") + + w = self.parts['cached_constants'] + w.start_initcfunc( + "int __Pyx_InitCachedConstants(" + f"{Naming.modulestatetype_cname} *{Naming.modulestatevalue_cname})", + refnanny=True) + w.putln(f"CYTHON_UNUSED_VAR({Naming.modulestatevalue_cname});") + w.put_setup_refcount_context(StringEncoding.EncodedString("__Pyx_InitCachedConstants")) + + w = self.parts['init_globals'] + w.start_initcfunc("int __Pyx_InitGlobals(void)") + + w = self.parts['init_constants'] + w.start_initcfunc( + "int __Pyx_InitConstants(" + f"{Naming.modulestatetype_cname} *{Naming.modulestatevalue_cname})") + w.putln(f"CYTHON_UNUSED_VAR({Naming.modulestatevalue_cname});") + + if not Options.generate_cleanup_code: + del self.parts['cleanup_globals'] + else: + w = self.parts['cleanup_globals'] + w.start_initcfunc( + "void __Pyx_CleanupGlobals(" + f"{Naming.modulestatetype_cname} *{Naming.modulestatevalue_cname})") + w.putln(f"CYTHON_UNUSED_VAR({Naming.modulestatevalue_cname});") + + code = self.parts['utility_code_proto'] + code.putln("") + code.putln("/* --- Runtime support code (head) --- */") + + code = self.parts['utility_code_def'] + if self.code_config.emit_linenums: + code.write('\n#line 1 "cython_utility"\n') + code.putln("") + code.putln("/* --- Runtime support code --- */") + + def initialize_main_h_code(self): + rootwriter = self.rootwriter + for part in self.h_code_layout: + self.parts[part] = rootwriter.insertion_point() + + def finalize_main_c_code(self): + self.close_global_decls() + + # + # utility_code_def + # + code = self.parts['utility_code_def'] + util = TempitaUtilityCode.load_cached("TypeConversions", "TypeConversion.c") + code.put(util.format_code(util.impl)) + code.putln("") + + # + # utility code pragmas + # + code = self.parts['utility_code_pragmas'] + util = UtilityCode.load_cached("UtilityCodePragmas", "ModuleSetupCode.c") + code.putln(util.format_code(util.impl)) + code.putln("") + code = self.parts['utility_code_pragmas_end'] + util = UtilityCode.load_cached("UtilityCodePragmasEnd", "ModuleSetupCode.c") + code.putln(util.format_code(util.impl)) + code.putln("") + + def __getitem__(self, key): + return self.parts[key] + + # + # Global constants, interned objects, etc. + # + def close_global_decls(self): + # This is called when it is known that no more global declarations will + # declared. + self.generate_const_declarations() + if Options.cache_builtins: + w = self.parts['cached_builtins'] + w.putln("return 0;") + if w.label_used(w.error_label): + w.put_label(w.error_label) + w.putln("return -1;") + w.putln("}") + w.exit_cfunc_scope() + + w = self.parts['cached_constants'] + w.put_finish_refcount_context() + w.putln("return 0;") + if w.label_used(w.error_label): + w.put_label(w.error_label) + w.put_finish_refcount_context() + w.putln("return -1;") + w.putln("}") + w.exit_cfunc_scope() + + for part in ['init_globals', 'init_constants']: + w = self.parts[part] + w.putln("return 0;") + if w.label_used(w.error_label): + w.put_label(w.error_label) + w.putln("return -1;") + w.putln("}") + w.exit_cfunc_scope() + + if Options.generate_cleanup_code: + w = self.parts['cleanup_globals'] + w.putln("}") + w.exit_cfunc_scope() + + if Options.generate_cleanup_code: + w = self.parts['cleanup_module'] + w.putln("}") + w.exit_cfunc_scope() + + def put_pyobject_decl(self, entry): + self['global_var'].putln("static PyObject *%s;" % entry.cname) + + # constant handling at code generation time + + def get_cached_constants_writer(self, target=None): + if target is not None: + if target in self.initialised_constants: + # Return None on second/later calls to prevent duplicate creation code. + return None + self.initialised_constants.add(target) + return self.parts['cached_constants'] + + def get_int_const(self, str_value, longness=False): + py_type = longness and 'long' or 'int' + try: + c = self.num_const_index[(str_value, py_type)] + except KeyError: + c = self.new_num_const(str_value, py_type) + return c + + def get_float_const(self, str_value, value_code): + try: + c = self.num_const_index[(str_value, 'float')] + except KeyError: + c = self.new_num_const(str_value, 'float', value_code) + return c + + def get_py_const(self, prefix, dedup_key=None): + if dedup_key is not None: + const = self.dedup_const_index.get(dedup_key) + if const is not None: + return const + const = self.new_array_const_cname(prefix) + if dedup_key is not None: + self.dedup_const_index[dedup_key] = const + return const + + def get_argument_default_const(self, type): + cname = self.new_const_cname('') + c = PyObjectConst(cname, type) + self.arg_default_constants.append(c) + # Argument default constants aren't currently cleaned up. + # If that changes, it needs to account for the fact that they + # aren't just Python objects + return c + + def get_string_const(self, text): + # return a C string constant, creating a new one if necessary + if text.is_unicode: + byte_string = text.utf8encode() + else: + byte_string = text.byteencode() + try: + c = self.string_const_index[byte_string] + except KeyError: + c = self.new_string_const(text, byte_string) + return c + + def get_pyunicode_ptr_const(self, text): + # return a Py_UNICODE[] constant, creating a new one if necessary + assert text.is_unicode + try: + c = self.pyunicode_ptr_const_index[text] + except KeyError: + c = self.pyunicode_ptr_const_index[text] = self.new_const_cname() + return c + + def get_py_string_const(self, text, identifier=None): + # return a Python string constant, creating a new one if necessary + c_string = self.get_string_const(text) + py_string = c_string.get_py_string_const(text.encoding, identifier) + return py_string + + def get_py_codeobj_const(self, node): + idx = len(self.codeobject_constants) + name = f"{Naming.codeobjtab_cname}[{idx}]" + self.codeobject_constants.append(node) + return name + + def get_interned_identifier(self, text): + return self.get_py_string_const(text, identifier=True) + + def new_string_const(self, text, byte_string): + cname = self.new_string_const_cname(byte_string) + c = StringConst(cname, text, byte_string) + self.string_const_index[byte_string] = c + return c + + def new_num_const(self, value, py_type, value_code=None): + cname = self.new_num_const_cname(value, py_type) + c = NumConst(cname, value, py_type, value_code) + self.num_const_index[(value, py_type)] = c + return c + + def new_string_const_cname(self, bytes_value): + # Create a new globally-unique nice name for a C string constant. + value = bytes_value.decode('ASCII', 'ignore') + return self.new_const_cname(value=value) + + def unique_const_cname(self, format_str): # type: (str) -> str + used = self.const_cnames_used + cname = value = format_str.format(sep='', counter='') + while cname in used: + counter = used[value] = used[value] + 1 + cname = format_str.format(sep='_', counter=counter) + used[cname] = 1 + return cname + + def new_num_const_cname(self, value, py_type): # type: (str, str) -> str + if py_type == 'long': + value += 'L' + py_type = 'int' + prefix = Naming.interned_prefixes[py_type] + + value = value.replace('.', '_').replace('+', '_').replace('-', 'neg_') + if len(value) > 42: + # update tests/run/large_integer_T5290.py in case the amount is changed + cname = self.unique_const_cname( + prefix + "large{counter}_" + value[:18] + "_xxx_" + value[-18:]) + else: + cname = "%s%s" % (prefix, value) + return cname + + def new_const_cname(self, prefix='', value=''): + value = replace_identifier('_', value)[:32].strip('_') + name_suffix = self.unique_const_cname(value + "{sep}{counter}") + if prefix: + prefix = Naming.interned_prefixes[prefix] + else: + prefix = Naming.const_prefix + return "%s%s" % (prefix, name_suffix) + + def new_array_const_cname(self, prefix: str): + count = self.const_array_counters.get(prefix, 0) + self.const_array_counters[prefix] = count+1 + return f"{Naming.pyrex_prefix}{prefix}[{count}]" + + def get_cached_unbound_method(self, type_cname, method_name): + key = (type_cname, method_name) + try: + cname = self.cached_cmethods[key] + except KeyError: + cname = self.cached_cmethods[key] = self.new_const_cname( + 'umethod', '%s_%s' % (type_cname, method_name)) + return cname + + def cached_unbound_method_call_code(self, modulestate_cname, obj_cname, type_cname, method_name, arg_cnames): + # admittedly, not the best place to put this method, but it is reused by UtilityCode and ExprNodes ... + utility_code_name = "CallUnboundCMethod%d" % len(arg_cnames) + self.use_utility_code(UtilityCode.load_cached(utility_code_name, "ObjectHandling.c")) + cache_cname = self.get_cached_unbound_method(type_cname, method_name) + args = [obj_cname] + arg_cnames + return "__Pyx_%s(&%s%s, %s)" % ( + utility_code_name, + modulestate_cname, + cache_cname, + ', '.join(args), + ) + + def add_cached_builtin_decl(self, entry): + if entry.is_builtin and entry.is_const: + if self.should_declare(entry.cname, entry): + self.put_pyobject_decl(entry) + name = entry.name + if name in renamed_py2_builtins_map: + name = renamed_py2_builtins_map[name] + self.put_cached_builtin_init( + entry.pos, StringEncoding.EncodedString(name), + entry.cname) + + def put_cached_builtin_init(self, pos, name, cname): + w = self.parts['cached_builtins'] + cname_in_modulestate = w.name_in_main_c_code_module_state( + self.get_interned_identifier(name).cname) + self.use_utility_code( + UtilityCode.load_cached("GetBuiltinName", "ObjectHandling.c")) + w.putln('%s = __Pyx_GetBuiltinName(%s); if (!%s) %s' % ( + cname, + cname_in_modulestate, + cname, + w.error_goto(pos))) + + def generate_const_declarations(self): + self.generate_cached_methods_decls() + self.generate_object_constant_decls() + self.generate_codeobject_constants() + # generate code for string and numeric constants as late as possible + # to allow new constants be to created by the earlier stages. + # (although the constants themselves are written early) + self.generate_string_constants() + self.generate_num_constants() + + def _generate_module_array_traverse_and_clear(self, struct_attr_cname, count, may_have_refcycles=True): + counter_type = 'int' if count < 2**15 else 'Py_ssize_t' + visit_call = "Py_VISIT" if may_have_refcycles else "__Pyx_VISIT_CONST" + + writer = self.parts['module_state_traverse'] + writer.putln(f"for ({counter_type} i=0; i<{count}; ++i) {{ {visit_call}(traverse_module_state->{struct_attr_cname}[i]); }}") + + writer = self.parts['module_state_clear'] + writer.putln(f"for ({counter_type} i=0; i<{count}; ++i) {{ Py_CLEAR(clear_module_state->{struct_attr_cname}[i]); }}") + + def generate_object_constant_decls(self): + consts = [(len(c.cname), c.cname, c) + for c in self.arg_default_constants] + consts.sort() + for _, cname, c in consts: + self.parts['module_state'].putln("%s;" % c.type.declaration_code(cname)) + if not c.type.needs_refcounting: + # Note that py_constants is used for all argument defaults + # which aren't necessarily PyObjects, so aren't appropriate + # to clear. + continue + + self.parts['module_state_clear'].put_xdecref_clear( + f"clear_module_state->{cname}", + c.type, + clear_before_decref=True, + nanny=False, + ) + + if c.type.is_memoryviewslice: + # TODO: Implement specific to type like CodeWriter.put_xdecref_clear() + cname += "->memview" + + self.parts['module_state_traverse'].putln( + f"Py_VISIT(traverse_module_state->{cname});") + + for prefix, count in sorted(self.const_array_counters.items()): + struct_attr_cname = f"{Naming.pyrex_prefix}{prefix}" + self.parts['module_state'].putln(f"PyObject *{struct_attr_cname}[{count}];") + + # The constant tuples/slices that we create can never participate in reference cycles. + self._generate_module_array_traverse_and_clear(struct_attr_cname, count, may_have_refcycles=False) + + cleanup_level = cleanup_level_for_type_prefix(prefix) + if cleanup_level is not None and cleanup_level <= Options.generate_cleanup_code: + part_writer = self.parts['cleanup_globals'] + part_writer.put(f"for (size_t i=0; i<{count}; ++i) ") + part_writer.putln( + "{ Py_CLEAR(%s); }" % + part_writer.name_in_main_c_code_module_state(f"{struct_attr_cname}[i]") + ) + + def generate_cached_methods_decls(self): + if not self.cached_cmethods: + return + + decl = self.parts['module_state'] + init = self.parts['init_constants'] + cnames = [] + for (type_cname, method_name), cname in sorted(self.cached_cmethods.items()): + cnames.append(cname) + method_name_cname = self.get_interned_identifier(StringEncoding.EncodedString(method_name)).cname + decl.putln('__Pyx_CachedCFunction %s;' % ( + cname)) + # split type reference storage as it might not be static + init.putln('%s.type = (PyObject*)%s;' % ( + init.name_in_main_c_code_module_state(cname), type_cname)) + # method name string isn't static in limited api + init.putln( + f'{init.name_in_main_c_code_module_state(cname)}.method_name = ' + f'&{init.name_in_main_c_code_module_state(method_name_cname)};') + + if Options.generate_cleanup_code: + cleanup = self.parts['cleanup_globals'] + for cname in cnames: + cleanup.putln(f"Py_CLEAR({init.name_in_main_c_code_module_state(cname)}.method);") + + def generate_string_constants(self): + c_consts = [(len(c.cname), c.cname, c) for c in self.string_const_index.values()] + c_consts.sort() + py_strings = [] + longest_pystring = 0 + encodings = set() + + def normalise_encoding_name(py_string): + if py_string.encoding and py_string.encoding not in ( + 'ASCII', 'USASCII', 'US-ASCII', 'UTF8', 'UTF-8'): + return f'"{py_string.encoding.lower()}"' + else: + return '0' + + decls_writer = self.parts['string_decls'] + for _, cname, c in c_consts: + cliteral = StringEncoding.split_string_literal(c.escaped_value) + decls_writer.putln( + f'static const char {cname}[] = "{cliteral}";', + safe=True) # Braces in user strings are not for indentation. + if c.py_strings is not None: + if len(c.escaped_value) > longest_pystring: + # This is not an accurate count since it adds up C escape characters, + # but it's probably good enough for an upper bound. + longest_pystring = len(c.escaped_value) + for py_string in c.py_strings.values(): + encodings.add(normalise_encoding_name(py_string)) + py_strings.append((c.cname, len(py_string.cname), py_string)) + + for c, cname in sorted(self.pyunicode_ptr_const_index.items()): + utf16_array, utf32_array = StringEncoding.encode_pyunicode_string(c) + if utf16_array: + # Narrow and wide representations differ + decls_writer.putln("#ifdef Py_UNICODE_WIDE") + decls_writer.putln("static Py_UNICODE %s[] = { %s };" % (cname, utf32_array)) + if utf16_array: + decls_writer.putln("#else") + decls_writer.putln("static Py_UNICODE %s[] = { %s };" % (cname, utf16_array)) + decls_writer.putln("#endif") + + if not py_strings: + return + + py_strings.sort() + + w = self.parts['pystring_table'] + w.putln("") + + # We use only type size macros from "pyport.h" here. + w.put(textwrap.dedent("""\ + typedef struct { + const char *s; + #if %(max_length)d <= 65535 + const unsigned short n; + #elif %(max_length)d / 2 < INT_MAX + const unsigned int n; + #elif %(max_length)d / 2 < LONG_MAX + const unsigned long n; + #else + const Py_ssize_t n; + #endif + #if %(num_encodings)d <= 31 + const unsigned int encoding : 5; + #elif %(num_encodings)d <= 255 + const unsigned char encoding; + #elif %(num_encodings)d <= 65535 + const unsigned short encoding; + #else + const Py_ssize_t encoding; + #endif + const unsigned int is_unicode : 1; + const unsigned int intern : 1; + } __Pyx_StringTabEntry; + """ % dict( + max_length=longest_pystring, + num_encodings=len(encodings), + ))) + + py_string_count = len(py_strings) + self.parts['module_state'].putln(f"PyObject *{Naming.stringtab_cname}[{py_string_count}];") + self._generate_module_array_traverse_and_clear(Naming.stringtab_cname, py_string_count, may_have_refcycles=False) + + encodings = sorted(encodings) + encodings.sort(key=len) # stable sort to make sure '0' comes first, index 0 + assert not encodings or '0' not in encodings or encodings[0] == '0', encodings + encodings_map = {encoding: i for i, encoding in enumerate(encodings)} + w.putln("static const char * const %s[] = { %s };" % ( + Naming.stringtab_encodings_cname, + ', '.join(encodings), + )) + + w.putln("static const __Pyx_StringTabEntry %s[] = {" % Naming.stringtab_cname) + for n, (c_cname, _, py_string) in enumerate(py_strings): + encodings_index = encodings_map[normalise_encoding_name(py_string)] + is_unicode = py_string.is_unicode + + self.parts['constant_name_defines'].putln("#define %s %s[%s]" % ( + py_string.cname, + Naming.stringtab_cname, + n)) + + w.putln("{%s, sizeof(%s), %d, %d, %d}, /* PyObject cname: %s */" % ( + c_cname, + c_cname, + encodings_index, + is_unicode, + py_string.intern, + py_string.cname + )) + w.putln("{0, 0, 0, 0, 0}") + w.putln("};") + + self.use_utility_code(UtilityCode.load_cached("InitStrings", "StringTools.c")) + + init_constants = self.parts['init_constants'] + init_constants.putln( + "if (__Pyx_InitStrings(%s, %s, %s) < 0) %s;" % ( + Naming.stringtab_cname, + init_constants.name_in_main_c_code_module_state(Naming.stringtab_cname), + Naming.stringtab_encodings_cname, + init_constants.error_goto(self.module_pos))) + + def generate_codeobject_constants(self): + w = self.parts['init_codeobjects'] + init_function = ( + f"int __Pyx_CreateCodeObjects({Naming.modulestatetype_cname} *{Naming.modulestatevalue_cname})" + ) + + if not self.codeobject_constants: + w.start_initcfunc(init_function) + w.putln(f"CYTHON_UNUSED_VAR({Naming.modulestatevalue_cname});") + w.putln("return 0;") + w.exit_cfunc_scope() + w.putln("}") + return + + # Create a downsized config struct and build code objects from it. + max_flags = 0x3ff # to be adapted when we start using new flags + max_func_args = 1 + max_kwonly_args = 1 + max_posonly_args = 1 + max_vars = 1 + max_line = 1 + max_positions = 1 + for node in self.codeobject_constants: + def_node = node.def_node + if not def_node.is_generator_expression: + max_func_args = max(max_func_args, len(def_node.args) - def_node.num_kwonly_args) + max_kwonly_args = max(max_kwonly_args, def_node.num_kwonly_args) + max_posonly_args = max(max_posonly_args, def_node.num_posonly_args) + max_vars = max(max_vars, len(node.varnames)) + max_line = max(max_line, def_node.pos[1]) + max_positions = max(max_positions, len(def_node.node_positions)) + + # Even for full 64-bit line/column values, one entry in the line table can never be larger than 45 bytes. + max_linetable_len = max_positions * 47 + + w.put(textwrap.dedent(f"""\ + typedef struct {{ + unsigned int argcount : {max_func_args.bit_length()}; + unsigned int num_posonly_args : {max_posonly_args.bit_length()}; + unsigned int num_kwonly_args : {max_kwonly_args.bit_length()}; + unsigned int nlocals : {max_vars.bit_length()}; + unsigned int flags : {max_flags.bit_length()}; + unsigned int first_line : {max_line.bit_length()}; + unsigned int line_table_length : {max_linetable_len.bit_length()}; + }} __Pyx_PyCode_New_function_description; + """)) + + self.use_utility_code(UtilityCode.load_cached("NewCodeObj", "ModuleSetupCode.c")) + + w.start_initcfunc(init_function) + + w.putln("PyObject* tuple_dedup_map = PyDict_New();") + w.putln("if (unlikely(!tuple_dedup_map)) return -1;") + + for node in self.codeobject_constants: + node.generate_codeobj(w, "bad") + + w.putln("Py_DECREF(tuple_dedup_map);") + w.putln("return 0;") + + w.putln("bad:") + w.putln("Py_DECREF(tuple_dedup_map);") + w.putln("return -1;") + w.exit_cfunc_scope() + w.putln("}") + + code_object_count = len(self.codeobject_constants) + self.parts['module_state'].putln(f"PyObject *{Naming.codeobjtab_cname}[{code_object_count}];") + # The code objects that we generate only contain plain constants and can never participate in reference cycles. + self._generate_module_array_traverse_and_clear(Naming.codeobjtab_cname, code_object_count, may_have_refcycles=False) + + def generate_num_constants(self): + consts = [(c.py_type, c.value[0] == '-', len(c.value), c.value, c.value_code, c) + for c in self.num_const_index.values()] + consts.sort() + init_constants = self.parts['init_constants'] + for py_type, _, _, value, value_code, c in consts: + cname = c.cname + self.parts['module_state'].putln("PyObject *%s;" % cname) + self.parts['module_state_clear'].putln( + "Py_CLEAR(clear_module_state->%s);" % cname) + self.parts['module_state_traverse'].putln( + "__Pyx_VISIT_CONST(traverse_module_state->%s);" % cname) + if py_type == 'float': + function = 'PyFloat_FromDouble(%s)' + elif py_type == 'long': + function = 'PyLong_FromString("%s", 0, 0)' + elif Utils.long_literal(value): + function = 'PyLong_FromString("%s", 0, 0)' + elif len(value.lstrip('-')) > 4: + function = "PyLong_FromLong(%sL)" + else: + function = "PyLong_FromLong(%s)" + init_cname = init_constants.name_in_main_c_code_module_state(cname) + init_constants.putln('%s = %s; %s' % ( + init_cname, function % value_code, + init_constants.error_goto_if_null(init_cname, self.module_pos))) + + # The functions below are there in a transition phase only + # and will be deprecated. They are called from Nodes.BlockNode. + # The copy&paste duplication is intentional in order to be able + # to see quickly how BlockNode worked, until this is replaced. + + def should_declare(self, cname, entry): + if cname in self.declared_cnames: + other = self.declared_cnames[cname] + assert str(entry.type) == str(other.type) + assert entry.init == other.init + return False + else: + self.declared_cnames[cname] = entry + return True + + # + # File name state + # + + def lookup_filename(self, source_desc): + entry = source_desc.get_filenametable_entry() + try: + index = self.filename_table[entry] + except KeyError: + index = len(self.filename_list) + self.filename_list.append(source_desc) + self.filename_table[entry] = index + return index + + def commented_file_contents(self, source_desc): + try: + return self.input_file_contents[source_desc] + except KeyError: + pass + source_file = source_desc.get_lines(encoding='ASCII', + error_handling='ignore') + try: + F = [' * ' + line.rstrip().replace( + '*/', '*[inserted by cython to avoid comment closer]/' + ).replace( + '/*', '/[inserted by cython to avoid comment start]*' + ) + for line in source_file] + finally: + if hasattr(source_file, 'close'): + source_file.close() + if not F: F.append('') + self.input_file_contents[source_desc] = F + return F + + # + # Utility code state + # + + def use_utility_code(self, utility_code): + """ + Adds code to the C file. utility_code should + a) implement __eq__/__hash__ for the purpose of knowing whether the same + code has already been included + b) implement put_code, which takes a globalstate instance + + See UtilityCode. + """ + if utility_code and utility_code not in self.utility_codes: + self.utility_codes.add(utility_code) + utility_code.put_code(self) + + def use_entry_utility_code(self, entry): + if entry is None: + return + if entry.utility_code: + self.use_utility_code(entry.utility_code) + if entry.utility_code_definition: + self.use_utility_code(entry.utility_code_definition) + + +def funccontext_property(func): + name = func.__name__ + attribute_of = operator.attrgetter(name) + def get(self): + return attribute_of(self.funcstate) + def set(self, value): + setattr(self.funcstate, name, value) + return property(get, set) + + +class CCodeConfig: + # emit_linenums boolean write #line pragmas? + # emit_code_comments boolean copy the original code into C comments? + # c_line_in_traceback boolean append the c file and line number to the traceback for exceptions? + + def __init__(self, emit_linenums=True, emit_code_comments=True, c_line_in_traceback=True): + self.emit_code_comments = emit_code_comments + self.emit_linenums = emit_linenums + self.c_line_in_traceback = c_line_in_traceback + + +class CCodeWriter: + """ + Utility class to output C code. + + When creating an insertion point one must care about the state that is + kept: + - formatting state (level, bol) is cloned and used in insertion points + as well + - labels, temps, exc_vars: One must construct a scope in which these can + exist by calling enter_cfunc_scope/exit_cfunc_scope (these are for + sanity checking and forward compatibility). Created insertion points + looses this scope and cannot access it. + - marker: Not copied to insertion point + - filename_table, filename_list, input_file_contents: All codewriters + coming from the same root share the same instances simultaneously. + """ + + # f file output file + # buffer StringIOTree + + # level int indentation level + # bol bool beginning of line? + # marker string comment to emit before next line + # funcstate FunctionState contains state local to a C function used for code + # generation (labels and temps state etc.) + # globalstate GlobalState contains state global for a C file (input file info, + # utility code, declared constants etc.) + # pyclass_stack list used during recursive code generation to pass information + # about the current class one is in + # code_config CCodeConfig configuration options for the C code writer + + @cython.locals(create_from='CCodeWriter') + def __init__(self, create_from=None, buffer=None, copy_formatting=False): + if buffer is None: buffer = StringIOTree() + self.buffer = buffer + self.last_pos = None + self.last_marked_pos = None + self.pyclass_stack = [] + + self.funcstate = None + self.globalstate = None + self.code_config = None + self.level = 0 + self.call_level = 0 + self.bol = 1 + + if create_from is not None: + # Use same global state + self.set_global_state(create_from.globalstate) + self.funcstate = create_from.funcstate + # Clone formatting state + if copy_formatting: + self.level = create_from.level + self.bol = create_from.bol + self.call_level = create_from.call_level + self.last_pos = create_from.last_pos + self.last_marked_pos = create_from.last_marked_pos + + def create_new(self, create_from, buffer, copy_formatting): + # polymorphic constructor -- very slightly more versatile + # than using __class__ + result = CCodeWriter(create_from, buffer, copy_formatting) + return result + + def set_global_state(self, global_state): + assert self.globalstate is None # prevent overwriting once it's set + self.globalstate = global_state + self.code_config = global_state.code_config + + def copyto(self, f): + self.buffer.copyto(f) + + def getvalue(self): + return self.buffer.getvalue() + + def write(self, s): + if '\n' in s: + self._write_lines(s) + else: + self._write_to_buffer(s) + + def _write_lines(self, s): + # Cygdb needs to know which Cython source line corresponds to which C line. + # Therefore, we write this information into "self.buffer.markers" and then write it from there + # into cython_debug/cython_debug_info_* (see ModuleNode._serialize_lineno_map). + filename_line = self.last_marked_pos[:2] if self.last_marked_pos else (None, 0) + self.buffer.markers.extend([filename_line] * s.count('\n')) + + self._write_to_buffer(s) + + def _write_to_buffer(self, s): + self.buffer.write(s) + + def insertion_point(self): + other = self.create_new(create_from=self, buffer=self.buffer.insertion_point(), copy_formatting=True) + return other + + def new_writer(self): + """ + Creates a new CCodeWriter connected to the same global state, which + can later be inserted using insert. + """ + return CCodeWriter(create_from=self) + + def insert(self, writer): + """ + Inserts the contents of another code writer (created with + the same global state) in the current location. + + It is ok to write to the inserted writer also after insertion. + """ + assert writer.globalstate is self.globalstate + self.buffer.insert(writer.buffer) + + # Properties delegated to function scope + @funccontext_property + def label_counter(self): pass + @funccontext_property + def return_label(self): pass + @funccontext_property + def error_label(self): pass + @funccontext_property + def labels_used(self): pass + @funccontext_property + def continue_label(self): pass + @funccontext_property + def break_label(self): pass + @funccontext_property + def return_from_error_cleanup_label(self): pass + @funccontext_property + def yield_labels(self): pass + + def label_interceptor(self, new_labels, orig_labels, skip_to_label=None, pos=None, trace=True): + """ + Helper for generating multiple label interceptor code blocks. + + @param new_labels: the new labels that should be intercepted + @param orig_labels: the original labels that we should dispatch to after the interception + @param skip_to_label: a label to skip to before starting the code blocks + @param pos: the node position to mark for each interceptor block + @param trace: add a trace line for the pos marker or not + """ + for label, orig_label in zip(new_labels, orig_labels): + if not self.label_used(label): + continue + if skip_to_label: + # jump over the whole interception block + self.put_goto(skip_to_label) + skip_to_label = None + + if pos is not None: + self.mark_pos(pos, trace=trace) + self.put_label(label) + yield (label, orig_label) + self.put_goto(orig_label) + + # Functions delegated to function scope + def new_label(self, name=None): return self.funcstate.new_label(name) + def new_error_label(self, *args): return self.funcstate.new_error_label(*args) + def new_yield_label(self, *args): return self.funcstate.new_yield_label(*args) + def get_loop_labels(self): return self.funcstate.get_loop_labels() + def set_loop_labels(self, labels): return self.funcstate.set_loop_labels(labels) + def new_loop_labels(self, *args): return self.funcstate.new_loop_labels(*args) + def get_all_labels(self): return self.funcstate.get_all_labels() + def set_all_labels(self, labels): return self.funcstate.set_all_labels(labels) + def all_new_labels(self): return self.funcstate.all_new_labels() + def use_label(self, lbl): return self.funcstate.use_label(lbl) + def label_used(self, lbl): return self.funcstate.label_used(lbl) + + + def enter_cfunc_scope(self, scope): + self.funcstate = FunctionState(self, scope=scope) + + def exit_cfunc_scope(self): + if self.funcstate is None: + return + self.funcstate.validate_exit() + self.funcstate = None + + def start_initcfunc(self, signature, scope=None, refnanny=False): + """ + Init code helper function to start a cfunc scope and generate + the prototype and function header ("static SIG {") of the function. + """ + proto = self.globalstate.parts['initfunc_declarations'] + proto.putln(f"static CYTHON_SMALL_CODE {signature}; /*proto*/") + self.enter_cfunc_scope(scope) + self.putln("") + self.putln(f"static {signature} {{") + if refnanny: + self.put_declare_refcount_context() + + def start_slotfunc(self, class_scope, return_type, c_slot_name, args_signature, needs_funcstate=True, needs_prototype=False): + # Slot functions currently live in the class scope as they don't have direct access to the module state. + slotfunc_cname = class_scope.mangle_internal(c_slot_name) + declaration = f"static {return_type.declaration_code(slotfunc_cname)}({args_signature})" + + if needs_prototype: + self.globalstate['decls'].putln(declaration.replace("CYTHON_UNUSED ", "") + "; /*proto*/") + if needs_funcstate: + self.enter_cfunc_scope(class_scope) + self.putln("") + self.putln(declaration + " {") + + # constant handling + + def get_py_int(self, str_value, longness): + return self.name_in_module_state( + self.globalstate.get_int_const(str_value, longness).cname + ) + + def get_py_float(self, str_value, value_code): + return self.name_in_module_state( + self.globalstate.get_float_const(str_value, value_code).cname + ) + + def get_py_const(self, prefix, dedup_key=None): + return self.name_in_module_state( + self.globalstate.get_py_const(prefix, dedup_key) + ) + + def get_string_const(self, text): + return self.globalstate.get_string_const(text).cname + + def get_pyunicode_ptr_const(self, text): + return self.globalstate.get_pyunicode_ptr_const(text) + + def get_py_string_const(self, text, identifier=None): + cname = self.globalstate.get_py_string_const( + text, identifier).cname + return self.name_in_module_state(cname) + + def get_py_codeobj_const(self, node): + return self.name_in_module_state(self.globalstate.get_py_codeobj_const(node)) + + def get_argument_default_const(self, type): + return self.name_in_module_state(self.globalstate.get_argument_default_const(type).cname) + + def intern(self, text): + return self.get_py_string_const(text) + + def intern_identifier(self, text): + return self.get_py_string_const(text, identifier=True) + + def get_cached_constants_writer(self, target=None): + return self.globalstate.get_cached_constants_writer(target) + + def name_in_module_state(self, cname): + if self.funcstate.scope is None: + # This is a mess. For example, within the codeobj generation + # funcstate.scope is None while evaluating the strings, but not while + # evaluating the code objects themselves. Right now it doesn't matter + # because it all ends up going to the same place, but to actually turn + # it into something useful this mess will need to be fixed. + return self.name_in_main_c_code_module_state(cname) + return self.funcstate.scope.name_in_module_state(cname) + + @staticmethod + def name_in_main_c_code_module_state(cname): + # The functions where this applies to have the modulestate passed + # as an argument to them and so it's better use that argument than + # to try to get it from a global variable. + return f"{Naming.modulestatevalue_cname}->{cname}" + + @staticmethod + def name_in_slot_module_state(cname): + # TODO - eventually this will go through PyType_GetModuleByDef + # in cases where it's supported. + return f"{Naming.modulestateglobal_cname}->{cname}" + + def namespace_cname_in_module_state(self, scope): + if scope.is_py_class_scope: + return scope.namespace_cname + else: + return self.name_in_module_state(scope.namespace_cname) + + def typeptr_cname_in_module_state(self, type): + if type.is_extension_type: + return self.name_in_module_state(type.typeptr_cname) + else: + return type.typeptr_cname + + # code generation + + def putln(self, code="", safe=False): + if self.last_pos and self.bol: + self.emit_marker() + if self.code_config.emit_linenums and self.last_marked_pos: + source_desc, line, _ = self.last_marked_pos + self._write_lines(f'\n#line {line} "{source_desc.get_escaped_description()}"\n') + if code: + if safe: + self.put_safe(code) + else: + self.put(code) + self._write_lines("\n") + self.bol = 1 + + def mark_pos(self, pos, trace=True): + if pos is None: + return + if self.last_marked_pos and self.last_marked_pos[:2] == pos[:2]: + return + self.last_pos = (pos, trace) + + def emit_marker(self): + pos, trace = self.last_pos + self.last_marked_pos = pos + self.last_pos = None + self._write_lines("\n") + if self.code_config.emit_code_comments: + self.indent() + self._write_lines(self._build_marker(pos)) + if trace: + self.write_trace_line(pos) + + def write_trace_line(self, pos): + if self.funcstate and self.funcstate.can_trace and self.globalstate.directives['linetrace']: + self.indent() + self._write_lines( + f'__Pyx_TraceLine({pos[1]:d},{self.pos_to_offset(pos):d},{not self.funcstate.gil_owned:d},{self.error_goto(pos)})\n') + + def _build_marker(self, pos): + source_desc, line, col = pos + assert isinstance(source_desc, SourceDescriptor) + contents = self.globalstate.commented_file_contents(source_desc) + lines = contents[max(0, line-3):line] # line numbers start at 1 + lines[-1] += ' # <<<<<<<<<<<<<<' + lines += contents[line:line+2] + code = "\n".join(lines) + return f'/* "{source_desc.get_escaped_description()}":{line:d}\n{code}\n*/\n' + + def put_safe(self, code): + # put code, but ignore {} + self.write(code) + self.bol = 0 + + def put_or_include(self, code, name): + include_dir = self.globalstate.common_utility_include_dir + if include_dir and len(code) > 1024: + hash = hashlib.sha256(code.encode('utf8')).hexdigest() + include_file = f"{name}_{hash}.h" + path = os.path.join(include_dir, include_file) + if not os.path.exists(path): + tmp_path = f'{path}.tmp{os.getpid()}' + done = False + try: + with Utils.open_new_file(tmp_path) as f: + f.write(code) + shutil.move(tmp_path, path) + done = True + except (FileExistsError, PermissionError): + # If a different process created the file faster than us, + # renaming can fail on Windows. It's ok if the file is there now. + if not os.path.exists(path): + raise + finally: + if not done and os.path.exists(tmp_path): + os.unlink(tmp_path) + # We use forward slashes in the include path to assure identical code generation + # under Windows and Posix. C/C++ compilers should still understand it. + c_path = path.replace('\\', '/') + code = f'#include "{c_path}"\n' + self.put(code) + + def put(self, code): + fix_indent = False + if "{" in code: + dl = code.count("{") + else: + dl = 0 + if "}" in code: + dl -= code.count("}") + if dl < 0: + self.level += dl + elif dl == 0 and code[0] == "}": + # special cases like "} else {" need a temporary dedent + fix_indent = True + self.level -= 1 + if self.bol: + self.indent() + self.write(code) + self.bol = 0 + if dl > 0: + self.level += dl + elif fix_indent: + self.level += 1 + + def put_code_here(self, utility: UtilityCode): + # Puts the impl section of the utility code directly to the current position. + # Ensure we don't have a proto section (but do allow init and cleanup sections + # because they might be useful in future). + assert not utility.proto, utility.name + utility._put_code_section(self, self.globalstate, "impl") + utility._put_init_code_section(self.globalstate) + if utility.cleanup and Options.generate_cleanup_code: + utility._put_code_section( + self.globalstate['cleanup_globals'], self.globalstate, "cleanup") + + def increase_indent(self): + self.level += 1 + + def decrease_indent(self): + self.level -= 1 + + def begin_block(self): + self.putln("{") + self.increase_indent() + + def end_block(self): + self.decrease_indent() + self.putln("}") + + def indent(self): + self._write_to_buffer(" " * self.level) + + def get_py_version_hex(self, pyversion): + return "0x%02X%02X%02X%02X" % (tuple(pyversion) + (0,0,0,0))[:4] + + def put_label(self, lbl): + if lbl in self.funcstate.labels_used: + self.putln("%s:;" % lbl) + + def put_goto(self, lbl): + self.funcstate.use_label(lbl) + self.putln("goto %s;" % lbl) + + def put_var_declaration(self, entry, storage_class="", + dll_linkage=None, definition=True): + #print "Code.put_var_declaration:", entry.name, "definition =", definition ### + if entry.visibility == 'private' and not (definition or entry.defined_in_pxd): + #print "...private and not definition, skipping", entry.cname ### + return + if entry.visibility == "private" and not entry.used: + #print "...private and not used, skipping", entry.cname ### + return + if not entry.cf_used: + self.put('CYTHON_UNUSED ') + if storage_class: + self.put("%s " % storage_class) + if entry.is_cpp_optional: + self.put(entry.type.cpp_optional_declaration_code( + entry.cname, dll_linkage=dll_linkage)) + else: + self.put(entry.type.declaration_code( + entry.cname, dll_linkage=dll_linkage)) + if entry.init is not None: + self.put_safe(" = %s" % entry.type.literal_code(entry.init)) + elif entry.type.is_pyobject: + self.put(" = NULL") + self.putln(";") + self.funcstate.scope.use_entry_utility_code(entry) + + def put_temp_declarations(self, func_context): + for name, type, manage_ref, static in func_context.temps_allocated: + if type.is_cpp_class and not type.is_fake_reference and func_context.scope.directives['cpp_locals']: + decl = type.cpp_optional_declaration_code(name) + else: + decl = type.declaration_code(name) + if type.is_pyobject: + self.putln("%s = NULL;" % decl) + elif type.is_memoryviewslice: + self.putln("%s = %s;" % (decl, type.literal_code(type.default_value))) + else: + self.putln("%s%s;" % (static and "static " or "", decl)) + + if func_context.should_declare_error_indicator: + if self.funcstate.uses_error_indicator: + unused = '' + else: + unused = 'CYTHON_UNUSED ' + # Initialize these variables to silence compiler warnings + self.putln("%sint %s = 0;" % (unused, Naming.lineno_cname)) + self.putln("%sconst char *%s = NULL;" % (unused, Naming.filename_cname)) + self.putln("%sint %s = 0;" % (unused, Naming.clineno_cname)) + + def put_generated_by(self): + self.putln(Utils.GENERATED_BY_MARKER) + self.putln("") + + def put_h_guard(self, guard): + self.putln("#ifndef %s" % guard) + self.putln("#define %s" % guard) + + def unlikely(self, cond): + if Options.gcc_branch_hints: + return 'unlikely(%s)' % cond + else: + return cond + + def build_function_modifiers(self, modifiers, mapper=modifier_output_mapper): + if not modifiers: + return '' + return '%s ' % ' '.join([mapper(m,m) for m in modifiers]) + + # Python objects and reference counting + + def entry_as_pyobject(self, entry): + type = entry.type + if (not entry.is_self_arg and not entry.type.is_complete() + or entry.type.is_extension_type): + return "(PyObject *)" + entry.cname + else: + return entry.cname + + def as_pyobject(self, cname, type): + from .PyrexTypes import py_object_type, typecast + return typecast(py_object_type, type, cname) + + def put_gotref(self, cname, type): + type.generate_gotref(self, cname) + + def put_giveref(self, cname, type): + type.generate_giveref(self, cname) + + def put_xgiveref(self, cname, type): + type.generate_xgiveref(self, cname) + + def put_xgotref(self, cname, type): + type.generate_xgotref(self, cname) + + def put_incref(self, cname, type, nanny=True): + # Note: original put_Memslice_Incref/Decref also added in some utility code + # this is unnecessary since the relevant utility code is loaded anyway if a memoryview is used + # and so has been removed. However, it's potentially a feature that might be useful here + type.generate_incref(self, cname, nanny=nanny) + + def put_xincref(self, cname, type, nanny=True): + type.generate_xincref(self, cname, nanny=nanny) + + def put_decref(self, cname, type, nanny=True, have_gil=True): + type.generate_decref(self, cname, nanny=nanny, have_gil=have_gil) + + def put_xdecref(self, cname, type, nanny=True, have_gil=True): + type.generate_xdecref(self, cname, nanny=nanny, have_gil=have_gil) + + def put_decref_clear(self, cname, type, clear_before_decref=False, nanny=True, have_gil=True): + type.generate_decref_clear(self, cname, clear_before_decref=clear_before_decref, + nanny=nanny, have_gil=have_gil) + + def put_xdecref_clear(self, cname, type, clear_before_decref=False, nanny=True, have_gil=True): + type.generate_xdecref_clear(self, cname, clear_before_decref=clear_before_decref, + nanny=nanny, have_gil=have_gil) + + def put_decref_set(self, cname, type, rhs_cname): + type.generate_decref_set(self, cname, rhs_cname) + + def put_xdecref_set(self, cname, type, rhs_cname): + type.generate_xdecref_set(self, cname, rhs_cname) + + def put_incref_memoryviewslice(self, slice_cname, type, have_gil): + # TODO ideally this would just be merged into "put_incref" + type.generate_incref_memoryviewslice(self, slice_cname, have_gil=have_gil) + + def put_var_incref_memoryviewslice(self, entry, have_gil): + self.put_incref_memoryviewslice(entry.cname, entry.type, have_gil=have_gil) + + def put_var_gotref(self, entry): + self.put_gotref(entry.cname, entry.type) + + def put_var_giveref(self, entry): + self.put_giveref(entry.cname, entry.type) + + def put_var_xgotref(self, entry): + self.put_xgotref(entry.cname, entry.type) + + def put_var_xgiveref(self, entry): + self.put_xgiveref(entry.cname, entry.type) + + def put_var_incref(self, entry, **kwds): + self.put_incref(entry.cname, entry.type, **kwds) + + def put_var_xincref(self, entry, **kwds): + self.put_xincref(entry.cname, entry.type, **kwds) + + def put_var_decref(self, entry, **kwds): + self.put_decref(entry.cname, entry.type, **kwds) + + def put_var_xdecref(self, entry, **kwds): + self.put_xdecref(entry.cname, entry.type, **kwds) + + def put_var_decref_clear(self, entry, **kwds): + self.put_decref_clear(entry.cname, entry.type, clear_before_decref=entry.in_closure, **kwds) + + def put_var_decref_set(self, entry, rhs_cname, **kwds): + self.put_decref_set(entry.cname, entry.type, rhs_cname, **kwds) + + def put_var_xdecref_set(self, entry, rhs_cname, **kwds): + self.put_xdecref_set(entry.cname, entry.type, rhs_cname, **kwds) + + def put_var_xdecref_clear(self, entry, **kwds): + self.put_xdecref_clear(entry.cname, entry.type, clear_before_decref=entry.in_closure, **kwds) + + def put_var_decrefs(self, entries, used_only = 0): + for entry in entries: + if not used_only or entry.used: + if entry.xdecref_cleanup: + self.put_var_xdecref(entry) + else: + self.put_var_decref(entry) + + def put_var_xdecrefs(self, entries): + for entry in entries: + self.put_var_xdecref(entry) + + def put_var_xdecrefs_clear(self, entries): + for entry in entries: + self.put_var_xdecref_clear(entry) + + def put_init_to_py_none(self, cname, type, nanny=True): + from .PyrexTypes import py_object_type, typecast + py_none = typecast(type, py_object_type, "Py_None") + if nanny: + self.putln("%s = %s; __Pyx_INCREF(Py_None);" % (cname, py_none)) + else: + self.putln("%s = %s; Py_INCREF(Py_None);" % (cname, py_none)) + + def put_init_var_to_py_none(self, entry, template = "%s", nanny=True): + code = template % entry.cname + #if entry.type.is_extension_type: + # code = "((PyObject*)%s)" % code + self.put_init_to_py_none(code, entry.type, nanny) + if entry.in_closure: + self.put_giveref('Py_None') + + def put_pymethoddef(self, entry, term, allow_skip=True, wrapper_code_writer=None): + is_number_slot = False + if entry.is_special or entry.name == '__getattribute__': + from . import TypeSlots + if entry.name not in special_py_methods: + if TypeSlots.is_binop_number_slot(entry.name): + # It's useful if numeric binops are created with meth coexist + # so they can be called directly by looking up the name, skipping the + # dispatch wrapper that enables the reverse slots. This is most useful + # when c_api_binop_methods is False, but there's no reason not to do it + # all the time + is_number_slot = True + elif entry.name == '__getattr__' and not self.globalstate.directives['fast_getattr']: + pass + # Python's typeobject.c will automatically fill in our slot + # in add_operators() (called by PyType_Ready) with a value + # that's better than ours. + elif allow_skip: + return + + method_flags = entry.signature.method_flags() + if not method_flags: + return + if entry.is_special: + method_flags += [TypeSlots.method_coexist] + func_ptr = wrapper_code_writer.put_pymethoddef_wrapper(entry) if wrapper_code_writer else entry.func_cname + # Add required casts, but try not to shadow real warnings. + cast = entry.signature.method_function_type() + if cast != 'PyCFunction': + func_ptr = '(void(*)(void))(%s)%s' % (cast, func_ptr) + entry_name = entry.name.as_c_string_literal() + if is_number_slot: + # Unlike most special functions, binop numeric operator slots are actually generated here + # (to ensure that they can be looked up). However, they're sometimes guarded by the preprocessor + # so a bit of extra logic is needed + slot = TypeSlots.get_slot_table(self.globalstate.directives).get_slot_by_method_name(entry.name) + preproc_guard = slot.preprocessor_guard_code() + if preproc_guard: + self.putln(preproc_guard) + self.putln( + '{%s, (PyCFunction)%s, %s, %s}%s' % ( + entry_name, + func_ptr, + "|".join(method_flags), + entry.doc_cname if entry.doc else '0', + term)) + if is_number_slot and preproc_guard: + self.putln("#endif") + + def put_pymethoddef_wrapper(self, entry): + func_cname = entry.func_cname + if entry.is_special: + method_flags = entry.signature.method_flags() or [] + from .TypeSlots import method_noargs + if method_noargs in method_flags: + # Special NOARGS methods really take no arguments besides 'self', but PyCFunction expects one. + func_cname = Naming.method_wrapper_prefix + func_cname + self.putln("static PyObject *%s(PyObject *self, CYTHON_UNUSED PyObject *arg) {" % func_cname) + func_call = "%s(self)" % entry.func_cname + if entry.name == "__next__": + self.putln("PyObject *res = %s;" % func_call) + # tp_iternext can return NULL without an exception + self.putln("if (!res && !PyErr_Occurred()) { PyErr_SetNone(PyExc_StopIteration); }") + self.putln("return res;") + else: + self.putln("return %s;" % func_call) + self.putln("}") + return func_cname + + # GIL methods + + def use_fast_gil_utility_code(self): + if self.globalstate.directives['fast_gil']: + self.globalstate.use_utility_code(UtilityCode.load_cached("FastGil", "ModuleSetupCode.c")) + else: + self.globalstate.use_utility_code(UtilityCode.load_cached("NoFastGil", "ModuleSetupCode.c")) + + def put_ensure_gil(self, declare_gilstate=True, variable=None): + """ + Acquire the GIL. The generated code is safe even when no PyThreadState + has been allocated for this thread (for threads not initialized by + using the Python API). Additionally, the code generated by this method + may be called recursively. + """ + if self.globalstate.directives['subinterpreters_compatible'] != 'no': + from .Errors import warning + warning( + self.last_marked_pos, + "Acquiring the GIL is currently very unlikely to work correctly with subinterpreters.", + 2 + ) + self.globalstate.use_utility_code( + UtilityCode.load_cached("ForceInitThreads", "ModuleSetupCode.c")) + self.use_fast_gil_utility_code() + if not variable: + variable = '__pyx_gilstate_save' + if declare_gilstate: + self.put("PyGILState_STATE ") + self.putln("%s = __Pyx_PyGILState_Ensure();" % variable) + + def put_release_ensured_gil(self, variable=None): + """ + Releases the GIL, corresponds to `put_ensure_gil`. + """ + self.use_fast_gil_utility_code() + if not variable: + variable = '__pyx_gilstate_save' + self.putln("__Pyx_PyGILState_Release(%s);" % variable) + + def put_acquire_freethreading_lock(self): + self.putln("#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING") + self.putln(f"PyMutex_Lock(&{Naming.parallel_freethreading_mutex});") + self.putln("#endif") + + def put_release_freethreading_lock(self): + self.putln("#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING") + self.putln(f"PyMutex_Unlock(&{Naming.parallel_freethreading_mutex});") + self.putln("#endif") + + def put_acquire_gil(self, variable=None, unknown_gil_state=True): + """ + Acquire the GIL. The thread's thread state must have been initialized + by a previous `put_release_gil` + """ + self.use_fast_gil_utility_code() + self.putln("__Pyx_FastGIL_Forget();") + if variable: + self.putln('_save = %s;' % variable) + if unknown_gil_state: + self.putln("if (_save) {") + self.putln("Py_BLOCK_THREADS") + if unknown_gil_state: + self.putln("}") + self.putln("#if CYTHON_COMPILING_IN_LIMITED_API") + self.put_release_ensured_gil() + self.putln("#endif") + + def put_release_gil(self, variable=None, unknown_gil_state=True): + "Release the GIL, corresponds to `put_acquire_gil`." + self.use_fast_gil_utility_code() + self.putln("PyThreadState *_save;") + self.putln("_save = NULL;") + if unknown_gil_state: + # We don't *know* that we don't have the GIL (since we may be inside a nogil function, + # and Py_UNBLOCK_THREADS is unsafe without the GIL). + self.putln("#if CYTHON_COMPILING_IN_LIMITED_API") + # In the Limited API we can't check whether we have the GIL. + # Therefore the only way to be sure that we can release it is to acquire it first. + self.put_ensure_gil() + self.putln("#else") + self.putln("if (PyGILState_Check())") + self.putln("#endif") + self.putln("{") + self.putln("Py_UNBLOCK_THREADS") + if unknown_gil_state: + self.putln("}") + if variable: + self.putln('%s = _save;' % variable) + self.putln("__Pyx_FastGIL_Remember();") + + def declare_gilstate(self): + self.putln("PyGILState_STATE __pyx_gilstate_save;") + + # error handling + + def put_error_if_neg(self, pos, value): + # TODO this path is almost _never_ taken, yet this macro makes is slower! + # return self.putln("if (unlikely(%s < 0)) %s" % (value, self.error_goto(pos))) + return self.putln("if (%s < (0)) %s" % (value, self.error_goto(pos))) + + def put_error_if_unbound(self, pos, entry, in_nogil_context=False, unbound_check_code=None): + nogil_tag = "Nogil" if in_nogil_context else "" + if entry.from_closure: + func = "RaiseClosureNameError" + elif entry.type.is_cpp_class and entry.is_cglobal: + func = "RaiseCppGlobalNameError" + elif entry.type.is_cpp_class and entry.is_variable and not entry.is_member and entry.scope.is_c_class_scope: + # there doesn't seem to be a good way to detecting an instance-attribute of a C class + # (is_member is only set for class attributes) + func = "RaiseCppAttributeError" + else: + func = "RaiseUnboundLocalError" + + self.globalstate.use_utility_code( + UtilityCode.load_cached(f"{func}{nogil_tag}", "ObjectHandling.c")) + + if not unbound_check_code: + unbound_check_code = entry.type.check_for_null_code(entry.cname) + self.putln('if (unlikely(!%s)) { %s(%s); %s }' % ( + unbound_check_code, + f"__Pyx_{func}{nogil_tag}", + entry.name.as_c_string_literal(), + self.error_goto(pos))) + + def set_error_info(self, pos, used=False): + self.funcstate.should_declare_error_indicator = True + if used: + self.funcstate.uses_error_indicator = True + return "__PYX_MARK_ERR_POS(%s, %s)" % ( + self.lookup_filename(pos[0]), + pos[1]) + + def error_goto(self, pos, used=True): + lbl = self.funcstate.error_label + self.funcstate.use_label(lbl) + if pos is None: + return 'goto %s;' % lbl + self.funcstate.should_declare_error_indicator = True + if used: + self.funcstate.uses_error_indicator = True + return "__PYX_ERR(%s, %s, %s)" % ( + self.lookup_filename(pos[0]), + pos[1], + lbl) + + def error_goto_if(self, cond, pos): + return "if (%s) %s" % (self.unlikely(cond), self.error_goto(pos)) + + def error_goto_if_null(self, cname, pos): + return self.error_goto_if("!%s" % cname, pos) + + def error_goto_if_neg(self, cname, pos): + # Add extra parentheses to silence clang warnings about constant conditions. + return self.error_goto_if("(%s < 0)" % cname, pos) + + def error_goto_if_PyErr(self, pos): + return self.error_goto_if("PyErr_Occurred()", pos) + + def lookup_filename(self, filename): + return self.globalstate.lookup_filename(filename) + + def put_declare_refcount_context(self): + self.putln('__Pyx_RefNannyDeclarations') + + def put_setup_refcount_context(self, name, acquire_gil=False): + name = name.as_c_string_literal() # handle unicode names + if acquire_gil: + self.globalstate.use_utility_code( + UtilityCode.load_cached("ForceInitThreads", "ModuleSetupCode.c")) + self.putln('__Pyx_RefNannySetupContext(%s, %d);' % (name, acquire_gil and 1 or 0)) + + def put_finish_refcount_context(self, nogil=False): + self.putln("__Pyx_RefNannyFinishContextNogil()" if nogil else "__Pyx_RefNannyFinishContext();") + + def put_add_traceback(self, qualified_name, include_cline=True): + """ + Build a Python traceback for propagating exceptions. + + qualified_name should be the qualified name of the function. + """ + qualified_name = qualified_name.as_c_string_literal() # handle unicode names + format_tuple = ( + qualified_name, + Naming.clineno_cname if include_cline else 0, + Naming.lineno_cname, + Naming.filename_cname, + ) + + self.funcstate.uses_error_indicator = True + self.putln('__Pyx_AddTraceback(%s, %s, %s, %s);' % format_tuple) + + def put_unraisable(self, qualified_name, nogil=False): + """ + Generate code to print a Python warning for an unraisable exception. + + qualified_name should be the qualified name of the function. + """ + format_tuple = ( + qualified_name, + Naming.clineno_cname, + Naming.lineno_cname, + Naming.filename_cname, + self.globalstate.directives['unraisable_tracebacks'], + nogil, + ) + self.funcstate.uses_error_indicator = True + self.putln('__Pyx_WriteUnraisable("%s", %s, %s, %s, %d, %d);' % format_tuple) + self.globalstate.use_utility_code( + UtilityCode.load_cached("WriteUnraisableException", "Exceptions.c")) + + def is_tracing(self): + return self.globalstate.directives['profile'] or self.globalstate.directives['linetrace'] + + def pos_to_offset(self, pos): + """ + Calculate a fake 'instruction offset' from a node position as 31 bit int (32 bit signed). + """ + scope = self.funcstate.scope + while scope and pos not in scope.node_positions_to_offset: + scope = scope.parent_scope + return scope.node_positions_to_offset[pos] if scope else 0 + + def put_trace_declarations(self, is_generator=False): + self.putln('__Pyx_TraceDeclarationsGen' if is_generator else '__Pyx_TraceDeclarationsFunc') + + def put_trace_frame_init(self, codeobj=None): + if codeobj: + self.putln('__Pyx_TraceFrameInit(%s)' % codeobj) + + def put_trace_start(self, name, pos, nogil=False, is_generator=False, is_cpdef_func=False): + trace_func = "__Pyx_TraceStartGen" if is_generator else "__Pyx_TraceStartFunc" + self.putln( + f'{trace_func}(' + f'{name.as_c_string_literal()}, ' + f'{Naming.filetable_cname}[{self.lookup_filename(pos[0])}], ' + f'{pos[1]}, ' + f'{self.pos_to_offset(pos):d}, ' + f'{nogil:d}, ' + f'{Naming.skip_dispatch_cname if is_cpdef_func else "0"}, ' + f'{self.error_goto(pos)}' + ');' + ) + + def put_trace_exit(self, nogil=False): + self.putln(f"__Pyx_PyMonitoring_ExitScope({bool(nogil):d});") + + def put_trace_yield(self, retvalue_cname, pos): + error_goto = self.error_goto(pos) + self.putln(f"__Pyx_TraceYield({retvalue_cname}, {self.pos_to_offset(pos)}, {error_goto});") + + def put_trace_resume(self, pos): + scope = self.funcstate.scope + # pos[1] is probably not the first line, so try to find the first line of the generator function. + first_line = scope.scope_class.pos[1] if scope.scope_class else pos[1] + name = scope.name.as_c_string_literal() + filename_index = self.lookup_filename(pos[0]) + error_goto = self.error_goto(pos) + self.putln( + '__Pyx_TraceResumeGen(' + f'{name}, ' + f'{Naming.filetable_cname}[{filename_index}], ' + f'{first_line}, ' + f'{self.pos_to_offset(pos)}, ' + f'{error_goto}' + ');' + ) + + def put_trace_exception(self, pos, reraise=False, fresh=False): + self.putln(f"__Pyx_TraceException({self.pos_to_offset(pos)}, {bool(reraise):d}, {bool(fresh):d});") + + def put_trace_exception_propagating(self): + self.putln(f"__Pyx_TraceException({Naming.lineno_cname}, 0, 0);") + + def put_trace_exception_handled(self, pos): + self.putln(f"__Pyx_TraceExceptionHandled({self.pos_to_offset(pos)});") + + def put_trace_unwind(self, pos, nogil=False): + self.putln(f"__Pyx_TraceExceptionUnwind({self.pos_to_offset(pos)}, {bool(nogil):d});") + + def put_trace_stopiteration(self, pos, value): + error_goto = self.error_goto(pos) + self.putln(f"__Pyx_TraceStopIteration({value}, {self.pos_to_offset(pos)}, {error_goto});") + + def put_trace_return(self, retvalue_cname, pos, return_type=None, nogil=False): + extra_arg = "" + trace_func = "__Pyx_TraceReturnValue" + + if return_type is None: + pass + elif return_type.is_pyobject: + retvalue_cname = return_type.as_pyobject(retvalue_cname) + elif return_type.is_void: + retvalue_cname = 'Py_None' + elif return_type.is_string: + # We don't know if the C string is 0-terminated, but we cannot convert if it's not. + retvalue_cname = 'Py_None' + elif return_type.to_py_function: + trace_func = "__Pyx_TraceReturnCValue" + extra_arg = f", {return_type.to_py_function}" + else: + # We don't have a Python visible return value but we still need to report that we returned. + # 'None' may not be a misleading (it's false, for one), but it's hopefully better than nothing. + retvalue_cname = 'Py_None' + + error_handling = self.error_goto(pos) + self.putln(f"{trace_func}({retvalue_cname}{extra_arg}, {self.pos_to_offset(pos)}, {bool(nogil):d}, {error_handling});") + + def put_cpp_placement_new(self, target, + _utility_code=UtilityCode.load("DefaultPlacementNew", "CppSupport.cpp")): + self.globalstate.use_utility_code(_utility_code) + self.putln(f"__Pyx_default_placement_construct(&({target}));") + + def putln_openmp(self, string): + self.putln("#ifdef _OPENMP") + self.putln(string) + self.putln("#endif /* _OPENMP */") + + def undef_builtin_expect(self, cond): + """ + Redefine the macros likely() and unlikely to no-ops, depending on + condition 'cond' + """ + self.putln("#if %s" % cond) + self.putln(" #undef likely") + self.putln(" #undef unlikely") + self.putln(" #define likely(x) (x)") + self.putln(" #define unlikely(x) (x)") + self.putln("#endif") + + def redef_builtin_expect(self, cond): + self.putln("#if %s" % cond) + self.putln(" #undef likely") + self.putln(" #undef unlikely") + self.putln(" #define likely(x) __builtin_expect(!!(x), 1)") + self.putln(" #define unlikely(x) __builtin_expect(!!(x), 0)") + self.putln("#endif") + + +class PyrexCodeWriter: + # f file output file + # level int indentation level + + def __init__(self, outfile_name): + self.f = Utils.open_new_file(outfile_name) + self.level = 0 + + def putln(self, code): + self.f.write("%s%s\n" % (" " * self.level, code)) + + def indent(self): + self.level += 1 + + def dedent(self): + self.level -= 1 + + +class PyxCodeWriter: + """ + Can be used for writing out some Cython code. + """ + + def __init__(self, buffer=None, indent_level=0, context=None, encoding='ascii'): + self.buffer = buffer or StringIOTree() + self.level = indent_level + self.original_level = indent_level + self.context = context + self.encoding = encoding + self._insertion_points = {} + + def indent(self, levels=1): + self.level += levels + return True + + def dedent(self, levels=1): + self.level -= levels + + @contextmanager + def indenter(self, line): + """ + with pyx_code.indenter("for i in range(10):"): + pyx_code.putln("print i") + """ + self.putln(line) + self.indent() + yield + self.dedent() + + def empty(self): + return self.buffer.empty() + + def getvalue(self): + result = self.buffer.getvalue() + if isinstance(result, bytes): + result = result.decode(self.encoding) + return result + + def putln(self, line, context=None): + if context is None: + if self.context is not None: + context = self.context + if context is not None: + line = sub_tempita(line, context) + # Avoid indenting empty lines. + self.buffer.write(f"{self.level * ' '}{line}\n" if line else "\n") + + def put_chunk(self, chunk, context=None): + if context is None: + if self.context is not None: + context = self.context + if context is not None: + chunk = sub_tempita(chunk, context) + + chunk = _indent_chunk(chunk, self.level * 4) + self.buffer.write(chunk) + + def insertion_point(self): + return type(self)(self.buffer.insertion_point(), self.level, self.context) + + def reset(self): + # resets the buffer so that nothing gets written. Most useful + # for abandoning all work in a specific insertion point + self.buffer.reset() + self.level = self.original_level + + def named_insertion_point(self, name): + self._insertion_points[name] = self.insertion_point() + + def __getitem__(self, name): + return self._insertion_points[name] + + +@cython.final +@cython.ccall +def _indent_chunk(chunk: str, indentation_length: cython.int) -> str: + """Normalise leading space to the intended indentation and strip empty lines. + """ + assert '\t' not in chunk + lines = chunk.splitlines(keepends=True) + if not lines: + return chunk + last_line = lines[-1].rstrip(' ') + if last_line: + lines[-1] = last_line + else: + del lines[-1] + if not lines: + return '\n' + + # Count minimal (non-empty) indentation and strip empty lines. + min_indentation: cython.int = len(chunk) + 1 + line_indentation: cython.int + line: str + i: cython.int + for i, line in enumerate(lines): + line_indentation = _count_indentation(line) + if line_indentation + 1 == len(line): + lines[i] = '\n' + elif line_indentation < min_indentation: + min_indentation = line_indentation + + if min_indentation > len(chunk): + # All empty lines. + min_indentation = 0 + + if min_indentation < indentation_length: + add_indent = ' ' * (indentation_length - min_indentation) + lines = [ + add_indent + line if line != '\n' else '\n' + for line in lines + ] + elif min_indentation > indentation_length: + start: cython.int = min_indentation - indentation_length + lines = [ + line[start:] if line != '\n' else '\n' + for line in lines + ] + + return ''.join(lines) + + +@cython.exceptval(-1) +@cython.cfunc +def _count_indentation(s: str) -> cython.int: + i: cython.int = 0 + ch: cython.Py_UCS4 + for i, ch in enumerate(s): + if ch != ' ': + break + return i + + +class ClosureTempAllocator: + def __init__(self, klass): + self.klass = klass + self.temps_allocated = {} + self.temps_free = {} + self.temps_count = 0 + + def reset(self): + for type, cnames in self.temps_allocated.items(): + self.temps_free[type] = list(cnames) + + def allocate_temp(self, type): + if type not in self.temps_allocated: + self.temps_allocated[type] = [] + self.temps_free[type] = [] + elif self.temps_free[type]: + return self.temps_free[type].pop(0) + cname = '%s%d' % (Naming.codewriter_temp_prefix, self.temps_count) + self.klass.declare_var(pos=None, name=cname, cname=cname, type=type, is_cdef=True) + self.temps_allocated[type].append(cname) + self.temps_count += 1 + return cname diff --git a/venv/lib/python3.10/site-packages/Cython/Compiler/CodeGeneration.py b/venv/lib/python3.10/site-packages/Cython/Compiler/CodeGeneration.py new file mode 100644 index 0000000000000000000000000000000000000000..c732481d7cfcb256be2e27c99e839077ee137c5f --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Compiler/CodeGeneration.py @@ -0,0 +1,33 @@ +from .Visitor import VisitorTransform +from .Nodes import StatListNode + + +class ExtractPxdCode(VisitorTransform): + """ + Finds nodes in a pxd file that should generate code, and + returns them in a StatListNode. + + The result is a tuple (StatListNode, ModuleScope), i.e. + everything that is needed from the pxd after it is processed. + + A purer approach would be to separately compile the pxd code, + but the result would have to be slightly more sophisticated + than pure strings (functions + wanted interned strings + + wanted utility code + wanted cached objects) so for now this + approach is taken. + """ + + def __call__(self, root): + self.funcs = [] + self.visitchildren(root) + return (StatListNode(root.pos, stats=self.funcs), root.scope) + + def visit_FuncDefNode(self, node): + self.funcs.append(node) + # Do not visit children, nested funcdefnodes will + # also be moved by this action... + return node + + def visit_Node(self, node): + self.visitchildren(node) + return node diff --git a/venv/lib/python3.10/site-packages/Cython/Compiler/CythonScope.py b/venv/lib/python3.10/site-packages/Cython/Compiler/CythonScope.py new file mode 100644 index 0000000000000000000000000000000000000000..82bccfcb5242d7e84bda08055158723bc16696cd --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Compiler/CythonScope.py @@ -0,0 +1,187 @@ +from .Symtab import ModuleScope +from .PyrexTypes import * +from .UtilityCode import CythonUtilityCode +from .Errors import error +from .Scanning import StringSourceDescriptor +from . import MemoryView +from .StringEncoding import EncodedString + + +class CythonScope(ModuleScope): + is_cython_builtin = 1 + _cythonscope_initialized = False + + def __init__(self, context): + ModuleScope.__init__(self, 'cython', None, None) + self.pxd_file_loaded = True + self.populate_cython_scope() + # The Main.Context object + self._context = context + + for fused_type in (cy_integral_type, cy_floating_type, cy_numeric_type): + entry = self.declare_typedef(fused_type.name, + fused_type, + None, + cname='') + entry.in_cinclude = True + + entry = self.declare_type( + "pymutex", cy_pymutex_type, None, + cname="__Pyx_Locks_PyMutex") + entry = self.declare_type( + "pythread_type_lock", cy_pythread_type_lock_type, None, + cname="__Pyx_Locks_PyThreadTypeLock") + + def is_cpp(self): + # Allow C++ utility code in C++ contexts. + return self.context.cpp + + def lookup_type(self, name): + # This function should go away when types are all first-level objects. + type = parse_basic_type(name) + if type: + return type + + return super().lookup_type(name) + + def lookup(self, name): + entry = super().lookup(name) + + if entry is None and not self._cythonscope_initialized: + self.load_cythonscope() + entry = super().lookup(name) + + return entry + + def find_module(self, module_name, pos): + error("cython.%s is not available" % module_name, pos) + + def find_submodule(self, module_name, as_package=False): + entry = self.entries.get(module_name, None) + if not entry: + self.load_cythonscope() + entry = self.entries.get(module_name, None) + + if entry and entry.as_module: + return entry.as_module + else: + # TODO: fix find_submodule control flow so that we're not + # expected to create a submodule here (to protect CythonScope's + # possible immutability). Hack ourselves out of the situation + # for now. + raise error((StringSourceDescriptor("cython", ""), 0, 0), + "cython.%s is not available" % module_name) + + def lookup_qualified_name(self, qname): + # ExprNode.as_cython_attribute generates qnames and we untangle it here... + name_path = qname.split('.') + scope = self + while len(name_path) > 1: + scope = scope.lookup_here(name_path[0]) + if scope: + scope = scope.as_module + del name_path[0] + if scope is None: + return None + else: + return scope.lookup_here(name_path[0]) + + def populate_cython_scope(self): + # These are used to optimize isinstance in FinalOptimizePhase + type_object = self.declare_typedef( + 'PyTypeObject', + base_type = c_void_type, + pos = None, + cname = 'PyTypeObject') + type_object.is_void = True + type_object_type = type_object.type + + self.declare_cfunction( + 'PyObject_TypeCheck', + CFuncType(c_bint_type, [CFuncTypeArg("o", py_object_type, None), + CFuncTypeArg("t", c_ptr_type(type_object_type), None)]), + pos = None, + defining = 1, + cname = 'PyObject_TypeCheck') + + def load_cythonscope(self): + """ + Creates some entries for testing purposes and entries for + cython.array() and for cython.view.*. + """ + if self._cythonscope_initialized: + return + + self._cythonscope_initialized = True + cython_testscope_utility_code.declare_in_scope( + self, cython_scope=self) + cython_test_extclass_utility_code.declare_in_scope( + self, cython_scope=self) + + # + # The view sub-scope + # + self.viewscope = viewscope = ModuleScope('view', self, None) + self.declare_module('view', viewscope, None).as_module = viewscope + viewscope.is_cython_builtin = True + viewscope.pxd_file_loaded = True + + cythonview_testscope_utility_code.declare_in_scope( + viewscope, cython_scope=self) + + view_utility_scope = MemoryView.get_view_utility_code( + self.context.shared_utility_qualified_name + ).declare_in_scope( + self.viewscope, cython_scope=self, allowlist=MemoryView.view_utility_allowlist) + + # Marks the types as being cython_builtin_type so that they can be + # extended from without Cython attempting to import cython.view + ext_types = [ entry.type + for entry in view_utility_scope.entries.values() + if entry.type.is_extension_type ] + for ext_type in ext_types: + ext_type.is_cython_builtin_type = 1 + + # self.entries["array"] = view_utility_scope.entries.pop("array") + + # dataclasses scope + dc_str = EncodedString('dataclasses') + dataclassesscope = ModuleScope(dc_str, self, context=None) + self.declare_module(dc_str, dataclassesscope, pos=None).as_module = dataclassesscope + dataclassesscope.is_cython_builtin = True + dataclassesscope.pxd_file_loaded = True + # doesn't actually have any contents + + +def create_cython_scope(context): + # One could in fact probably make it a singleton, + # but not sure yet whether any code mutates it (which would kill reusing + # it across different contexts) + return CythonScope(context) + +# Load test utilities for the cython scope + +def load_testscope_utility(cy_util_name, **kwargs): + return CythonUtilityCode.load(cy_util_name, "TestCythonScope.pyx", **kwargs) + + +undecorated_methods_protos = UtilityCode(proto=""" + /* These methods are undecorated and have therefore no prototype */ + static PyObject *__pyx_TestClass_cdef_method( + struct __pyx_TestClass_obj *self, int value); + static PyObject *__pyx_TestClass_cpdef_method( + struct __pyx_TestClass_obj *self, int value, int skip_dispatch); + static PyObject *__pyx_TestClass_def_method( + PyObject *self, PyObject *value); +""") + +cython_testscope_utility_code = load_testscope_utility("TestScope") + +test_cython_utility_dep = load_testscope_utility("TestDep") + +cython_test_extclass_utility_code = \ + load_testscope_utility("TestClass", name="TestClass", + requires=[undecorated_methods_protos, + test_cython_utility_dep]) + +cythonview_testscope_utility_code = load_testscope_utility("View.TestScope") diff --git a/venv/lib/python3.10/site-packages/Cython/Compiler/Dataclass.py b/venv/lib/python3.10/site-packages/Cython/Compiler/Dataclass.py new file mode 100644 index 0000000000000000000000000000000000000000..50d08d9608209ba53e88289a42b589e458baee61 --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Compiler/Dataclass.py @@ -0,0 +1,868 @@ +# functions to transform a c class into a dataclass + +from collections import OrderedDict +from textwrap import dedent +import operator + +from . import ExprNodes +from . import Nodes +from . import PyrexTypes +from . import Builtin +from . import Naming +from .Errors import error, warning +from .Code import UtilityCode, TempitaUtilityCode, PyxCodeWriter +from .Visitor import VisitorTransform +from .StringEncoding import EncodedString +from .TreeFragment import TreeFragment +from .ParseTreeTransforms import NormalizeTree, SkipDeclarations +from .Options import copy_inherited_directives + +_dataclass_loader_utilitycode = None + +def make_dataclasses_module_callnode(pos): + global _dataclass_loader_utilitycode + if not _dataclass_loader_utilitycode: + python_utility_code = UtilityCode.load_cached("Dataclasses_fallback", "Dataclasses.py") + python_utility_code = EncodedString(python_utility_code.impl) + _dataclass_loader_utilitycode = TempitaUtilityCode.load( + "SpecificModuleLoader", "Dataclasses.c", + context={'cname': "dataclasses", 'py_code': python_utility_code.as_c_string_literal()}) + return ExprNodes.PythonCapiCallNode( + pos, "__Pyx_Load_dataclasses_Module", + PyrexTypes.CFuncType(PyrexTypes.py_object_type, []), + utility_code=_dataclass_loader_utilitycode, + args=[], + ) + +def make_dataclass_call_helper(pos, callable, kwds): + utility_code = UtilityCode.load_cached("DataclassesCallHelper", "Dataclasses.c") + func_type = PyrexTypes.CFuncType( + PyrexTypes.py_object_type, [ + PyrexTypes.CFuncTypeArg("callable", PyrexTypes.py_object_type, None), + PyrexTypes.CFuncTypeArg("kwds", PyrexTypes.py_object_type, None) + ], + ) + return ExprNodes.PythonCapiCallNode( + pos, + function_name="__Pyx_DataclassesCallHelper", + func_type=func_type, + utility_code=utility_code, + args=[callable, kwds], + ) + + +class RemoveAssignmentsToNames(VisitorTransform, SkipDeclarations): + """ + Cython (and Python) normally treats + + class A: + x = 1 + + as generating a class attribute. However for dataclasses the `= 1` should be interpreted as + a default value to initialize an instance attribute with. + This transform therefore removes the `x=1` assignment so that the class attribute isn't + generated, while recording what it has removed so that it can be used in the initialization. + """ + def __init__(self, names): + super().__init__() + self.names = names + self.removed_assignments = {} + + def visit_CClassNode(self, node): + self.visitchildren(node) + return node + + def visit_PyClassNode(self, node): + return node # go no further + + def visit_FuncDefNode(self, node): + return node # go no further + + def visit_SingleAssignmentNode(self, node): + if node.lhs.is_name and node.lhs.name in self.names: + if node.lhs.name in self.removed_assignments: + warning(node.pos, ("Multiple assignments for '%s' in dataclass; " + "using most recent") % node.lhs.name, 1) + self.removed_assignments[node.lhs.name] = node.rhs + return [] + return node + + # I believe cascaded assignment is always a syntax error with annotations + # so there's no need to define visit_CascadedAssignmentNode + + def visit_Node(self, node): + self.visitchildren(node) + return node + + +class TemplateCode: + """ + Adds the ability to keep track of placeholder argument names to PyxCodeWriter. + + Also adds extra_stats which are nodes bundled at the end when this + is converted to a tree. + """ + _placeholder_count = 0 + + def __init__(self, writer=None, placeholders=None, extra_stats=None): + self.writer = PyxCodeWriter() if writer is None else writer + self.placeholders = {} if placeholders is None else placeholders + self.extra_stats = [] if extra_stats is None else extra_stats + + def add_code_line(self, code_line): + self.writer.putln(code_line) + + def add_code_chunk(self, code_chunk): + self.writer.put_chunk(code_chunk) + + def reset(self): + # don't attempt to reset placeholders - it really doesn't matter if + # we have unused placeholders + self.writer.reset() + + def empty(self): + return self.writer.empty() + + def indent(self): + self.writer.indent() + + def dedent(self): + self.writer.dedent() + + def indenter(self, block_opener_line): + return self.writer.indenter(block_opener_line) + + def new_placeholder(self, field_names, value): + name = self._new_placeholder_name(field_names) + self.placeholders[name] = value + return name + + def add_extra_statements(self, statements): + if self.extra_stats is None: + assert False, "Can only use add_extra_statements on top-level writer" + self.extra_stats.extend(statements) + + def _new_placeholder_name(self, field_names): + while True: + name = f"DATACLASS_PLACEHOLDER_{self._placeholder_count:d}" + if (name not in self.placeholders + and name not in field_names): + # make sure name isn't already used and doesn't + # conflict with a variable name (which is unlikely but possible) + break + self._placeholder_count += 1 + return name + + def generate_tree(self, level='c_class'): + stat_list_node = TreeFragment( + self.writer.getvalue(), + level=level, + pipeline=[NormalizeTree(None)], + ).substitute(self.placeholders) + + stat_list_node.stats += self.extra_stats + return stat_list_node + + def insertion_point(self): + new_writer = self.writer.insertion_point() + return TemplateCode( + writer=new_writer, + placeholders=self.placeholders, + extra_stats=self.extra_stats + ) + + +class _MISSING_TYPE: + pass +MISSING = _MISSING_TYPE() + + +class Field: + """ + Field is based on the dataclasses.field class from the standard library module. + It is used internally during the generation of Cython dataclasses to keep track + of the settings for individual attributes. + + Attributes of this class are stored as nodes so they can be used in code construction + more readily (i.e. we store BoolNode rather than bool) + """ + default = MISSING + default_factory = MISSING + private = False + + literal_keys = ("repr", "hash", "init", "compare", "metadata") + + # default values are defined by the CPython dataclasses.field + def __init__(self, pos, default=MISSING, default_factory=MISSING, + repr=None, hash=None, init=None, + compare=None, metadata=None, + is_initvar=False, is_classvar=False, + **additional_kwds): + if default is not MISSING: + self.default = default + if default_factory is not MISSING: + self.default_factory = default_factory + self.repr = repr or ExprNodes.BoolNode(pos, value=True) + self.hash = hash or ExprNodes.NoneNode(pos) + self.init = init or ExprNodes.BoolNode(pos, value=True) + self.compare = compare or ExprNodes.BoolNode(pos, value=True) + self.metadata = metadata or ExprNodes.NoneNode(pos) + self.is_initvar = is_initvar + self.is_classvar = is_classvar + + for k, v in additional_kwds.items(): + # There should not be any additional keywords! + error(v.pos, "cython.dataclasses.field() got an unexpected keyword argument '%s'" % k) + + for field_name in self.literal_keys: + field_value = getattr(self, field_name) + if not field_value.is_literal: + error(field_value.pos, + "cython.dataclasses.field parameter '%s' must be a literal value" % field_name) + + def iterate_record_node_arguments(self): + for key in (self.literal_keys + ('default', 'default_factory')): + value = getattr(self, key) + if value is not MISSING: + yield key, value + + +def process_class_get_fields(node): + var_entries = node.scope.var_entries + # order of definition is used in the dataclass + var_entries = sorted(var_entries, key=operator.attrgetter('pos')) + var_names = [entry.name for entry in var_entries] + + # don't treat `x = 1` as an assignment of a class attribute within the dataclass + transform = RemoveAssignmentsToNames(var_names) + transform(node) + default_value_assignments = transform.removed_assignments + + base_type = node.base_type + fields = OrderedDict() + while base_type: + if base_type.is_external or not base_type.scope.implemented: + warning(node.pos, "Cannot reliably handle Cython dataclasses with base types " + "in external modules since it is not possible to tell what fields they have", 2) + if base_type.dataclass_fields: + fields = base_type.dataclass_fields.copy() + break + base_type = base_type.base_type + + for entry in var_entries: + name = entry.name + is_initvar = entry.declared_with_pytyping_modifier("dataclasses.InitVar") + # TODO - classvars aren't included in "var_entries" so are missed here + # and thus this code is never triggered + is_classvar = entry.declared_with_pytyping_modifier("typing.ClassVar") + if name in default_value_assignments: + assignment = default_value_assignments[name] + if (isinstance(assignment, ExprNodes.CallNode) and ( + assignment.function.as_cython_attribute() == "dataclasses.field" or + Builtin.exprnode_to_known_standard_library_name( + assignment.function, node.scope) == "dataclasses.field")): + # I believe most of this is well-enforced when it's treated as a directive + # but it doesn't hurt to make sure + valid_general_call = (isinstance(assignment, ExprNodes.GeneralCallNode) + and isinstance(assignment.positional_args, ExprNodes.TupleNode) + and not assignment.positional_args.args + and (assignment.keyword_args is None or isinstance(assignment.keyword_args, ExprNodes.DictNode))) + valid_simple_call = (isinstance(assignment, ExprNodes.SimpleCallNode) and not assignment.args) + if not (valid_general_call or valid_simple_call): + error(assignment.pos, "Call to 'cython.dataclasses.field' must only consist " + "of compile-time keyword arguments") + continue + keyword_args = assignment.keyword_args.as_python_dict() if valid_general_call and assignment.keyword_args else {} + if 'default' in keyword_args and 'default_factory' in keyword_args: + error(assignment.pos, "cannot specify both default and default_factory") + continue + field = Field(node.pos, **keyword_args) + else: + if assignment.type in [Builtin.list_type, Builtin.dict_type, Builtin.set_type]: + # The standard library module generates a TypeError at runtime + # in this situation. + # Error message is copied from CPython + error(assignment.pos, "mutable default for field {} is not allowed: " + "use default_factory".format(assignment.type.name, name)) + + field = Field(node.pos, default=assignment) + else: + field = Field(node.pos) + field.is_initvar = is_initvar + field.is_classvar = is_classvar + if entry.visibility == "private": + field.private = True + fields[name] = field + node.entry.type.dataclass_fields = fields + return fields + + +def handle_cclass_dataclass(node, dataclass_args, analyse_decs_transform): + # default argument values from https://docs.python.org/3/library/dataclasses.html + kwargs = dict(init=True, repr=True, eq=True, + order=False, unsafe_hash=False, + frozen=False, kw_only=False, match_args=True) + if dataclass_args is not None: + if dataclass_args[0]: + error(node.pos, "cython.dataclasses.dataclass takes no positional arguments") + for k, v in dataclass_args[1].items(): + if k not in kwargs: + error(node.pos, + "cython.dataclasses.dataclass() got an unexpected keyword argument '%s'" % k) + if not isinstance(v, ExprNodes.BoolNode): + error(node.pos, + "Arguments passed to cython.dataclasses.dataclass must be True or False") + kwargs[k] = v.value + + kw_only = kwargs['kw_only'] + + fields = process_class_get_fields(node) + + dataclass_module = make_dataclasses_module_callnode(node.pos) + + # create __dataclass_params__ attribute. I try to use the exact + # `_DataclassParams` class defined in the standard library module if at all possible + # for maximum duck-typing compatibility. + dataclass_params_func = ExprNodes.AttributeNode(node.pos, obj=dataclass_module, + attribute=EncodedString("_DataclassParams")) + dataclass_params_keywords = ExprNodes.DictNode.from_pairs( + node.pos, + [ (ExprNodes.IdentifierStringNode(node.pos, value=EncodedString(k)), + ExprNodes.BoolNode(node.pos, value=v)) + for k, v in kwargs.items() ] + + [ (ExprNodes.IdentifierStringNode(node.pos, value=EncodedString(k)), + ExprNodes.BoolNode(node.pos, value=v)) + for k, v in [('kw_only', kw_only), + ('slots', False), ('weakref_slot', False)] + ]) + dataclass_params = make_dataclass_call_helper( + node.pos, dataclass_params_func, dataclass_params_keywords) + dataclass_params_assignment = Nodes.SingleAssignmentNode( + node.pos, + lhs = ExprNodes.NameNode(node.pos, name=EncodedString("__dataclass_params__")), + rhs = dataclass_params) + + dataclass_fields_stats = _set_up_dataclass_fields(node, fields, dataclass_module) + + stats = Nodes.StatListNode(node.pos, + stats=[dataclass_params_assignment] + dataclass_fields_stats) + + code = TemplateCode() + generate_init_code(code, kwargs['init'], node, fields, kw_only) + generate_match_args(code, kwargs['match_args'], node, fields, kw_only) + generate_repr_code(code, kwargs['repr'], node, fields) + generate_eq_code(code, kwargs['eq'], node, fields) + generate_order_code(code, kwargs['order'], node, fields) + generate_hash_code(code, kwargs['unsafe_hash'], kwargs['eq'], kwargs['frozen'], node, fields) + + stats.stats += code.generate_tree().stats + + # turn off annotation typing, so all arguments to __init__ are accepted as + # generic objects and thus can accept _HAS_DEFAULT_FACTORY. + # Type conversion comes later + comp_directives = Nodes.CompilerDirectivesNode(node.pos, + directives=copy_inherited_directives(node.scope.directives, annotation_typing=False), + body=stats) + + comp_directives.analyse_declarations(node.scope) + # probably already in this scope, but it doesn't hurt to make sure + analyse_decs_transform.enter_scope(node, node.scope) + analyse_decs_transform.visit(comp_directives) + analyse_decs_transform.exit_scope() + + node.body.stats.append(comp_directives) + + +def generate_init_code(code, init, node, fields, kw_only): + """ + Notes on CPython generated "__init__": + * Implemented in `_init_fn`. + * The use of the `dataclasses._HAS_DEFAULT_FACTORY` sentinel value as + the default argument for fields that need constructing with a factory + function is copied from the CPython implementation. (`None` isn't + suitable because it could also be a value for the user to pass.) + There's no real reason why it needs importing from the dataclasses module + though - it could equally be a value generated by Cython when the module loads. + * seen_default and the associated error message are copied directly from Python + * Call to user-defined __post_init__ function (if it exists) is copied from + CPython. + + Cython behaviour deviates a little here (to be decided if this is right...) + Because the class variable from the assignment does not exist Cython fields will + return None (or whatever their type default is) if not initialized while Python + dataclasses will fall back to looking up the class variable. + """ + if not init or node.scope.lookup_here("__init__"): + return + + # selfname behaviour copied from the cpython module + selfname = "__dataclass_self__" if "self" in fields else "self" + args = [selfname] + + if kw_only: + args.append("*") + + function_start_point = code.insertion_point() + code = code.insertion_point() + code.indent() + + # create a temp to get _HAS_DEFAULT_FACTORY + dataclass_module = make_dataclasses_module_callnode(node.pos) + has_default_factory = ExprNodes.AttributeNode( + node.pos, + obj=dataclass_module, + attribute=EncodedString("_HAS_DEFAULT_FACTORY") + ) + + default_factory_placeholder = code.new_placeholder(fields, has_default_factory) + + seen_default = False + for name, field in fields.items(): + entry = node.scope.lookup(name) + if entry.annotation: + annotation = f": {entry.annotation.string.value}" + else: + annotation = "" + assignment = '' + if field.default is not MISSING or field.default_factory is not MISSING: + if field.init.value: + seen_default = True + if field.default_factory is not MISSING: + ph_name = default_factory_placeholder + else: + ph_name = code.new_placeholder(fields, field.default) # 'default' should be a node + assignment = f" = {ph_name}" + elif seen_default and not kw_only and field.init.value: + error(entry.pos, ("non-default argument '%s' follows default argument " + "in dataclass __init__") % name) + code.reset() + return + + if field.init.value: + args.append(f"{name}{annotation}{assignment}") + + if field.is_initvar: + continue + elif field.default_factory is MISSING: + if field.init.value: + code.add_code_line(f"{selfname}.{name} = {name}") + elif assignment: + # not an argument to the function, but is still initialized + code.add_code_line(f"{selfname}.{name}{assignment}") + else: + ph_name = code.new_placeholder(fields, field.default_factory) + if field.init.value: + # close to: + # def __init__(self, name=_PLACEHOLDER_VALUE): + # self.name = name_default_factory() if name is _PLACEHOLDER_VALUE else name + code.add_code_line( + f"{selfname}.{name} = {ph_name}() if {name} is {default_factory_placeholder} else {name}" + ) + else: + # still need to use the default factory to initialize + code.add_code_line(f"{selfname}.{name} = {ph_name}()") + + if node.scope.lookup("__post_init__"): + post_init_vars = ", ".join(name for name, field in fields.items() + if field.is_initvar) + code.add_code_line(f"{selfname}.__post_init__({post_init_vars})") + + if code.empty(): + code.add_code_line("pass") + + args = ", ".join(args) + function_start_point.add_code_line(f"def __init__({args}):") + + +def generate_match_args(code, match_args, node, fields, global_kw_only): + """ + Generates a tuple containing what would be the positional args to __init__ + + Note that this is generated even if the user overrides init + """ + if not match_args or node.scope.lookup_here("__match_args__"): + return + positional_arg_names = [] + for field_name, field in fields.items(): + # TODO hasattr and global_kw_only can be removed once full kw_only support is added + field_is_kw_only = global_kw_only or ( + hasattr(field, 'kw_only') and field.kw_only.value + ) + if not field_is_kw_only: + positional_arg_names.append(field_name) + code.add_code_line("__match_args__ = %s" % str(tuple(positional_arg_names))) + + +def generate_repr_code(code, repr, node, fields): + """ + The core of the CPython implementation is just: + ['return self.__class__.__qualname__ + f"(' + + ', '.join([f"{f.name}={{self.{f.name}!r}}" + for f in fields]) + + ')"'], + + The only notable difference here is self.__class__.__qualname__ -> type(self).__name__ + which is because Cython currently supports Python 2. + + However, it also has some guards for recursive repr invocations. In the standard + library implementation they're done with a wrapper decorator that captures a set + (with the set keyed by id and thread). Here we create a set as a thread local + variable and key only by id. + """ + if not repr or node.scope.lookup("__repr__"): + return + + # The recursive guard is likely a little costly, so skip it if possible. + # is_gc_simple defines where it can contain recursive objects + needs_recursive_guard = False + for name in fields.keys(): + entry = node.scope.lookup(name) + type_ = entry.type + if type_.is_memoryviewslice: + type_ = type_.dtype + if not type_.is_pyobject: + continue # no GC + if not type_.is_gc_simple: + needs_recursive_guard = True + break + + if needs_recursive_guard: + code.add_code_chunk(""" + __pyx_recursive_repr_guard = __import__('threading').local() + __pyx_recursive_repr_guard.running = set() + """) + + with code.indenter("def __repr__(self):"): + if needs_recursive_guard: + code.add_code_chunk(""" + key = id(self) + guard_set = self.__pyx_recursive_repr_guard.running + if key in guard_set: return '...' + guard_set.add(key) + try: + """) + code.indent() + + strs = ["%s={self.%s!r}" % (name, name) + for name, field in fields.items() + if field.repr.value and not field.is_initvar] + format_string = ", ".join(strs) + + code.add_code_chunk(f''' + name = getattr(type(self), "__qualname__", None) or type(self).__name__ + return f'{{name}}({format_string})' + ''') + if needs_recursive_guard: + code.dedent() + with code.indenter("finally:"): + code.add_code_line("guard_set.remove(key)") + + +def generate_cmp_code(code, op, funcname, node, fields): + if node.scope.lookup_here(funcname): + return + + names = [name for name, field in fields.items() if (field.compare.value and not field.is_initvar)] + + with code.indenter(f"def {funcname}(self, other):"): + code.add_code_chunk(f""" + if other.__class__ is not self.__class__: return NotImplemented + + cdef {node.class_name} other_cast + other_cast = <{node.class_name}>other + """) + + # The Python implementation of dataclasses.py does a tuple comparison + # (roughly): + # return self._attributes_to_tuple() {op} other._attributes_to_tuple() + # + # For the Cython implementation a tuple comparison isn't an option because + # not all attributes can be converted to Python objects and stored in a tuple + # + # TODO - better diagnostics of whether the types support comparison before + # generating the code. Plus, do we want to convert C structs to dicts and + # compare them that way (I think not, but it might be in demand)? + checks = [] + op_without_equals = op.replace('=', '') + + for name in names: + if op != '==': + # tuple comparison rules - early elements take precedence + code.add_code_line(f"if self.{name} {op_without_equals} other_cast.{name}: return True") + code.add_code_line(f"if self.{name} != other_cast.{name}: return False") + code.add_code_line(f"return {'True' if '=' in op else 'False'}") # "() == ()" is True + + +def generate_eq_code(code, eq, node, fields): + if not eq: + return + generate_cmp_code(code, "==", "__eq__", node, fields) + + +def generate_order_code(code, order, node, fields): + if not order: + return + + for op, name in [("<", "__lt__"), + ("<=", "__le__"), + (">", "__gt__"), + (">=", "__ge__")]: + generate_cmp_code(code, op, name, node, fields) + + +def generate_hash_code(code, unsafe_hash, eq, frozen, node, fields): + """ + Copied from CPython implementation - the intention is to follow this as far as + is possible: + # +------------------- unsafe_hash= parameter + # | +----------- eq= parameter + # | | +--- frozen= parameter + # | | | + # v v v | | | + # | no | yes | <--- class has explicitly defined __hash__ + # +=======+=======+=======+========+========+ + # | False | False | False | | | No __eq__, use the base class __hash__ + # +-------+-------+-------+--------+--------+ + # | False | False | True | | | No __eq__, use the base class __hash__ + # +-------+-------+-------+--------+--------+ + # | False | True | False | None | | <-- the default, not hashable + # +-------+-------+-------+--------+--------+ + # | False | True | True | add | | Frozen, so hashable, allows override + # +-------+-------+-------+--------+--------+ + # | True | False | False | add | raise | Has no __eq__, but hashable + # +-------+-------+-------+--------+--------+ + # | True | False | True | add | raise | Has no __eq__, but hashable + # +-------+-------+-------+--------+--------+ + # | True | True | False | add | raise | Not frozen, but hashable + # +-------+-------+-------+--------+--------+ + # | True | True | True | add | raise | Frozen, so hashable + # +=======+=======+=======+========+========+ + # For boxes that are blank, __hash__ is untouched and therefore + # inherited from the base class. If the base is object, then + # id-based hashing is used. + + The Python implementation creates a tuple of all the fields, then hashes them. + This implementation creates a tuple of all the hashes of all the fields and hashes that. + The reason for this slight difference is to avoid to-Python conversions for anything + that Cython knows how to hash directly (It doesn't look like this currently applies to + anything though...). + """ + + hash_entry = node.scope.lookup_here("__hash__") + if hash_entry: + # TODO ideally assignment of __hash__ to None shouldn't trigger this + # but difficult to get the right information here + if unsafe_hash: + # error message taken from CPython dataclasses module + error(node.pos, "Cannot overwrite attribute __hash__ in class %s" % node.class_name) + return + + if not unsafe_hash: + if not eq: + return + if not frozen: + code.add_extra_statements([ + Nodes.SingleAssignmentNode( + node.pos, + lhs=ExprNodes.NameNode(node.pos, name=EncodedString("__hash__")), + rhs=ExprNodes.NoneNode(node.pos), + ) + ]) + return + + names = [ + name for name, field in fields.items() + if not field.is_initvar and ( + field.compare.value if field.hash.value is None else field.hash.value) + ] + + # make a tuple of the hashes + hash_tuple_items = ", ".join("self.%s" % name for name in names) + if hash_tuple_items: + hash_tuple_items += "," # ensure that one arg form is a tuple + + # if we're here we want to generate a hash + with code.indenter("def __hash__(self):"): + code.add_code_line(f"return hash(({hash_tuple_items}))") + + +def get_field_type(pos, entry): + """ + sets the .type attribute for a field + + Returns the annotation if possible (since this is what the dataclasses + module does). If not (for example, attributes defined with cdef) then + it creates a string fallback. + """ + if entry.annotation: + # Right now it doesn't look like cdef classes generate an + # __annotations__ dict, therefore it's safe to just return + # entry.annotation + # (TODO: remove .string if we ditch PEP563) + return entry.annotation.string + # If they do in future then we may need to look up into that + # to duplicating the node. The code below should do this: + #class_name_node = ExprNodes.NameNode(pos, name=entry.scope.name) + #annotations = ExprNodes.AttributeNode( + # pos, obj=class_name_node, + # attribute=EncodedString("__annotations__") + #) + #return ExprNodes.IndexNode( + # pos, base=annotations, + # index=ExprNodes.UnicodeNode(pos, value=entry.name) + #) + else: + # it's slightly unclear what the best option is here - we could + # try to return PyType_Type. This case should only happen with + # attributes defined with cdef so Cython is free to make it's own + # decision + s = EncodedString(entry.type.declaration_code("", for_display=1)) + return ExprNodes.UnicodeNode(pos, value=s) + + +class FieldRecordNode(ExprNodes.ExprNode): + """ + __dataclass_fields__ contains a bunch of field objects recording how each field + of the dataclass was initialized (mainly corresponding to the arguments passed to + the "field" function). This node is used for the attributes of these field objects. + + If possible, coerces `arg` to a Python object. + Otherwise, generates a sensible backup string. + """ + subexprs = ['arg'] + + def __init__(self, pos, arg): + super().__init__(pos, arg=arg) + + def analyse_types(self, env): + self.arg.analyse_types(env) + self.type = self.arg.type + return self + + def coerce_to_pyobject(self, env): + if self.arg.type.can_coerce_to_pyobject(env): + return self.arg.coerce_to_pyobject(env) + else: + # A string representation of the code that gave the field seems like a reasonable + # fallback. This'll mostly happen for "default" and "default_factory" where the + # type may be a C-type that can't be converted to Python. + return self._make_string() + + def _make_string(self): + from .AutoDocTransforms import AnnotationWriter + writer = AnnotationWriter(description="Dataclass field") + string = writer.write(self.arg) + return ExprNodes.UnicodeNode(self.pos, value=EncodedString(string)) + + def generate_evaluation_code(self, code): + return self.arg.generate_evaluation_code(code) + + +def _set_up_dataclass_fields(node, fields, dataclass_module): + # For defaults and default_factories containing things like lambda, + # they're already declared in the class scope, and it creates a big + # problem if multiple copies are floating around in both the __init__ + # function, and in the __dataclass_fields__ structure. + # Therefore, create module-level constants holding these values and + # pass those around instead + # + # If possible we use the `Field` class defined in the standard library + # module so that the information stored here is as close to a regular + # dataclass as is possible. + variables_assignment_stats = [] + for name, field in fields.items(): + if field.private: + continue # doesn't appear in the public interface + for attrname in [ "default", "default_factory" ]: + field_default = getattr(field, attrname) + if field_default is MISSING or field_default.is_literal or field_default.is_name: + # some simple cases where we don't need to set up + # the variable as a module-level constant + continue + global_scope = node.scope.global_scope() + module_field_name = global_scope.mangle( + global_scope.mangle(Naming.dataclass_field_default_cname, node.class_name), + name) + # create an entry in the global scope for this variable to live + field_node = ExprNodes.NameNode(field_default.pos, name=EncodedString(module_field_name)) + field_node.entry = global_scope.declare_var( + field_node.name, type=field_default.type or PyrexTypes.unspecified_type, + pos=field_default.pos, cname=field_node.name, is_cdef=True, + # TODO: do we need to set 'pytyping_modifiers' here? + ) + # replace the field so that future users just receive the namenode + setattr(field, attrname, field_node) + + variables_assignment_stats.append( + Nodes.SingleAssignmentNode(field_default.pos, lhs=field_node, rhs=field_default)) + + placeholders = {} + field_func = ExprNodes.AttributeNode(node.pos, obj=dataclass_module, + attribute=EncodedString("field")) + dc_fields = ExprNodes.DictNode(node.pos, key_value_pairs=[]) + dc_fields_namevalue_assignments = [] + + for name, field in fields.items(): + if field.private: + continue # doesn't appear in the public interface + type_placeholder_name = "PLACEHOLDER_%s" % name + placeholders[type_placeholder_name] = get_field_type( + node.pos, node.scope.entries[name] + ) + + # defining these make the fields introspect more like a Python dataclass + field_type_placeholder_name = "PLACEHOLDER_FIELD_TYPE_%s" % name + if field.is_initvar: + placeholders[field_type_placeholder_name] = ExprNodes.AttributeNode( + node.pos, obj=dataclass_module, + attribute=EncodedString("_FIELD_INITVAR") + ) + elif field.is_classvar: + # TODO - currently this isn't triggered + placeholders[field_type_placeholder_name] = ExprNodes.AttributeNode( + node.pos, obj=dataclass_module, + attribute=EncodedString("_FIELD_CLASSVAR") + ) + else: + placeholders[field_type_placeholder_name] = ExprNodes.AttributeNode( + node.pos, obj=dataclass_module, + attribute=EncodedString("_FIELD") + ) + + dc_field_keywords = ExprNodes.DictNode.from_pairs( + node.pos, + [(ExprNodes.IdentifierStringNode(node.pos, value=EncodedString(k)), + FieldRecordNode(node.pos, arg=v)) + for k, v in field.iterate_record_node_arguments()] + + ) + dc_field_call = make_dataclass_call_helper( + node.pos, field_func, dc_field_keywords + ) + dc_fields.key_value_pairs.append( + ExprNodes.DictItemNode( + node.pos, + key=ExprNodes.IdentifierStringNode(node.pos, value=EncodedString(name)), + value=dc_field_call)) + dc_fields_namevalue_assignments.append( + dedent(f"""\ + __dataclass_fields__[{name!r}].name = {name!r} + __dataclass_fields__[{name!r}].type = {type_placeholder_name} + __dataclass_fields__[{name!r}]._field_type = {field_type_placeholder_name} + """)) + + dataclass_fields_assignment = \ + Nodes.SingleAssignmentNode(node.pos, + lhs = ExprNodes.NameNode(node.pos, + name=EncodedString("__dataclass_fields__")), + rhs = dc_fields) + + dc_fields_namevalue_assignments = "\n".join(dc_fields_namevalue_assignments) + dc_fields_namevalue_assignments = TreeFragment(dc_fields_namevalue_assignments, + level="c_class", + pipeline=[NormalizeTree(None)]) + dc_fields_namevalue_assignments = dc_fields_namevalue_assignments.substitute(placeholders) + + return (variables_assignment_stats + + [dataclass_fields_assignment] + + dc_fields_namevalue_assignments.stats) diff --git a/venv/lib/python3.10/site-packages/Cython/Compiler/DebugFlags.py b/venv/lib/python3.10/site-packages/Cython/Compiler/DebugFlags.py new file mode 100644 index 0000000000000000000000000000000000000000..8f86e038d31e8e4bca34df4c198e04a4f7b02f74 --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Compiler/DebugFlags.py @@ -0,0 +1,24 @@ +# Can be enabled at the command line with --debug-xxx. + +debug_disposal_code = 0 +debug_temp_alloc = 0 +debug_coercion = 0 + +# Write comments into the C code that show where temporary variables +# are allocated and released. +debug_temp_code_comments = 0 + +# Write a call trace of the code generation phase into the C code. +debug_trace_code_generation = 0 + +# Do not replace exceptions with user-friendly error messages. +debug_no_exception_intercept = 0 + +# Print a message each time a new stage in the pipeline is entered. +debug_verbose_pipeline = 0 + +# Print a message each time an Entry type is assigned. +debug_verbose_entry_types = False + +# Raise an exception when an error is encountered. +debug_exception_on_error = 0 diff --git a/venv/lib/python3.10/site-packages/Cython/Compiler/Errors.py b/venv/lib/python3.10/site-packages/Cython/Compiler/Errors.py new file mode 100644 index 0000000000000000000000000000000000000000..336ebc3e135422b996c35b7503dd93e80896e8a3 --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Compiler/Errors.py @@ -0,0 +1,295 @@ +# +# Errors +# + +any_string_type = (bytes, str) + +import sys +from contextlib import contextmanager + +try: + from threading import local as _threadlocal +except ImportError: + class _threadlocal: pass + +threadlocal = _threadlocal() + +from ..Utils import open_new_file +from . import DebugFlags +from . import Options + + +class PyrexError(Exception): + pass + + +class PyrexWarning(Exception): + pass + +class CannotSpecialize(PyrexError): + pass + +def context(position): + source = position[0] + assert not (isinstance(source, any_string_type)), ( + "Please replace filename strings with Scanning.FileSourceDescriptor instances %r" % source) + try: + F = source.get_lines() + except UnicodeDecodeError: + # file has an encoding problem + s = "[unprintable code]\n" + else: + s = ''.join(F[max(0, position[1]-6):position[1]]) + s = '...\n%s%s^\n' % (s, ' '*(position[2])) + s = '%s\n%s%s\n' % ('-'*60, s, '-'*60) + return s + +def format_position(position): + if position: + return "%s:%d:%d: " % (position[0].get_error_description(), + position[1], position[2]) + return '' + +def format_error(message, position): + if position: + pos_str = format_position(position) + cont = context(position) + message = '\nError compiling Cython file:\n%s\n%s%s' % (cont, pos_str, message or '') + return message + +class CompileError(PyrexError): + + def __init__(self, position = None, message = ""): + self.position = position + self.message_only = message + self.formatted_message = format_error(message, position) + self.reported = False + Exception.__init__(self, self.formatted_message) + # Python Exception subclass pickling is broken, + # see https://bugs.python.org/issue1692335 + self.args = (position, message) + + def __str__(self): + return self.formatted_message + +class CompileWarning(PyrexWarning): + + def __init__(self, position = None, message = ""): + self.position = position + Exception.__init__(self, format_position(position) + message) + +class InternalError(Exception): + # If this is ever raised, there is a bug in the compiler. + + def __init__(self, message): + self.message_only = message + Exception.__init__(self, "Internal compiler error: %s" + % message) + +class AbortError(Exception): + # Throw this to stop the compilation immediately. + + def __init__(self, message): + self.message_only = message + Exception.__init__(self, "Abort error: %s" % message) + +class CompilerCrash(CompileError): + # raised when an unexpected exception occurs in a transform + def __init__(self, pos, context, message, cause, stacktrace=None): + if message: + message = '\n' + message + else: + message = '\n' + self.message_only = message + if context: + message = "Compiler crash in %s%s" % (context, message) + if stacktrace: + import traceback + message += ( + '\n\nCompiler crash traceback from this point on:\n' + + ''.join(traceback.format_tb(stacktrace))) + if cause: + if not stacktrace: + message += '\n' + message += '%s: %s' % (cause.__class__.__name__, cause) + CompileError.__init__(self, pos, message) + # Python Exception subclass pickling is broken, + # see https://bugs.python.org/issue1692335 + self.args = (pos, context, message, cause, stacktrace) + +class NoElementTreeInstalledException(PyrexError): + """raised when the user enabled options.gdb_debug but no ElementTree + implementation was found + """ + +def open_listing_file(path, echo_to_stderr=True): + # Begin a new error listing. If path is None, no file + # is opened, the error counter is just reset. + if path is not None: + threadlocal.cython_errors_listing_file = open_new_file(path) + else: + threadlocal.cython_errors_listing_file = None + if echo_to_stderr: + threadlocal.cython_errors_echo_file = sys.stderr + else: + threadlocal.cython_errors_echo_file = None + threadlocal.cython_errors_count = 0 + +def close_listing_file(): + if threadlocal.cython_errors_listing_file: + threadlocal.cython_errors_listing_file.close() + threadlocal.cython_errors_listing_file = None + +def report_error(err, use_stack=True): + error_stack = threadlocal.cython_errors_stack + if error_stack and use_stack: + error_stack[-1].append(err) + else: + # See Main.py for why dual reporting occurs. Quick fix for now. + if err.reported: return + err.reported = True + try: line = "%s\n" % err + except UnicodeEncodeError: + # Python <= 2.5 does this for non-ASCII Unicode exceptions + line = format_error(getattr(err, 'message_only', "[unprintable exception message]"), + getattr(err, 'position', None)) + '\n' + listing_file = threadlocal.cython_errors_listing_file + if listing_file: + try: listing_file.write(line) + except UnicodeEncodeError: + listing_file.write(line.encode('ASCII', 'replace')) + echo_file = threadlocal.cython_errors_echo_file + if echo_file: + try: echo_file.write(line) + except UnicodeEncodeError: + echo_file.write(line.encode('ASCII', 'replace')) + threadlocal.cython_errors_count += 1 + if Options.fast_fail: + raise AbortError("fatal errors") + +def error(position, message): + #print("Errors.error:", repr(position), repr(message)) ### + if position is None: + raise InternalError(message) + err = CompileError(position, message) + if DebugFlags.debug_exception_on_error: raise Exception(err) # debug + report_error(err) + return err + + +LEVEL = 1 # warn about all errors level 1 or higher + +def _write_file_encode(file, line): + try: + file.write(line) + except UnicodeEncodeError: + file.write(line.encode('ascii', 'replace')) + + +def performance_hint(position, message, env): + if not env.directives['show_performance_hints']: + return + warn = CompileWarning(position, message) + line = "performance hint: %s\n" % warn + listing_file = threadlocal.cython_errors_listing_file + if listing_file: + _write_file_encode(listing_file, line) + echo_file = threadlocal.cython_errors_echo_file + if echo_file: + _write_file_encode(echo_file, line) + return warn + + +def message(position, message, level=1): + if level < LEVEL: + return + warn = CompileWarning(position, message) + line = "note: %s\n" % warn + listing_file = threadlocal.cython_errors_listing_file + if listing_file: + _write_file_encode(listing_file, line) + echo_file = threadlocal.cython_errors_echo_file + if echo_file: + _write_file_encode(echo_file, line) + return warn + + +def warning(position, message, level=0): + if level < LEVEL: + return + if Options.warning_errors and position: + return error(position, message) + warn = CompileWarning(position, message) + line = "warning: %s\n" % warn + listing_file = threadlocal.cython_errors_listing_file + if listing_file: + _write_file_encode(listing_file, line) + echo_file = threadlocal.cython_errors_echo_file + if echo_file: + _write_file_encode(echo_file, line) + return warn + + +def warn_once(position, message, level=0): + if level < LEVEL: + return + warn_once_seen = threadlocal.cython_errors_warn_once_seen + if message in warn_once_seen: + return + warn = CompileWarning(position, message) + line = "warning: %s\n" % warn + listing_file = threadlocal.cython_errors_listing_file + if listing_file: + _write_file_encode(listing_file, line) + echo_file = threadlocal.cython_errors_echo_file + if echo_file: + _write_file_encode(echo_file, line) + warn_once_seen.add(message) + return warn + + +# These functions can be used to momentarily suppress errors. + +def hold_errors(): + errors = [] + threadlocal.cython_errors_stack.append(errors) + return errors + + +def release_errors(ignore=False): + held_errors = threadlocal.cython_errors_stack.pop() + if not ignore: + for err in held_errors: + report_error(err) + + +def held_errors(): + return threadlocal.cython_errors_stack[-1] + + +# same as context manager: + +@contextmanager +def local_errors(ignore=False): + errors = hold_errors() + try: + yield errors + finally: + release_errors(ignore=ignore) + + +# Keep all global state in thread local storage to support parallel cythonisation in distutils. + +def init_thread(): + threadlocal.cython_errors_count = 0 + threadlocal.cython_errors_listing_file = None + threadlocal.cython_errors_echo_file = None + threadlocal.cython_errors_warn_once_seen = set() + threadlocal.cython_errors_stack = [] + +def reset(): + threadlocal.cython_errors_warn_once_seen.clear() + del threadlocal.cython_errors_stack[:] + +def get_errors_count(): + return threadlocal.cython_errors_count diff --git a/venv/lib/python3.10/site-packages/Cython/Compiler/ExprNodes.py b/venv/lib/python3.10/site-packages/Cython/Compiler/ExprNodes.py new file mode 100644 index 0000000000000000000000000000000000000000..18cd30f66996789ab96c716e5d619d4d9b2d7cbf --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Compiler/ExprNodes.py @@ -0,0 +1,15305 @@ +# +# Parse tree nodes for expressions +# + + +import cython +cython.declare(error=object, warning=object, warn_once=object, InternalError=object, + CompileError=object, UtilityCode=object, TempitaUtilityCode=object, + StringEncoding=object, operator=object, local_errors=object, report_error=object, + Naming=object, Nodes=object, PyrexTypes=object, py_object_type=object, + list_type=object, tuple_type=object, set_type=object, dict_type=object, + unicode_type=object, bytes_type=object, type_type=object, + Builtin=object, Symtab=object, Utils=object, find_coercion_error=object, + debug_disposal_code=object, debug_temp_alloc=object, debug_coercion=object, + bytearray_type=object, slice_type=object, memoryview_type=object, + builtin_sequence_types=object, build_line_table=object, + inspect=object, copy=object, os=object, pathlib=object, re=object, sys=object, +) + +import copy +import inspect +import operator +import os.path +import pathlib +import re +import sys +from typing import Optional + +from .Errors import ( + error, warning, InternalError, CompileError, report_error, local_errors, + CannotSpecialize, performance_hint) +from .Code import UtilityCode, TempitaUtilityCode +from .LineTable import build_line_table +from . import StringEncoding +from . import Naming +from . import Nodes +from .Nodes import Node, SingleAssignmentNode +from . import PyrexTypes +from .PyrexTypes import c_char_ptr_type, py_object_type, typecast, error_type, \ + unspecified_type +from . import TypeSlots +from .Builtin import ( + list_type, tuple_type, set_type, dict_type, type_type, + unicode_type, bytes_type, bytearray_type, + slice_type, sequence_types as builtin_sequence_types, memoryview_type, +) +from . import Builtin +from . import Symtab +from .. import Utils +from .Annotate import AnnotationItem +from . import Future +from ..Debugging import print_call_chain +from .DebugFlags import debug_disposal_code, debug_coercion + +from .Pythran import (to_pythran, is_pythran_supported_type, is_pythran_supported_operation_type, + is_pythran_expr, pythran_func_type, pythran_binop_type, pythran_unaryop_type, has_np_pythran, + pythran_indexing_code, pythran_indexing_type, is_pythran_supported_node_or_none, pythran_type, + pythran_is_numpy_func_supported, pythran_get_func_include_file, pythran_functor) +from .PyrexTypes import PythranExpr + +any_string_type = (bytes, str) + + +class NotConstant: + _obj = None + + def __new__(cls): + if NotConstant._obj is None: + NotConstant._obj = super().__new__(cls) + + return NotConstant._obj + + def __repr__(self): + return "" + +not_a_constant = NotConstant() +constant_value_not_set = object() + +# error messages when coercing from key[0] to key[1] +coercion_error_dict = { + # string related errors + (unicode_type, bytes_type): "Cannot convert Unicode string to 'bytes' implicitly, encoding required.", + (unicode_type, PyrexTypes.c_char_ptr_type): "Unicode objects only support coercion to Py_UNICODE*.", + (unicode_type, PyrexTypes.c_const_char_ptr_type): "Unicode objects only support coercion to Py_UNICODE*.", + (unicode_type, PyrexTypes.c_uchar_ptr_type): "Unicode objects only support coercion to Py_UNICODE*.", + (unicode_type, PyrexTypes.c_const_uchar_ptr_type): "Unicode objects only support coercion to Py_UNICODE*.", + (bytes_type, unicode_type): "Cannot convert 'bytes' object to str implicitly, decoding required", + (bytes_type, PyrexTypes.c_py_unicode_ptr_type): "Cannot convert 'bytes' object to Py_UNICODE*, use 'str'.", + (bytes_type, PyrexTypes.c_const_py_unicode_ptr_type): ( + "Cannot convert 'bytes' object to Py_UNICODE*, use 'str'."), + (PyrexTypes.c_char_ptr_type, unicode_type): "Cannot convert 'char*' to unicode implicitly, decoding required", + (PyrexTypes.c_const_char_ptr_type, unicode_type): ( + "Cannot convert 'char*' to unicode implicitly, decoding required"), + (PyrexTypes.c_uchar_ptr_type, unicode_type): "Cannot convert 'char*' to unicode implicitly, decoding required", + (PyrexTypes.c_const_uchar_ptr_type, unicode_type): ( + "Cannot convert 'char*' to unicode implicitly, decoding required"), + (PyrexTypes.cy_pymutex_type, PyrexTypes.cy_pymutex_type): ( + "cython.pymutex cannot be copied"), + (PyrexTypes.cy_pythread_type_lock_type, PyrexTypes.cy_pythread_type_lock_type): ( + "cython.pythread_type_lock cannot be copied"), +} + +def find_coercion_error(type_tuple, default, env): + err = coercion_error_dict.get(type_tuple) + if err is None: + return default + elif (env.directives['c_string_encoding'] and + any(t in type_tuple for t in (PyrexTypes.c_char_ptr_type, PyrexTypes.c_uchar_ptr_type, + PyrexTypes.c_const_char_ptr_type, PyrexTypes.c_const_uchar_ptr_type))): + if type_tuple[1].is_pyobject: + return default + elif env.directives['c_string_encoding'] in ('ascii', 'utf8'): + return default + else: + return "'%s' objects do not support coercion to C types with non-ascii or non-utf8 c_string_encoding" % type_tuple[0].name + else: + return err + + +def default_str_type(env): + return { + 'bytes': bytes_type, + 'bytearray': bytearray_type, + 'str': unicode_type, + 'unicode': unicode_type + }.get(env.directives['c_string_type']) + + +def check_negative_indices(*nodes): + """ + Raise a warning on nodes that are known to have negative numeric values. + Used to find (potential) bugs inside of "wraparound=False" sections. + """ + for node in nodes: + if node is None or not isinstance(node.constant_result, (int, float)): + continue + if node.constant_result < 0: + warning(node.pos, + "the result of using negative indices inside of " + "code sections marked as 'wraparound=False' is " + "undefined", level=1) + + +def infer_sequence_item_type(env, seq_node, index_node=None, seq_type=None): + if not seq_node.is_sequence_constructor: + if seq_type is None: + seq_type = seq_node.infer_type(env) + if seq_type is tuple_type: + # tuples are immutable => we can safely follow assignments + if seq_node.cf_state and len(seq_node.cf_state) == 1: + try: + seq_node = seq_node.cf_state[0].rhs + except AttributeError: + pass + if seq_node is not None and seq_node.is_sequence_constructor: + if index_node is not None and index_node.has_constant_result(): + try: + item = seq_node.args[index_node.constant_result] + except (ValueError, TypeError, IndexError): + pass + else: + return item.infer_type(env) + # if we're lucky, all items have the same type + item_types = { + infer_sequence_item_type(env, item) if item.is_starred else item.infer_type(env) + for item in seq_node.args + } + if len(item_types) == 1: + return item_types.pop() + return None + + +def make_dedup_key(outer_type, item_nodes): + """ + Recursively generate a deduplication key from a sequence of values. + Includes Cython node types to work around the fact that (1, 2.0) == (1.0, 2), for example. + + @param outer_type: The type of the outer container. + @param item_nodes: A sequence of constant nodes that will be traversed recursively. + @return: A tuple that can be used as a dict key for deduplication. + """ + item_keys = [ + (py_object_type, None, type(None)) if node is None + # For sequences and their "mult_factor", see TupleNode. + else make_dedup_key(node.type, [node.mult_factor if node.is_literal else None] + node.args) if node.is_sequence_constructor + else make_dedup_key(node.type, (node.start, node.stop, node.step)) if node.is_slice + # For constants, look at the Python value type if we don't know the concrete Cython type. + else (node.type, node.constant_result, + type(node.constant_result) if node.type is py_object_type else None) if node.has_constant_result() + else None # something we cannot handle => short-circuit below + for node in item_nodes + ] + if None in item_keys: + return None + return outer_type, tuple(item_keys) + + +# Returns a block of code to translate the exception, +# plus a boolean indicating whether to check for Python exceptions. +def get_exception_handler(exception_value): + if exception_value is None: + return "__Pyx_CppExn2PyErr();", False + elif (exception_value.type == PyrexTypes.c_char_type + and exception_value.value == '*'): + return "__Pyx_CppExn2PyErr();", True + elif exception_value.type.is_pyobject: + return ( + 'try { throw; } catch(const std::exception& exn) {' + 'PyErr_SetString(%s, exn.what());' + '} catch(...) { PyErr_SetNone(%s); }' % ( + exception_value.entry.cname, + exception_value.entry.cname), + False) + else: + return ( + '%s(); if (!PyErr_Occurred())' + 'PyErr_SetString(PyExc_RuntimeError, ' + '"Error converting c++ exception.");' % ( + exception_value.entry.cname), + False) + + +def maybe_check_py_error(code, check_py_exception, pos, nogil): + if check_py_exception: + if nogil: + code.globalstate.use_utility_code( + UtilityCode.load_cached("ErrOccurredWithGIL", "Exceptions.c")) + code.putln(code.error_goto_if("__Pyx_ErrOccurredWithGIL()", pos)) + else: + code.putln(code.error_goto_if("PyErr_Occurred()", pos)) + + +def translate_cpp_exception(code, pos, inside, py_result, exception_value, nogil): + raise_py_exception, check_py_exception = get_exception_handler(exception_value) + code.putln("try {") + code.putln("%s" % inside) + if py_result: + code.putln(code.error_goto_if_null(py_result, pos)) + maybe_check_py_error(code, check_py_exception, pos, nogil) + code.putln("} catch(...) {") + if nogil: + code.put_ensure_gil(declare_gilstate=True) + code.putln(raise_py_exception) + if nogil: + code.put_release_ensured_gil() + code.putln(code.error_goto(pos)) + code.putln("}") + +def needs_cpp_exception_conversion(node): + assert node.exception_check == "+" + if node.exception_value is None: + return True + # exception_value can be a NameNode + # (in which case it's used as a handler function and no conversion is needed) + if node.exception_value.is_name: + return False + # or a CharNode with a value of "*" + if isinstance(node.exception_value, CharNode) and node.exception_value.value == "*": + return True + # Most other const-nodes are disallowed after "+" by the parser + return False + + +# Used to handle the case where an lvalue expression and an overloaded assignment +# both have an exception declaration. +def translate_double_cpp_exception(code, pos, lhs_type, lhs_code, rhs_code, lhs_exc_val, assign_exc_val, nogil): + handle_lhs_exc, lhc_check_py_exc = get_exception_handler(lhs_exc_val) + handle_assignment_exc, assignment_check_py_exc = get_exception_handler(assign_exc_val) + code.putln("try {") + code.putln(lhs_type.declaration_code("__pyx_local_lvalue = %s;" % lhs_code)) + maybe_check_py_error(code, lhc_check_py_exc, pos, nogil) + code.putln("try {") + code.putln("__pyx_local_lvalue = %s;" % rhs_code) + maybe_check_py_error(code, assignment_check_py_exc, pos, nogil) + # Catch any exception from the overloaded assignment. + code.putln("} catch(...) {") + if nogil: + code.put_ensure_gil(declare_gilstate=True) + code.putln(handle_assignment_exc) + if nogil: + code.put_release_ensured_gil() + code.putln(code.error_goto(pos)) + code.putln("}") + # Catch any exception from evaluating lhs. + code.putln("} catch(...) {") + if nogil: + code.put_ensure_gil(declare_gilstate=True) + code.putln(handle_lhs_exc) + if nogil: + code.put_release_ensured_gil() + code.putln(code.error_goto(pos)) + code.putln('}') + + +class ExprNode(Node): + # subexprs [string] Class var holding names of subexpr node attrs + # type PyrexType Type of the result + # result_code string Code fragment + # result_ctype string C type of result_code if different from type + # is_temp boolean Result is in a temporary variable + # is_sequence_constructor + # boolean Is a list or tuple constructor expression + # is_starred boolean Is a starred expression (e.g. '*a') + # use_managed_ref boolean use ref-counted temps/assignments/etc. + # result_is_used boolean indicates that the result will be dropped and the + # result_code/temp_result can safely be set to None + # is_numpy_attribute boolean Is a Numpy module attribute + # annotation ExprNode or None PEP526 annotation for names or expressions + # generator_arg_tag None or Node A tag to mark ExprNodes that potentially need to + # be changed to a generator argument + + result_ctype = None + type = None + annotation = None + temp_code = None + old_temp = None # error checker for multiple frees etc. + use_managed_ref = True # can be set by optimisation transforms + result_is_used = True + is_numpy_attribute = False + generator_arg_tag = None + + # The Analyse Expressions phase for expressions is split + # into two sub-phases: + # + # Analyse Types + # Determines the result type of the expression based + # on the types of its sub-expressions, and inserts + # coercion nodes into the expression tree where needed. + # Marks nodes which will need to have temporary variables + # allocated. + # + # Allocate Temps + # Allocates temporary variables where needed, and fills + # in the result_code field of each node. + # + # ExprNode provides some convenience routines which + # perform both of the above phases. These should only + # be called from statement nodes, and only when no + # coercion nodes need to be added around the expression + # being analysed. In that case, the above two phases + # should be invoked separately. + # + # Framework code in ExprNode provides much of the common + # processing for the various phases. It makes use of the + # 'subexprs' class attribute of ExprNodes, which should + # contain a list of the names of attributes which can + # hold sub-nodes or sequences of sub-nodes. + # + # The framework makes use of a number of abstract methods. + # Their responsibilities are as follows. + # + # Declaration Analysis phase + # + # analyse_target_declaration + # Called during the Analyse Declarations phase to analyse + # the LHS of an assignment or argument of a del statement. + # Nodes which cannot be the LHS of an assignment need not + # implement it. + # + # Expression Analysis phase + # + # analyse_types + # - Call analyse_types on all sub-expressions. + # - Check operand types, and wrap coercion nodes around + # sub-expressions where needed. + # - Set the type of this node. + # - If a temporary variable will be required for the + # result, set the is_temp flag of this node. + # + # analyse_target_types + # Called during the Analyse Types phase to analyse + # the LHS of an assignment or argument of a del + # statement. Similar responsibilities to analyse_types. + # + # target_code + # Called by the default implementation of allocate_target_temps. + # Should return a C lvalue for assigning to the node. The default + # implementation calls calculate_result_code. + # + # check_const + # - Check that this node and its subnodes form a + # legal constant expression. If so, do nothing, + # otherwise call not_const. + # + # The default implementation of check_const + # assumes that the expression is not constant. + # + # check_const_addr + # - Same as check_const, except check that the + # expression is a C lvalue whose address is + # constant. Otherwise, call addr_not_const. + # + # The default implementation of calc_const_addr + # assumes that the expression is not a constant + # lvalue. + # + # Code Generation phase + # + # generate_evaluation_code + # - Call generate_evaluation_code for sub-expressions. + # - Perform the functions of generate_result_code + # (see below). + # - If result is temporary, call generate_disposal_code + # on all sub-expressions. + # + # A default implementation of generate_evaluation_code + # is provided which uses the following abstract methods: + # + # generate_result_code + # - Generate any C statements necessary to calculate + # the result of this node from the results of its + # sub-expressions. + # + # calculate_result_code + # - Should return a C code fragment evaluating to the + # result. This is only called when the result is not + # a temporary. + # + # generate_assignment_code + # Called on the LHS of an assignment. + # - Call generate_evaluation_code for sub-expressions. + # - Generate code to perform the assignment. + # - If the assignment absorbed a reference, call + # generate_post_assignment_code on the RHS, + # otherwise call generate_disposal_code on it. + # + # generate_deletion_code + # Called on an argument of a del statement. + # - Call generate_evaluation_code for sub-expressions. + # - Generate code to perform the deletion. + # - Call generate_disposal_code on all sub-expressions. + # + # + + is_sequence_constructor = False + is_dict_literal = False + is_set_literal = False + is_string_literal = False + is_attribute = False + is_subscript = False + is_slice = False + + is_buffer_access = False + is_memview_index = False + is_memview_slice = False + is_memview_broadcast = False + is_memview_copy_assignment = False + + is_temp = False + has_temp_moved = False # if True then attempting to do anything but free the temp is invalid + is_target = False + is_starred = False + + constant_result = constant_value_not_set + + if sys.implementation.name == "cpython": + child_attrs = property(fget=operator.attrgetter('subexprs')) + else: + @property + def child_attrs(self): + return self.subexprs + + def analyse_annotations(self, env): + pass + + def not_implemented(self, method_name): + print_call_chain(method_name, "not implemented") + raise InternalError( + "%s.%s not implemented" % (self.__class__.__name__, method_name)) + + def is_lvalue(self): + return 0 + + def is_addressable(self): + return self.is_lvalue() and not self.type.is_memoryviewslice + + def is_ephemeral(self): + # An ephemeral node is one whose result is in + # a Python temporary and we suspect there are no + # other references to it. Certain operations are + # disallowed on such values, since they are + # likely to result in a dangling pointer. + return self.type.is_pyobject and self.is_temp + + def subexpr_nodes(self): + # Extract a list of subexpression nodes based + # on the contents of the subexprs class attribute. + nodes = [] + for name in self.subexprs: + item = getattr(self, name) + if item is not None: + if type(item) is list: + nodes.extend(item) + else: + nodes.append(item) + return nodes + + def result(self): + if self.is_temp: + #if not self.temp_code: + # pos = (os.path.basename(self.pos[0].get_description()),) + self.pos[1:] if self.pos else '(?)' + # raise RuntimeError("temp result name not set in %s at %r" % ( + # self.__class__.__name__, pos)) + return self.temp_code + else: + return self.calculate_result_code() + + def _make_move_result_rhs(self, result, optional=False): + if optional and not (self.is_temp and self.type.is_cpp_class and not self.type.is_reference): + return result + self.has_temp_moved = True + return "{}({})".format("__PYX_STD_MOVE_IF_SUPPORTED" if optional else "std::move", result) + + def move_result_rhs(self): + return self._make_move_result_rhs(self.result(), optional=True) + + def move_result_rhs_as(self, type): + result = self.result_as(type) + if not (type.is_reference or type.needs_refcounting): + requires_move = type.is_rvalue_reference and self.is_temp + result = self._make_move_result_rhs(result, optional=not requires_move) + return result + + def pythran_result(self, type_=None): + if is_pythran_supported_node_or_none(self): + return to_pythran(self) + + assert type_ is not None + return to_pythran(self, type_) + + def is_c_result_required(self): + """ + Subtypes may return False here if result temp allocation can be skipped. + """ + return True + + def result_as(self, type = None): + # Return the result code cast to the specified C type. + if (self.is_temp and self.type.is_pyobject and + type != py_object_type): + # Allocated temporaries are always PyObject *, which may not + # reflect the actual type (e.g. an extension type) + return typecast(type, py_object_type, self.result()) + return typecast(type, self.ctype(), self.result()) + + def py_result(self): + # Return the result code cast to PyObject *. + return self.result_as(py_object_type) + + def ctype(self): + # Return the native C type of the result (i.e. the + # C type of the result_code expression). + return self.result_ctype or self.type + + def get_constant_c_result_code(self): + # Return the constant value of this node as a result code + # string, or None if the node is not constant. This method + # can be called when the constant result code is required + # before the code generation phase. + # + # The return value is a string that can represent a simple C + # value, a constant C name or a constant C expression. If the + # node type depends on Python code, this must return None. + return None + + def calculate_constant_result(self): + # Calculate the constant compile time result value of this + # expression and store it in ``self.constant_result``. Does + # nothing by default, thus leaving ``self.constant_result`` + # unknown. If valid, the result can be an arbitrary Python + # value. + # + # This must only be called when it is assured that all + # sub-expressions have a valid constant_result value. The + # ConstantFolding transform will do this. + pass + + def has_constant_result(self): + return self.constant_result is not constant_value_not_set and \ + self.constant_result is not not_a_constant + + def compile_time_value(self, denv): + # Return value of compile-time expression, or report error. + error(self.pos, "Invalid compile-time expression") + + def compile_time_value_error(self, e): + error(self.pos, "Error in compile-time expression: %s: %s" % ( + e.__class__.__name__, e)) + + def as_exception_value(self, env): + # Return the constant Python value if possible. + # This can be either a Python constant or a string + # for types that can't be represented by a Python constant + # (e.g. enums) + if self.has_constant_result(): + return self.constant_result + # this isn't the preferred fallback because it can end up + # hard to distinguish between identical types, e.g. -1.0 vs -1 + # for floats. However, it lets things like NULL and typecasts work + result = self.get_constant_c_result_code() + if result is not None: + return result + error(self.pos, "Exception value must be constant") + + # ------------- Declaration Analysis ---------------- + + def analyse_target_declaration(self, env): + error(self.pos, "Cannot assign to or delete this") + + def analyse_assignment_expression_target_declaration(self, env): + error(self.pos, "Cannot use anything except a name in an assignment expression") + + # ------------- Expression Analysis ---------------- + + def analyse_const_expression(self, env): + # Called during the analyse_declarations phase of a + # constant expression. Analyses the expression's type, + # checks whether it is a legal const expression, + # and determines its value. + node = self.analyse_types(env) + node.check_const() + return node + + def analyse_expressions(self, env): + # Convenience routine performing both the Type + # Analysis and Temp Allocation phases for a whole + # expression. + return self.analyse_types(env) + + def analyse_target_expression(self, env, rhs): + # Convenience routine performing both the Type + # Analysis and Temp Allocation phases for the LHS of + # an assignment. + return self.analyse_target_types(env) + + def analyse_boolean_expression(self, env): + # Analyse expression and coerce to a boolean. + node = self.analyse_types(env) + bool = node.coerce_to_boolean(env) + return bool + + def analyse_temp_boolean_expression(self, env): + # Analyse boolean expression and coerce result into + # a temporary. This is used when a branch is to be + # performed on the result and we won't have an + # opportunity to ensure disposal code is executed + # afterwards. By forcing the result into a temporary, + # we ensure that all disposal has been done by the + # time we get the result. + node = self.analyse_types(env) + return node.coerce_to_boolean(env).coerce_to_simple(env) + + # --------------- Type Inference ----------------- + + def type_dependencies(self, env): + # Returns the list of entries whose types must be determined + # before the type of self can be inferred. + if getattr(self, 'type', None) is not None: + return () + return sum([node.type_dependencies(env) for node in self.subexpr_nodes()], ()) + + def infer_type(self, env): + # Attempt to deduce the type of self. + # Differs from analyse_types as it avoids unnecessary + # analysis of subexpressions, but can assume everything + # in self.type_dependencies() has been resolved. + type = getattr(self, 'type', None) + if type is not None: + return type + entry = getattr(self, 'entry', None) + if entry is not None: + return entry.type + self.not_implemented("infer_type") + + def nonlocally_immutable(self): + # Returns whether this variable is a safe reference, i.e. + # can't be modified as part of globals or closures. + return self.is_literal or self.is_temp or self.type.is_array or self.type.is_cfunction + + def inferable_item_node(self, index=0): + """ + Return a node that represents the (type) result of an indexing operation, + e.g. for tuple unpacking or iteration. + """ + return IndexNode(self.pos, base=self, index=IntNode( + self.pos, value=str(index), constant_result=index, type=PyrexTypes.c_py_ssize_t_type)) + + # --------------- Type Analysis ------------------ + + def analyse_as_module(self, env): + # If this node can be interpreted as a reference to a + # cimported module, return its scope, else None. + return None + + def analyse_as_type(self, env): + # If this node can be interpreted as a reference to a + # type, return that type, else None. + return None + + def analyse_as_specialized_type(self, env): + type = self.analyse_as_type(env) + if type and type.is_fused and env.fused_to_specific: + # while it would be nice to test "if entry.type in env.fused_to_specific" + # rather than try/catch this doesn't work reliably (mainly for nested fused types) + try: + return type.specialize(env.fused_to_specific) + except KeyError: + pass + if type and type.is_fused: + error(self.pos, "Type is not specific") + return type + + def analyse_as_extension_type(self, env): + # If this node can be interpreted as a reference to an + # extension type or builtin type, return its type, else None. + return None + + def analyse_types(self, env): + self.not_implemented("analyse_types") + + def analyse_target_types(self, env): + return self.analyse_types(env) + + def nogil_check(self, env): + # By default, any expression based on Python objects is + # prevented in nogil environments. Subtypes must override + # this if they can work without the GIL. + if self.type and self.type.is_pyobject: + self.gil_error() + + def gil_assignment_check(self, env): + if env.nogil and self.type.is_pyobject: + error(self.pos, "Assignment of Python object not allowed without gil") + + def check_const(self): + self.not_const() + return False + + def not_const(self): + error(self.pos, "Not allowed in a constant expression") + + def check_const_addr(self): + self.addr_not_const() + return False + + def addr_not_const(self): + error(self.pos, "Address is not constant") + + # ----------------- Result Allocation ----------------- + + def result_in_temp(self): + # Return true if result is in a temporary owned by + # this node or one of its subexpressions. Overridden + # by certain nodes which can share the result of + # a subnode. + return self.is_temp + + def target_code(self): + # Return code fragment for use as LHS of a C assignment. + return self.calculate_result_code() + + def calculate_result_code(self): + self.not_implemented("calculate_result_code") + +# def release_target_temp(self, env): +# # Release temporaries used by LHS of an assignment. +# self.release_subexpr_temps(env) + + def allocate_temp_result(self, code): + if self.temp_code: + raise RuntimeError("Temp allocated multiple times in %r: %r" % (self.__class__.__name__, self.pos)) + type = self.type + if not type.is_void: + if type.is_pyobject: + type = PyrexTypes.py_object_type + elif not (self.result_is_used or type.is_memoryviewslice or self.is_c_result_required()): + self.temp_code = None + return + self.temp_code = code.funcstate.allocate_temp( + type, manage_ref=self.use_managed_ref) + else: + self.temp_code = None + + def release_temp_result(self, code): + if not self.temp_code: + if not self.result_is_used: + # not used anyway, so ignore if not set up + return + pos = (os.path.basename(self.pos[0].get_description()),) + self.pos[1:] if self.pos else '(?)' + if self.old_temp: + raise RuntimeError("temp %s released multiple times in %s at %r" % ( + self.old_temp, self.__class__.__name__, pos)) + else: + raise RuntimeError("no temp, but release requested in %s at %r" % ( + self.__class__.__name__, pos)) + code.funcstate.release_temp(self.temp_code) + self.old_temp = self.temp_code + self.temp_code = None + + # ---------------- Code Generation ----------------- + + def make_owned_reference(self, code): + """ + Make sure we own a reference to result. + If the result is in a temp, it is already a new reference. + """ + if not self.result_in_temp(): + code.put_incref(self.result(), self.ctype()) + + def make_owned_memoryviewslice(self, code): + """ + Make sure we own the reference to this memoryview slice. + """ + # TODO ideally this would be shared with "make_owned_reference" + if not self.result_in_temp(): + code.put_incref_memoryviewslice(self.result(), self.type, + have_gil=not self.in_nogil_context) + + def generate_evaluation_code(self, code): + # Generate code to evaluate this node and + # its sub-expressions, and dispose of any + # temporary results of its sub-expressions. + self.generate_subexpr_evaluation_code(code) + + code.mark_pos(self.pos) + if self.is_temp: + self.allocate_temp_result(code) + + self.generate_result_code(code) + if self.is_temp and not (self.type.is_string or self.type.is_pyunicode_ptr): + # If we are temp we do not need to wait until this node is disposed + # before disposing children. + self.generate_subexpr_disposal_code(code) + self.free_subexpr_temps(code) + + def generate_subexpr_evaluation_code(self, code): + for node in self.subexpr_nodes(): + node.generate_evaluation_code(code) + + def generate_result_code(self, code): + self.not_implemented("generate_result_code") + + def generate_disposal_code(self, code): + if self.has_temp_moved: + code.globalstate.use_utility_code( + UtilityCode.load_cached("MoveIfSupported", "CppSupport.cpp")) + if self.is_temp: + if self.type.is_string or self.type.is_pyunicode_ptr: + # postponed from self.generate_evaluation_code() + self.generate_subexpr_disposal_code(code) + self.free_subexpr_temps(code) + if self.result(): + code.put_decref_clear(self.result(), self.ctype(), + have_gil=not self.in_nogil_context) + else: + # Already done if self.is_temp + self.generate_subexpr_disposal_code(code) + + def generate_subexpr_disposal_code(self, code): + # Generate code to dispose of temporary results + # of all sub-expressions. + for node in self.subexpr_nodes(): + node.generate_disposal_code(code) + + def generate_post_assignment_code(self, code): + if self.is_temp: + if self.type.is_string or self.type.is_pyunicode_ptr: + # postponed from self.generate_evaluation_code() + self.generate_subexpr_disposal_code(code) + self.free_subexpr_temps(code) + elif self.type.is_pyobject: + code.putln("%s = 0;" % self.result()) + elif self.type.is_memoryviewslice: + code.putln("%s.memview = NULL;" % self.result()) + code.putln("%s.data = NULL;" % self.result()) + + if self.has_temp_moved: + code.globalstate.use_utility_code( + UtilityCode.load_cached("MoveIfSupported", "CppSupport.cpp")) + else: + self.generate_subexpr_disposal_code(code) + + def generate_assignment_code(self, rhs, code, overloaded_assignment=False, + exception_check=None, exception_value=None): + # Stub method for nodes which are not legal as + # the LHS of an assignment. An error will have + # been reported earlier. + pass + + def generate_deletion_code(self, code, ignore_nonexisting=False): + # Stub method for nodes that are not legal as + # the argument of a del statement. An error + # will have been reported earlier. + pass + + def free_temps(self, code): + if self.is_temp: + if not self.type.is_void: + self.release_temp_result(code) + else: + self.free_subexpr_temps(code) + + def free_subexpr_temps(self, code): + for sub in self.subexpr_nodes(): + sub.free_temps(code) + + def generate_function_definitions(self, env, code): + pass + + # ----Generation of small bits of reference counting -- + + def generate_decref_set(self, code, rhs): + code.put_decref_set(self.result(), self.ctype(), rhs) + + def generate_xdecref_set(self, code, rhs): + code.put_xdecref_set(self.result(), self.ctype(), rhs) + + def generate_gotref(self, code, handle_null=False, + maybe_null_extra_check=True): + if not (handle_null and self.cf_is_null): + if (handle_null and self.cf_maybe_null + and maybe_null_extra_check): + self.generate_xgotref(code) + else: + code.put_gotref(self.result(), self.ctype()) + + def generate_xgotref(self, code): + code.put_xgotref(self.result(), self.ctype()) + + def generate_giveref(self, code): + code.put_giveref(self.result(), self.ctype()) + + def generate_xgiveref(self, code): + code.put_xgiveref(self.result(), self.ctype()) + + # ---------------- Annotation --------------------- + + def annotate(self, code): + for node in self.subexpr_nodes(): + node.annotate(code) + + # ----------------- Coercion ---------------------- + + def coerce_to(self, dst_type, env): + # Coerce the result so that it can be assigned to + # something of type dst_type. If processing is necessary, + # wraps this node in a coercion node and returns that. + # Otherwise, returns this node unchanged. + # + # This method is called during the analyse_expressions + # phase of the src_node's processing. + # + # Note that subclasses that override this (especially + # ConstNodes) must not (re-)set their own .type attribute + # here. Since expression nodes may turn up in different + # places in the tree (e.g. inside of CloneNodes in cascaded + # assignments), this method must return a new node instance + # if it changes the type. + # + src = self + src_type = self.type + + if self.check_for_coercion_error(dst_type, env): + return self + + used_as_reference = dst_type.is_reference + if used_as_reference and not src_type.is_reference: + dst_type = dst_type.ref_base_type + + if src_type.is_cv_qualified: + src_type = src_type.cv_base_type + + if src_type.is_fused or dst_type.is_fused: + # See if we are coercing a fused function to a pointer to a + # specialized function + if (src_type.is_cfunction and not dst_type.is_fused and + dst_type.is_ptr and dst_type.base_type.is_cfunction): + + dst_type = dst_type.base_type + + for signature in src_type.get_all_specialized_function_types(): + if signature.same_as(dst_type): + src.type = signature + src.entry = src.type.entry + src.entry.used = True + return self + + if src_type.is_fused: + error(self.pos, "Type is not specialized") + elif src_type.is_null_ptr and dst_type.is_ptr: + # NULL can be implicitly cast to any pointer type + return self + else: + error(self.pos, "Cannot coerce to a type that is not specialized") + + self.type = error_type + return self + + if self.coercion_type is not None: + # This is purely for error checking purposes! + node = NameNode(self.pos, name='', type=self.coercion_type) + node.coerce_to(dst_type, env) + + if dst_type.is_memoryviewslice: + from . import MemoryView + if not src.type.is_memoryviewslice: + if src.type.is_pyobject: + src = CoerceToMemViewSliceNode(src, dst_type, env) + elif src.type.is_array: + src = CythonArrayNode.from_carray(src, env).coerce_to(dst_type, env) + elif not src_type.is_error: + error(self.pos, + "Cannot convert '%s' to memoryviewslice" % (src_type,)) + else: + if src.type.writable_needed: + dst_type.writable_needed = True + if not src.type.conforms_to(dst_type, broadcast=self.is_memview_broadcast, + copying=self.is_memview_copy_assignment): + if src.type.dtype.same_as(dst_type.dtype): + msg = "Memoryview '%s' not conformable to memoryview '%s'." + tup = src.type, dst_type + else: + msg = "Different base types for memoryviews (%s, %s)" + tup = src.type.dtype, dst_type.dtype + + error(self.pos, msg % tup) + + elif dst_type.is_pyobject: + # We never need a type check when assigning None to a Python object type. + if src.is_none: + pass + elif src.constant_result is None: + src = NoneNode(src.pos).coerce_to(dst_type, env) + else: + if not src.type.is_pyobject: + if dst_type is bytes_type and src.type.is_int: + src = CoerceIntToBytesNode(src, env) + else: + src = CoerceToPyTypeNode(src, env, type=dst_type) + # FIXME: I would expect that CoerceToPyTypeNode(type=dst_type) returns a value of type dst_type + # but it doesn't for ctuples. Thus, we add a PyTypeTestNode which then triggers the + # Python conversion and becomes useless. That seems backwards and inefficient. + # We should not need a PyTypeTestNode after a previous conversion above. + if not src.type.subtype_of(dst_type): + src = PyTypeTestNode(src, dst_type, env) + elif is_pythran_expr(dst_type) and is_pythran_supported_type(src.type): + # We let the compiler decide whether this is valid + return src + elif is_pythran_expr(src.type): + if is_pythran_supported_type(dst_type): + # Match the case were a pythran expr is assigned to a value, or vice versa. + # We let the C++ compiler decide whether this is valid or not! + return src + # Else, we need to convert the Pythran expression to a Python object + src = CoerceToPyTypeNode(src, env, type=dst_type) + elif src.type.is_pyobject: + if used_as_reference and dst_type.is_cpp_class: + warning( + self.pos, + "Cannot pass Python object as C++ data structure reference (%s &), will pass by copy." % dst_type) + src = CoerceFromPyTypeNode(dst_type, src, env) + elif (dst_type.is_complex + and src_type != dst_type + and dst_type.assignable_from(src_type)): + src = CoerceToComplexNode(src, dst_type, env) + elif (src_type is PyrexTypes.soft_complex_type + and src_type != dst_type + and not dst_type.assignable_from(src_type)): + src = coerce_from_soft_complex(src, dst_type, env) + else: + # neither src nor dst are py types + # Added the string comparison, since for c types that + # is enough, but Cython gets confused when the types are + # in different pxi files. + # TODO: Remove this hack and require shared declarations. + if not (src.type == dst_type or str(src.type) == str(dst_type) or dst_type.assignable_from(src_type)): + self.fail_assignment(dst_type) + return src + + def fail_assignment(self, dst_type): + src_name = self.entry.name if hasattr(self, "entry") else None + src_resolved = f" (alias of '{self.type.resolve()}')" if self.type.is_typedef else "" + dst_resolved = f" (alias of '{dst_type.resolve()}')" if dst_type.is_typedef else "" + extra_diagnostics = dst_type.assignment_failure_extra_info(self.type, src_name) + error(self.pos, + f"Cannot assign type '{self.type}'{src_resolved}" + f" to '{dst_type}'{dst_resolved}" + f"{'.' if extra_diagnostics else ''}{extra_diagnostics}" + ) + + def check_for_coercion_error(self, dst_type, env, fail=False, default=None): + if fail and not default: + default = "Cannot assign type '%(FROM)s' to '%(TO)s'" + message = find_coercion_error((self.type, dst_type), default, env) + if message is not None: + error(self.pos, message % {'FROM': self.type, 'TO': dst_type}) + return True + if fail: + self.fail_assignment(dst_type) + return True + return False + + def coerce_to_pyobject(self, env): + return self.coerce_to(PyrexTypes.py_object_type, env) + + def coerce_to_boolean(self, env): + # Coerce result to something acceptable as + # a boolean value. + + # if it's constant, calculate the result now + if self.has_constant_result(): + bool_value = bool(self.constant_result) + return BoolNode(self.pos, value=bool_value, + constant_result=bool_value) + + type = self.type + if type.is_enum or type.is_error: + return self + elif type is PyrexTypes.c_bint_type: + return self + elif type.is_pyobject or type.is_int or type.is_ptr or type.is_float: + return CoerceToBooleanNode(self, env) + elif type.is_cpp_class and type.scope and type.scope.lookup("operator bool"): + return SimpleCallNode( + self.pos, + function=AttributeNode( + self.pos, obj=self, attribute=StringEncoding.EncodedString('operator bool')), + args=[]).analyse_types(env) + elif type.is_ctuple: + bool_value = len(type.components) == 0 + return BoolNode(self.pos, value=bool_value, + constant_result=bool_value) + else: + error(self.pos, "Type '%s' not acceptable as a boolean" % type) + return self + + def coerce_to_index(self, env): + # If not already some C integer type, coerce to Py_ssize_t. + return self if self.type.is_int else self.coerce_to(PyrexTypes.c_py_ssize_t_type, env) + + def coerce_to_temp(self, env): + # Ensure that the result is in a temporary. + if self.result_in_temp(): + return self + else: + return CoerceToTempNode(self, env) + + def coerce_to_simple(self, env): + # Ensure that the result is simple (see is_simple). + if self.is_simple(): + return self + else: + return self.coerce_to_temp(env) + + def is_simple(self): + # A node is simple if its result is something that can + # be referred to without performing any operations, e.g. + # a constant, local var, C global var, struct member + # reference, or temporary. + return self.result_in_temp() + + def try_is_simple(self): + # Allow ".is_simple()" to fail (e.g. before type analysis) and assume it's not simple. + try: + return self.is_simple() + except Exception: + return False + + def may_be_none(self): + if self.type and not (self.type.is_pyobject or + self.type.is_memoryviewslice): + return False + if self.has_constant_result(): + return self.constant_result is not None + return True + + def as_cython_attribute(self): + return None + + def as_none_safe_node(self, message, error="PyExc_TypeError", format_args=()): + # Wraps the node in a NoneCheckNode if it is not known to be + # not-None (e.g. because it is a Python literal). + if self.may_be_none(): + return NoneCheckNode(self, error, message, format_args) + else: + return self + + @classmethod + def from_node(cls, node, **kwargs): + """Instantiate this node class from another node, properly + copying over all attributes that one would forget otherwise. + """ + attributes = "cf_state cf_maybe_null cf_is_null constant_result".split() + for attr_name in attributes: + if attr_name in kwargs: + continue + try: + value = getattr(node, attr_name) + except AttributeError: + pass + else: + kwargs[attr_name] = value + return cls(node.pos, **kwargs) + + def get_known_standard_library_import(self): + """ + Gets the module.path that this node was imported from. + + Many nodes do not have one, or it is ambiguous, in which case + this function returns a false value. + """ + return None + + +class _TempModifierNode(ExprNode): + """Base class for nodes that inherit the result of their temp argument and can modify it. + """ + subexprs = ['arg'] + is_temp = False + + def __init__(self, pos, arg): + super().__init__(pos, arg=arg) + + @property + def type(self): + return self.arg.type + + def infer_type(self, env): + return self.arg.infer_type(env) + + def analyse_types(self, env): + self.arg = self.arg.analyse_types(env) + return self + + def calculate_constant_result(self): + return self.arg.calculate_constant_result() + + def may_be_none(self): + return self.arg.may_be_none() + + def is_simple(self): + return self.arg.is_simple() + + def result_in_temp(self): + return self.arg.result_in_temp() + + def nonlocally_immutable(self): + return self.arg.nonlocally_immutable() + + def calculate_result_code(self): + return self.arg.result() + + def generate_result_code(self, code): + pass + + def generate_post_assignment_code(self, code): + self.arg.generate_post_assignment_code(code) + + def allocate_temp_result(self, code): + return self.arg.allocate_temp_result(code) + + def free_temps(self, code): + self.arg.free_temps(code) + + +#------------------------------------------------------------------- +# +# Constants +# +#------------------------------------------------------------------- + +class AtomicExprNode(ExprNode): + # Abstract base class for expression nodes which have + # no sub-expressions. + + subexprs = [] + + # Override to optimize -- we know we have no children + def generate_subexpr_evaluation_code(self, code): + pass + def generate_subexpr_disposal_code(self, code): + pass + + +class PyConstNode(AtomicExprNode): + # Abstract base class for constant Python values. + + is_literal = 1 + type = py_object_type + nogil_check = None + + def is_simple(self): + return 1 + + def may_be_none(self): + return False + + def analyse_types(self, env): + return self + + def calculate_result_code(self): + return self.value + + def generate_result_code(self, code): + pass + + +class NoneNode(PyConstNode): + # The constant value None + + is_none = 1 + value = "Py_None" + + constant_result = None + + def compile_time_value(self, denv): + return None + + def may_be_none(self): + return True + + def coerce_to(self, dst_type, env): + if not (dst_type.is_pyobject or dst_type.is_memoryviewslice or dst_type.is_error): + # Catch this error early and loudly. + error(self.pos, "Cannot assign None to %s" % dst_type) + return super().coerce_to(dst_type, env) + + +class EllipsisNode(PyConstNode): + # '...' in a subscript list. + + value = "Py_Ellipsis" + + constant_result = Ellipsis + + def compile_time_value(self, denv): + return Ellipsis + + +class ConstNode(AtomicExprNode): + # Abstract base type for literal constant nodes. + # + # value string C code fragment + + is_literal = 1 + nogil_check = None + + def is_simple(self): + return 1 + + def nonlocally_immutable(self): + return 1 + + def may_be_none(self): + return False + + def analyse_types(self, env): + return self # Types are held in class variables + + def check_const(self): + return True + + def get_constant_c_result_code(self): + return self.calculate_result_code() + + def calculate_result_code(self): + return str(self.value) + + def generate_result_code(self, code): + pass + + @staticmethod + def for_type(pos, value, type, constant_result=constant_value_not_set): + cls = ConstNode + if type is PyrexTypes.c_null_ptr_type or ( + (value == "NULL" or value == 0) and type.is_ptr): + return NullNode(pos) # value and type are preset here + # char node is deliberately skipped and treated as IntNode + elif type.is_int or PyrexTypes.c_bint_type: + # use this instead of BoolNode for c_bint_type because + # BoolNode handles values differently to most other ConstNode + # derivatives (they aren't strings). + cls = IntNode + elif type.is_float: + cls = FloatNode + elif type is bytes_type: + cls = BytesNode + elif type is unicode_type: + cls = UnicodeNode + + if cls.type is type: + result = cls(pos, value=value, constant_result=constant_result) + else: + result = cls(pos, value=value, type=type, constant_result=constant_result) + + return result + + +class BoolNode(ConstNode): + type = PyrexTypes.c_bint_type + # The constant value True or False + + def calculate_constant_result(self): + self.constant_result = self.value + + def compile_time_value(self, denv): + return self.value + + def calculate_result_code(self): + if self.type.is_pyobject: + return 'Py_True' if self.value else 'Py_False' + else: + return str(int(self.value)) + + def coerce_to(self, dst_type, env): + if dst_type == self.type: + return self + if dst_type is py_object_type and self.type is Builtin.bool_type: + return self + if dst_type.is_pyobject and self.type.is_int: + return BoolNode( + self.pos, value=self.value, + constant_result=self.constant_result, + type=Builtin.bool_type) + if dst_type.is_int and self.type.is_pyobject: + return BoolNode( + self.pos, value=self.value, + constant_result=self.constant_result, + type=PyrexTypes.c_bint_type) + return ConstNode.coerce_to(self, dst_type, env) + + +class NullNode(ConstNode): + type = PyrexTypes.c_null_ptr_type + value = "NULL" + constant_result = 0 + + def get_constant_c_result_code(self): + return self.value + + +class CharNode(ConstNode): + type = PyrexTypes.c_char_type + + def calculate_constant_result(self): + self.constant_result = ord(self.value) + + def compile_time_value(self, denv): + return ord(self.value) + + def calculate_result_code(self): + return "'%s'" % StringEncoding.escape_char(self.value) + + +class IntNode(ConstNode): + + # unsigned "" or "U" + # longness "" or "L" or "LL" + # is_c_literal True/False/None creator considers this a C integer literal + + unsigned = "" + longness = "" + is_c_literal = None # unknown + + # hex_value and base_10_value are designed only to simplify + # writing tests to get a consistent representation of value + @property + def hex_value(self): + return Utils.strip_py2_long_suffix(hex(Utils.str_to_number(self.value))) + + @property + def base_10_value(self): + return str(Utils.str_to_number(self.value)) + + def __init__(self, pos, **kwds): + ExprNode.__init__(self, pos, **kwds) + if 'type' not in kwds: + self.type = self.find_suitable_type_for_value() + + def find_suitable_type_for_value(self): + if self.constant_result is constant_value_not_set: + try: + self.calculate_constant_result() + except ValueError: + pass + # we ignore 'is_c_literal = True' and instead map signed 32bit + # integers as C long values + if self.is_c_literal or \ + not self.has_constant_result() or \ + self.unsigned or self.longness == 'LL': + # clearly a C literal + rank = (self.longness == 'LL') and 2 or 1 + suitable_type = PyrexTypes.modifiers_and_name_to_type[not self.unsigned, rank, "int"] + if self.type: + suitable_type = PyrexTypes.widest_numeric_type(suitable_type, self.type) + else: + # C literal or Python literal - split at 32bit boundary + if -2**31 <= self.constant_result < 2**31: + if self.type and self.type.is_int: + suitable_type = self.type + else: + suitable_type = PyrexTypes.c_long_type + else: + suitable_type = Builtin.int_type + return suitable_type + + def coerce_to(self, dst_type, env): + if self.type is dst_type: + return self + elif dst_type.is_float or dst_type is Builtin.float_type: + if self.has_constant_result(): + return FloatNode(self.pos, value='%d.0' % int(self.constant_result), type=dst_type, + constant_result=float(self.constant_result)) + else: + return FloatNode(self.pos, value=self.value, type=dst_type, + constant_result=not_a_constant) + elif dst_type.is_numeric and not dst_type.is_complex: + node = IntNode(self.pos, value=self.value, constant_result=self.constant_result, + type=dst_type, is_c_literal=True, + unsigned=self.unsigned, longness=self.longness) + return node + elif dst_type.is_pyobject: + node = IntNode(self.pos, value=self.value, constant_result=self.constant_result, + type=Builtin.int_type, is_c_literal=False, + unsigned=self.unsigned, longness=self.longness) + else: + # FIXME: not setting the type here to keep it working with + # complex numbers. Should they be special cased? + node = IntNode(self.pos, value=self.value, constant_result=self.constant_result, + unsigned=self.unsigned, longness=self.longness) + # We still need to perform normal coerce_to processing on the + # result, because we might be coercing to an extension type, + # in which case a type test node will be needed. + return ConstNode.coerce_to(node, dst_type, env) + + def coerce_to_boolean(self, env): + return IntNode( + self.pos, value=self.value, + constant_result=self.constant_result, + type=PyrexTypes.c_bint_type, + unsigned=self.unsigned, longness=self.longness) + + def generate_evaluation_code(self, code): + if self.type.is_pyobject: + # pre-allocate a Python version of the number + # (In hex if sufficiently large to cope with Python's string-to-int limitations. + # We use quite a small value of "sufficiently large" - 10**13 is picked as + # the approximate point where hex strings become shorter) + value = Utils.str_to_number(self.value) + formatter = hex if value > (10**13) else str + plain_integer_string = formatter(value) + plain_integer_string = Utils.strip_py2_long_suffix(plain_integer_string) + self.result_code = code.get_py_int(plain_integer_string, self.longness) + else: + self.result_code = self.get_constant_c_result_code() + + def get_constant_c_result_code(self): + unsigned, longness = self.unsigned, self.longness + literal = self.value_as_c_integer_string() + if not (unsigned or longness) and self.type.is_int and literal[0] == '-' and literal[1] != '0': + # negative decimal literal => guess longness from type to prevent wrap-around + if self.type.rank >= PyrexTypes.c_longlong_type.rank: + longness = 'LL' + elif self.type.rank >= PyrexTypes.c_long_type.rank: + longness = 'L' + return literal + unsigned + longness + + def value_as_c_integer_string(self): + value = self.value + if len(value) <= 2: + # too short to go wrong (and simplifies code below) + return value + neg_sign = '' + if value[0] == '-': + neg_sign = '-' + value = value[1:] + if value[0] == '0': + literal_type = value[1] # 0'o' - 0'b' - 0'x' + # 0x123 hex literals and 0123 octal literals work nicely in C + # but C-incompatible Py3 oct/bin notations need conversion + if neg_sign and literal_type in 'oOxX0123456789' and value[2:].isdigit(): + # negative hex/octal literal => prevent C compiler from using + # unsigned integer types by converting to decimal (see C standard 6.4.4.1) + value = str(Utils.str_to_number(value)) + elif literal_type in 'oO': + value = '0' + value[2:] # '0o123' => '0123' + elif literal_type in 'bB': + value = str(int(value[2:], 2)) + elif value.isdigit() and not self.unsigned and not self.longness: + if not neg_sign: + # C compilers do not consider unsigned types for decimal literals, + # but they do for hex (see C standard 6.4.4.1) + value = '0x%X' % int(value) + return neg_sign + value + + def calculate_result_code(self): + return self.result_code + + def calculate_constant_result(self): + self.constant_result = Utils.str_to_number(self.value) + + def compile_time_value(self, denv): + return Utils.str_to_number(self.value) + +class FloatNode(ConstNode): + type = PyrexTypes.c_double_type + + def calculate_constant_result(self): + self.constant_result = float(self.value) + + def compile_time_value(self, denv): + float_value = float(self.value) + str_float_value = ("%.330f" % float_value).strip('0') + str_value = Utils.normalise_float_repr(self.value) + if str_value not in (str_float_value, repr(float_value).lstrip('0')): + warning(self.pos, "Using this floating point value with DEF may lose precision, using %r" % float_value) + return float_value + + def coerce_to(self, dst_type, env): + if dst_type.is_pyobject and self.type.is_float: + return FloatNode( + self.pos, value=self.value, + constant_result=self.constant_result, + type=Builtin.float_type) + if dst_type.is_float and self.type.is_pyobject: + return FloatNode( + self.pos, value=self.value, + constant_result=self.constant_result, + type=dst_type) + return ConstNode.coerce_to(self, dst_type, env) + + def calculate_result_code(self): + return self.result_code + + def get_constant_c_result_code(self): + strval = self.value + assert isinstance(strval, str) + cmpval = repr(float(strval)) + if cmpval == 'nan': + return "(Py_HUGE_VAL * 0)" + elif cmpval == 'inf': + return "Py_HUGE_VAL" + elif cmpval == '-inf': + return "(-Py_HUGE_VAL)" + else: + return strval + + def generate_evaluation_code(self, code): + c_value = self.get_constant_c_result_code() + if self.type.is_pyobject: + self.result_code = code.get_py_float(self.value, c_value) + else: + self.result_code = c_value + + +def _analyse_name_as_type(name, pos, env): + ctype = PyrexTypes.parse_basic_type(name) + if ctype is not None and env.in_c_type_context: + return ctype + + global_scope = env.global_scope() + global_entry = global_scope.lookup(name) + if global_entry and global_entry.is_type: + type = global_entry.type + if type and (type.is_pyobject or env.in_c_type_context): + return type + ctype = ctype or type + + # This is fairly heavy, so it's worth trying some easier things above. + from .TreeFragment import TreeFragment + with local_errors(ignore=True): + pos = (pos[0], pos[1], pos[2]-7) + try: + declaration = TreeFragment("sizeof(%s)" % name, name=pos[0].filename, initial_pos=pos) + except CompileError: + pass + else: + sizeof_node = declaration.root.stats[0].expr + if isinstance(sizeof_node, SizeofTypeNode): + sizeof_node = sizeof_node.analyse_types(env) + if isinstance(sizeof_node, SizeofTypeNode): + type = sizeof_node.arg_type + if type and (type.is_pyobject or env.in_c_type_context): + return type + ctype = ctype or type + return ctype + + +class BytesNode(ConstNode): + # A char* or bytes literal + # + # value BytesLiteral + + is_string_literal = True + # start off as Python 'bytes' to support len() in O(1) + type = bytes_type + + def calculate_constant_result(self): + self.constant_result = self.value + + def as_sliced_node(self, start, stop, step=None): + value = StringEncoding.bytes_literal(self.value[start:stop:step], self.value.encoding) + return BytesNode(self.pos, value=value, constant_result=value) + + def compile_time_value(self, denv): + return self.value.byteencode() + + def analyse_as_type(self, env): + return _analyse_name_as_type(self.value.decode('ISO8859-1'), self.pos, env) + + def can_coerce_to_char_literal(self): + return len(self.value) == 1 + + def coerce_to_boolean(self, env): + # This is special because testing a C char* for truth directly + # would yield the wrong result. + bool_value = bool(self.value) + return BoolNode(self.pos, value=bool_value, constant_result=bool_value) + + def coerce_to(self, dst_type, env): + if self.type == dst_type: + return self + if dst_type.is_int: + if not self.can_coerce_to_char_literal(): + error(self.pos, "Only single-character string literals can be coerced into ints.") + return self + if dst_type.is_unicode_char: + error(self.pos, "Bytes literals cannot coerce to Py_UNICODE/Py_UCS4, use a unicode literal instead.") + return self + return CharNode(self.pos, value=self.value, + constant_result=ord(self.value)) + + node = BytesNode(self.pos, value=self.value, constant_result=self.constant_result) + if dst_type.is_pyobject: + if dst_type in (py_object_type, Builtin.bytes_type): + node.type = Builtin.bytes_type + else: + self.check_for_coercion_error(dst_type, env, fail=True) + return node + elif dst_type in (PyrexTypes.c_char_ptr_type, PyrexTypes.c_const_char_ptr_type): + node.type = dst_type + return node + elif dst_type in (PyrexTypes.c_uchar_ptr_type, PyrexTypes.c_const_uchar_ptr_type, PyrexTypes.c_void_ptr_type): + node.type = (PyrexTypes.c_const_char_ptr_type if dst_type == PyrexTypes.c_const_uchar_ptr_type + else PyrexTypes.c_char_ptr_type) + return CastNode(node, dst_type) + elif dst_type.assignable_from(PyrexTypes.c_char_ptr_type): + # Exclude the case of passing a C string literal into a non-const C++ string. + if not dst_type.is_cpp_class or dst_type.is_const: + node.type = dst_type + return node + + # We still need to perform normal coerce_to processing on the + # result, because we might be coercing to an extension type, + # in which case a type test node will be needed. + return ConstNode.coerce_to(node, dst_type, env) + + def generate_evaluation_code(self, code): + if self.type.is_pyobject: + result = code.get_py_string_const(self.value) + elif self.type.is_const: + result = code.get_string_const(self.value) + else: + # not const => use plain C string literal and cast to mutable type + literal = self.value.as_c_string_literal() + # C++ may require a cast + result = typecast(self.type, PyrexTypes.c_void_ptr_type, literal) + self.result_code = result + + def get_constant_c_result_code(self): + return None # FIXME + + def calculate_result_code(self): + return self.result_code + + +class UnicodeNode(ConstNode): + # A unicode literal + # + # value EncodedString + # bytes_value BytesLiteral the literal parsed as bytes string + # ('-3' unicode literals only) + # is_identifier boolean + + is_string_literal = True + is_identifier = None + bytes_value = None + type = unicode_type + + def __init__(self, pos, value, bytes_value=None, type=None): + super().__init__(pos, value=value, constant_result=value) + if bytes_value is not None: + self.bytes_value = bytes_value + if type is not None and type is not unicode_type: + self.type = type + + def calculate_constant_result(self): + self.constant_result = self.value + + def analyse_as_type(self, env): + return _analyse_name_as_type(self.value, self.pos, env) + + def as_sliced_node(self, start, stop, step=None): + value = StringEncoding.encoded_string( + self.value[start:stop:step], self.value.encoding) + if self.bytes_value is not None: + bytes_value = StringEncoding.bytes_literal( + self.bytes_value[start:stop:step], self.bytes_value.encoding) + else: + bytes_value = None + return UnicodeNode(self.pos, value=value, bytes_value=bytes_value) + + def coerce_to(self, dst_type, env): + if dst_type is self.type: + pass + elif dst_type.is_unicode_char: + if not self.can_coerce_to_char_literal(): + error(self.pos, + "Only single-character Unicode string literals or " + "surrogate pairs can be coerced into Py_UCS4/Py_UNICODE.") + return self + int_value = ord(self.value) + return IntNode(self.pos, type=dst_type, value=str(int_value), + constant_result=int_value) + elif dst_type.is_pyunicode_ptr: + return UnicodeNode(self.pos, value=self.value, type=dst_type) + elif not dst_type.is_pyobject: + if dst_type.is_string or dst_type.is_cpp_string or dst_type.is_int or ( + dst_type.is_ptr and dst_type.base_type.is_void): + # Allow using '-3' enforced unicode literals in a C char/char*/void* context. + if self.bytes_value is not None: + return BytesNode(self.pos, value=self.bytes_value).coerce_to(dst_type, env) + if env.directives['c_string_encoding']: + try: + byte_string = self.value.encode(env.directives['c_string_encoding']) + except (UnicodeEncodeError, LookupError): + pass + else: + return BytesNode(self.pos, value=byte_string).coerce_to(dst_type, env) + if self.value.isascii(): + return BytesNode(self.pos, value=StringEncoding.BytesLiteral(self.value.encode('ascii')) + ).coerce_to(dst_type, env) + error(self.pos, + "Unicode literals do not support coercion to C types other " + "than Py_UCS4/Py_UNICODE (for characters), Py_UNICODE* " + "(for strings) or char*/void* (for auto-encoded strings).") + elif dst_type is not py_object_type: + self.check_for_coercion_error(dst_type, env, fail=True) + return self + + def can_coerce_to_char_literal(self): + return len(self.value) == 1 + + def coerce_to_boolean(self, env): + bool_value = bool(self.value) + return BoolNode(self.pos, value=bool_value, constant_result=bool_value) + + def estimate_max_charval(self): + # Most strings will probably be ASCII. + if self.value.isascii(): + return 127 + max_charval = ord(max(self.value)) + if max_charval <= 255: + return 255 + elif max_charval <= 65535: + return 65535 + else: + return 1114111 + + def contains_surrogates(self): + return StringEncoding.string_contains_surrogates(self.value) + + def generate_evaluation_code(self, code): + if self.type.is_pyobject: + if StringEncoding.string_contains_lone_surrogates(self.value): + # lone (unpaired) surrogates are not really portable and cannot be + # decoded by the UTF-8 codec in Py3.3+ + self.result_code = code.get_py_const('ustring') + data_cname = code.get_string_const( + StringEncoding.BytesLiteral(self.value.encode('unicode_escape'))) + const_code = code.get_cached_constants_writer(self.result_code) + if const_code is None: + return # already initialised + const_code.mark_pos(self.pos) + const_code.putln( + "%s = PyUnicode_DecodeUnicodeEscape(%s, sizeof(%s) - 1, NULL); %s" % ( + self.result_code, + data_cname, + data_cname, + const_code.error_goto_if_null(self.result_code, self.pos))) + const_code.put_error_if_neg( + self.pos, "__Pyx_PyUnicode_READY(%s)" % self.result_code) + elif self.is_identifier: + self.result_code = code.intern_identifier(self.value) + else: + self.result_code = code.get_py_string_const(self.value) + else: + self.result_code = code.get_pyunicode_ptr_const(self.value) + + def calculate_result_code(self): + return self.result_code + + def compile_time_value(self, denv): + return self.value + + +class IdentifierStringNode(UnicodeNode): + # A special str value that represents an identifier (a Unicode name). + is_identifier = True + + +class ImagNode(AtomicExprNode): + # Imaginary number literal + # + # value string imaginary part (float value) + + type = PyrexTypes.c_double_complex_type + + def calculate_constant_result(self): + self.constant_result = complex(0.0, float(self.value)) + + def compile_time_value(self, denv): + return complex(0.0, float(self.value)) + + def analyse_types(self, env): + self.type.create_declaration_utility_code(env) + return self + + def may_be_none(self): + return False + + def coerce_to(self, dst_type, env): + if self.type is dst_type: + return self + node = ImagNode(self.pos, value=self.value) + if dst_type.is_pyobject: + node.is_temp = 1 + node.type = Builtin.complex_type + # We still need to perform normal coerce_to processing on the + # result, because we might be coercing to an extension type, + # in which case a type test node will be needed. + return AtomicExprNode.coerce_to(node, dst_type, env) + + gil_message = "Constructing complex number" + + def calculate_result_code(self): + if self.type.is_pyobject: + return self.result() + else: + return "%s(0, %r)" % (self.type.from_parts, float(self.value)) + + def generate_result_code(self, code): + if self.type.is_pyobject: + code.putln( + "%s = PyComplex_FromDoubles(0.0, %r); %s" % ( + self.result(), + float(self.value), + code.error_goto_if_null(self.result(), self.pos))) + self.generate_gotref(code) + + +#------------------------------------------------------------------- +# +# Simple expressions +# +#------------------------------------------------------------------- + +class NewExprNode(AtomicExprNode): + + # C++ new statement + # + # cppclass node c++ class to create + + type = None + + def infer_type(self, env): + type = self.cppclass.analyse_as_type(env) + if type is None or not type.is_cpp_class: + error(self.pos, "new operator can only be applied to a C++ class") + self.type = error_type + return + self.cpp_check(env) + constructor = type.get_constructor(self.pos) + self.class_type = type + self.entry = constructor + self.type = constructor.type + return self.type + + def analyse_types(self, env): + if self.type is None: + self.infer_type(env) + return self + + def may_be_none(self): + return False + + def generate_result_code(self, code): + pass + + def calculate_result_code(self): + return "new " + self.class_type.empty_declaration_code() + + +class NameNode(AtomicExprNode): + # Reference to a local or global variable name. + # + # name string Python name of the variable + # entry Entry Symbol table entry + # type_entry Entry For extension type names, the original type entry + # cf_is_null boolean Is uninitialized before this node + # cf_maybe_null boolean Maybe uninitialized before this node + # allow_null boolean Don't raise UnboundLocalError + # nogil boolean Whether it is used in a nogil context + + is_name = True + is_cython_module = False + cython_attribute = None + lhs_of_first_assignment = False # TODO: remove me + is_used_as_rvalue = 0 + entry = None + type_entry = None + cf_maybe_null = True + cf_is_null = False + allow_null = False + nogil = False + inferred_type = None + module_state_lookup = "" + + def as_cython_attribute(self): + return self.cython_attribute + + def type_dependencies(self, env): + if self.entry is None: + self.entry = env.lookup(self.name) + if self.entry is not None and self.entry.type.is_unspecified: + return (self,) + else: + return () + + def infer_type(self, env): + if self.entry is None: + self.entry = env.lookup(self.name) + + if self.entry is None or self.entry.type is unspecified_type: + if self.inferred_type is not None: + return self.inferred_type + return py_object_type + elif (self.entry.type.is_extension_type or self.entry.type.is_builtin_type) and \ + self.entry == self.entry.type.entry: + # Unfortunately the type attribute of type objects + # is used for the pointer to the type they represent. + return type_type + elif (self.entry.type is unicode_type and + self.entry == self.entry.type.entry and self.name in ('unicode', 'basestring')): + # Keep recognising the old Py2 names for 'str' as type. + return type_type + elif self.entry.type.is_cfunction: + if self.entry.scope.is_builtin_scope: + # special case: optimised builtin functions must be treated as Python objects + return py_object_type + else: + # special case: referring to a C function must return its pointer + return PyrexTypes.CPtrType(self.entry.type) + else: + # If entry is inferred as pyobject it's safe to use local + # NameNode's inferred_type. + if self.entry.type.is_pyobject and self.inferred_type: + # Overflow may happen if integer + if not (self.inferred_type.is_int and self.entry.might_overflow): + return self.inferred_type + return self.entry.type + + def compile_time_value(self, denv): + try: + return denv.lookup(self.name) + except KeyError: + error(self.pos, "Compile-time name '%s' not defined" % self.name) + + def get_constant_c_result_code(self): + if not self.entry or self.entry.type.is_pyobject: + return None + return self.entry.cname + + def coerce_to(self, dst_type, env): + # If coercing to a generic pyobject and this is a builtin + # C function with a Python equivalent, manufacture a NameNode + # referring to the Python builtin. + #print "NameNode.coerce_to:", self.name, dst_type ### + if dst_type is py_object_type: + entry = self.entry + if entry and entry.is_cfunction: + var_entry = entry.as_variable + if var_entry: + if var_entry.is_builtin and var_entry.is_const: + var_entry = env.declare_builtin(var_entry.name, self.pos) + node = NameNode(self.pos, name = self.name) + node.entry = var_entry + node.analyse_rvalue_entry(env) + return node + + return super().coerce_to(dst_type, env) + + def declare_from_annotation(self, env, as_target=False): + """Implements PEP 526 annotation typing in a fairly relaxed way. + + Annotations are ignored for global variables. + All other annotations are stored on the entry in the symbol table. + String literals are allowed and not evaluated. + The ambiguous Python types 'int' and 'long' are not evaluated - the 'cython.int' form must be used instead. + """ + name = self.name + annotation = self.annotation + entry = self.entry or env.lookup_here(name) + if not entry: + # annotations never create global cdef names + if env.is_module_scope: + return + + modifiers = () + if ( + # name: "description" => not a type, but still a declared variable or attribute + annotation.expr.is_string_literal + # don't do type analysis from annotations if not asked to, but still collect the annotation + or not env.directives['annotation_typing'] + ): + atype = None + elif env.is_py_class_scope: + # For Python class scopes every attribute is a Python object + atype = py_object_type + else: + modifiers, atype = annotation.analyse_type_annotation(env) + + if atype is None: + atype = unspecified_type if as_target and env.directives['infer_types'] != False else py_object_type + elif atype.is_fused and env.fused_to_specific: + try: + atype = atype.specialize(env.fused_to_specific) + except CannotSpecialize: + error(self.pos, + "'%s' cannot be specialized since its type is not a fused argument to this function" % + self.name) + atype = error_type + + visibility = 'private' + if env.is_c_dataclass_scope: + # handle "frozen" directive - full inspection of the dataclass directives happens + # in Dataclass.py + is_frozen = env.is_c_dataclass_scope == "frozen" + if atype.is_pyobject or atype.can_coerce_to_pyobject(env): + visibility = 'readonly' if is_frozen else 'public' + # If the object can't be coerced that's fine - we just don't create a property + + if as_target and env.is_c_class_scope and not (atype.is_pyobject or atype.is_error): + # TODO: this will need revising slightly if annotated cdef attributes are implemented + atype = py_object_type + warning(annotation.pos, "Annotation ignored since class-level attributes must be Python objects. " + "Were you trying to set up an instance attribute?", 2) + + entry = self.entry = env.declare_var( + name, atype, self.pos, is_cdef=not as_target, visibility=visibility, + pytyping_modifiers=modifiers) + + # Even if the entry already exists, make sure we're supplying an annotation if we can. + if annotation and not entry.annotation: + entry.annotation = annotation + + def analyse_as_module(self, env): + # Try to interpret this as a reference to a cimported module. + # Returns the module scope, or None. + entry = self.entry + if not entry: + entry = env.lookup(self.name) + if entry and entry.as_module: + return entry.as_module + if entry and entry.known_standard_library_import: + scope = Builtin.get_known_standard_library_module_scope(entry.known_standard_library_import) + if scope and scope.is_module_scope: + return scope + return None + + def analyse_as_type(self, env): + type = None + if self.cython_attribute: + type = PyrexTypes.parse_basic_type(self.cython_attribute) + elif env.in_c_type_context: + type = PyrexTypes.parse_basic_type(self.name) + if type: + return type + + entry = self.entry + if not entry: + entry = env.lookup(self.name) + if entry and not entry.is_type and entry.known_standard_library_import: + entry = Builtin.get_known_standard_library_entry(entry.known_standard_library_import) + if entry and entry.is_type: + # Infer equivalent C types instead of Python types when possible. + type = entry.type + if type.is_pyobject and type.equivalent_type: + type = type.equivalent_type + return type + if self.name == 'object': + # This is normally parsed as "simple C type", but not if we don't parse C types. + return py_object_type + + # Try to give a helpful warning when users write plain C type names. + if not env.in_c_type_context and PyrexTypes.parse_basic_type(self.name): + warning(self.pos, "Found C type name '%s' in a Python annotation. Did you mean to use 'cython.%s'?" % (self.name, self.name)) + + return None + + def analyse_as_extension_type(self, env): + # Try to interpret this as a reference to an extension type. + # Returns the extension type, or None. + entry = self.entry + if not entry: + entry = env.lookup(self.name) + if entry and entry.is_type: + if entry.type.is_extension_type or entry.type.is_builtin_type: + return entry.type + return None + + def analyse_target_declaration(self, env): + return self._analyse_target_declaration(env, is_assignment_expression=False) + + def analyse_assignment_expression_target_declaration(self, env): + return self._analyse_target_declaration(env, is_assignment_expression=True) + + def _analyse_target_declaration(self, env, is_assignment_expression): + self.is_target = True + if not self.entry: + if is_assignment_expression: + self.entry = env.lookup_assignment_expression_target(self.name) + else: + self.entry = env.lookup_here(self.name) + if self.entry: + self.entry.known_standard_library_import = "" # already exists somewhere and so is now ambiguous + if not self.entry and self.annotation is not None: + # name : type = ... + is_dataclass = env.is_c_dataclass_scope + # In a dataclass, an assignment should not prevent a name from becoming an instance attribute. + # Hence, "as_target = not is_dataclass". + self.declare_from_annotation(env, as_target=not is_dataclass) + elif (self.entry and self.entry.is_inherited and + self.annotation and env.is_c_dataclass_scope): + error(self.pos, "Cannot redeclare inherited fields in Cython dataclasses") + if not self.entry: + if env.directives['warn.undeclared']: + warning(self.pos, "implicit declaration of '%s'" % self.name, 1) + if env.directives['infer_types'] != False: + type = unspecified_type + else: + type = py_object_type + if is_assignment_expression: + self.entry = env.declare_assignment_expression_target(self.name, type, self.pos) + else: + self.entry = env.declare_var(self.name, type, self.pos) + if self.entry.is_declared_generic: + self.result_ctype = py_object_type + if self.entry.as_module: + # cimported modules namespace can shadow actual variables + self.entry.is_variable = 1 + + def analyse_types(self, env): + self.initialized_check = env.directives['initializedcheck'] + entry = self.entry + if entry is None: + entry = env.lookup(self.name) + if not entry: + entry = env.declare_builtin(self.name, self.pos) + if entry and entry.is_builtin and entry.is_const: + self.is_literal = True + if not entry: + self.type = PyrexTypes.error_type + return self + self.entry = entry + entry.used = 1 + if entry.type.is_buffer: + from . import Buffer + Buffer.used_buffer_aux_vars(entry) + self.analyse_rvalue_entry(env) + return self + + def analyse_target_types(self, env): + self.analyse_entry(env, is_target=True) + + entry = self.entry + if entry.is_cfunction and entry.as_variable: + # FIXME: unify "is_overridable" flags below + if (entry.is_overridable or entry.type.is_overridable) or not self.is_lvalue() and entry.fused_cfunction: + # We need this for assigning to cpdef names and for the fused 'def' TreeFragment + entry = self.entry = entry.as_variable + self.type = entry.type + + if not self.is_lvalue(): + error(self.pos, "Assignment to non-lvalue '%s'" % self.name) + self.type = PyrexTypes.error_type + entry.used = 1 + if entry.type.is_buffer: + from . import Buffer + Buffer.used_buffer_aux_vars(entry) + return self + + def analyse_rvalue_entry(self, env): + #print "NameNode.analyse_rvalue_entry:", self.name ### + #print "Entry:", self.entry.__dict__ ### + self.analyse_entry(env) + entry = self.entry + + if entry.is_declared_generic: + self.result_ctype = py_object_type + + if entry.is_pyglobal or entry.is_builtin: + if entry.is_builtin and entry.is_const: + self.is_temp = 0 + else: + self.is_temp = 1 + + self.is_used_as_rvalue = 1 + elif entry.type.is_memoryviewslice: + self.is_temp = False + self.is_used_as_rvalue = True + self.use_managed_ref = True + return self + + def nogil_check(self, env): + self.nogil = True + if self.is_used_as_rvalue: + entry = self.entry + if entry.is_builtin: + if not entry.is_const: # cached builtins are ok + self.gil_error() + elif entry.is_pyglobal: + self.gil_error() + + gil_message = "Accessing Python global or builtin" + + def analyse_entry(self, env, is_target=False): + #print "NameNode.analyse_entry:", self.name ### + self.check_identifier_kind() + entry = self.entry + type = entry.type + if (not is_target and type.is_pyobject and self.inferred_type and + self.inferred_type.is_builtin_type): + # assume that type inference is smarter than the static entry + type = self.inferred_type + self.type = type + if entry.scope.is_module_scope and ( + entry.is_pyglobal or entry.is_cclass_var_entry): + # TODO - eventually this should apply to cglobals too + self.module_state_lookup = env.name_in_module_state("") + + def check_identifier_kind(self): + # Check that this is an appropriate kind of name for use in an + # expression. Also finds the variable entry associated with + # an extension type. + entry = self.entry + if entry.is_type and entry.type.is_extension_type: + self.type_entry = entry + if entry.is_type and (entry.type.is_enum or entry.type.is_cpp_enum) and entry.create_wrapper: + py_entry = Symtab.Entry(self.name, None, py_object_type) + py_entry.is_pyglobal = True + py_entry.scope = self.entry.scope + self.entry = py_entry + elif not (entry.is_const or entry.is_variable or + entry.is_builtin or entry.is_cfunction or + entry.is_cpp_class): + if self.entry.as_variable: + self.entry = self.entry.as_variable + elif not self.is_cython_module: + error(self.pos, "'%s' is not a constant, variable or function identifier" % self.name) + + def is_cimported_module_without_shadow(self, env): + if self.is_cython_module or self.cython_attribute: + return False + entry = self.entry or env.lookup(self.name) + return entry.as_module and not entry.is_variable + + def is_simple(self): + # If it's not a C variable, it'll be in a temp. + return 1 + + def may_be_none(self): + if self.cf_state and self.type and (self.type.is_pyobject or + self.type.is_memoryviewslice): + # guard against infinite recursion on self-dependencies + if getattr(self, '_none_checking', False): + # self-dependency - either this node receives a None + # value from *another* node, or it can not reference + # None at this point => safe to assume "not None" + return False + self._none_checking = True + # evaluate control flow state to see if there were any + # potential None values assigned to the node so far + may_be_none = False + for assignment in self.cf_state: + if assignment.rhs.may_be_none(): + may_be_none = True + break + del self._none_checking + return may_be_none + return super().may_be_none() + + def nonlocally_immutable(self): + if ExprNode.nonlocally_immutable(self): + return True + entry = self.entry + if not entry or entry.in_closure: + return False + return entry.is_local or entry.is_arg or entry.is_builtin or entry.is_readonly + + def calculate_target_results(self, env): + pass + + def check_const(self): + entry = self.entry + if entry is not None and not ( + entry.is_const or + entry.is_cfunction or + entry.is_builtin or + entry.type.is_const): + self.not_const() + return False + return True + + def check_const_addr(self): + entry = self.entry + if not (entry.is_cglobal or entry.is_cfunction or entry.is_builtin): + self.addr_not_const() + return False + return True + + def is_lvalue(self): + return ( + self.entry.is_variable and + not self.entry.is_readonly + ) or ( + self.entry.is_cfunction and + self.entry.is_overridable + ) + + def is_addressable(self): + return self.entry.is_variable and not self.type.is_memoryviewslice + + def is_ephemeral(self): + # Name nodes are never ephemeral, even if the + # result is in a temporary. + return 0 + + def calculate_result_code(self): + entry = self.entry + if not entry: + return "" # There was an error earlier + if self.entry.is_cpp_optional and not self.is_target: + return "(*%s)" % entry.cname + return self.module_state_lookup + entry.cname + + def generate_result_code(self, code): + entry = self.entry + if entry is None: + return # There was an error earlier + if entry.utility_code: + code.globalstate.use_utility_code(entry.utility_code) + if entry.is_builtin and entry.is_const: + return # Lookup already cached + elif entry.is_pyclass_attr: + assert entry.type.is_pyobject, "Python global or builtin not a Python object" + interned_cname = code.intern_identifier(self.entry.name) + if entry.is_builtin: + namespace = Naming.builtins_cname + else: # entry.is_pyglobal + namespace = entry.scope.namespace_cname + if not self.cf_is_null: + code.putln( + '%s = PyObject_GetItem(%s, %s);' % ( + self.result(), + namespace, + interned_cname)) + code.putln('if (unlikely(!%s)) {' % self.result()) + code.putln('PyErr_Clear();') + code.globalstate.use_utility_code( + UtilityCode.load_cached("GetModuleGlobalName", "ObjectHandling.c")) + code.putln( + '__Pyx_GetModuleGlobalName(%s, %s);' % ( + self.result(), + interned_cname)) + if not self.cf_is_null: + code.putln("}") + code.putln(code.error_goto_if_null(self.result(), self.pos)) + self.generate_gotref(code) + + elif entry.is_builtin and not entry.scope.is_module_scope: + # known builtin + assert entry.type.is_pyobject, "Python global or builtin not a Python object" + interned_cname = code.intern_identifier(self.entry.name) + code.globalstate.use_utility_code( + UtilityCode.load_cached("GetBuiltinName", "ObjectHandling.c")) + code.putln( + '%s = __Pyx_GetBuiltinName(%s); %s' % ( + self.result(), + interned_cname, + code.error_goto_if_null(self.result(), self.pos))) + self.generate_gotref(code) + + elif entry.is_pyglobal or (entry.is_builtin and entry.scope.is_module_scope): + # name in class body, global name or unknown builtin + assert entry.type.is_pyobject, "Python global or builtin not a Python object" + interned_cname = code.intern_identifier(self.entry.name) + if entry.scope.is_module_scope: + code.globalstate.use_utility_code( + UtilityCode.load_cached("GetModuleGlobalName", "ObjectHandling.c")) + code.putln( + '__Pyx_GetModuleGlobalName(%s, %s); %s' % ( + self.result(), + interned_cname, + code.error_goto_if_null(self.result(), self.pos))) + else: + namespace_cname = code.namespace_cname_in_module_state(entry.scope) + namespace_cname_is_type = self.entry.scope.namespace_cname_is_type + # FIXME: is_pyglobal is also used for class namespace + code.globalstate.use_utility_code( + UtilityCode.load_cached("GetNameInClass", "ObjectHandling.c")) + code.putln( + '__Pyx_GetNameInClass(%s, %s%s, %s); %s' % ( + self.result(), + "(PyObject*)" if namespace_cname_is_type else "", + namespace_cname, + interned_cname, + code.error_goto_if_null(self.result(), self.pos))) + self.generate_gotref(code) + + elif entry.is_local or entry.in_closure or entry.from_closure or entry.type.is_memoryviewslice: + # Raise UnboundLocalError for objects and memoryviewslices + raise_unbound = ( + (self.cf_maybe_null or self.cf_is_null) and not self.allow_null) + + memslice_check = entry.type.is_memoryviewslice and self.initialized_check + optional_cpp_check = entry.is_cpp_optional and self.initialized_check + + if optional_cpp_check: + unbound_check_code = entry.type.cpp_optional_check_for_null_code(entry.cname) + else: + unbound_check_code = entry.type.check_for_null_code(entry.cname) + + if unbound_check_code and raise_unbound and (entry.type.is_pyobject or memslice_check or optional_cpp_check): + code.put_error_if_unbound(self.pos, entry, self.in_nogil_context, unbound_check_code=unbound_check_code) + + elif entry.is_cglobal and entry.is_cpp_optional and self.initialized_check: + unbound_check_code = entry.type.cpp_optional_check_for_null_code(entry.cname) + code.put_error_if_unbound(self.pos, entry, self.in_nogil_context, unbound_check_code=unbound_check_code) + + def generate_assignment_code(self, rhs, code, overloaded_assignment=False, + exception_check=None, exception_value=None): + #print "NameNode.generate_assignment_code:", self.name ### + entry = self.entry + if entry is None: + return # There was an error earlier + + if (self.entry.type.is_ptr and isinstance(rhs, ListNode) + and not self.lhs_of_first_assignment and not rhs.in_module_scope): + error(self.pos, "Literal list must be assigned to pointer at time of declaration") + + # is_pyglobal seems to be True for module level-globals only. + # We use this to access class->tp_dict if necessary. + if entry.is_pyglobal: + assert entry.type.is_pyobject, "Python global or builtin not a Python object" + interned_cname = code.intern_identifier(self.entry.name) + namespace = code.namespace_cname_in_module_state(self.entry.scope) + namespace_is_type = self.entry.scope.namespace_cname_is_type + namespace_needs_type = False + if entry.is_member: + # if the entry is a member we have to cheat: SetAttr does not work + # on types, so we create a descriptor which is then added to tp_dict. + setter = '__Pyx_SetItemOnTypeDict' + namespace_needs_type = True + code.globalstate.use_utility_code( + UtilityCode.load_cached("SetItemOnTypeDict", "ExtensionTypes.c")) + elif entry.scope.is_module_scope: + setter = 'PyDict_SetItem' + namespace = code.name_in_module_state(Naming.moddict_cname) + elif entry.is_pyclass_attr: + # Special-case setting __new__ + n = "SetNewInClass" if self.name == "__new__" else "SetNameInClass" + code.globalstate.use_utility_code(UtilityCode.load_cached(n, "ObjectHandling.c")) + setter = '__Pyx_' + n + else: + assert False, repr(entry) + if namespace_is_type and not namespace_needs_type: + namespace = f"((PyObject*){namespace})" + # This combination shouldn't happen, and we don't know enough to cast + assert not (namespace_needs_type and not namespace_is_type) + code.put_error_if_neg( + self.pos, + '%s(%s, %s, %s)' % ( + setter, + namespace, + interned_cname, + rhs.py_result())) + if debug_disposal_code: + print("NameNode.generate_assignment_code:") + print("...generating disposal code for %s" % rhs) + rhs.generate_disposal_code(code) + rhs.free_temps(code) + else: + if self.type.is_memoryviewslice: + self.generate_acquire_memoryviewslice(rhs, code) + + elif self.type.is_buffer: + # Generate code for doing the buffer release/acquisition. + # This might raise an exception in which case the assignment (done + # below) will not happen. + # + # The reason this is not in a typetest-like node is because the + # variables that the acquired buffer info is stored to is allocated + # per entry and coupled with it. + self.generate_acquire_buffer(rhs, code) + assigned = False + if self.type.is_const: + # Const variables are assigned when declared + assigned = True + if self.type.is_pyobject: + #print "NameNode.generate_assignment_code: to", self.name ### + #print "...from", rhs ### + #print "...LHS type", self.type, "ctype", self.ctype() ### + #print "...RHS type", rhs.type, "ctype", rhs.ctype() ### + if self.use_managed_ref: + rhs.make_owned_reference(code) + is_external_ref = entry.is_cglobal or self.entry.in_closure or self.entry.from_closure + if is_external_ref: + self.generate_gotref(code, handle_null=True) + assigned = True + if entry.is_cglobal: + self.generate_decref_set(code, rhs.result_as(self.ctype())) + else: + if not self.cf_is_null: + if self.cf_maybe_null: + self.generate_xdecref_set(code, rhs.result_as(self.ctype())) + else: + self.generate_decref_set(code, rhs.result_as(self.ctype())) + else: + assigned = False + if is_external_ref: + rhs.generate_giveref(code) + if not self.type.is_memoryviewslice: + if not assigned: + if overloaded_assignment: + result = rhs.move_result_rhs() + if exception_check == '+': + translate_cpp_exception( + code, self.pos, + '%s = %s;' % (self.result(), result), + self.result() if self.type.is_pyobject else None, + exception_value, self.in_nogil_context) + else: + code.putln('%s = %s;' % (self.result(), result)) + else: + result = rhs.move_result_rhs_as(self.ctype()) + + if is_pythran_expr(self.type): + code.putln('new (&%s) decltype(%s){%s};' % (self.result(), self.result(), result)) + elif result != self.result(): + code.putln('%s = %s;' % (self.result(), result)) + if debug_disposal_code: + print("NameNode.generate_assignment_code:") + print("...generating post-assignment code for %s" % rhs) + rhs.generate_post_assignment_code(code) + elif rhs.result_in_temp(): + rhs.generate_post_assignment_code(code) + + rhs.free_temps(code) + + def generate_acquire_memoryviewslice(self, rhs, code): + """ + Slices, coercions from objects, return values etc are new references. + We have a borrowed reference in case of dst = src + """ + from . import MemoryView + + MemoryView.put_acquire_memoryviewslice( + lhs_cname=self.result(), + lhs_type=self.type, + lhs_pos=self.pos, + rhs=rhs, + code=code, + have_gil=not self.in_nogil_context, + first_assignment=self.cf_is_null) + + def generate_acquire_buffer(self, rhs, code): + # rhstmp is only used in case the rhs is a complicated expression leading to + # the object, to avoid repeating the same C expression for every reference + # to the rhs. It does NOT hold a reference. + pretty_rhs = isinstance(rhs, NameNode) or rhs.result_in_temp() + if pretty_rhs: + rhstmp = rhs.result_as(self.ctype()) + else: + rhstmp = code.funcstate.allocate_temp(self.entry.type, manage_ref=False) + code.putln('%s = %s;' % (rhstmp, rhs.result_as(self.ctype()))) + + from . import Buffer + Buffer.put_assign_to_buffer(self.result(), rhstmp, self.entry, + is_initialized=not self.lhs_of_first_assignment, + pos=self.pos, code=code) + + if not pretty_rhs: + code.putln("%s = 0;" % rhstmp) + code.funcstate.release_temp(rhstmp) + + def generate_deletion_code(self, code, ignore_nonexisting=False): + if self.entry is None: + return # There was an error earlier + elif self.entry.is_pyclass_attr: + namespace = self.entry.scope.namespace_cname + interned_cname = code.intern_identifier(self.entry.name) + if ignore_nonexisting: + key_error_code = 'PyErr_Clear(); else' + else: + # minor hack: fake a NameError on KeyError + key_error_code = ( + '{ PyErr_Clear(); PyErr_Format(PyExc_NameError, "name \'%%s\' is not defined", "%s"); }' % + self.entry.name) + code.putln( + 'if (unlikely(PyObject_DelItem(%s, %s) < 0)) {' + ' if (likely(PyErr_ExceptionMatches(PyExc_KeyError))) %s' + ' %s ' + '}' % (namespace, interned_cname, + key_error_code, + code.error_goto(self.pos))) + elif self.entry.is_pyglobal: + code.globalstate.use_utility_code( + UtilityCode.load_cached("PyObjectSetAttrStr", "ObjectHandling.c")) + interned_cname = code.intern_identifier(self.entry.name) + del_code = '__Pyx_PyObject_DelAttrStr(%s, %s)' % ( + Naming.module_cname, interned_cname) + if ignore_nonexisting: + code.putln( + 'if (unlikely(%s < 0)) {' + ' if (likely(PyErr_ExceptionMatches(PyExc_AttributeError))) PyErr_Clear(); else %s ' + '}' % (del_code, code.error_goto(self.pos))) + else: + code.put_error_if_neg(self.pos, del_code) + elif self.entry.type.is_pyobject or self.entry.type.is_memoryviewslice: + if not self.cf_is_null: + if self.cf_maybe_null and not ignore_nonexisting: + code.put_error_if_unbound(self.pos, self.entry, self.in_nogil_context) + + if self.entry.in_closure: + # generator + self.generate_gotref(code, handle_null=True, maybe_null_extra_check=ignore_nonexisting) + if ignore_nonexisting and self.cf_maybe_null: + code.put_xdecref_clear(self.result(), self.ctype(), + have_gil=not self.nogil) + else: + code.put_decref_clear(self.result(), self.ctype(), + have_gil=not self.nogil) + else: + error(self.pos, "Deletion of C names not supported") + + def annotate(self, code): + if getattr(self, 'is_called', False): + pos = (self.pos[0], self.pos[1], self.pos[2] - len(self.name) - 1) + if self.type.is_pyobject: + style, text = 'py_call', 'python function (%s)' + else: + style, text = 'c_call', 'c function (%s)' + code.annotate(pos, AnnotationItem(style, text % self.type, size=len(self.name))) + + def get_known_standard_library_import(self): + if self.entry: + return self.entry.known_standard_library_import + return None + + +class BackquoteNode(ExprNode): + # `expr` + # + # arg ExprNode + + type = py_object_type + + subexprs = ['arg'] + + def analyse_types(self, env): + self.arg = self.arg.analyse_types(env) + self.arg = self.arg.coerce_to_pyobject(env) + self.is_temp = 1 + return self + + gil_message = "Backquote expression" + + def calculate_constant_result(self): + self.constant_result = repr(self.arg.constant_result) + + def generate_result_code(self, code): + code.putln( + "%s = PyObject_Repr(%s); %s" % ( + self.result(), + self.arg.py_result(), + code.error_goto_if_null(self.result(), self.pos))) + self.generate_gotref(code) + + +#------------------------------------------------------------------- +# +# Control-flow related expressions +# +#------------------------------------------------------------------- + +class ImportNode(ExprNode): + # Used as part of import statement implementation. + # Implements result = + # __import__(module_name, globals(), None, name_list, level) + # + # module_name UnicodeNode dotted name of module. Empty module + # name means importing the parent package according + # to level + # name_list ListNode or None list of names to be imported + # level int relative import level: + # -1: attempt both relative import and absolute import; + # 0: absolute import; + # >0: the number of parent directories to search + # relative to the current module. + # None: decide the level according to language level and + # directives + # get_top_level_module int true: return top-level module, false: return imported module + # module_names TupleNode the separate names of the module and submodules, or None + + type = py_object_type + module_names = None + get_top_level_module = False + is_temp = True + + subexprs = ['module_name', 'name_list', 'module_names'] + + def analyse_types(self, env): + if self.level is None: + # For modules in packages, and without 'absolute_import' enabled, try relative (Py2) import first. + if env.global_scope().parent_module and ( + env.directives['py2_import'] or + Future.absolute_import not in env.context.future_directives): + self.level = -1 + else: + self.level = 0 + module_name = self.module_name.analyse_types(env) + self.module_name = module_name.coerce_to_pyobject(env) + assert self.module_name.is_string_literal + if self.name_list: + name_list = self.name_list.analyse_types(env) + self.name_list = name_list.coerce_to_pyobject(env) + elif '.' in self.module_name.value: + self.module_names = TupleNode(self.module_name.pos, args=[ + IdentifierStringNode(self.module_name.pos, value=part) + for part in map(StringEncoding.EncodedString, self.module_name.value.split('.')) + ]).analyse_types(env) + return self + + gil_message = "Python import" + + def generate_result_code(self, code): + assert self.module_name.is_string_literal + module_name = self.module_name.value + + if self.level <= 0 and not self.name_list and not self.get_top_level_module: + if self.module_names: + assert self.module_names.is_literal # make sure we create the tuple only once + if self.level == 0: + utility_code = UtilityCode.load_cached("ImportDottedModule", "ImportExport.c") + helper_func = "__Pyx_ImportDottedModule" + else: + utility_code = UtilityCode.load_cached("ImportDottedModuleRelFirst", "ImportExport.c") + helper_func = "__Pyx_ImportDottedModuleRelFirst" + code.globalstate.use_utility_code(utility_code) + import_code = "%s(%s, %s)" % ( + helper_func, + self.module_name.py_result(), + self.module_names.py_result() if self.module_names else 'NULL', + ) + else: + code.globalstate.use_utility_code(UtilityCode.load_cached("Import", "ImportExport.c")) + import_code = "__Pyx_Import(%s, %s, %d)" % ( + self.module_name.py_result(), + self.name_list.py_result() if self.name_list else '0', + self.level) + + code.putln("%s = %s; %s" % ( + self.result(), + import_code, + code.error_goto_if_null(self.result(), self.pos))) + self.generate_gotref(code) + + def get_known_standard_library_import(self): + return self.module_name.value + + +class ScopedExprNode(ExprNode): + # Abstract base class for ExprNodes that have their own local + # scope, such as generator expressions. + # + # expr_scope Scope the inner scope of the expression + + subexprs = [] + expr_scope = None + + # does this node really have a local scope, e.g. does it leak loop + # variables or not? non-leaking Py3 behaviour is default, except + # for list comprehensions where the behaviour differs in Py2 and + # Py3 (set in Parsing.py based on parser context) + has_local_scope = True + + def init_scope(self, outer_scope, expr_scope=None): + if expr_scope is not None: + self.expr_scope = expr_scope + elif self.has_local_scope: + self.expr_scope = Symtab.ComprehensionScope(outer_scope) + elif not self.expr_scope: # don't unset if it's already been set + self.expr_scope = None + + def analyse_declarations(self, env): + self.init_scope(env) + + def analyse_scoped_declarations(self, env): + # this is called with the expr_scope as env + pass + + def analyse_types(self, env): + # no recursion here, the children will be analysed separately below + return self + + def analyse_scoped_expressions(self, env): + # this is called with the expr_scope as env + return self + + def generate_evaluation_code(self, code): + # set up local variables and free their references on exit + generate_inner_evaluation_code = super().generate_evaluation_code + if not self.has_local_scope or not self.expr_scope.var_entries: + # no local variables => delegate, done + generate_inner_evaluation_code(code) + return + + code.putln('{ /* enter inner scope */') + py_entries = [] + for _, entry in sorted(item for item in self.expr_scope.entries.items() if item[0]): + if not entry.in_closure: + if entry.type.is_pyobject and entry.used: + py_entries.append(entry) + if not py_entries: + # no local Python references => no cleanup required + generate_inner_evaluation_code(code) + code.putln('} /* exit inner scope */') + return + + # must free all local Python references at each exit point + old_loop_labels = code.new_loop_labels() + old_error_label = code.new_error_label() + + generate_inner_evaluation_code(code) + + # normal (non-error) exit + self._generate_vars_cleanup(code, py_entries) + + # error/loop body exit points + exit_scope = code.new_label('exit_scope') + code.put_goto(exit_scope) + for label, old_label in ([(code.error_label, old_error_label)] + + list(zip(code.get_loop_labels(), old_loop_labels))): + if code.label_used(label): + code.put_label(label) + self._generate_vars_cleanup(code, py_entries) + code.put_goto(old_label) + code.put_label(exit_scope) + code.putln('} /* exit inner scope */') + + code.set_loop_labels(old_loop_labels) + code.error_label = old_error_label + + def _generate_vars_cleanup(self, code, py_entries): + for entry in py_entries: + if entry.is_cglobal: + code.put_var_gotref(entry) + code.put_var_decref_set(entry, "Py_None") + else: + code.put_var_xdecref_clear(entry) + + +class IteratorNode(ScopedExprNode): + # Used as part of for statement implementation. + # + # Implements result = iter(sequence) + # + # sequence ExprNode + + type = py_object_type + iter_func_ptr = None + counter_cname = None + reversed = False # currently only used for list/tuple types (see Optimize.py) + is_async = False + has_local_scope = False + + subexprs = ['sequence'] + + def analyse_types(self, env): + if self.expr_scope: + env = self.expr_scope # actually evaluate sequence in this scope instead + self.sequence = self.sequence.analyse_types(env) + if (self.sequence.type.is_array or self.sequence.type.is_ptr) and \ + not self.sequence.type.is_string: + # C array iteration will be transformed later on + self.type = self.sequence.type + elif self.sequence.type.is_cpp_class: + return CppIteratorNode(self.pos, sequence=self.sequence).analyse_types(env) + elif self.is_reversed_cpp_iteration(): + sequence = self.sequence.arg_tuple.args[0].arg + return CppIteratorNode(self.pos, sequence=sequence, reversed=True).analyse_types(env) + else: + self.sequence = self.sequence.coerce_to_pyobject(env) + if self.sequence.type in (list_type, tuple_type): + self.sequence = self.sequence.as_none_safe_node("'NoneType' object is not iterable") + self.is_temp = 1 + return self + + gil_message = "Iterating over Python object" + + _func_iternext_type = PyrexTypes.CPtrType(PyrexTypes.CFuncType( + PyrexTypes.py_object_type, [ + PyrexTypes.CFuncTypeArg("it", PyrexTypes.py_object_type, None), + ])) + + def is_reversed_cpp_iteration(self): + """ + Returns True if the 'reversed' function is applied to a C++ iterable. + + This supports C++ classes with reverse_iterator implemented. + """ + if not (isinstance(self.sequence, SimpleCallNode) and + self.sequence.arg_tuple and len(self.sequence.arg_tuple.args) == 1): + return False + func = self.sequence.function + if func.is_name and func.name == "reversed": + if not func.entry.is_builtin: + return False + arg = self.sequence.arg_tuple.args[0] + if isinstance(arg, CoercionNode) and arg.arg.is_name: + arg = arg.arg.entry + return arg.type.is_cpp_class + return False + + def type_dependencies(self, env): + return self.sequence.type_dependencies(self.expr_scope or env) + + def infer_type(self, env): + sequence_type = self.sequence.infer_type(env) + if sequence_type.is_array or sequence_type.is_ptr: + return sequence_type + elif sequence_type.is_cpp_class: + begin = sequence_type.scope.lookup("begin") + if begin is not None: + return begin.type.return_type + elif sequence_type.is_pyobject: + return sequence_type + return py_object_type + + def generate_result_code(self, code): + sequence_type = self.sequence.type + if sequence_type.is_cpp_class: + assert False, "Should have been changed to CppIteratorNode" + if sequence_type.is_array or sequence_type.is_ptr: + raise InternalError("for in carray slice not transformed") + + is_builtin_sequence = sequence_type in (list_type, tuple_type) + if not is_builtin_sequence: + # reversed() not currently optimised (see Optimize.py) + assert not self.reversed, "internal error: reversed() only implemented for list/tuple objects" + self.may_be_a_sequence = not sequence_type.is_builtin_type + if self.may_be_a_sequence: + code.putln( + "if (likely(PyList_CheckExact(%s)) || PyTuple_CheckExact(%s)) {" % ( + self.sequence.py_result(), + self.sequence.py_result())) + + if is_builtin_sequence or self.may_be_a_sequence: + code.putln("%s = %s; __Pyx_INCREF(%s);" % ( + self.result(), + self.sequence.py_result(), + self.result(), + )) + self.counter_cname = code.funcstate.allocate_temp( + PyrexTypes.c_py_ssize_t_type, manage_ref=False) + if self.reversed: + if sequence_type is list_type: + len_func = '__Pyx_PyList_GET_SIZE' + else: + len_func = '__Pyx_PyTuple_GET_SIZE' + code.putln("%s = %s(%s);" % (self.counter_cname, len_func, self.result())) + code.putln("#if !CYTHON_ASSUME_SAFE_SIZE") + code.putln(code.error_goto_if_neg(self.counter_cname, self.pos)) + code.putln("#endif") + code.putln("--%s;" % self.counter_cname) # len -> last item + else: + code.putln("%s = 0;" % self.counter_cname) + + if not is_builtin_sequence: + self.iter_func_ptr = code.funcstate.allocate_temp(self._func_iternext_type, manage_ref=False) + if self.may_be_a_sequence: + code.putln("%s = NULL;" % self.iter_func_ptr) + code.putln("} else {") + code.put("%s = -1; " % self.counter_cname) + + code.putln("%s = PyObject_GetIter(%s); %s" % ( + self.result(), + self.sequence.py_result(), + code.error_goto_if_null(self.result(), self.pos))) + self.generate_gotref(code) + + # PyObject_GetIter() fails if "tp_iternext" is not set, but the check below + # makes it visible to the C compiler that the pointer really isn't NULL, so that + # it can distinguish between the special cases and the generic case. + code.put( + f"{self.iter_func_ptr} = (CYTHON_COMPILING_IN_LIMITED_API) ? " + f"PyIter_Next : __Pyx_PyObject_GetIterNextFunc({self.py_result()}); " + ) + code.putln(code.error_goto_if_null(self.iter_func_ptr, self.pos)) + if self.may_be_a_sequence: + code.putln("}") + + def generate_for_loop_header(self, code): + code.put(";;") + + def generate_next_sequence_item(self, test_name, result_name, code): + assert self.counter_cname, "internal error: counter_cname temp not prepared" + assert test_name in ('List', 'Tuple') + + final_size = f'__Pyx_Py{test_name}_GET_SIZE({self.py_result()})' + size_is_safe = False + if self.sequence.is_sequence_constructor: + item_count = len(self.sequence.args) + if self.sequence.mult_factor is None: + final_size = item_count + size_is_safe = True + elif isinstance(self.sequence.mult_factor.constant_result, int): + final_size = item_count * self.sequence.mult_factor.constant_result + size_is_safe = True + + if size_is_safe: + code.putln("if (%s >= %s) break;" % (self.counter_cname, final_size)) + else: + code.putln("{") + code.putln("Py_ssize_t %s = %s;" % (Naming.quick_temp_cname, final_size)) + code.putln("#if !CYTHON_ASSUME_SAFE_SIZE") + code.putln(code.error_goto_if_neg(Naming.quick_temp_cname, self.pos)) + code.putln("#endif") + code.putln("if (%s >= %s) break;" % (self.counter_cname, Naming.quick_temp_cname)) + code.putln("}") + + inc_dec = '--' if self.reversed else '++' + + if test_name == 'List': + code.putln(f"{result_name} = __Pyx_PyList_GetItemRef({self.py_result()}, {self.counter_cname});") + else: # Tuple + code.putln("#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS") + code.putln(f"{result_name} = __Pyx_NewRef(PyTuple_GET_ITEM({self.py_result()}, {self.counter_cname}));") + code.putln("#else") + code.putln(f"{result_name} = __Pyx_PySequence_ITEM({self.py_result()}, {self.counter_cname});") + code.putln("#endif") + code.putln(f"{inc_dec}{self.counter_cname};") + + def generate_iter_next_result_code(self, result_name, code): + sequence_type = self.sequence.type + if self.reversed: + code.putln(f"if ({self.counter_cname} < 0) break;") + if sequence_type is list_type: + self.generate_next_sequence_item('List', result_name, code) + code.putln(code.error_goto_if_null(result_name, self.pos)) + code.put_gotref(result_name, py_object_type) + return + elif sequence_type is tuple_type: + self.generate_next_sequence_item('Tuple', result_name, code) + code.putln(code.error_goto_if_null(result_name, self.pos)) + code.put_gotref(result_name, py_object_type) + return + + if self.may_be_a_sequence: + code.putln("if (likely(!%s)) {" % self.iter_func_ptr) + code.putln("if (likely(PyList_CheckExact(%s))) {" % self.py_result()) + self.generate_next_sequence_item('List', result_name, code) + code.putln("} else {") + self.generate_next_sequence_item('Tuple', result_name, code) + code.putln("}") + code.putln(code.error_goto_if_null(result_name, self.pos)) + code.put("} else ") + + code.putln("{") + code.putln(f"{result_name} = {self.iter_func_ptr}({self.py_result()});") + code.putln("if (unlikely(!%s)) {" % result_name) + code.putln("PyObject* exc_type = PyErr_Occurred();") + code.putln("if (exc_type) {") + code.putln(code.error_goto_if("!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration)", self.pos)) + code.putln("PyErr_Clear();") + code.putln("}") + code.putln("break;") + code.putln("}") + code.putln("}") + code.put_gotref(result_name, py_object_type) + + def free_temps(self, code): + if self.counter_cname: + code.funcstate.release_temp(self.counter_cname) + if self.iter_func_ptr: + code.funcstate.release_temp(self.iter_func_ptr) + self.iter_func_ptr = None + ExprNode.free_temps(self, code) + + +class CppIteratorNode(ExprNode): + # Iteration over a C++ container. + # Created at the analyse_types stage by IteratorNode + cpp_sequence_cname = None + cpp_attribute_op = "." + extra_dereference = "" + is_temp = True + reversed = False + + subexprs = ['sequence'] + + def get_iterator_func_names(self): + return ("begin", "end") if not self.reversed else ("rbegin", "rend") + + def analyse_types(self, env): + sequence_type = self.sequence.type + if sequence_type.is_ptr: + sequence_type = sequence_type.base_type + begin_name, end_name = self.get_iterator_func_names() + begin = sequence_type.scope.lookup(begin_name) + end = sequence_type.scope.lookup(end_name) + if (begin is None + or not begin.type.is_cfunction + or begin.type.args): + error(self.pos, "missing %s() on %s" % (begin_name, self.sequence.type)) + self.type = error_type + return self + if (end is None + or not end.type.is_cfunction + or end.type.args): + error(self.pos, "missing %s() on %s" % (end_name, self.sequence.type)) + self.type = error_type + return self + iter_type = begin.type.return_type + if iter_type.is_cpp_class: + if env.directives['cpp_locals']: + self.extra_dereference = "*" + if env.lookup_operator_for_types( + self.pos, + "!=", + [iter_type, end.type.return_type]) is None: + error(self.pos, "missing operator!= on result of %s() on %s" % (begin_name, self.sequence.type)) + self.type = error_type + return self + if env.lookup_operator_for_types(self.pos, '++', [iter_type]) is None: + error(self.pos, "missing operator++ on result of %s() on %s" % (begin_name, self.sequence.type)) + self.type = error_type + return self + if env.lookup_operator_for_types(self.pos, '*', [iter_type]) is None: + error(self.pos, "missing operator* on result of %s() on %s" % (begin_name, self.sequence.type)) + self.type = error_type + return self + self.type = iter_type + elif iter_type.is_ptr: + if not (iter_type == end.type.return_type): + error(self.pos, "incompatible types for %s() and %s()" % (begin_name, end_name)) + self.type = iter_type + else: + error(self.pos, "result type of %s() on %s must be a C++ class or pointer" % (begin_name, self.sequence.type)) + self.type = error_type + return self + + def generate_result_code(self, code): + sequence_type = self.sequence.type + begin_name, _ = self.get_iterator_func_names() + # essentially 3 options: + if self.sequence.is_simple(): + # 1) Sequence can be accessed directly, like a name; + # assigning to it may break the container, but that's the responsibility + # of the user + code.putln("%s = %s%s%s();" % ( + self.result(), + self.sequence.result(), + self.cpp_attribute_op, + begin_name)) + else: + # (while it'd be nice to limit the scope of the loop temp, it's essentially + # impossible to do while supporting generators) + temp_type = sequence_type + if temp_type.is_reference: + # 2) Sequence is a reference (often obtained by dereferencing a pointer); + # make the temp a pointer so we are not sensitive to users reassigning + # the pointer than it came from + temp_type = PyrexTypes.CPtrType(sequence_type.ref_base_type) + if temp_type.is_ptr or code.globalstate.directives['cpp_locals']: + self.cpp_attribute_op = "->" + # 3) (otherwise) sequence comes from a function call or similar, so we must + # create a temp to store it in + self.cpp_sequence_cname = code.funcstate.allocate_temp(temp_type, manage_ref=False) + code.putln("%s = %s%s;" % (self.cpp_sequence_cname, + "&" if temp_type.is_ptr else "", + self.sequence.move_result_rhs())) + code.putln("%s = %s%s%s();" % ( + self.result(), + self.cpp_sequence_cname, + self.cpp_attribute_op, + begin_name)) + + def generate_for_loop_header(self, code): + # end call isn't cached to support containers that allow adding while iterating + # (much as this is usually a bad idea) + _, end_name = self.get_iterator_func_names() + code.put("; %s%s != %s%s%s(); ++%s%s" % ( + self.extra_dereference, + self.result(), + self.cpp_sequence_cname or self.sequence.result(), + self.cpp_attribute_op, + end_name, + self.extra_dereference, + self.result())) + + def generate_iter_next_result_code(self, result_name, code): + code.putln("%s = *%s%s;" % ( + result_name, + self.extra_dereference, + self.result())) + + def generate_subexpr_disposal_code(self, code): + if not self.cpp_sequence_cname: + # the sequence is accessed directly so any temporary result in its + # subexpressions must remain available until the iterator is not needed + return + ExprNode.generate_subexpr_disposal_code(self, code) + + def free_subexpr_temps(self, code): + if not self.cpp_sequence_cname: + # the sequence is accessed directly so any temporary result in its + # subexpressions must remain available until the iterator is not needed + return + ExprNode.free_subexpr_temps(self, code) + + def generate_disposal_code(self, code): + if not self.cpp_sequence_cname: + # postponed from CppIteratorNode.generate_subexpr_disposal_code + # and CppIteratorNode.free_subexpr_temps + ExprNode.generate_subexpr_disposal_code(self, code) + ExprNode.free_subexpr_temps(self, code) + ExprNode.generate_disposal_code(self, code) + + def free_temps(self, code): + if self.cpp_sequence_cname: + code.funcstate.release_temp(self.cpp_sequence_cname) + # skip over IteratorNode since we don't use any of the temps it does + ExprNode.free_temps(self, code) + + +class NextNode(AtomicExprNode): + # Used as part of for statement implementation. + # Implements result = next(iterator) + # Created during analyse_types phase. + # The iterator is not owned by this node. + # + # iterator IteratorNode + + def __init__(self, iterator): + AtomicExprNode.__init__(self, iterator.pos) + self.iterator = iterator + + def nogil_check(self, env): + # ignore - errors (if any) are already handled by IteratorNode + pass + + def type_dependencies(self, env): + return self.iterator.type_dependencies(env) + + def infer_type(self, env, iterator_type=None): + if iterator_type is None: + iterator_type = self.iterator.infer_type(env) + if iterator_type.is_ptr or iterator_type.is_array: + return iterator_type.base_type + elif iterator_type.is_cpp_class: + item_type = env.lookup_operator_for_types(self.pos, "*", [iterator_type]).type.return_type + item_type = PyrexTypes.remove_cv_ref(item_type, remove_fakeref=True) + return item_type + else: + # Avoid duplication of complicated logic. + fake_index_node = IndexNode( + self.pos, + base=self.iterator.sequence, + index=IntNode(self.pos, value='PY_SSIZE_T_MAX', + type=PyrexTypes.c_py_ssize_t_type)) + return fake_index_node.infer_type(env) + + def analyse_types(self, env): + self.type = self.infer_type(env, self.iterator.type) + self.is_temp = 1 + return self + + def generate_result_code(self, code): + self.iterator.generate_iter_next_result_code(self.result(), code) + + +class AsyncIteratorNode(ScopedExprNode): + # Used as part of 'async for' statement implementation. + # + # Implements result = sequence.__aiter__() + # + # sequence ExprNode + + subexprs = ['sequence'] + + is_async = True + type = py_object_type + is_temp = 1 + has_local_scope = False + + def infer_type(self, env): + return py_object_type + + def analyse_types(self, env): + if self.expr_scope: + env = self.expr_scope + self.sequence = self.sequence.analyse_types(env) + if not self.sequence.type.is_pyobject: + error(self.pos, "async for loops not allowed on C/C++ types") + self.sequence = self.sequence.coerce_to_pyobject(env) + return self + + def generate_result_code(self, code): + code.globalstate.use_utility_code(UtilityCode.load_cached("AsyncIter", "Coroutine.c")) + code.putln("%s = __Pyx_Coroutine_GetAsyncIter(%s); %s" % ( + self.result(), + self.sequence.py_result(), + code.error_goto_if_null(self.result(), self.pos))) + self.generate_gotref(code) + + def generate_for_loop_header(self, code): + code.put(";;") + + +class AsyncNextNode(AtomicExprNode): + # Used as part of 'async for' statement implementation. + # Implements result = iterator.__anext__() + # Created during analyse_types phase. + # The iterator is not owned by this node. + # + # iterator IteratorNode + + type = py_object_type + is_temp = 1 + + def __init__(self, iterator): + AtomicExprNode.__init__(self, iterator.pos) + self.iterator = iterator + + def infer_type(self, env): + return py_object_type + + def analyse_types(self, env): + return self + + def generate_result_code(self, code): + code.globalstate.use_utility_code(UtilityCode.load_cached("AsyncIter", "Coroutine.c")) + code.putln("%s = __Pyx_Coroutine_AsyncIterNext(%s); %s" % ( + self.result(), + self.iterator.py_result(), + code.error_goto_if_null(self.result(), self.pos))) + self.generate_gotref(code) + + +class WithExitCallNode(ExprNode): + # The __exit__() call of a 'with' statement. Used in both the + # except and finally clauses. + + # with_stat WithStatNode the surrounding 'with' statement + # args TupleNode or ResultStatNode the exception info tuple + # await_expr AwaitExprNode the await expression of an 'async with' statement + + subexprs = ['args', 'await_expr'] + test_if_run = True + await_expr = None + + def analyse_types(self, env): + self.args = self.args.analyse_types(env) + if self.await_expr: + self.await_expr = self.await_expr.analyse_types(env) + self.type = PyrexTypes.c_bint_type + self.is_temp = True + return self + + def generate_evaluation_code(self, code): + if self.test_if_run: + # call only if it was not already called (and decref-cleared) + code.putln("if (%s) {" % self.with_stat.exit_var) + + self.args.generate_evaluation_code(code) + result_var = code.funcstate.allocate_temp(py_object_type, manage_ref=False) + + code.mark_pos(self.pos) + code.globalstate.use_utility_code(UtilityCode.load_cached( + "PyObjectCall", "ObjectHandling.c")) + code.putln("%s = __Pyx_PyObject_Call(%s, %s, NULL);" % ( + result_var, + self.with_stat.exit_var, + self.args.result())) + code.put_decref_clear(self.with_stat.exit_var, type=py_object_type) + self.args.generate_disposal_code(code) + self.args.free_temps(code) + + code.putln(code.error_goto_if_null(result_var, self.pos)) + code.put_gotref(result_var, py_object_type) + + if self.await_expr: + # FIXME: result_var temp currently leaks into the closure + self.await_expr.generate_evaluation_code(code, source_cname=result_var, decref_source=True) + code.putln("%s = %s;" % (result_var, self.await_expr.py_result())) + self.await_expr.generate_post_assignment_code(code) + self.await_expr.free_temps(code) + + if self.result_is_used: + self.allocate_temp_result(code) + code.putln("%s = __Pyx_PyObject_IsTrue(%s);" % (self.result(), result_var)) + code.put_decref_clear(result_var, type=py_object_type) + if self.result_is_used: + code.put_error_if_neg(self.pos, self.result()) + code.funcstate.release_temp(result_var) + if self.test_if_run: + code.putln("}") + + +class ExcValueNode(AtomicExprNode): + # Node created during analyse_types phase + # of an ExceptClauseNode to fetch the current + # exception value. + + type = py_object_type + + def __init__(self, pos): + ExprNode.__init__(self, pos) + + def set_var(self, var): + self.var = var + + def calculate_result_code(self): + return self.var + + def generate_result_code(self, code): + pass + + def analyse_types(self, env): + return self + + +class TempNode(ExprNode): + # Node created during analyse_types phase + # of some nodes to hold a temporary value. + # + # Note: One must call "allocate" and "release" on + # the node during code generation to get/release the temp. + # This is because the temp result is often used outside of + # the regular cycle. + + subexprs = [] + + def __init__(self, pos, type, env=None): + ExprNode.__init__(self, pos) + self.type = type + if type.is_pyobject: + self.result_ctype = py_object_type + self.is_temp = 1 + + def analyse_types(self, env): + return self + + def analyse_target_declaration(self, env): + self.is_target = True + + def generate_result_code(self, code): + pass + + def allocate(self, code): + self.temp_cname = code.funcstate.allocate_temp(self.type, manage_ref=True) + + def release(self, code): + code.funcstate.release_temp(self.temp_cname) + self.temp_cname = None + + def result(self): + try: + return self.temp_cname + except: + assert False, "Remember to call allocate/release on TempNode" + raise + + # Do not participate in normal temp alloc/dealloc: + def allocate_temp_result(self, code): + pass + + def release_temp_result(self, code): + pass + +class PyTempNode(TempNode): + # TempNode holding a Python value. + + def __init__(self, pos, env): + TempNode.__init__(self, pos, PyrexTypes.py_object_type, env) + +class RawCNameExprNode(ExprNode): + subexprs = [] + + def __init__(self, pos, type=None, cname=None): + ExprNode.__init__(self, pos, type=type) + if cname is not None: + self.cname = cname + + def analyse_types(self, env): + return self + + def set_cname(self, cname): + self.cname = cname + + def result(self): + return self.cname + + def generate_result_code(self, code): + pass + + +#------------------------------------------------------------------- +# +# F-strings +# +#------------------------------------------------------------------- + + +class JoinedStrNode(ExprNode): + # F-strings + # + # values [UnicodeNode|FormattedValueNode|CloneNode] Substrings of the f-string + # + # CloneNodes for repeated substrings are only inserted right before the code generation phase. + + type = unicode_type + is_temp = True + gil_message = "String concatenation" + + subexprs = ['values'] + + def analyse_types(self, env): + self.values = [v.analyse_types(env).coerce_to_pyobject(env) for v in self.values] + return self + + def may_be_none(self): + # PyUnicode_Join() always returns a Unicode string or raises an exception + return False + + def generate_evaluation_code(self, code): + code.mark_pos(self.pos) + num_items = len(self.values) + use_stack_memory = num_items < 32 + + unknown_nodes = set() + max_char_value = 127 + for node in self.values: + if isinstance(node, UnicodeNode): + max_char_value = max(max_char_value, node.estimate_max_charval()) + elif (isinstance(node, FormattedValueNode) and + node.c_format_spec != 'c' and node.value.type.is_numeric): + # formatted C numbers are always ASCII + pass + elif isinstance(node, CloneNode): + # we already know the result + pass + else: + unknown_nodes.add(node) + + length_parts = [] + counts = {} + charval_parts = [str(max_char_value)] + for node in self.values: + node.generate_evaluation_code(code) + + if isinstance(node, UnicodeNode): + length_part = str(len(node.value)) + else: + # TODO: add exception handling for these macro calls if not ASSUME_SAFE_SIZE/MACROS + length_part = f"__Pyx_PyUnicode_GET_LENGTH({node.py_result()})" + if node in unknown_nodes: + charval_parts.append(f"__Pyx_PyUnicode_MAX_CHAR_VALUE({node.py_result()})") + + if length_part in counts: + counts[length_part] += 1 + else: + length_parts.append(length_part) + counts[length_part] = 1 + + if use_stack_memory: + values_array = code.funcstate.allocate_temp( + PyrexTypes.c_array_type(PyrexTypes.py_object_type, num_items), manage_ref=False) + else: + values_array = code.funcstate.allocate_temp( + PyrexTypes.CPtrType(PyrexTypes.py_object_type), manage_ref=False) + code.putln("%s = (PyObject **) PyMem_Calloc(%d, sizeof(PyObject*));" % (values_array, num_items)) + code.putln("if (unlikely(!%s)) {" % values_array) + code.putln("PyErr_NoMemory(); %s" % code.error_goto(self.pos)) + code.putln("}") + + for i, node in enumerate(self.values): + code.putln('%s[%d] = %s;' % (values_array, i, node.py_result())) + + length_parts = [ + f"{part} * {counts[part]}" if counts[part] > 1 else part + for part in length_parts + ] + + code.mark_pos(self.pos) + self.allocate_temp_result(code) + code.globalstate.use_utility_code(UtilityCode.load_cached("JoinPyUnicode", "StringTools.c")) + code.putln('%s = __Pyx_PyUnicode_Join(%s, %d, %s, %s);' % ( + self.result(), + values_array, + num_items, + ' + '.join(length_parts), + # or-ing isn't entirely correct here since it can produce values > 1114111, + # but we crop that in __Pyx_PyUnicode_Join(). + ' | '.join(charval_parts), + )) + + if not use_stack_memory: + code.putln("PyMem_Free(%s);" % values_array) + code.funcstate.release_temp(values_array) + + code.putln(code.error_goto_if_null(self.py_result(), self.pos)) + self.generate_gotref(code) + + for node in self.values: + node.generate_disposal_code(code) + node.free_temps(code) + + +class FormattedValueNode(ExprNode): + # {}-delimited portions of an f-string + # + # value ExprNode The expression itself + # conversion_char str or None Type conversion (!s, !r, !a, none, or 'd' for integer conversion) + # format_spec JoinedStrNode or None Format string passed to __format__ + # c_format_spec str or None If not None, formatting can be done at the C level + + subexprs = ['value', 'format_spec'] + + type = unicode_type + is_temp = True + c_format_spec = None + gil_message = "String formatting" + + find_conversion_func = { + 's': 'PyObject_Str', + 'r': 'PyObject_Repr', + 'a': 'PyObject_ASCII', + 'd': '__Pyx_PyNumber_Long', # NOTE: internal mapping for '%d' formatting + }.get + + def may_be_none(self): + # PyObject_Format() always returns a Unicode string or raises an exception + return False + + def analyse_types(self, env): + self.value = self.value.analyse_types(env) + if not self.format_spec or self.format_spec.is_string_literal: + c_format_spec = self.format_spec.value if self.format_spec else self.value.type.default_format_spec + if self.value.type.can_coerce_to_pystring(env, format_spec=c_format_spec): + self.c_format_spec = c_format_spec + + if self.format_spec: + self.format_spec = self.format_spec.analyse_types(env).coerce_to_pyobject(env) + if self.c_format_spec is None: + self.value = self.value.coerce_to_pyobject(env) + if not self.format_spec and (not self.conversion_char or self.conversion_char == 's'): + if self.value.type is unicode_type and not self.value.may_be_none(): + # value is definitely a unicode string and we don't format it any special + return self.value + return self + + def generate_result_code(self, code): + if self.c_format_spec is not None and not self.value.type.is_pyobject: + convert_func_call = self.value.type.convert_to_pystring( + self.value.result(), code, self.c_format_spec) + code.putln("%s = %s; %s" % ( + self.result(), + convert_func_call, + code.error_goto_if_null(self.result(), self.pos))) + self.generate_gotref(code) + return + + value_result = self.value.py_result() + value_is_unicode = self.value.type is unicode_type and not self.value.may_be_none() + if self.format_spec: + format_func = '__Pyx_PyObject_Format' + format_spec = self.format_spec.py_result() + else: + # common case: expect simple Unicode pass-through if no format spec + format_func = '__Pyx_PyObject_FormatSimple' + # passing a Unicode format string in Py2 forces PyObject_Format() to also return a Unicode string + format_spec = code.name_in_module_state(Naming.empty_unicode) + + conversion_char = self.conversion_char + if conversion_char == 's' and value_is_unicode: + # no need to pipe unicode strings through str() + conversion_char = None + + if conversion_char: + fn = self.find_conversion_func(conversion_char) + assert fn is not None, "invalid conversion character found: '%s'" % conversion_char + value_result = '%s(%s)' % (fn, value_result) + code.globalstate.use_utility_code( + UtilityCode.load_cached("PyObjectFormatAndDecref", "StringTools.c")) + format_func += 'AndDecref' + elif self.format_spec: + code.globalstate.use_utility_code( + UtilityCode.load_cached("PyObjectFormat", "StringTools.c")) + else: + code.globalstate.use_utility_code( + UtilityCode.load_cached("PyObjectFormatSimple", "StringTools.c")) + + code.putln("%s = %s(%s, %s); %s" % ( + self.result(), + format_func, + value_result, + format_spec, + code.error_goto_if_null(self.result(), self.pos))) + self.generate_gotref(code) + + +#------------------------------------------------------------------- +# +# Parallel nodes (cython.parallel.thread(savailable|id)) +# +#------------------------------------------------------------------- + +class ParallelThreadsAvailableNode(AtomicExprNode): + """ + Note: this is disabled and not a valid directive at this moment + + Implements cython.parallel.threadsavailable(). If we are called from the + sequential part of the application, we need to call omp_get_max_threads(), + and in the parallel part we can just call omp_get_num_threads() + """ + + type = PyrexTypes.c_int_type + + def analyse_types(self, env): + self.is_temp = True + # env.add_include_file("omp.h") + return self + + def generate_result_code(self, code): + code.putln("#ifdef _OPENMP") + code.putln("if (omp_in_parallel()) %s = omp_get_max_threads();" % + self.temp_code) + code.putln("else %s = omp_get_num_threads();" % self.temp_code) + code.putln("#else") + code.putln("%s = 1;" % self.temp_code) + code.putln("#endif") + + def result(self): + return self.temp_code + + +class ParallelThreadIdNode(AtomicExprNode): #, Nodes.ParallelNode): + """ + Implements cython.parallel.threadid() + """ + + type = PyrexTypes.c_int_type + + def analyse_types(self, env): + self.is_temp = True + # env.add_include_file("omp.h") + return self + + def generate_result_code(self, code): + code.putln("#ifdef _OPENMP") + code.putln("%s = omp_get_thread_num();" % self.temp_code) + code.putln("#else") + code.putln("%s = 0;" % self.temp_code) + code.putln("#endif") + + def result(self): + return self.temp_code + + +#------------------------------------------------------------------- +# +# Trailer nodes +# +#------------------------------------------------------------------- + + +class _IndexingBaseNode(ExprNode): + # Base class for indexing nodes. + # + # base ExprNode the value being indexed + + def is_ephemeral(self): + # in most cases, indexing will return a safe reference to an object in a container, + # so we consider the result safe if the base object is + return self.base.is_ephemeral() or self.base.type in ( + unicode_type, bytes_type, bytearray_type) + + def check_const_addr(self): + return self.base.check_const_addr() and self.index.check_const() + + def is_lvalue(self): + # NOTE: references currently have both is_reference and is_ptr + # set. Since pointers and references have different lvalue + # rules, we must be careful to separate the two. + if self.type.is_reference: + if self.type.ref_base_type.is_array: + # fixed-sized arrays aren't l-values + return False + elif self.type.is_ptr: + # non-const pointers can always be reassigned + return True + # Just about everything else returned by the index operator + # can be an lvalue. + return True + + +class IndexNode(_IndexingBaseNode): + # Sequence indexing. + # + # base ExprNode + # index ExprNode + # type_indices [PyrexType] + # + # is_fused_index boolean Whether the index is used to specialize a + # c(p)def function + + subexprs = ['base', 'index'] + type_indices = None + + is_subscript = True + is_fused_index = False + + def calculate_constant_result(self): + self.constant_result = self.base.constant_result[self.index.constant_result] + + def compile_time_value(self, denv): + base = self.base.compile_time_value(denv) + index = self.index.compile_time_value(denv) + try: + return base[index] + except Exception as e: + self.compile_time_value_error(e) + + def is_simple(self): + base = self.base + return (base.is_simple() and self.index.is_simple() + and base.type and (base.type.is_ptr or base.type.is_array)) + + def may_be_none(self): + base_type = self.base.type + if base_type: + if base_type.is_string: + return False + if base_type in (unicode_type, bytes_type, bytearray_type): + return False + if isinstance(self.index, SliceNode): + # slicing! + if base_type.is_builtin_type: + # It seems that none of the builtin types can return None for "__getitem__[slice]". + # Slices are not hashable, and thus cannot be used as key in dicts, for example. + return False + return ExprNode.may_be_none(self) + + def analyse_target_declaration(self, env): + pass + + def analyse_as_type(self, env): + modifier = self.base.as_cython_attribute() + + if modifier is not None and modifier in ('pointer', 'const', 'volatile'): + base_type = self.index.analyse_as_type(env) + if base_type is None: + error(self.base.pos, f"invalid use of '{modifier}', argument is not a type") + return None + if modifier == 'pointer': + # pointer[base_type] + return PyrexTypes.CPtrType(base_type) + + # const[base_type] or volatile[base_type] + is_const = modifier == 'const' + is_volatile = not is_const + if base_type.is_cv_qualified: + if base_type.is_const: + if is_const: + error(self.base.pos, "Duplicate 'const'") + is_const = True + if base_type.is_volatile: + if is_volatile: + error(self.base.pos, "Duplicate 'volatile'") + is_volatile = True + base_type = base_type.cv_base_type + if base_type.is_memoryviewslice: + error(self.base.pos, + f"Cannot declare memory view variable as '{modifier}'. Did you mean '{modifier}[item_type][:]' ?") + return PyrexTypes.c_const_or_volatile_type( + base_type, is_const=is_const, is_volatile=not is_const) + + base_type = self.base.analyse_as_type(env) + if base_type: + # base_type[...] + if base_type.is_cpp_class or base_type.python_type_constructor_name: + if self.index.is_sequence_constructor: + template_values = self.index.args + else: + template_values = [self.index] + type_node = Nodes.TemplatedTypeNode( + pos=self.pos, + positional_args=template_values, + keyword_args=None) + return type_node.analyse(env, base_type=base_type) + elif self.index.is_slice or self.index.is_sequence_constructor: + # memory view + from . import MemoryView + env.use_utility_code( + MemoryView.get_view_utility_code( + env.context.shared_utility_qualified_name + ) + ) + axes = [self.index] if self.index.is_slice else list(self.index.args) + return PyrexTypes.MemoryViewSliceType(base_type, MemoryView.get_axes_specs(env, axes)) + elif not base_type.is_pyobject: + # C array + index = self.index.compile_time_value(env) + if index is not None: + try: + index = int(index) + except (ValueError, TypeError): + pass + else: + return PyrexTypes.CArrayType(base_type, index) + error(self.pos, "Array size must be a compile time constant") + return None + + def analyse_pytyping_modifiers(self, env): + # Check for declaration modifiers, e.g. "typing.Optional[...]" or "dataclasses.InitVar[...]" + # `typing.Optional` is used for all variants of modifiers representing Optional type (Optional[T], Union[T, None]) + # TODO: somehow bring this together with TemplatedTypeNode.analyse_pytyping_modifiers() + modifiers = [] + modifier_node = self + while modifier_node.is_subscript: + modifier_type = modifier_node.base.analyse_as_type(env) + if (modifier_type and modifier_type.python_type_constructor_name + and modifier_type.modifier_name): + modifiers.append('typing.Optional' if modifier_type.allows_none() else modifier_type.modifier_name) + modifier_node = modifier_node.index + return modifiers + + def type_dependencies(self, env): + return self.base.type_dependencies(env) + self.index.type_dependencies(env) + + def infer_type(self, env): + base_type = self.base.infer_type(env) + if self.index.is_slice: + # slicing! + if base_type.is_string: + # sliced C strings must coerce to Python + return bytes_type + elif base_type.is_pyunicode_ptr: + # sliced Py_UNICODE* strings must coerce to Python + return unicode_type + elif base_type in (unicode_type, bytes_type, bytearray_type, list_type, tuple_type): + # slicing these returns the same type + return base_type + elif base_type.is_memoryviewslice: + return base_type + else: + # TODO: Handle buffers (hopefully without too much redundancy). + return py_object_type + + index_type = self.index.infer_type(env) + if index_type and index_type.is_int or isinstance(self.index, IntNode): + # indexing! + if base_type is unicode_type: + # Py_UCS4 will automatically coerce to a unicode string + # if required, so this is safe. We only infer Py_UCS4 + # when the index is a C integer type. Otherwise, we may + # need to use normal Python item access, in which case + # it's faster to return the one-char unicode string than + # to receive it, throw it away, and potentially rebuild it + # on a subsequent PyObject coercion. + return PyrexTypes.c_py_ucs4_type + elif base_type is bytearray_type or self.base is bytes_type: + return PyrexTypes.c_uchar_type + elif base_type in (tuple_type, list_type): + # if base is a literal, take a look at its values + item_type = infer_sequence_item_type( + env, self.base, self.index, seq_type=base_type) + if item_type is not None: + return item_type + elif base_type.is_ptr or base_type.is_array: + return base_type.base_type + elif base_type.is_ctuple and isinstance(self.index, IntNode): + if self.index.has_constant_result(): + index = self.index.constant_result + if index < 0: + index += base_type.size + if 0 <= index < base_type.size: + return base_type.components[index] + elif base_type.is_memoryviewslice: + if base_type.ndim == 0: + pass # probably an error, but definitely don't know what to do - return pyobject for now + if base_type.ndim == 1: + return base_type.dtype + else: + return PyrexTypes.MemoryViewSliceType(base_type.dtype, base_type.axes[1:]) + + if self.index.is_sequence_constructor and base_type.is_memoryviewslice: + inferred_type = base_type + for a in self.index.args: + if not inferred_type.is_memoryviewslice: + break # something's gone wrong + inferred_type = IndexNode(self.pos, base=ExprNode(self.base.pos, type=inferred_type), + index=a).infer_type(env) + else: + return inferred_type + + if base_type.is_cpp_class: + class FakeOperand: + def __init__(self, **kwds): + self.__dict__.update(kwds) + operands = [ + FakeOperand(pos=self.pos, type=base_type), + FakeOperand(pos=self.pos, type=index_type), + ] + index_func = env.lookup_operator('[]', operands) + if index_func is not None: + return index_func.type.return_type + + if is_pythran_expr(base_type) and is_pythran_expr(index_type): + index_with_type = (self.index, index_type) + return PythranExpr(pythran_indexing_type(base_type, [index_with_type])) + + # may be slicing or indexing, we don't know + if base_type is unicode_type: + # always returns its own type on Python indexing/slicing + return base_type + + # TODO: Handle buffers (hopefully without too much redundancy). + return py_object_type + + def analyse_types(self, env): + return self.analyse_base_and_index_types(env, getting=True) + + def analyse_target_types(self, env): + node = self.analyse_base_and_index_types(env, setting=True) + if node.type.is_const: + error(self.pos, "Assignment to const dereference") + if node is self and not node.is_lvalue(): + error(self.pos, "Assignment to non-lvalue of type '%s'" % node.type) + return node + + def analyse_base_and_index_types(self, env, getting=False, setting=False, + analyse_base=True): + # Note: This might be cleaned up by having IndexNode + # parsed in a saner way and only construct the tuple if + # needed. + if analyse_base: + self.base = self.base.analyse_types(env) + + if self.base.type.is_error: + # Do not visit child tree if base is undeclared to avoid confusing + # error messages + self.type = PyrexTypes.error_type + return self + + is_slice = self.index.is_slice + if not env.directives['wraparound']: + if is_slice: + check_negative_indices(self.index.start, self.index.stop) + else: + check_negative_indices(self.index) + + # Potentially overflowing index value. + if not is_slice and isinstance(self.index, IntNode) and Utils.long_literal(self.index.value): + self.index = self.index.coerce_to_pyobject(env) + + is_memslice = self.base.type.is_memoryviewslice + # Handle the case where base is a literal char* (and we expect a string, not an int) + if not is_memslice and (isinstance(self.base, BytesNode) or is_slice): + if self.base.type.is_string or not (self.base.type.is_ptr or self.base.type.is_array): + self.base = self.base.coerce_to_pyobject(env) + + replacement_node = self.analyse_as_buffer_operation(env, getting) + if replacement_node is not None: + return replacement_node + + self.nogil = env.nogil + base_type = self.base.type + + if not base_type.is_cfunction: + self.index = self.index.analyse_types(env) + self.original_index_type = self.index.type + if self.original_index_type.is_reference: + self.original_index_type = self.original_index_type.ref_base_type + + if base_type.is_unicode_char: + # we infer Py_UNICODE/Py_UCS4 for unicode strings in some + # cases, but indexing must still work for them + if setting: + warning(self.pos, "cannot assign to Unicode string index", level=1) + elif self.index.constant_result in (0, -1): + # uchar[0] => uchar + return self.base + self.base = self.base.coerce_to_pyobject(env) + base_type = self.base.type + + if base_type.is_pyobject: + return self.analyse_as_pyobject(env, is_slice, getting, setting) + elif base_type.is_ptr or base_type.is_array: + return self.analyse_as_c_array(env, is_slice) + elif base_type.is_cpp_class: + return self.analyse_as_cpp(env, setting) + elif base_type.is_cfunction: + return self.analyse_as_c_function(env) + elif base_type.is_ctuple: + return self.analyse_as_c_tuple(env, getting, setting) + else: + error(self.pos, + "Attempting to index non-array type '%s'" % + base_type) + self.type = PyrexTypes.error_type + return self + + def analyse_as_pyobject(self, env, is_slice, getting, setting): + base_type = self.base.type + if self.index.type.is_unicode_char and base_type is not dict_type: + # TODO: eventually fold into case below and remove warning, once people have adapted their code + warning(self.pos, + "Item lookup of unicode character codes now always converts to a Unicode string. " + "Use an explicit C integer cast to get back the previous integer lookup behaviour.", level=1) + self.index = self.index.coerce_to_pyobject(env) + self.is_temp = 1 + elif self.index.type.is_int and base_type is not dict_type: + if (getting + and not env.directives['boundscheck'] + and (base_type in (list_type, tuple_type, bytearray_type)) + and (not self.index.type.signed + or not env.directives['wraparound'] + or (isinstance(self.index, IntNode) and + self.index.has_constant_result() and self.index.constant_result >= 0)) + ): + self.is_temp = 0 + else: + self.is_temp = 1 + self.index = self.index.coerce_to(PyrexTypes.c_py_ssize_t_type, env).coerce_to_simple(env) + self.original_index_type.create_to_py_utility_code(env) + else: + self.index = self.index.coerce_to_pyobject(env) + self.is_temp = 1 + + if self.index.type.is_int and base_type is unicode_type: + # Py_UNICODE/Py_UCS4 will automatically coerce to a unicode string + # if required, so this is fast and safe + self.type = PyrexTypes.c_py_ucs4_type + elif self.index.type.is_int and base_type is bytearray_type: + if setting: + self.type = PyrexTypes.c_uchar_type + else: + # not using 'uchar' to enable fast and safe error reporting as '-1' + self.type = PyrexTypes.c_int_type + elif is_slice and base_type in (bytes_type, bytearray_type, unicode_type, list_type, tuple_type): + self.type = base_type + else: + item_type = None + if base_type in (list_type, tuple_type) and self.index.type.is_int: + item_type = infer_sequence_item_type( + env, self.base, self.index, seq_type=base_type) + if base_type in (list_type, tuple_type, dict_type): + # do the None check explicitly (not in a helper) to allow optimising it away + self.base = self.base.as_none_safe_node("'NoneType' object is not subscriptable") + if item_type is None or not item_type.is_pyobject: + # Even if we inferred a C type as result, we will read a Python object, so trigger coercion if needed. + # We could potentially use "item_type.equivalent_type" here, but that may trigger assumptions + # about the actual runtime item types, rather than just their ability to coerce to the C "item_type". + self.type = py_object_type + else: + self.type = item_type + + self.wrap_in_nonecheck_node(env, getting) + return self + + def analyse_as_c_array(self, env, is_slice): + base_type = self.base.type + self.type = base_type.base_type + if self.type.is_cpp_class: + self.type = PyrexTypes.CReferenceType(self.type) + if is_slice: + self.type = base_type + elif self.index.type.is_pyobject: + self.index = self.index.coerce_to(PyrexTypes.c_py_ssize_t_type, env) + elif not self.index.type.is_int: + error(self.pos, "Invalid index type '%s'" % self.index.type) + return self + + def analyse_as_cpp(self, env, setting): + base_type = self.base.type + function = env.lookup_operator("[]", [self.base, self.index]) + if function is None: + error(self.pos, "Indexing '%s' not supported for index type '%s'" % (base_type, self.index.type)) + self.type = PyrexTypes.error_type + self.result_code = "" + return self + func_type = function.type + if func_type.is_ptr: + func_type = func_type.base_type + self.exception_check = func_type.exception_check + self.exception_value = func_type.exception_value + if self.exception_check: + if not setting: + self.is_temp = True + if needs_cpp_exception_conversion(self): + env.use_utility_code(UtilityCode.load_cached("CppExceptionConversion", "CppSupport.cpp")) + self.index = self.index.coerce_to(func_type.args[0].type, env) + self.type = func_type.return_type + if setting and not func_type.return_type.is_reference: + error(self.pos, "Can't set non-reference result '%s'" % self.type) + return self + + def analyse_as_c_function(self, env): + base_type = self.base.type + if base_type.is_fused: + self.parse_indexed_fused_cdef(env) + else: + self.type_indices = self.parse_index_as_types(env) + self.index = None # FIXME: use a dedicated Node class instead of generic IndexNode + if base_type.templates is None: + error(self.pos, "Can only parameterize template functions.") + self.type = error_type + elif self.type_indices is None: + # Error recorded earlier. + self.type = error_type + elif len(base_type.templates) != len(self.type_indices): + error(self.pos, "Wrong number of template arguments: expected %s, got %s" % ( + (len(base_type.templates), len(self.type_indices)))) + self.type = error_type + else: + self.type = base_type.specialize(dict(zip(base_type.templates, self.type_indices))) + # FIXME: use a dedicated Node class instead of generic IndexNode + return self + + def analyse_as_c_tuple(self, env, getting, setting): + base_type = self.base.type + if isinstance(self.index, IntNode) and self.index.has_constant_result(): + index = self.index.constant_result + if -base_type.size <= index < base_type.size: + if index < 0: + index += base_type.size + self.type = base_type.components[index] + else: + error(self.pos, + "Index %s out of bounds for '%s'" % + (index, base_type)) + self.type = PyrexTypes.error_type + return self + else: + self.base = self.base.coerce_to_pyobject(env) + return self.analyse_base_and_index_types(env, getting=getting, setting=setting, analyse_base=False) + + def analyse_as_buffer_operation(self, env, getting): + """ + Analyse buffer indexing and memoryview indexing/slicing + """ + if isinstance(self.index, TupleNode): + indices = self.index.args + else: + indices = [self.index] + + base = self.base + base_type = base.type + replacement_node = None + if base_type.is_memoryviewslice: + # memoryviewslice indexing or slicing + from . import MemoryView + if base.is_memview_slice: + # For memory views, "view[i][j]" is the same as "view[i, j]" => use the latter for speed. + merged_indices = base.merged_indices(indices) + if merged_indices is not None: + base = base.base + base_type = base.type + indices = merged_indices + have_slices, indices, newaxes = MemoryView.unellipsify(indices, base_type.ndim) + if have_slices: + replacement_node = MemoryViewSliceNode(self.pos, indices=indices, base=base) + else: + replacement_node = MemoryViewIndexNode(self.pos, indices=indices, base=base) + elif base_type.is_buffer or base_type.is_pythran_expr: + if base_type.is_pythran_expr or len(indices) == base_type.ndim: + # Buffer indexing + is_buffer_access = True + indices = [index.analyse_types(env) for index in indices] + if base_type.is_pythran_expr: + do_replacement = all( + index.type.is_int or index.is_slice or index.type.is_pythran_expr + for index in indices) + if do_replacement: + for i,index in enumerate(indices): + if index.is_slice: + index = SliceIntNode(index.pos, start=index.start, stop=index.stop, step=index.step) + index = index.analyse_types(env) + indices[i] = index + else: + do_replacement = all(index.type.is_int for index in indices) + if do_replacement: + replacement_node = BufferIndexNode(self.pos, indices=indices, base=base) + # On cloning, indices is cloned. Otherwise, unpack index into indices. + assert not isinstance(self.index, CloneNode) + + if replacement_node is not None: + replacement_node = replacement_node.analyse_types(env, getting) + return replacement_node + + def wrap_in_nonecheck_node(self, env, getting): + if not env.directives['nonecheck'] or not self.base.may_be_none(): + return + self.base = self.base.as_none_safe_node("'NoneType' object is not subscriptable") + + def parse_index_as_types(self, env, required=True): + if isinstance(self.index, TupleNode): + indices = self.index.args + else: + indices = [self.index] + type_indices = [] + for index in indices: + type_indices.append(index.analyse_as_type(env)) + if type_indices[-1] is None: + if required: + error(index.pos, "not parsable as a type") + return None + return type_indices + + def parse_indexed_fused_cdef(self, env): + """ + Interpret fused_cdef_func[specific_type1, ...] + + Note that if this method is called, we are an indexed cdef function + with fused argument types, and this IndexNode will be replaced by the + NameNode with specific entry just after analysis of expressions by + AnalyseExpressionsTransform. + """ + self.type = PyrexTypes.error_type + + self.is_fused_index = True + + base_type = self.base.type + positions = [] + + if self.index.is_name or self.index.is_attribute: + positions.append(self.index.pos) + elif isinstance(self.index, TupleNode): + for arg in self.index.args: + positions.append(arg.pos) + specific_types = self.parse_index_as_types(env, required=False) + + if specific_types is None: + self.index = self.index.analyse_types(env) + + if not self.base.entry.as_variable: + error(self.pos, "Can only index fused functions with types") + else: + # A cpdef function indexed with Python objects + self.base.entry = self.entry = self.base.entry.as_variable + self.base.type = self.type = self.entry.type + + self.base.is_temp = True + self.is_temp = True + + self.entry.used = True + + self.is_fused_index = False + return + + for i, type in enumerate(specific_types): + specific_types[i] = type.specialize_fused(env) + + fused_types = base_type.get_fused_types() + if len(specific_types) > len(fused_types): + return error(self.pos, "Too many types specified") + elif len(specific_types) < len(fused_types): + t = fused_types[len(specific_types)] + return error(self.pos, "Not enough types specified to specialize " + "the function, %s is still fused" % t) + + # See if our index types form valid specializations + for pos, specific_type, fused_type in zip(positions, + specific_types, + fused_types): + if not any([specific_type.same_as(t) for t in fused_type.types]): + return error(pos, "Type not in fused type") + + if specific_type is None or specific_type.is_error: + return + + fused_to_specific = dict(zip(fused_types, specific_types)) + type = base_type.specialize(fused_to_specific) + + if type.is_fused: + # Only partially specific, this is invalid + error(self.pos, + "Index operation makes function only partially specific") + else: + # Fully specific, find the signature with the specialized entry + for signature in self.base.type.get_all_specialized_function_types(): + if type.same_as(signature): + self.type = signature + + if self.base.is_attribute: + # Pretend to be a normal attribute, for cdef extension + # methods + self.entry = signature.entry + self.is_attribute = True + self.obj = self.base.obj + + self.type.entry.used = True + self.base.type = signature + self.base.entry = signature.entry + + break + else: + # This is a bug + raise InternalError("Couldn't find the right signature") + + gil_message = "Indexing Python object" + + def calculate_result_code(self): + if self.base.type in (list_type, tuple_type, bytearray_type): + # Note - These functions are missing error checks in not CYTHON_ASSUME_SAFE_MACROS. + # Since they're only used in optimized modes without boundschecking, I think this is + # a reasonable optimization to make. + if self.base.type is list_type: + index_code = "__Pyx_PyList_GET_ITEM(%s, %s)" + elif self.base.type is tuple_type: + index_code = "__Pyx_PyTuple_GET_ITEM(%s, %s)" + elif self.base.type is bytearray_type: + index_code = "((unsigned char)(__Pyx_PyByteArray_AsString(%s)[%s]))" + else: + assert False, "unexpected base type in indexing: %s" % self.base.type + elif self.base.type.is_cfunction: + return "%s<%s>" % ( + self.base.result(), + ",".join([param.empty_declaration_code() for param in self.type_indices])) + elif self.base.type.is_ctuple: + index = self.index.constant_result + if index < 0: + index += self.base.type.size + return "%s.f%s" % (self.base.result(), index) + else: + if (self.type.is_ptr or self.type.is_array) and self.type == self.base.type: + error(self.pos, "Invalid use of pointer slice") + return + index_code = "(%s[%s])" + return index_code % (self.base.result(), self.index.result()) + + def extra_index_params(self, code): + if self.index.type.is_int: + is_list = self.base.type is list_type + wraparound = ( + bool(code.globalstate.directives['wraparound']) and + self.original_index_type.signed and + not (isinstance(self.index.constant_result, int) + and self.index.constant_result >= 0)) + boundscheck = bool(code.globalstate.directives['boundscheck']) + has_gil = not self.in_nogil_context + return ", %s, %d, %s, %d, %d, %d, %d" % ( + self.original_index_type.empty_declaration_code(), + self.original_index_type.signed and 1 or 0, + self.original_index_type.to_py_function, + is_list, wraparound, boundscheck, has_gil) + else: + return "" + + def generate_result_code(self, code): + if not self.is_temp: + # all handled in self.calculate_result_code() + return + + base_type = self.base.type + utility_code = None + error_value = None + if self.type.is_pyobject: + error_value = 'NULL' + if self.index.type.is_int: + if base_type is list_type: + function = "__Pyx_GetItemInt_List" + elif base_type is tuple_type: + function = "__Pyx_GetItemInt_Tuple" + else: + function = "__Pyx_GetItemInt" + utility_code = TempitaUtilityCode.load_cached("GetItemInt", "ObjectHandling.c") + else: + if base_type is dict_type: + function = "__Pyx_PyDict_GetItem" + utility_code = UtilityCode.load_cached("DictGetItem", "ObjectHandling.c") + elif base_type is py_object_type and self.index.type is unicode_type: + # obj[str] is probably doing a dict lookup + function = "__Pyx_PyObject_Dict_GetItem" + utility_code = UtilityCode.load_cached("DictGetItem", "ObjectHandling.c") + else: + function = "__Pyx_PyObject_GetItem" + code.globalstate.use_utility_code( + TempitaUtilityCode.load_cached("GetItemInt", "ObjectHandling.c")) + utility_code = UtilityCode.load_cached("ObjectGetItem", "ObjectHandling.c") + elif self.type.is_unicode_char and base_type is unicode_type: + assert self.index.type.is_int + function = "__Pyx_GetItemInt_Unicode" + error_value = '(Py_UCS4)-1' + utility_code = UtilityCode.load_cached("GetItemIntUnicode", "StringTools.c") + elif base_type is bytearray_type: + assert self.index.type.is_int + assert self.type.is_int + function = "__Pyx_GetItemInt_ByteArray" + error_value = '-1' + utility_code = UtilityCode.load_cached("GetItemIntByteArray", "StringTools.c") + elif not (base_type.is_cpp_class and self.exception_check): + assert False, "unexpected type %s and base type %s for indexing (%s)" % ( + self.type, base_type, self.pos) + + if utility_code is not None: + code.globalstate.use_utility_code(utility_code) + + if self.index.type.is_int: + index_code = self.index.result() + else: + index_code = self.index.py_result() + + if base_type.is_cpp_class and self.exception_check: + translate_cpp_exception(code, self.pos, + "%s = %s[%s];" % (self.result(), self.base.result(), + self.index.result()), + self.result() if self.type.is_pyobject else None, + self.exception_value, self.in_nogil_context) + else: + error_check = '!%s' if error_value == 'NULL' else '%%s == %s' % error_value + code.putln( + "%s = %s(%s, %s%s); %s" % ( + self.result(), + function, + self.base.py_result(), + index_code, + self.extra_index_params(code), + code.error_goto_if(error_check % self.result(), self.pos))) + if self.type.is_pyobject: + self.generate_gotref(code) + + def generate_setitem_code(self, value_code, code): + if self.index.type.is_int: + if self.base.type is bytearray_type: + code.globalstate.use_utility_code( + UtilityCode.load_cached("SetItemIntByteArray", "StringTools.c")) + function = "__Pyx_SetItemInt_ByteArray" + else: + code.globalstate.use_utility_code( + UtilityCode.load_cached("SetItemInt", "ObjectHandling.c")) + function = "__Pyx_SetItemInt" + index_code = self.index.result() + else: + index_code = self.index.py_result() + if self.base.type is dict_type: + function = "PyDict_SetItem" + # It would seem that we could specialized lists/tuples, but that + # shouldn't happen here. + # Both PyList_SetItem() and PyTuple_SetItem() take a Py_ssize_t as + # index instead of an object, and bad conversion here would give + # the wrong exception. Also, tuples are supposed to be immutable, + # and raise a TypeError when trying to set their entries + # (PyTuple_SetItem() is for creating new tuples from scratch). + else: + function = "PyObject_SetItem" + code.putln(code.error_goto_if_neg( + "%s(%s, %s, %s%s)" % ( + function, + self.base.py_result(), + index_code, + value_code, + self.extra_index_params(code)), + self.pos)) + + def generate_assignment_code(self, rhs, code, overloaded_assignment=False, + exception_check=None, exception_value=None): + self.generate_subexpr_evaluation_code(code) + + if self.type.is_pyobject: + self.generate_setitem_code(rhs.py_result(), code) + elif self.base.type is bytearray_type: + value_code = self._check_byte_value(code, rhs) + self.generate_setitem_code(value_code, code) + elif self.base.type.is_cpp_class and self.exception_check and self.exception_check == '+': + if overloaded_assignment and exception_check and self.exception_value != exception_value: + # Handle the case that both the index operator and the assignment + # operator have a c++ exception handler and they are not the same. + translate_double_cpp_exception(code, self.pos, self.type, + self.result(), rhs.result(), self.exception_value, + exception_value, self.in_nogil_context) + else: + # Handle the case that only the index operator has a + # c++ exception handler, or that + # both exception handlers are the same. + translate_cpp_exception(code, self.pos, + "%s = %s;" % (self.result(), rhs.result()), + self.result() if self.type.is_pyobject else None, + self.exception_value, self.in_nogil_context) + else: + code.putln( + "%s = %s;" % (self.result(), rhs.result())) + + self.generate_subexpr_disposal_code(code) + self.free_subexpr_temps(code) + rhs.generate_disposal_code(code) + rhs.free_temps(code) + + def _check_byte_value(self, code, rhs): + # TODO: should we do this generally on downcasts, or just here? + assert rhs.type.is_int, repr(rhs.type) + value_code = rhs.result() + if rhs.has_constant_result(): + if 0 <= rhs.constant_result < 256: + return value_code + needs_cast = True # make at least the C compiler happy + warning(rhs.pos, + "value outside of range(0, 256)" + " when assigning to byte: %s" % rhs.constant_result, + level=1) + else: + needs_cast = rhs.type != PyrexTypes.c_uchar_type + + if not self.nogil: + conditions = [] + if rhs.is_literal or rhs.type.signed: + conditions.append('%s < 0' % value_code) + if (rhs.is_literal or not + (rhs.result_in_temp() and rhs.type in ( + PyrexTypes.c_uchar_type, PyrexTypes.c_char_type, + PyrexTypes.c_schar_type))): + conditions.append('%s > 255' % value_code) + if conditions: + code.putln("if (unlikely(%s)) {" % ' || '.join(conditions)) + code.putln( + 'PyErr_SetString(PyExc_ValueError,' + ' "byte must be in range(0, 256)"); %s' % + code.error_goto(self.pos)) + code.putln("}") + + if needs_cast: + value_code = '((unsigned char)%s)' % value_code + return value_code + + def generate_deletion_code(self, code, ignore_nonexisting=False): + self.generate_subexpr_evaluation_code(code) + #if self.type.is_pyobject: + if self.index.type.is_int: + function = "__Pyx_DelItemInt" + index_code = self.index.result() + code.globalstate.use_utility_code( + UtilityCode.load_cached("DelItemInt", "ObjectHandling.c")) + else: + index_code = self.index.py_result() + if self.base.type is dict_type: + function = "PyDict_DelItem" + else: + function = "PyObject_DelItem" + code.putln(code.error_goto_if_neg( + "%s(%s, %s%s)" % ( + function, + self.base.py_result(), + index_code, + self.extra_index_params(code)), + self.pos)) + self.generate_subexpr_disposal_code(code) + self.free_subexpr_temps(code) + + +class BufferIndexNode(_IndexingBaseNode): + """ + Indexing of buffers and memoryviews. This node is created during type + analysis from IndexNode and replaces it. + + Attributes: + base - base node being indexed + indices - list of indexing expressions + """ + + subexprs = ['base', 'indices'] + + is_buffer_access = True + + # Whether we're assigning to a buffer (in that case it needs to be writable) + writable_needed = False + + # Any indexing temp variables that we need to clean up. + index_temps = () + + def analyse_target_types(self, env): + self.analyse_types(env, getting=False) + + def analyse_types(self, env, getting=True): + """ + Analyse types for buffer indexing only. Overridden by memoryview + indexing and slicing subclasses + """ + # self.indices are already analyzed + if not self.base.is_name and not is_pythran_expr(self.base.type): + error(self.pos, "Can only index buffer variables") + self.type = error_type + return self + + if not getting: + if not self.base.entry.type.writable: + error(self.pos, "Writing to readonly buffer") + else: + self.writable_needed = True + if self.base.type.is_buffer: + self.base.entry.buffer_aux.writable_needed = True + + self.none_error_message = "'NoneType' object is not subscriptable" + self.analyse_buffer_index(env, getting) + self.wrap_in_nonecheck_node(env) + return self + + def analyse_buffer_index(self, env, getting): + if is_pythran_expr(self.base.type): + index_with_type_list = [(idx, idx.type) for idx in self.indices] + self.type = PythranExpr(pythran_indexing_type(self.base.type, index_with_type_list)) + else: + self.base = self.base.coerce_to_simple(env) + self.type = self.base.type.dtype + self.buffer_type = self.base.type + + if getting and (self.type.is_pyobject or self.type.is_pythran_expr): + self.is_temp = True + + def analyse_assignment(self, rhs): + """ + Called by IndexNode when this node is assigned to, + with the rhs of the assignment + """ + + def wrap_in_nonecheck_node(self, env): + if not env.directives['nonecheck'] or not self.base.may_be_none(): + return + self.base = self.base.as_none_safe_node(self.none_error_message) + + def nogil_check(self, env): + if self.is_buffer_access or self.is_memview_index: + if self.type.is_pyobject: + error(self.pos, "Cannot access buffer with object dtype without gil") + self.type = error_type + + def calculate_result_code(self): + return "(*%s)" % self.buffer_ptr_code + + def buffer_entry(self): + base = self.base + if self.base.is_nonecheck: + base = base.arg + return base.type.get_entry(base) + + def get_index_in_temp(self, code, ivar): + ret = code.funcstate.allocate_temp( + PyrexTypes.widest_numeric_type( + ivar.type, + PyrexTypes.c_ssize_t_type if ivar.type.signed else PyrexTypes.c_size_t_type), + manage_ref=False) + code.putln("%s = %s;" % (ret, ivar.result())) + return ret + + def buffer_lookup_code(self, code): + """ + ndarray[1, 2, 3] and memslice[1, 2, 3] + """ + if self.in_nogil_context: + if self.is_buffer_access or self.is_memview_index: + if code.globalstate.directives['boundscheck']: + performance_hint(self.pos, "Use boundscheck(False) for faster access", code.globalstate) + + # Assign indices to temps of at least (s)size_t to allow further index calculations. + self.index_temps = index_temps = [self.get_index_in_temp(code,ivar) for ivar in self.indices] + + # Generate buffer access code using these temps + from . import Buffer + buffer_entry = self.buffer_entry() + if buffer_entry.type.is_buffer: + negative_indices = buffer_entry.type.negative_indices + else: + negative_indices = Buffer.buffer_defaults['negative_indices'] + + return buffer_entry, Buffer.put_buffer_lookup_code( + entry=buffer_entry, + index_signeds=[ivar.type.signed for ivar in self.indices], + index_cnames=index_temps, + directives=code.globalstate.directives, + pos=self.pos, code=code, + negative_indices=negative_indices, + in_nogil_context=self.in_nogil_context) + + def generate_assignment_code(self, rhs, code, overloaded_assignment=False): + self.generate_subexpr_evaluation_code(code) + self.generate_buffer_setitem_code(rhs, code) + self.generate_subexpr_disposal_code(code) + self.free_subexpr_temps(code) + rhs.generate_disposal_code(code) + rhs.free_temps(code) + + def generate_buffer_setitem_code(self, rhs, code, op=""): + base_type = self.base.type + if is_pythran_expr(base_type) and is_pythran_supported_type(rhs.type): + obj = code.funcstate.allocate_temp(PythranExpr(pythran_type(self.base.type)), manage_ref=False) + # We have got to do this because we have to declare pythran objects + # at the beginning of the functions. + # Indeed, Cython uses "goto" statement for error management, and + # RAII doesn't work with that kind of construction. + # Moreover, the way Pythran expressions are made is that they don't + # support move-assignation easily. + # This, we explicitly destroy then in-place new objects in this + # case. + code.putln("__Pyx_call_destructor(%s);" % obj) + code.putln("new (&%s) decltype(%s){%s};" % (obj, obj, self.base.pythran_result())) + code.putln("%s%s %s= %s;" % ( + obj, + pythran_indexing_code(self.indices), + op, + rhs.pythran_result())) + code.funcstate.release_temp(obj) + return + + # Used from generate_assignment_code and InPlaceAssignmentNode + buffer_entry, ptrexpr = self.buffer_lookup_code(code) + + if self.buffer_type.dtype.is_pyobject: + # Must manage refcounts. XDecref what is already there + # and incref what we put in (NumPy allows there to be NULL) + ptr = code.funcstate.allocate_temp(buffer_entry.buf_ptr_type, + manage_ref=False) + rhs_code = rhs.result() + code.putln("%s = %s;" % (ptr, ptrexpr)) + code.put_xgotref("*%s" % ptr, self.buffer_type.dtype) + code.putln("__Pyx_INCREF(%s); __Pyx_XDECREF(*%s);" % ( + rhs_code, ptr)) + code.putln("*%s %s= %s;" % (ptr, op, rhs_code)) + code.put_xgiveref("*%s" % ptr, self.buffer_type.dtype) + code.funcstate.release_temp(ptr) + else: + # Simple case + code.putln("*%s %s= %s;" % (ptrexpr, op, rhs.result())) + + def generate_result_code(self, code): + if is_pythran_expr(self.base.type): + res = self.result() + code.putln("__Pyx_call_destructor(%s);" % res) + code.putln("new (&%s) decltype(%s){%s%s};" % ( + res, + res, + self.base.pythran_result(), + pythran_indexing_code(self.indices))) + return + buffer_entry, self.buffer_ptr_code = self.buffer_lookup_code(code) + if self.type.is_pyobject: + # is_temp is True, so must pull out value and incref it. + # NOTE: object temporary results for nodes are declared + # as PyObject *, so we need a cast + res = self.result() + code.putln("%s = (PyObject *) *%s;" % (res, self.buffer_ptr_code)) + # NumPy does (occasionally) allow NULL to denote None. + code.putln("if (unlikely(%s == NULL)) %s = Py_None;" % (res, res)) + code.putln("__Pyx_INCREF((PyObject*)%s);" % res) + + def free_subexpr_temps(self, code): + for temp in self.index_temps: + code.funcstate.release_temp(temp) + self.index_temps = () + super().free_subexpr_temps(code) + + +class MemoryViewIndexNode(BufferIndexNode): + + is_memview_index = True + is_buffer_access = False + + def analyse_types(self, env, getting=True): + # memoryviewslice indexing or slicing + from . import MemoryView + + self.is_pythran_mode = has_np_pythran(env) + indices = self.indices + have_slices, indices, newaxes = MemoryView.unellipsify(indices, self.base.type.ndim) + + if not getting: + self.writable_needed = True + if self.base.is_name or self.base.is_attribute: + self.base.entry.type.writable_needed = True + + self.memslice_index = (not newaxes and len(indices) == self.base.type.ndim) + axes = [] + + index_type = PyrexTypes.c_py_ssize_t_type + new_indices = [] + + if len(indices) - len(newaxes) > self.base.type.ndim: + self.type = error_type + error(indices[self.base.type.ndim].pos, + "Too many indices specified for type %s" % self.base.type) + return self + + axis_idx = 0 + for i, index in enumerate(indices): + index = index.analyse_types(env) + if index.is_none: + self.is_memview_slice = True + new_indices.append(index) + axes.append(('direct', 'strided')) + continue + + access, packing = self.base.type.axes[axis_idx] + axis_idx += 1 + + if index.is_slice: + self.is_memview_slice = True + if index.step.is_none: + axes.append((access, packing)) + else: + axes.append((access, 'strided')) + + # Coerce start, stop and step to temps of the right type + for attr in ('start', 'stop', 'step'): + value = getattr(index, attr) + if not value.is_none: + value = value.coerce_to(index_type, env) + #value = value.coerce_to_temp(env) + setattr(index, attr, value) + new_indices.append(value) + + elif index.type.is_int or index.type.is_pyobject: + if index.type.is_pyobject: + performance_hint(index.pos, "Index should be typed for more efficient access", env) + + self.is_memview_index = True + index = index.coerce_to(index_type, env) + indices[i] = index + new_indices.append(index) + + else: + self.type = error_type + error(index.pos, "Invalid index for memoryview specified, type %s" % index.type) + return self + + ### FIXME: replace by MemoryViewSliceNode if is_memview_slice ? + self.is_memview_index = self.is_memview_index and not self.is_memview_slice + self.indices = new_indices + # All indices with all start/stop/step for slices. + # We need to keep this around. + self.original_indices = indices + self.nogil = env.nogil + + node = self.analyse_operation(env, getting, axes) + node.wrap_in_nonecheck_node(env) + return node + + def analyse_operation(self, env, getting, axes): + self.none_error_message = "Cannot index None memoryview slice" + self.analyse_buffer_index(env, getting) + return self + + def analyse_broadcast_operation(self, rhs): + """ + Support broadcasting for slice assignment. + E.g. + m_2d[...] = m_1d # or, + m_1d[...] = m_2d # if the leading dimension has extent 1 + """ + if self.type.is_memoryviewslice: + lhs = self + if lhs.is_memview_broadcast or rhs.is_memview_broadcast: + lhs.is_memview_broadcast = True + rhs.is_memview_broadcast = True + + def analyse_as_memview_scalar_assignment(self, rhs): + lhs = self.analyse_assignment(rhs) + if lhs: + rhs.is_memview_copy_assignment = lhs.is_memview_copy_assignment + return lhs + return self + + +class MemoryViewSliceNode(MemoryViewIndexNode): + + is_memview_slice = True + + # No-op slicing operation, this node will be replaced + is_ellipsis_noop = False + is_memview_scalar_assignment = False + is_memview_index = False + is_memview_broadcast = False + + def analyse_ellipsis_noop(self, env, getting): + """Slicing operations needing no evaluation, i.e. m[...] or m[:, :]""" + ### FIXME: replace directly + self.is_ellipsis_noop = all( + index.is_slice and index.start.is_none and index.stop.is_none and index.step.is_none + for index in self.indices) + + if self.is_ellipsis_noop: + self.type = self.base.type + + def analyse_operation(self, env, getting, axes): + from . import MemoryView + + if not getting: + self.is_memview_broadcast = True + self.none_error_message = "Cannot assign to None memoryview slice" + else: + self.none_error_message = "Cannot slice None memoryview slice" + + self.analyse_ellipsis_noop(env, getting) + if self.is_ellipsis_noop: + return self + + self.index = None + self.is_temp = True + self.use_managed_ref = True + + if not MemoryView.validate_axes(self.pos, axes): + self.type = error_type + return self + + self.type = PyrexTypes.MemoryViewSliceType(self.base.type.dtype, axes) + + if not (self.base.is_simple() or self.base.result_in_temp()): + self.base = self.base.coerce_to_temp(env) + return self + + def analyse_assignment(self, rhs): + if not rhs.type.is_memoryviewslice and ( + self.type.dtype.assignable_from(rhs.type) or + rhs.type.is_pyobject): + # scalar assignment + return MemoryCopyScalar(self.pos, self) + else: + return MemoryCopySlice(self.pos, self) + + def merged_indices(self, indices): + """Return a new list of indices/slices with 'indices' merged into the current ones + according to slicing rules. + Is used to implement "view[i][j]" => "view[i, j]". + Return None if the indices cannot (easily) be merged at compile time. + """ + if not indices: + return None + # NOTE: Need to evaluate "self.original_indices" here as they might differ from "self.indices". + new_indices = self.original_indices[:] + indices = indices[:] + for i, s in enumerate(self.original_indices): + if s.is_slice: + if s.start.is_none and s.stop.is_none and s.step.is_none: + # Full slice found, replace by index. + new_indices[i] = indices[0] + indices.pop(0) + if not indices: + return new_indices + else: + # Found something non-trivial, e.g. a partial slice. + return None + elif not s.type.is_int: + # Not a slice, not an integer index => could be anything... + return None + if indices: + if len(new_indices) + len(indices) > self.base.type.ndim: + return None + new_indices += indices + return new_indices + + def is_simple(self): + if self.is_ellipsis_noop: + # TODO: fix SimpleCallNode.is_simple() + return self.base.is_simple() or self.base.result_in_temp() + + return self.result_in_temp() + + def calculate_result_code(self): + """This is called in case this is a no-op slicing node""" + return self.base.result() + + def generate_result_code(self, code): + if self.is_ellipsis_noop: + return ### FIXME: remove + buffer_entry = self.buffer_entry() + have_gil = not self.in_nogil_context + + # TODO Mark: this is insane, do it better + have_slices = False + it = iter(self.indices) + for index in self.original_indices: + if index.is_slice: + have_slices = True + if not index.start.is_none: + index.start = next(it) + if not index.stop.is_none: + index.stop = next(it) + if not index.step.is_none: + index.step = next(it) + else: + next(it) + + assert not list(it) + + buffer_entry.generate_buffer_slice_code( + code, self.original_indices, self.result(), self.type, + have_gil=have_gil, have_slices=have_slices, + directives=code.globalstate.directives) + + def generate_assignment_code(self, rhs, code, overloaded_assignment=False): + if self.is_ellipsis_noop: + self.generate_subexpr_evaluation_code(code) + else: + self.generate_evaluation_code(code) + + if self.is_memview_scalar_assignment: + self.generate_memoryviewslice_assign_scalar_code(rhs, code) + else: + self.generate_memoryviewslice_setslice_code(rhs, code) + + if self.is_ellipsis_noop: + self.generate_subexpr_disposal_code(code) + else: + self.generate_disposal_code(code) + + rhs.generate_disposal_code(code) + rhs.free_temps(code) + + +class MemoryCopyNode(ExprNode): + """ + Wraps a memoryview slice for slice assignment. + + dst: destination mememoryview slice + """ + + subexprs = ['dst'] + + def __init__(self, pos, dst): + super().__init__(pos) + self.dst = dst + self.type = dst.type + + def generate_assignment_code(self, rhs, code, overloaded_assignment=False): + self.dst.generate_evaluation_code(code) + self._generate_assignment_code(rhs, code) + self.dst.generate_disposal_code(code) + self.dst.free_temps(code) + rhs.generate_disposal_code(code) + rhs.free_temps(code) + + +class MemoryCopySlice(MemoryCopyNode): + """ + Copy the contents of slice src to slice dst. Does not support indirect + slices. + + memslice1[...] = memslice2 + memslice1[:] = memslice2 + """ + + is_memview_copy_assignment = True + copy_slice_cname = "__pyx_memoryview_copy_contents" + + def _generate_assignment_code(self, src, code): + dst = self.dst + + src.type.assert_direct_dims(src.pos) + dst.type.assert_direct_dims(dst.pos) + + code.putln(code.error_goto_if_neg( + "%s(%s, %s, %d, %d, %d)" % (self.copy_slice_cname, + src.result(), dst.result(), + src.type.ndim, dst.type.ndim, + dst.type.dtype.is_pyobject), + dst.pos)) + + +class MemoryCopyScalar(MemoryCopyNode): + """ + Assign a scalar to a slice. dst must be simple, scalar will be assigned + to a correct type and not just something assignable. + + memslice1[...] = 0.0 + memslice1[:] = 0.0 + """ + + def __init__(self, pos, dst): + super().__init__(pos, dst) + self.type = dst.type.dtype + + def _generate_assignment_code(self, scalar, code): + from . import MemoryView + + self.dst.type.assert_direct_dims(self.dst.pos) + + dtype = self.dst.type.dtype + type_decl = dtype.declaration_code("") + slice_decl = self.dst.type.declaration_code("") + + code.begin_block() + code.putln("%s __pyx_temp_scalar = %s;" % (type_decl, scalar.result())) + if self.dst.result_in_temp() or self.dst.is_simple(): + dst_temp = self.dst.result() + else: + code.putln("%s __pyx_temp_slice = %s;" % (slice_decl, self.dst.result())) + dst_temp = "__pyx_temp_slice" + + force_strided = False + indices = self.dst.original_indices + for idx in indices: + if isinstance(idx, SliceNode) and not (idx.start.is_none and + idx.stop.is_none and + idx.step.is_none): + force_strided = True + + slice_iter_obj = MemoryView.slice_iter(self.dst.type, dst_temp, + self.dst.type.ndim, code, + force_strided=force_strided) + p = slice_iter_obj.start_loops() + + if dtype.is_pyobject: + code.putln("Py_DECREF(*(PyObject **) %s);" % p) + + code.putln("*((%s *) %s) = __pyx_temp_scalar;" % (type_decl, p)) + + if dtype.is_pyobject: + code.putln("Py_INCREF(__pyx_temp_scalar);") + + slice_iter_obj.end_loops() + code.end_block() + + +class SliceIndexNode(ExprNode): + # 2-element slice indexing + # + # base ExprNode + # start ExprNode or None + # stop ExprNode or None + # slice ExprNode or None constant slice object + # nogil bool used internally + + subexprs = ['base', 'start', 'stop', 'slice'] + nogil = False + + slice = None + + def infer_type(self, env): + base_type = self.base.infer_type(env) + if base_type.is_string or base_type.is_cpp_class: + return bytes_type + elif base_type.is_pyunicode_ptr: + return unicode_type + elif base_type in (bytes_type, bytearray_type, unicode_type, + list_type, tuple_type): + return base_type + elif base_type.is_ptr or base_type.is_array: + return PyrexTypes.c_array_type(base_type.base_type, None) + return py_object_type + + def inferable_item_node(self, index=0): + # slicing shouldn't change the result type of the base, but the index might + if index is not not_a_constant and self.start: + if self.start.has_constant_result(): + index += self.start.constant_result + else: + index = not_a_constant + return self.base.inferable_item_node(index) + + def may_be_none(self): + base_type = self.base.type + if base_type: + if base_type.is_string: + return False + if base_type in (bytes_type, bytearray_type, unicode_type, + list_type, tuple_type): + return False + return ExprNode.may_be_none(self) + + def calculate_constant_result(self): + if self.start is None: + start = None + else: + start = self.start.constant_result + if self.stop is None: + stop = None + else: + stop = self.stop.constant_result + self.constant_result = self.base.constant_result[start:stop] + + def compile_time_value(self, denv): + base = self.base.compile_time_value(denv) + if self.start is None: + start = 0 + else: + start = self.start.compile_time_value(denv) + if self.stop is None: + stop = None + else: + stop = self.stop.compile_time_value(denv) + try: + return base[start:stop] + except Exception as e: + self.compile_time_value_error(e) + + def analyse_target_declaration(self, env): + pass + + def analyse_target_types(self, env): + node = self.analyse_types(env, getting=False) + # when assigning, we must accept any Python type + if node.type.is_pyobject: + node.type = py_object_type + return node + + def analyse_types(self, env, getting=True): + self.base = self.base.analyse_types(env) + + if self.base.type.is_buffer or self.base.type.is_pythran_expr or self.base.type.is_memoryviewslice: + none_node = NoneNode(self.pos) + index = SliceNode(self.pos, + start=self.start or none_node, + stop=self.stop or none_node, + step=none_node) + index_node = IndexNode(self.pos, index=index, base=self.base) + return index_node.analyse_base_and_index_types( + env, getting=getting, setting=not getting, + analyse_base=False) + + if self.start: + self.start = self.start.analyse_types(env) + if self.stop: + self.stop = self.stop.analyse_types(env) + + if not env.directives['wraparound']: + check_negative_indices(self.start, self.stop) + + base_type = self.base.type + if base_type.is_array and not getting: + # cannot assign directly to C array => try to assign by making a copy + if not self.start and not self.stop: + self.type = base_type + else: + self.type = PyrexTypes.CPtrType(base_type.base_type) + elif base_type.is_string or base_type.is_cpp_string: + self.type = default_str_type(env) + elif base_type.is_pyunicode_ptr: + self.type = unicode_type + elif base_type.is_ptr: + self.type = base_type + elif base_type.is_array: + # we need a ptr type here instead of an array type, as + # array types can result in invalid type casts in the C + # code + self.type = PyrexTypes.CPtrType(base_type.base_type) + else: + self.base = self.base.coerce_to_pyobject(env) + self.type = py_object_type + if base_type.is_builtin_type: + # slicing builtin types returns something of the same type + self.type = base_type + self.base = self.base.as_none_safe_node("'NoneType' object is not subscriptable") + + if self.type is py_object_type: + if (not self.start or self.start.is_literal) and \ + (not self.stop or self.stop.is_literal): + # cache the constant slice object, in case we need it + none_node = NoneNode(self.pos) + self.slice = SliceNode( + self.pos, + start=copy.deepcopy(self.start or none_node), + stop=copy.deepcopy(self.stop or none_node), + step=none_node + ).analyse_types(env) + else: + c_int = PyrexTypes.c_py_ssize_t_type + + def allow_none(node, default_value, env): + # Coerce to Py_ssize_t, but allow None as meaning the default slice bound. + from .UtilNodes import EvalWithTempExprNode, ResultRefNode + + node_ref = ResultRefNode(node) + new_expr = CondExprNode( + node.pos, + true_val=IntNode( + node.pos, + type=c_int, + value=default_value, + constant_result=int(default_value) if default_value.isdigit() else not_a_constant, + ), + false_val=node_ref.coerce_to(c_int, env), + test=PrimaryCmpNode( + node.pos, + operand1=node_ref, + operator='is', + operand2=NoneNode(node.pos), + ).analyse_types(env) + ).analyse_result_type(env) + return EvalWithTempExprNode(node_ref, new_expr) + + if self.start: + if self.start.type.is_pyobject: + self.start = allow_none(self.start, '0', env) + self.start = self.start.coerce_to(c_int, env) + if self.stop: + if self.stop.type.is_pyobject: + self.stop = allow_none(self.stop, 'PY_SSIZE_T_MAX', env) + self.stop = self.stop.coerce_to(c_int, env) + self.is_temp = 1 + return self + + def analyse_as_type(self, env): + base_type = self.base.analyse_as_type(env) + if base_type: + if not self.start and not self.stop: + # memory view + from . import MemoryView + env.use_utility_code( + MemoryView.get_view_utility_code( + env.context.shared_utility_qualified_name + ) + ) + none_node = NoneNode(self.pos) + slice_node = SliceNode( + self.pos, + start=none_node, + stop=none_node, + step=none_node, + ) + return PyrexTypes.MemoryViewSliceType( + base_type, MemoryView.get_axes_specs(env, [slice_node])) + return None + + def nogil_check(self, env): + self.nogil = env.nogil + return super().nogil_check(env) + + gil_message = "Slicing Python object" + + get_slice_utility_code = TempitaUtilityCode.load( + "SliceObject", "ObjectHandling.c", context={'access': 'Get'}) + + set_slice_utility_code = TempitaUtilityCode.load( + "SliceObject", "ObjectHandling.c", context={'access': 'Set'}) + + def coerce_to(self, dst_type, env): + if ((self.base.type.is_string or self.base.type.is_cpp_string) + and dst_type in (bytes_type, bytearray_type, unicode_type)): + if (dst_type is unicode_type and not env.directives['c_string_encoding']): + error(self.pos, + "default encoding required for conversion from '%s' to '%s'" % + (self.base.type, dst_type)) + self.type = dst_type + if dst_type.is_array and self.base.type.is_array: + if not self.start and not self.stop: + # redundant slice building, copy C arrays directly + return self.base.coerce_to(dst_type, env) + # else: check array size if possible + return super().coerce_to(dst_type, env) + + def generate_result_code(self, code): + if not self.type.is_pyobject: + error(self.pos, + "Slicing is not currently supported for '%s'." % self.type) + return + + base_type = self.base.type + result = self.result() + start_code = self.start_code() + stop_code = self.stop_code() + + if base_type.is_string: + base_result = self.base.result_as(PyrexTypes.c_const_char_ptr_type) + if self.type is bytearray_type: + # TODO - arguably bytearray should be protected by a critical section, but it's + # hard to generate good code for this, and it's hard to imagine a good use for slicing + # a volatile bytearray. + type_name = 'ByteArray' + elif self.type is unicode_type: + type_name = 'Unicode' + else: + type_name = self.type.name.title() + + if self.stop is None: + call = f"__Pyx_Py{type_name}_FromString({base_result} + {start_code})" + else: + call = f"__Pyx_Py{type_name}_FromStringAndSize({base_result} + {start_code}, {stop_code} - {start_code})" + + elif base_type.is_pyunicode_ptr: + base_result = self.base.result_as(PyrexTypes.c_const_py_unicode_ptr_type) + code.globalstate.use_utility_code( + UtilityCode.load_cached("pyunicode_from_unicode", "StringTools.c")) + if self.stop is None: + call = f"__Pyx_PyUnicode_FromUnicode({base_result} + {start_code})" + else: + call = f"__Pyx_PyUnicode_FromUnicodeAndLength({base_result} + {start_code}, {stop_code} - {start_code})" + + elif base_type is unicode_type: + base_result = self.base.result() + code.globalstate.use_utility_code( + UtilityCode.load_cached("PyUnicode_Substring", "StringTools.c")) + call = f"__Pyx_PyUnicode_Substring({base_result}, {start_code}, {stop_code})" + + elif self.type is py_object_type: + base_result = self.base.py_result() + has_c_start, has_c_stop, c_start, c_stop, py_start, py_stop, py_slice = self.get_slice_config() + wraparound = bool(code.globalstate.directives['wraparound']) + + code.globalstate.use_utility_code(self.get_slice_utility_code) + call = ("__Pyx_PyObject_GetSlice(" + f"{base_result}, {c_start}, {c_stop}, {py_start}, {py_stop}, {py_slice}, " + f"{has_c_start:d}, {has_c_stop:d}, {wraparound:d})" + ) + + else: + base_result = self.base.py_result() + if base_type is list_type: + code.globalstate.use_utility_code( + TempitaUtilityCode.load_cached("SliceTupleAndList", "ObjectHandling.c")) + cfunc = '__Pyx_PyList_GetSlice' + elif base_type is tuple_type: + code.globalstate.use_utility_code( + TempitaUtilityCode.load_cached("SliceTupleAndList", "ObjectHandling.c")) + cfunc = '__Pyx_PyTuple_GetSlice' + else: + cfunc = 'PySequence_GetSlice' + call = f"{cfunc}({base_result}, {start_code}, {stop_code})" + + code.putln(f"{result} = {call}; {code.error_goto_if_null(result, self.pos)}") + self.generate_gotref(code) + + def generate_assignment_code(self, rhs, code, overloaded_assignment=False, + exception_check=None, exception_value=None): + self.generate_subexpr_evaluation_code(code) + if self.type.is_pyobject: + code.globalstate.use_utility_code(self.set_slice_utility_code) + has_c_start, has_c_stop, c_start, c_stop, py_start, py_stop, py_slice = self.get_slice_config() + code.put_error_if_neg(self.pos, + "__Pyx_PyObject_SetSlice(%s, %s, %s, %s, %s, %s, %s, %d, %d, %d)" % ( + self.base.py_result(), + rhs.py_result(), + c_start, c_stop, + py_start, py_stop, py_slice, + has_c_start, has_c_stop, + bool(code.globalstate.directives['wraparound']))) + else: + start_offset = self.start_code() if self.start else '0' + if rhs.type.is_array: + array_length = rhs.type.size + self.generate_slice_guard_code(code, array_length) + else: + array_length = '%s - %s' % (self.stop_code(), start_offset) + + code.globalstate.use_utility_code(UtilityCode.load_cached("IncludeStringH", "StringTools.c")) + code.putln("memcpy(&(%s[%s]), %s, sizeof(%s[0]) * (%s));" % ( + self.base.result(), start_offset, + rhs.result(), + self.base.result(), array_length + )) + + self.generate_subexpr_disposal_code(code) + self.free_subexpr_temps(code) + rhs.generate_disposal_code(code) + rhs.free_temps(code) + + def generate_deletion_code(self, code, ignore_nonexisting=False): + if not self.base.type.is_pyobject: + error(self.pos, + "Deleting slices is only supported for Python types, not '%s'." % self.type) + return + self.generate_subexpr_evaluation_code(code) + code.globalstate.use_utility_code(self.set_slice_utility_code) + (has_c_start, has_c_stop, c_start, c_stop, + py_start, py_stop, py_slice) = self.get_slice_config() + code.put_error_if_neg(self.pos, + "__Pyx_PyObject_DelSlice(%s, %s, %s, %s, %s, %s, %d, %d, %d)" % ( + self.base.py_result(), + c_start, c_stop, + py_start, py_stop, py_slice, + has_c_start, has_c_stop, + bool(code.globalstate.directives['wraparound']))) + self.generate_subexpr_disposal_code(code) + self.free_subexpr_temps(code) + + def get_slice_config(self): + has_c_start, c_start, py_start = False, '0', 'NULL' + if self.start: + has_c_start = not self.start.type.is_pyobject + if has_c_start: + c_start = self.start.result() + else: + py_start = '&%s' % self.start.py_result() + has_c_stop, c_stop, py_stop = False, '0', 'NULL' + if self.stop: + has_c_stop = not self.stop.type.is_pyobject + if has_c_stop: + c_stop = self.stop.result() + else: + py_stop = '&%s' % self.stop.py_result() + py_slice = self.slice and '&%s' % self.slice.py_result() or 'NULL' + return (has_c_start, has_c_stop, c_start, c_stop, + py_start, py_stop, py_slice) + + def generate_slice_guard_code(self, code, target_size): + if not self.base.type.is_array: + return + slice_size = self.base.type.size + try: + total_length = slice_size = int(slice_size) + except ValueError: + total_length = None + + start = stop = None + if self.stop: + stop = self.stop.result() + try: + stop = int(stop) + if stop < 0: + if total_length is None: + slice_size = '%s + %d' % (slice_size, stop) + else: + slice_size += stop + else: + slice_size = stop + stop = None + except ValueError: + pass + + if self.start: + start = self.start.result() + try: + start = int(start) + if start < 0: + if total_length is None: + start = '%s + %d' % (self.base.type.size, start) + else: + start += total_length + if isinstance(slice_size, int): + slice_size -= start + else: + slice_size = '%s - (%s)' % (slice_size, start) + start = None + except ValueError: + pass + + runtime_check = None + compile_time_check = False + try: + int_target_size = int(target_size) + except ValueError: + int_target_size = None + else: + compile_time_check = isinstance(slice_size, int) + + if compile_time_check and slice_size < 0: + if int_target_size > 0: + error(self.pos, "Assignment to empty slice.") + elif compile_time_check and start is None and stop is None: + # we know the exact slice length + if int_target_size != slice_size: + error(self.pos, "Assignment to slice of wrong length, expected %s, got %s" % ( + slice_size, target_size)) + elif start is not None: + if stop is None: + stop = slice_size + runtime_check = "(%s)-(%s)" % (stop, start) + elif stop is not None: + runtime_check = stop + else: + runtime_check = slice_size + + if runtime_check: + code.putln("if (unlikely((%s) != (%s))) {" % (runtime_check, target_size)) + if self.nogil: + code.put_ensure_gil() + code.putln( + 'PyErr_Format(PyExc_ValueError, "Assignment to slice of wrong length,' + ' expected %%" CYTHON_FORMAT_SSIZE_T "d, got %%" CYTHON_FORMAT_SSIZE_T "d",' + ' (Py_ssize_t)(%s), (Py_ssize_t)(%s));' % ( + target_size, runtime_check)) + if self.nogil: + code.put_release_ensured_gil() + code.putln(code.error_goto(self.pos)) + code.putln("}") + + def start_code(self): + if self.start: + return self.start.result() + else: + return "0" + + def stop_code(self): + if self.stop: + return self.stop.result() + elif self.base.type.is_array: + return self.base.type.size + else: + return "PY_SSIZE_T_MAX" + + def calculate_result_code(self): + # self.result() is not used, but this method must exist + return "" + + +class SliceNode(ExprNode): + # start:stop:step in subscript list + # + # start ExprNode + # stop ExprNode + # step ExprNode + + subexprs = ['start', 'stop', 'step'] + is_slice = True + type = slice_type + is_temp = 1 + + def calculate_constant_result(self): + self.constant_result = slice( + self.start.constant_result, + self.stop.constant_result, + self.step.constant_result) + + def compile_time_value(self, denv): + start = self.start.compile_time_value(denv) + stop = self.stop.compile_time_value(denv) + step = self.step.compile_time_value(denv) + try: + return slice(start, stop, step) + except Exception as e: + self.compile_time_value_error(e) + + def may_be_none(self): + return False + + def analyse_types(self, env): + start = self.start.analyse_types(env) + stop = self.stop.analyse_types(env) + step = self.step.analyse_types(env) + self.start = start.coerce_to_pyobject(env) + self.stop = stop.coerce_to_pyobject(env) + self.step = step.coerce_to_pyobject(env) + if self.start.is_literal and self.stop.is_literal and self.step.is_literal: + self.is_literal = True + self.is_temp = False + return self + + gil_message = "Constructing Python slice object" + + def calculate_result_code(self): + return self.result_code + + def generate_result_code(self, code): + if self.is_literal: + dedup_key = make_dedup_key(self.type, (self,)) + self.result_code = code.get_py_const('slice', dedup_key=dedup_key) + code = code.get_cached_constants_writer(self.result_code) + if code is None: + return # already initialised + code.mark_pos(self.pos) + + code.putln( + "%s = PySlice_New(%s, %s, %s); %s" % ( + self.result(), + self.start.py_result(), + self.stop.py_result(), + self.step.py_result(), + code.error_goto_if_null(self.result(), self.pos))) + self.generate_gotref(code) + if self.is_literal: + self.generate_giveref(code) + +class SliceIntNode(SliceNode): + # start:stop:step in subscript list + # This is just a node to hold start,stop and step nodes that can be + # converted to integers. This does not generate a slice python object. + # + # start ExprNode + # stop ExprNode + # step ExprNode + + is_temp = 0 + + def calculate_constant_result(self): + self.constant_result = slice( + self.start.constant_result, + self.stop.constant_result, + self.step.constant_result) + + def compile_time_value(self, denv): + start = self.start.compile_time_value(denv) + stop = self.stop.compile_time_value(denv) + step = self.step.compile_time_value(denv) + try: + return slice(start, stop, step) + except Exception as e: + self.compile_time_value_error(e) + + def may_be_none(self): + return False + + def analyse_types(self, env): + self.start = self.start.analyse_types(env) + self.stop = self.stop.analyse_types(env) + self.step = self.step.analyse_types(env) + + if not self.start.is_none: + self.start = self.start.coerce_to_index(env) + if not self.stop.is_none: + self.stop = self.stop.coerce_to_index(env) + if not self.step.is_none: + self.step = self.step.coerce_to_index(env) + + if self.start.is_literal and self.stop.is_literal and self.step.is_literal: + self.is_literal = True + self.is_temp = False + return self + + def calculate_result_code(self): + pass + + def generate_result_code(self, code): + for a in self.start,self.stop,self.step: + if isinstance(a, CloneNode): + a.arg.result() + + +class CallNode(ExprNode): + + # allow overriding the default 'may_be_none' behaviour + may_return_none = None + + def infer_type(self, env): + function = self.function + # TODO(robertwb): Reduce redundancy with analyse_types. + func_type = function.infer_type(env) + if isinstance(function, NewExprNode): + # note: needs call to infer_type() above + return PyrexTypes.CPtrType(function.class_type) + if func_type is py_object_type: + # function might have lied for safety => try to find better type + if function.is_attribute: + method_obj_type = function.obj.infer_type(env) + if method_obj_type.is_builtin_type: + result_type = Builtin.find_return_type_of_builtin_method(method_obj_type, function.attribute) + if result_type is not py_object_type: + return result_type + entry = getattr(function, 'entry', None) + if entry is not None: + func_type = entry.type or func_type + if func_type.is_ptr: + func_type = func_type.base_type + if func_type.is_cfunction: + if getattr(self.function, 'entry', None) and hasattr(self, 'args'): + arg_types = [arg.infer_type(env) for arg in self.args] + func_entry = self.function.entry.best_function_match(env, arg_types) + if func_entry: + func_type = func_entry.type + if func_type.is_ptr: + func_type = func_type.base_type + return func_type.return_type + return func_type.return_type + elif func_type is type_type: + if function.is_name and function.entry and function.entry.type: + result_type = function.entry.type + if result_type.is_extension_type: + return result_type + elif result_type.is_builtin_type: + func_name = function.entry.name + if func_name == 'float': + return PyrexTypes.c_double_type + elif func_name == 'bool': + return PyrexTypes.c_bint_type + elif func_name in Builtin.types_that_construct_their_instance: + return result_type + func_type = self.function.analyse_as_type(env) + if func_type and (func_type.is_struct_or_union or func_type.is_cpp_class): + return func_type + return py_object_type + + def type_dependencies(self, env): + # TODO: Update when Danilo's C++ code merged in to handle the + # the case of function overloading. + return self.function.type_dependencies(env) + + def is_simple(self): + # C function calls could be considered simple, but they may + # have side-effects that may hit when multiple operations must + # be effected in order, e.g. when constructing the argument + # sequence for a function call or comparing values. + return False + + def may_be_none(self): + if self.may_return_none is not None: + return self.may_return_none + func_type = self.function.type + if func_type is type_type and self.function.is_name: + entry = self.function.entry + if entry.type.is_extension_type: + return False + if (entry.type.is_builtin_type and + entry.name in Builtin.types_that_construct_their_instance): + return False + return ExprNode.may_be_none(self) + + def set_py_result_type(self, function, func_type=None): + if func_type is None: + func_type = function.type + if func_type is Builtin.type_type and ( + function.is_name and + function.entry and + function.entry.is_builtin and + function.entry.name in Builtin.types_that_construct_their_instance): + # calling a builtin type that returns a specific object type + if function.entry.name == 'float': + # the following will come true later on in a transform + self.type = PyrexTypes.c_double_type + self.result_ctype = PyrexTypes.c_double_type + else: + self.type = Builtin.builtin_types[function.entry.name] + self.result_ctype = py_object_type + self.may_return_none = False + elif function.is_name and function.type_entry: + # We are calling an extension type constructor. As long as we do not + # support __new__(), the result type is clear + self.type = function.type_entry.type + self.result_ctype = py_object_type + self.may_return_none = False + elif function.is_attribute and function.obj.type.is_builtin_type: + method_obj_type = function.obj.type + result_type = Builtin.find_return_type_of_builtin_method(method_obj_type, function.attribute) + self.may_return_none = result_type is py_object_type + if result_type.is_pyobject: + self.type = result_type + elif result_type.equivalent_type: + self.type = result_type.equivalent_type + else: + self.type = py_object_type + else: + self.type = py_object_type + + def analyse_as_type_constructor(self, env): + """ + Returns a replacement node or None + """ + type = self.function.analyse_as_type(env) + if type and type.is_struct_or_union: + args, kwds = self.explicit_args_kwds() + items = [] + for arg, member in zip(args, type.scope.var_entries): + items.append(DictItemNode(arg.pos, key=UnicodeNode(arg.pos, value=member.name), value=arg)) + if kwds: + items += kwds.key_value_pairs + + node = DictNode(self.pos, key_value_pairs=items) + node = node.analyse_types(env).coerce_to(type, env) + return node + elif type and type.is_cpp_class: + self.args = [ arg.analyse_types(env) for arg in self.args ] + constructor = type.scope.lookup("") + if not constructor: + error(self.function.pos, "no constructor found for C++ type '%s'" % self.function.name) + self.type = error_type + return self + self.function = RawCNameExprNode(self.function.pos, constructor.type) + self.function.entry = constructor + self.function.set_cname(type.empty_declaration_code()) + self.analyse_c_function_call(env) + self.type = type + return self + + def function_type(self): + # Return the type of the function being called, coercing a function + # pointer to a function if necessary. + func_type = self.function.type + + if func_type.is_ptr: + func_type = func_type.base_type + + return func_type + + def is_lvalue(self): + return self.type.is_reference + + def nogil_check(self, env): + func_type = self.function_type() + if func_type.is_pyobject: + self.gil_error() + elif not func_type.is_error and not getattr(func_type, 'nogil', False): + self.gil_error() + + gil_message = "Calling gil-requiring function" + + +class SimpleCallNode(CallNode): + # Function call without keyword, * or ** args. + # + # function ExprNode + # args [ExprNode] + # arg_tuple ExprNode or None used internally + # self ExprNode or None used internally + # coerced_self ExprNode or None used internally + # wrapper_call bool used internally + # has_optional_args bool used internally + # nogil bool used internally + + subexprs = ['self', 'coerced_self', 'function', 'args', 'arg_tuple'] + + self = None + coerced_self = None + arg_tuple = None + wrapper_call = False + has_optional_args = False + nogil = False + analysed = False + overflowcheck = False + + def compile_time_value(self, denv): + function = self.function.compile_time_value(denv) + args = [arg.compile_time_value(denv) for arg in self.args] + try: + return function(*args) + except Exception as e: + self.compile_time_value_error(e) + + def calculate_constant_result(self): + if self.function.is_attribute and self.function.obj.is_literal: + method = self.function.constant_result + if inspect.isbuiltin(method) or inspect.ismethod(method): + method_name = method.__name__ + # Prefer the actual builtin type over internal representations like "EncodedString". + object_type = self.function.obj.type + object_type_name = object_type.name if object_type else type(method.__self__).__name__ + + if Builtin.is_safe_compile_time_method(object_type_name, method_name): + args = [arg.constant_result for arg in self.args] + self.constant_result = method(*args) + + @classmethod + def for_cproperty(cls, pos, obj, entry): + # Create a call node for C property access. + property_scope = entry.scope + getter_entry = property_scope.lookup_here(entry.name) + assert getter_entry, "Getter not found in scope %s: %s" % (property_scope, property_scope.entries) + function = NameNode(pos, name=entry.name, entry=getter_entry, type=getter_entry.type) + node = cls(pos, function=function, args=[obj]) + return node + + def analyse_as_type(self, env): + attr = self.function.as_cython_attribute() + if attr == 'pointer': + if len(self.args) != 1: + error(self.args.pos, "only one type allowed.") + else: + type = self.args[0].analyse_as_type(env) + if not type: + error(self.args[0].pos, "Unknown type") + else: + return PyrexTypes.CPtrType(type) + elif attr == 'typeof': + if len(self.args) != 1: + error(self.args.pos, "only one type allowed.") + operand = self.args[0].analyse_types(env) + return operand.type + + def explicit_args_kwds(self): + return self.args, None + + def analyse_types(self, env): + if self.analysed: + return self + self.analysed = True + if (as_type_constructor := self.analyse_as_type_constructor(env)) is not None: + return as_type_constructor + self.function.is_called = 1 + self.function = self.function.analyse_types(env) + function = self.function + + if function.is_attribute and function.entry and function.entry.is_cmethod: + # Take ownership of the object from which the attribute + # was obtained, because we need to pass it as 'self'. + self.self = function.obj + function.obj = CloneNode(self.self) + + func_type = self.function_type() + self.is_numpy_call_with_exprs = False + if (has_np_pythran(env) and function.is_numpy_attribute and + pythran_is_numpy_func_supported(function)): + has_pythran_args = True + self.arg_tuple = TupleNode(self.pos, args = self.args) + self.arg_tuple = self.arg_tuple.analyse_types(env) + for arg in self.arg_tuple.args: + has_pythran_args &= is_pythran_supported_node_or_none(arg) + self.is_numpy_call_with_exprs = bool(has_pythran_args) + if self.is_numpy_call_with_exprs: + env.add_include_file(pythran_get_func_include_file(function)) + return NumPyMethodCallNode.from_node( + self, + function_cname=pythran_functor(function), + arg_tuple=self.arg_tuple, + type=PythranExpr(pythran_func_type(function, self.arg_tuple.args)), + ) + elif func_type.is_pyobject: + self.arg_tuple = TupleNode(self.pos, args = self.args) + self.arg_tuple = self.arg_tuple.analyse_types(env).coerce_to_pyobject(env) + self.args = None + self.set_py_result_type(function, func_type) + self.is_temp = 1 + else: + self.args = [ arg.analyse_types(env) for arg in self.args ] + self.analyse_c_function_call(env) + if func_type.exception_check == '+': + self.is_temp = True + + return self + + def analyse_c_function_call(self, env): + func_type = self.function.type + if func_type is error_type: + self.type = error_type + return + + if func_type.is_cfunction and func_type.is_static_method: + if self.self and self.self.type.is_extension_type: + # To support this we'd need to pass self to determine whether + # it was overloaded in Python space (possibly via a Cython + # superclass turning a cdef method into a cpdef one). + error(self.pos, "Cannot call a static method on an instance variable.") + args = self.args + elif self.self: + args = [self.self] + self.args + else: + args = self.args + + if func_type.is_cpp_class: + overloaded_entry = self.function.type.scope.lookup("operator()") + if overloaded_entry is None: + self.type = PyrexTypes.error_type + self.result_code = "" + return + elif hasattr(self.function, 'entry'): + overloaded_entry = self.function.entry + elif self.function.is_subscript and self.function.is_fused_index: + overloaded_entry = self.function.type.entry + else: + overloaded_entry = None + + if overloaded_entry: + try: + entry = overloaded_entry.best_function_match( + env, + [arg.type for arg in args], + fail_if_empty=True, + arg_is_lvalue_array=[arg.is_lvalue() for arg in args], + ) + except PyrexTypes.NoMatchFound as exc: + message = str(exc) + if message: + error(self.pos, message) + self.type = PyrexTypes.error_type + self.result_code = "" + return + + entry.used = True + if not func_type.is_cpp_class: + self.function.entry = entry + self.function.type = entry.type + func_type = self.function_type() + else: + entry = None + func_type = self.function_type() + if not func_type.is_cfunction: + error(self.pos, "Calling non-function type '%s'" % func_type) + self.type = PyrexTypes.error_type + self.result_code = "" + return + + # Check no. of args + max_nargs = len(func_type.args) + expected_nargs = max_nargs - func_type.optional_arg_count + actual_nargs = len(args) + if func_type.optional_arg_count and expected_nargs != actual_nargs: + self.has_optional_args = 1 + self.is_temp = 1 + + # check 'self' argument + if entry and entry.is_cmethod and func_type.args and not func_type.is_static_method: + formal_arg = func_type.args[0] + arg = args[0] + if formal_arg.not_none: + if self.self: + self.self = self.self.as_none_safe_node( + "'NoneType' object has no attribute '%{}s'".format('.30' if len(entry.name) <= 30 else ''), + error='PyExc_AttributeError', + format_args=[entry.name]) + else: + # unbound method + arg = arg.as_none_safe_node( + "descriptor '%s' requires a '%s' object but received a 'NoneType'", + format_args=[entry.name, formal_arg.type.name]) + if self.self: + if formal_arg.accept_builtin_subtypes: + arg = CMethodSelfCloneNode(self.self) + else: + arg = CloneNode(self.self) + arg = self.coerced_self = arg.coerce_to(formal_arg.type, env) + elif formal_arg.type.is_builtin_type: + # special case: unbound methods of builtins accept subtypes + arg = arg.coerce_to(formal_arg.type, env) + if arg.type.is_builtin_type and isinstance(arg, PyTypeTestNode): + arg.exact_builtin_type = False + args[0] = arg + + # Coerce arguments + some_args_in_temps = False + for i in range(min(max_nargs, actual_nargs)): + formal_arg = func_type.args[i] + formal_type = formal_arg.type + arg = args[i].coerce_to(formal_type, env) + if formal_arg.not_none: + # C methods must do the None checks at *call* time + arg = arg.as_none_safe_node( + "cannot pass None into a C function argument that is declared 'not None'") + if arg.result_in_temp(): + if i > 0: + # first argument in temp doesn't impact subsequent arguments + some_args_in_temps = True + elif arg.type.is_pyobject and not env.nogil: + if i == 0 and self.self is not None: + # a method's cloned "self" argument is ok + pass + elif arg.nonlocally_immutable(): + # plain local variables are ok + pass + else: + # we do not safely own the argument's reference, + # but we must make sure it cannot be collected + # before we return from the function, so we create + # an owned temp reference to it + if i > 0: # first argument doesn't matter + some_args_in_temps = True + arg = arg.coerce_to_temp(env) + args[i] = arg + + # handle additional varargs parameters + for i in range(max_nargs, actual_nargs): + arg = args[i] + if arg.type.is_pyobject: + if arg.type is unicode_type: + # TODO: require "arg.type.bytes_value"? + arg_ctype = PyrexTypes.c_char_ptr_type + else: + arg_ctype = arg.type.default_coerced_ctype() + if arg_ctype is None: + error(self.args[i-1].pos, + "Python object cannot be passed as a varargs parameter") + else: + args[i] = arg = arg.coerce_to(arg_ctype, env) + if arg.result_in_temp() and i > 0: + some_args_in_temps = True + + if some_args_in_temps: + # if some args are temps and others are not, they may get + # constructed in the wrong order (temps first) => make + # sure they are either all temps or all not temps (except + # for the last argument, which is evaluated last in any + # case) + for i in range(actual_nargs-1): + if i == 0 and self.self is not None: + continue # self is ok + arg = args[i] + if arg.nonlocally_immutable(): + # locals, C functions, unassignable types are safe. + pass + elif arg.type.is_cpp_class: + # Assignment has side effects, avoid. + pass + elif env.nogil and arg.type.is_pyobject: + # can't copy a Python reference into a temp in nogil + # env (this is safe: a construction would fail in + # nogil anyway) + pass + else: + #self.args[i] = arg.coerce_to_temp(env) + # instead: issue a warning + if i > 0 or i == 1 and self.self is not None: # skip first arg + warning(arg.pos, "Argument evaluation order in C function call is undefined and may not be as expected", 0) + break + + self.args[:] = args + + # Calc result type and code fragment + if isinstance(self.function, NewExprNode): + self.type = PyrexTypes.CPtrType(self.function.class_type) + else: + self.type = func_type.return_type + + if self.function.is_name or self.function.is_attribute: + func_entry = self.function.entry + if func_entry and (func_entry.utility_code or func_entry.utility_code_definition): + self.is_temp = 1 # currently doesn't work for self.calculate_result_code() + + if self.type.is_pyobject: + self.result_ctype = py_object_type + self.is_temp = 1 + elif func_type.exception_value is not None or func_type.exception_check: + self.is_temp = 1 + elif self.type.is_memoryviewslice: + self.is_temp = 1 + # func_type.exception_check = True + + if self.is_temp and self.type.is_reference: + self.type = PyrexTypes.CFakeReferenceType(self.type.ref_base_type) + if func_type.return_type.is_ctuple: + # Make sure we properly declare new ctuple types coming in from function calls. + env.declare_tuple_type(self.function.pos, func_type.return_type.components).used = True + + # C++ exception handler + if func_type.exception_check == '+': + if needs_cpp_exception_conversion(func_type): + env.use_utility_code(UtilityCode.load_cached("CppExceptionConversion", "CppSupport.cpp")) + + self.overflowcheck = env.directives['overflowcheck'] + + def calculate_result_code(self): + return self.c_call_code() + + def c_call_code(self): + func_type = self.function_type() + if self.type is PyrexTypes.error_type or not func_type.is_cfunction: + return "" + formal_args = func_type.args + arg_list_code = [] + args = list(zip(formal_args, self.args)) + max_nargs = len(func_type.args) + expected_nargs = max_nargs - func_type.optional_arg_count + actual_nargs = len(self.args) + for formal_arg, actual_arg in args[:expected_nargs]: + arg_code = actual_arg.move_result_rhs_as(formal_arg.type) + arg_list_code.append(arg_code) + + if func_type.is_overridable: + arg_list_code.append(str(int(self.wrapper_call or self.function.entry.is_unbound_cmethod))) + + if func_type.optional_arg_count: + if expected_nargs == actual_nargs: + optional_args = 'NULL' + else: + optional_args = "&%s" % self.opt_arg_struct + arg_list_code.append(optional_args) + + for actual_arg in self.args[len(formal_args):]: + arg_list_code.append(actual_arg.move_result_rhs()) + + result = "%s(%s)" % (self.function.result(), ', '.join(arg_list_code)) + return result + + def is_c_result_required(self): + func_type = self.function_type() + if func_type.exception_value is None or func_type.exception_check == '+': + return False # skip allocation of unused result temp + return True + + def generate_evaluation_code(self, code): + function = self.function + if function.is_name or function.is_attribute: + code.globalstate.use_entry_utility_code(function.entry) + + abs_function_cnames = ('abs', 'labs', '__Pyx_abs_longlong') + is_signed_int = self.type.is_int and self.type.signed + if self.overflowcheck and is_signed_int and function.result() in abs_function_cnames: + code.globalstate.use_utility_code(UtilityCode.load_cached("Common", "Overflow.c")) + code.putln('if (unlikely(%s == __PYX_MIN(%s))) {\ + PyErr_SetString(PyExc_OverflowError,\ + "Trying to take the absolute value of the most negative integer is not defined."); %s; }' % ( + self.args[0].result(), + self.args[0].type.empty_declaration_code(), + code.error_goto(self.pos))) + + if not function.type.is_pyobject or len(self.arg_tuple.args) > 1 or ( + self.arg_tuple.args and self.arg_tuple.is_literal): + super().generate_evaluation_code(code) + return + + # Special case 0-args and try to avoid explicit tuple creation for Python calls with 1 arg. + arg = self.arg_tuple.args[0] if self.arg_tuple.args else None + subexprs = (self.self, self.coerced_self, function, arg) + for subexpr in subexprs: + if subexpr is not None: + subexpr.generate_evaluation_code(code) + + code.mark_pos(self.pos) + assert self.is_temp + self.allocate_temp_result(code) + + if arg is None: + code.globalstate.use_utility_code(UtilityCode.load_cached( + "PyObjectCallNoArg", "ObjectHandling.c")) + code.putln( + "%s = __Pyx_PyObject_CallNoArg(%s); %s" % ( + self.result(), + function.py_result(), + code.error_goto_if_null(self.result(), self.pos))) + else: + code.globalstate.use_utility_code(UtilityCode.load_cached( + "PyObjectCallOneArg", "ObjectHandling.c")) + code.putln( + "%s = __Pyx_PyObject_CallOneArg(%s, %s); %s" % ( + self.result(), + function.py_result(), + arg.py_result(), + code.error_goto_if_null(self.result(), self.pos))) + + self.generate_gotref(code) + + for subexpr in subexprs: + if subexpr is not None: + subexpr.generate_disposal_code(code) + subexpr.free_temps(code) + + def generate_result_code(self, code): + func_type = self.function_type() + if func_type.is_pyobject: + arg_code = self.arg_tuple.py_result() + code.globalstate.use_utility_code(UtilityCode.load_cached( + "PyObjectCall", "ObjectHandling.c")) + code.putln( + "%s = __Pyx_PyObject_Call(%s, %s, NULL); %s" % ( + self.result(), + self.function.py_result(), + arg_code, + code.error_goto_if_null(self.result(), self.pos))) + self.generate_gotref(code) + elif func_type.is_cfunction: + nogil = not code.funcstate.gil_owned + if self.has_optional_args: + actual_nargs = len(self.args) + expected_nargs = len(func_type.args) - func_type.optional_arg_count + self.opt_arg_struct = code.funcstate.allocate_temp( + func_type.op_arg_struct.base_type, manage_ref=True) + code.putln("%s.%s = %s;" % ( + self.opt_arg_struct, + Naming.pyrex_prefix + "n", + len(self.args) - expected_nargs)) + args = list(zip(func_type.args, self.args)) + for formal_arg, actual_arg in args[expected_nargs:actual_nargs]: + code.putln("%s.%s = %s;" % ( + self.opt_arg_struct, + func_type.opt_arg_cname(formal_arg.name), + actual_arg.result_as(formal_arg.type))) + exc_checks = [] + if self.type.is_pyobject and self.is_temp: + exc_checks.append("!%s" % self.result()) + elif self.type.is_memoryviewslice: + assert self.is_temp + exc_checks.append(self.type.error_condition(self.result())) + elif func_type.exception_check != '+': + exc_val = func_type.exception_value + exc_check = func_type.exception_check + if exc_val is not None: + typed_exc_val = func_type.return_type.cast_code(exc_val) + if func_type.return_type.is_ctuple: + code.globalstate.use_utility_code(UtilityCode.load_cached( + "IncludeStringH", "StringTools.c")) + exc_checks.append(f"memcmp(&{self.result()}, &{typed_exc_val}, sizeof({self.result()})) == 0") + else: + exc_checks.append(f"{self.result()} == {typed_exc_val}") + if exc_check: + if nogil: + if not exc_checks: + perf_hint_entry = getattr(self.function, "entry", None) + PyrexTypes.write_noexcept_performance_hint( + self.pos, code.funcstate.scope, + function_name=perf_hint_entry.name if perf_hint_entry else None, + void_return=self.type.is_void, is_call=True, + is_from_pxd=(perf_hint_entry and perf_hint_entry.defined_in_pxd)) + code.globalstate.use_utility_code( + UtilityCode.load_cached("ErrOccurredWithGIL", "Exceptions.c")) + exc_checks.append("__Pyx_ErrOccurredWithGIL()") + else: + exc_checks.append("PyErr_Occurred()") + if self.is_temp or exc_checks: + rhs = self.c_call_code() + if self.result(): + lhs = "%s = " % self.result() + if self.is_temp and self.type.is_pyobject: + #return_type = self.type # func_type.return_type + #print "SimpleCallNode.generate_result_code: casting", rhs, \ + # "from", return_type, "to pyobject" ### + rhs = typecast(py_object_type, self.type, rhs) + else: + lhs = "" + if func_type.exception_check == '+': + translate_cpp_exception(code, self.pos, '%s%s;' % (lhs, rhs), + self.result() if self.type.is_pyobject else None, + func_type.exception_value, nogil) + else: + if exc_checks: + goto_error = code.error_goto_if(" && ".join(exc_checks), self.pos) + else: + goto_error = "" + code.putln("%s%s; %s" % (lhs, rhs, goto_error)) + if self.type.is_pyobject and self.result(): + self.generate_gotref(code) + if self.has_optional_args: + code.funcstate.release_temp(self.opt_arg_struct) + + +class NumPyMethodCallNode(ExprNode): + # Pythran call to a NumPy function or method. + # + # function_cname string the function/method to call + # arg_tuple TupleNode the arguments as an args tuple + + subexprs = ['arg_tuple'] + is_temp = True + may_return_none = True + + def generate_evaluation_code(self, code): + code.mark_pos(self.pos) + self.allocate_temp_result(code) + + assert self.arg_tuple.mult_factor is None + args = self.arg_tuple.args + for arg in args: + arg.generate_evaluation_code(code) + + code.putln("// function evaluation code for numpy function") + code.putln("__Pyx_call_destructor(%s);" % self.result()) + code.putln("new (&%s) decltype(%s){%s{}(%s)};" % ( + self.result(), + self.result(), + self.function_cname, + ", ".join(a.pythran_result() for a in args))) + + +class PyMethodCallNode(CallNode): + # Specialised call to a (potential) PyMethodObject with non-constant argument tuple. + # Allows the self argument to be injected directly instead of repacking a tuple for it. + # + # function ExprNode the function/method object to call + # arg_tuple TupleNode the arguments for the args tuple + # kwdict ExprNode or None keyword dictionary (if present) + # kwargs_key_value_pairs [ExprNode] or None list of unpacked kwargs key-value pairs, if known + # function_obj ExprNode or None == self.function.obj when using PyObject_VectorcallMethod() + # unpack bool + + subexprs = ['function', 'arg_tuple', 'kwdict', 'kwargs_key_value_pairs'] + is_temp = True + use_method_vectorcall = False + kwdict = None + kwargs_key_value_pairs = None + function_obj = None + + def __init__(self, pos, **kw): + super().__init__(pos, **kw) + if self.can_avoid_attribute_lookup(): + self.use_method_vectorcall = True + self.function_obj = self.function.obj + if self.kwdict and self.kwdict.is_dict_literal: + self.kwargs_key_value_pairs = self.kwdict.key_value_pairs + self.kwdict = None + + def can_avoid_attribute_lookup(self): + # Essentially, if the signature matches PyObject_VectorcallMethod + # then it's worth doing that directly and not creating a new method in + # the attribute lookup. + if self.kwdict and not isinstance(self.kwdict, DictNode): + return False + function = self.function + if not function.is_attribute: + return False + # These two determine that it's not just a plain getattr + if not function.is_py_attr: + return False + if function.is_special_lookup: + return False + if not PyMethodCallNode.attribute_is_likely_method(function): + # PyObject_VectorcallMethod would work, but is more likely to + # be a pessimization. + return False + return True + + @staticmethod + def attribute_is_likely_method(attr): + obj = attr.obj + if obj.is_name and obj.entry.is_pyglobal: + return False # more likely to be a function + return True + + @staticmethod + def can_be_used_for_posargs(positional_args, has_kwargs, has_explicit_kwargs=False): + """ + Test whether the positional args given are compatible with + being translated into a PyMethodCallNode. + """ + if not isinstance(positional_args, TupleNode): + return False + if positional_args.mult_factor: + return False + if positional_args.is_literal and len(positional_args.args) > 1: + return False + if not len(positional_args.args): + # If positional_args is an empty tuple, it's probably only worth optimizing + # if the kwds are f(a=1, b=2) or none at all, and not if they're f(**kwds). + return has_explicit_kwargs or not has_kwargs + return True + + @staticmethod + def can_be_used_for_function(function): + """ + Test whether the function passed is suitable to be translated + into a PyMethodCallNode + """ + may_be_a_method = True + if function.is_attribute: + if function.entry and function.entry.type.is_cfunction: + # optimised builtin method + may_be_a_method = False + elif function.is_name: + entry = function.entry + if entry.type.is_cfunction: + may_be_a_method = False + elif entry.cf_assignments: + # local functions/classes are definitely not methods + non_method_nodes = (PyCFunctionNode, ClassNode, Py3ClassNode) + may_be_a_method = any( + assignment.rhs and not isinstance(assignment.rhs, non_method_nodes) + for assignment in entry.cf_assignments) + return may_be_a_method + + def generate_evaluate_function(self, code, self_arg) -> str: + # Returns the cname of the function variable, temp or name (for VectorcallMethod). + if self.use_method_vectorcall: + self.function_obj.generate_evaluation_code(code) + code.putln(f"{self_arg} = {self.function_obj.py_result()};") + code.put_incref(self_arg, py_object_type) + return code.get_py_string_const(self.function.attribute) + + code.putln(f"{self_arg} = NULL;") + self.function.generate_evaluation_code(code) + + # Make sure function is in temp so that we can replace the reference if it's a method. + if self.function.result_in_temp(): + return self.function.result() + + # FIXME: Should use "coerce_to_temp()" in "__init__()" instead, but that needs "env". + function = code.funcstate.allocate_temp(py_object_type, manage_ref=True) + self.function.make_owned_reference(code) + code.putln("%s = %s; " % (function, self.function.py_result())) + self.function.generate_disposal_code(code) + self.function.free_temps(code) + return function + + def generate_dispose_function(self, code, function): + if self.use_method_vectorcall: + self.function_obj.generate_disposal_code(code) + self.function_obj.free_temps(code) + elif self.function.result_in_temp(): + self.function.generate_disposal_code(code) + self.function.free_temps(code) + else: + code.put_decref_clear(function, py_object_type) + code.funcstate.release_temp(function) + + def generate_runtime_method_unpacking_code(self, code, self_arg, space_for_selfarg_var, method_obj): + if self.use_method_vectorcall or not self.unpack: + return + + if self.function.is_attribute: + likely_method = 'likely' if self.attribute_is_likely_method(self.function) else 'unlikely' + elif self.function.is_name and self.function.cf_state: + # not an attribute itself, but might have been assigned from one (e.g. bound method) + for assignment in self.function.cf_state: + value = assignment.rhs + if value and value.is_attribute and value.obj.type and value.obj.type.is_pyobject: + if self.attribute_is_likely_method(value): + likely_method = 'likely' + break + else: + likely_method = 'unlikely' + else: + likely_method = 'unlikely' + + # Unpacking is ultimately governed by "optimize.unpack_method_calls" + # and is a separate decision to whether we want vectorcall-type behaviour. + code.putln("#if CYTHON_UNPACK_METHODS") + code.putln("if (%s(PyMethod_Check(%s))) {" % (likely_method, method_obj)) + code.putln(f"{self_arg} = PyMethod_GET_SELF({method_obj});") + # The result of PyMethod_GET_SELF is always true in Py3. + code.putln(f"assert({self_arg});") + code.putln(f"PyObject* __pyx__function = PyMethod_GET_FUNCTION({method_obj});") + code.put_incref(self_arg, py_object_type) + code.put_incref("__pyx__function", py_object_type) + # free method object as early to possible to enable reuse from CPython's freelist + code.put_decref_set(method_obj, py_object_type, "__pyx__function") + code.putln(f"{space_for_selfarg_var} = 0;") + code.putln("}") + code.putln("#endif") # CYTHON_UNPACK_METHODS + # TODO may need to deal with unused variables in the #else case + + def generate_keyvalue_args(self, code, args, kwargs_key_value_pairs, kwnames_temp): + code.putln( + f"{kwnames_temp} = __Pyx_MakeVectorcallBuilderKwds({len(kwargs_key_value_pairs)}); " + f"{code.error_goto_if_null(kwnames_temp, self.pos)}" + ) + code.put_gotref(kwnames_temp, py_object_type) + + for n, keyvalue in enumerate(kwargs_key_value_pairs): + key_is_str = keyvalue.key.type is Builtin.unicode_type and not keyvalue.key.may_be_none() + code.put_error_if_neg( + self.pos, + f"__Pyx_VectorcallBuilder_AddArg{'' if key_is_str else '_Check'}(" + f"{keyvalue.key.py_result()}, " + f"{keyvalue.value.py_result()}, " + f"{kwnames_temp}, " + f"{Naming.callargs_cname}+{len(args) + 1}, " + f"{n:d}" + ")" + ) + + def select_utility_code(self, code): + # ... and return the utility function's cname. + if self.use_method_vectorcall: + if self.kwargs_key_value_pairs: + name = "PyObjectVectorCallMethodKwBuilder" + cfunc = "__Pyx_Object_VectorcallMethod_CallFromBuilder" + else: + name = "PyObjectFastCallMethod" + cfunc = "__Pyx_PyObject_FastCallMethod" + elif self.kwargs_key_value_pairs: + name = "PyObjectVectorCallKwBuilder" + cfunc = "__Pyx_Object_Vectorcall_CallFromBuilder" + elif self.kwdict: + name = "PyObjectFastCall" + cfunc = "__Pyx_PyObject_FastCallDict" + else: + name = "PyObjectFastCall" + cfunc = "__Pyx_PyObject_FastCall" + + code.globalstate.use_utility_code( + UtilityCode.load_cached(name, "ObjectHandling.c")) + return cfunc + + def generate_evaluation_code(self, code): + code.mark_pos(self.pos) + self.allocate_temp_result(code) + + kwargs_key_value_pairs = self.kwargs_key_value_pairs + kwdict = self.kwdict + + self_arg = code.funcstate.allocate_temp(py_object_type, manage_ref=True) + function = self.generate_evaluate_function(code, self_arg) + + args = self.arg_tuple.args + assert self.arg_tuple.mult_factor is None + for arg in args: + arg.generate_evaluation_code(code) + + if kwargs_key_value_pairs: + for keyvalue in kwargs_key_value_pairs: + keyvalue.generate_evaluation_code(code) + elif kwdict: + kwdict.generate_evaluation_code(code) + + # Leave space for self argument in before-first argument? + space_for_selfarg = code.funcstate.allocate_temp(PyrexTypes.c_size_t_type, manage_ref=False) + code.putln(f"{space_for_selfarg} = {'0' if self.use_method_vectorcall else '1'};") + + self.generate_runtime_method_unpacking_code( + code, + self_arg=self_arg, + space_for_selfarg_var=space_for_selfarg, + method_obj=function, + ) + + function_caller = self.select_utility_code(code) + + # Actually call the function. + code.putln("{") + + # To avoid passing an out-of-bounds argument pointer in the no-args case, + # we need at least two entries, so we pad with NULL and point to that. + # See https://github.com/cython/cython/issues/5668 + args_list = ', '.join(arg.py_result() for arg in args) if args else "NULL" + extra_keyword_args = f" + ((CYTHON_VECTORCALL) ? {len(kwargs_key_value_pairs)} : 0)" if kwargs_key_value_pairs else "" + code.putln( + f"PyObject *{Naming.callargs_cname}[{(len(args) + 1) if args else 2:d}{extra_keyword_args}] = {{{self_arg}, {args_list}}};" + ) + + keyword_variable = "" + if kwargs_key_value_pairs: + keyword_variable = code.funcstate.allocate_temp(py_object_type, manage_ref=True) + self.generate_keyvalue_args(code, args, kwargs_key_value_pairs, keyword_variable) + elif kwdict: + keyword_variable = kwdict.result() + + code.putln( + f"{self.result()} = {function_caller}(" + f"{function}, " + f"{Naming.callargs_cname}+{space_for_selfarg}, " + f"({len(args)+1:d}-{space_for_selfarg})" + f" | ({'1' if self.use_method_vectorcall else space_for_selfarg}*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)" + f"{', ' if keyword_variable else ''}{keyword_variable}" + ");") + + # Clean up. + + code.put_xdecref_clear(self_arg, py_object_type) + for tmp in [self_arg, space_for_selfarg]: + code.funcstate.release_temp(tmp) + + for arg in args: + arg.generate_disposal_code(code) + arg.free_temps(code) + + if kwargs_key_value_pairs: + for kw_node in kwargs_key_value_pairs: + kw_node.generate_disposal_code(code) + kw_node.free_temps(code) + code.put_decref_clear(keyword_variable, py_object_type) + code.funcstate.release_temp(keyword_variable) + elif kwdict: + kwdict.generate_disposal_code(code) + kwdict.free_temps(code) + + self.generate_dispose_function(code, function) + + code.putln(code.error_goto_if_null(self.result(), self.pos)) + self.generate_gotref(code) + + code.putln("}") + + +class InlinedDefNodeCallNode(CallNode): + # Inline call to defnode + # + # function PyCFunctionNode + # function_name NameNode + # args [ExprNode] + + subexprs = ['args', 'function_name'] + is_temp = 1 + type = py_object_type + function = None + function_name = None + + def can_be_inlined(self): + func_type= self.function.def_node + if func_type.star_arg or func_type.starstar_arg: + return False + if len(func_type.args) != len(self.args): + return False + if func_type.num_kwonly_args: + return False # actually wrong number of arguments + return True + + def analyse_types(self, env): + self.function_name = self.function_name.analyse_types(env) + + self.args = [ arg.analyse_types(env) for arg in self.args ] + func_type = self.function.def_node + actual_nargs = len(self.args) + + # Coerce arguments + some_args_in_temps = False + for i in range(actual_nargs): + formal_type = func_type.args[i].type + arg = self.args[i].coerce_to(formal_type, env) + if arg.result_in_temp(): + if i > 0: + # first argument in temp doesn't impact subsequent arguments + some_args_in_temps = True + elif arg.type.is_pyobject and not env.nogil: + if arg.nonlocally_immutable(): + # plain local variables are ok + pass + else: + # we do not safely own the argument's reference, + # but we must make sure it cannot be collected + # before we return from the function, so we create + # an owned temp reference to it + if i > 0: # first argument doesn't matter + some_args_in_temps = True + arg = arg.coerce_to_temp(env) + self.args[i] = arg + + if some_args_in_temps: + # if some args are temps and others are not, they may get + # constructed in the wrong order (temps first) => make + # sure they are either all temps or all not temps (except + # for the last argument, which is evaluated last in any + # case) + for i in range(actual_nargs-1): + arg = self.args[i] + if arg.nonlocally_immutable(): + # locals, C functions, unassignable types are safe. + pass + elif arg.type.is_cpp_class: + # Assignment has side effects, avoid. + pass + elif env.nogil and arg.type.is_pyobject: + # can't copy a Python reference into a temp in nogil + # env (this is safe: a construction would fail in + # nogil anyway) + pass + else: + #self.args[i] = arg.coerce_to_temp(env) + # instead: issue a warning + if i > 0: + warning(arg.pos, "Argument evaluation order in C function call is undefined and may not be as expected", 0) + break + return self + + def generate_result_code(self, code): + self_code = self.function_name.py_result() + if not self.function.def_node.is_cyfunction: + # If the function is a PyCFunction then the self_code is the PyCFunction. + # In this case, the self argument will either be NULL and unused, or it'll be + # the self attribute of the PyCfunction. + code.putln("{") + code.putln("#if CYTHON_COMPILING_IN_LIMITED_API") + code.putln( + f"PyObject *{Naming.quick_temp_cname} = PyCFunction_GetSelf({self_code});") + code.putln(code.error_goto_if( + f"{Naming.quick_temp_cname} == NULL && PyErr_Occurred()", + self.pos + )) + code.putln("#else") + code.putln( + f"PyObject *{Naming.quick_temp_cname} = PyCFunction_GET_SELF({self_code});") + code.putln("#endif") + # Note - borrowed reference to self + self_code = Naming.quick_temp_cname + + arg_code = [self_code] + func_type = self.function.def_node + for arg, proto_arg in zip(self.args, func_type.args): + if arg.type.is_pyobject: + arg_code.append(arg.result_as(proto_arg.type)) + else: + arg_code.append(arg.result()) + arg_code = ', '.join(arg_code) + code.putln( + "%s = %s(%s); %s" % ( + self.result(), + self.function.def_node.entry.pyfunc_cname, + arg_code, + code.error_goto_if_null(self.result(), self.pos))) + if not self.function.def_node.is_cyfunction: + code.putln("}") + self.generate_gotref(code) + + +class PythonCapiFunctionNode(ExprNode): + subexprs = [] + + def __init__(self, pos, py_name, cname, func_type, utility_code = None): + ExprNode.__init__(self, pos, name=py_name, cname=cname, + type=func_type, utility_code=utility_code) + + def analyse_types(self, env): + return self + + def generate_result_code(self, code): + if self.utility_code: + code.globalstate.use_utility_code(self.utility_code) + + def calculate_result_code(self): + return self.cname + + +class PythonCapiCallNode(SimpleCallNode): + # Python C-API Function call (only created in transforms) + + # By default, we assume that the call never returns None, as this + # is true for most C-API functions in CPython. If this does not + # apply to a call, set the following to True (or None to inherit + # the default behaviour). + may_return_none = False + + def __init__(self, pos, function_name, func_type, + utility_code = None, py_name=None, **kwargs): + self.type = func_type.return_type + self.result_ctype = self.type + self.function = PythonCapiFunctionNode( + pos, py_name, function_name, func_type, + utility_code = utility_code) + # call this last so that we can override the constructed + # attributes above with explicit keyword arguments if required + SimpleCallNode.__init__(self, pos, **kwargs) + + +class CachedBuiltinMethodCallNode(CallNode): + # Python call to a method of a known Python builtin (only created in transforms) + + subexprs = ['obj', 'args'] + is_temp = True + + def __init__(self, call_node, obj, method_name, args): + super().__init__( + call_node.pos, + obj=obj, method_name=method_name, args=args, + may_return_none=call_node.may_return_none, + type=call_node.type) + + def may_be_none(self): + if self.may_return_none is not None: + return self.may_return_none + return ExprNode.may_be_none(self) + + def generate_result_code(self, code): + type_cname = self.obj.type.typeptr_cname + obj_cname = self.obj.py_result() + args = [arg.py_result() for arg in self.args] + call_code = code.globalstate.cached_unbound_method_call_code( + code.name_in_module_state(""), + obj_cname, type_cname, self.method_name, args) + code.putln("%s = %s; %s" % ( + self.result(), call_code, + code.error_goto_if_null(self.result(), self.pos) + )) + self.generate_gotref(code) + + +class GeneralCallNode(CallNode): + # General Python function call, including keyword, + # * and ** arguments. + # + # function ExprNode + # positional_args ExprNode Tuple of positional arguments + # keyword_args ExprNode or None Dict of keyword arguments + + type = py_object_type + + subexprs = ['function', 'positional_args', 'keyword_args'] + + nogil_check = Node.gil_error + + def compile_time_value(self, denv): + function = self.function.compile_time_value(denv) + positional_args = self.positional_args.compile_time_value(denv) + keyword_args = self.keyword_args.compile_time_value(denv) + try: + return function(*positional_args, **keyword_args) + except Exception as e: + self.compile_time_value_error(e) + + def calculate_constant_result(self): + if self.function.is_attribute and self.function.obj.is_literal: + method = self.function.constant_result + if inspect.isbuiltin(method) or inspect.ismethod(method): + method_name = method.__name__ + # Prefer the actual builtin type over internal representations like "EncodedString". + object_type = self.function.obj.type + object_type_name = object_type.name if object_type else type(method.__self__).__name__ + + if Builtin.is_safe_compile_time_method(object_type_name, method_name): + args = self.positional_args.constant_result + kwargs = self.keyword_args.constant_result + self.constant_result = method(*args, **kwargs) + + def explicit_args_kwds(self): + if (self.keyword_args and not self.keyword_args.is_dict_literal or + not self.positional_args.is_sequence_constructor): + raise CompileError(self.pos, + 'Compile-time keyword arguments must be explicit.') + return self.positional_args.args, self.keyword_args + + def analyse_types(self, env): + if (as_type_constructor := self.analyse_as_type_constructor(env)) is not None: + return as_type_constructor + self.function = self.function.analyse_types(env) + if not self.function.type.is_pyobject: + if self.function.type.is_error: + self.type = error_type + return self + if hasattr(self.function, 'entry'): + node = self.map_to_simple_call_node() + if node is not None and node is not self: + return node.analyse_types(env) + elif self.function.entry.as_variable: + self.function = self.function.coerce_to_pyobject(env) + elif node is self: + error(self.pos, + "Non-trivial keyword arguments and starred " + "arguments not allowed in cdef functions.") + else: + # error was already reported + pass + else: + self.function = self.function.coerce_to_pyobject(env) + if self.keyword_args: + self.keyword_args = self.keyword_args.analyse_types(env) + self.positional_args = self.positional_args.analyse_types(env) + self.positional_args = \ + self.positional_args.coerce_to_pyobject(env) + self.set_py_result_type(self.function) + self.is_temp = 1 + return self + + def map_to_simple_call_node(self): + """ + Tries to map keyword arguments to declared positional arguments. + Returns self to try a Python call, None to report an error + or a SimpleCallNode if the mapping succeeds. + """ + if not isinstance(self.positional_args, TupleNode): + # has starred argument + return self + if not self.keyword_args.is_dict_literal: + # keywords come from arbitrary expression => nothing to do here + return self + function = self.function + entry = getattr(function, 'entry', None) + if not entry: + return self + function_type = entry.type + if function_type.is_ptr: + function_type = function_type.base_type + if not function_type.is_cfunction: + return self + + pos_args = self.positional_args.args + kwargs = self.keyword_args + declared_args = function_type.args + if entry.is_cmethod: + declared_args = declared_args[1:] # skip 'self' + + if len(pos_args) > len(declared_args): + error(self.pos, "function call got too many positional arguments, " + "expected %d, got %s" % (len(declared_args), + len(pos_args))) + return None + + matched_args = { + arg.name for arg in declared_args[:len(pos_args)] + if arg.name + } + unmatched_args = declared_args[len(pos_args):] + matched_kwargs_count = 0 + args = list(pos_args) + + # check for duplicate keywords + seen = set(matched_args) + has_errors = False + for arg in kwargs.key_value_pairs: + name = arg.key.value + if name in seen: + error(arg.pos, "argument '%s' passed twice" % name) + has_errors = True + # continue to report more errors if there are any + seen.add(name) + + # match keywords that are passed in order + for decl_arg, arg in zip(unmatched_args, kwargs.key_value_pairs): + name = arg.key.value + if decl_arg.name == name: + matched_args.add(name) + matched_kwargs_count += 1 + args.append(arg.value) + else: + break + + # match keyword arguments that are passed out-of-order, but keep + # the evaluation of non-simple arguments in order by moving them + # into temps + from .UtilNodes import EvalWithTempExprNode, LetRefNode + temps = [] + if len(kwargs.key_value_pairs) > matched_kwargs_count: + unmatched_args = declared_args[len(args):] + keywords = {arg.key.value: (i+len(pos_args), arg) + for i, arg in enumerate(kwargs.key_value_pairs)} + first_missing_keyword = None + for decl_arg in unmatched_args: + name = decl_arg.name + if name not in keywords: + # missing keyword argument => either done or error + if not first_missing_keyword: + first_missing_keyword = name + continue + elif first_missing_keyword: + if entry.as_variable: + # we might be able to convert the function to a Python + # object, which then allows full calling semantics + # with default values in gaps - currently, we only + # support optional arguments at the end + return self + # wasn't the last keyword => gaps are not supported + error(self.pos, "C function call is missing " + "argument '%s'" % first_missing_keyword) + return None + pos, arg = keywords[name] + matched_args.add(name) + matched_kwargs_count += 1 + if arg.value.is_simple(): + args.append(arg.value) + else: + temp = LetRefNode(arg.value) + assert temp.is_simple() + args.append(temp) + temps.append((pos, temp)) + + if temps: + # may have to move preceding non-simple args into temps + final_args = [] + new_temps = [] + first_temp_arg = temps[0][-1] + for arg_value in args: + if arg_value is first_temp_arg: + break # done + if arg_value.is_simple(): + final_args.append(arg_value) + else: + temp = LetRefNode(arg_value) + new_temps.append(temp) + final_args.append(temp) + if new_temps: + args = final_args + temps = new_temps + [ arg for i,arg in sorted(temps) ] + + # check for unexpected keywords + for arg in kwargs.key_value_pairs: + name = arg.key.value + if name not in matched_args: + has_errors = True + error(arg.pos, + "C function got unexpected keyword argument '%s'" % + name) + + if has_errors: + # error was reported already + return None + + # all keywords mapped to positional arguments + # if we are missing arguments, SimpleCallNode will figure it out + node = SimpleCallNode(self.pos, function=function, args=args) + for temp in temps[::-1]: + node = EvalWithTempExprNode(temp, node) + return node + + def generate_result_code(self, code): + if self.type.is_error: return + if self.keyword_args: + kwargs = self.keyword_args.py_result() + else: + kwargs = 'NULL' + code.globalstate.use_utility_code(UtilityCode.load_cached( + "PyObjectCall", "ObjectHandling.c")) + code.putln( + "%s = __Pyx_PyObject_Call(%s, %s, %s); %s" % ( + self.result(), + self.function.py_result(), + self.positional_args.py_result(), + kwargs, + code.error_goto_if_null(self.result(), self.pos))) + self.generate_gotref(code) + + +class AsTupleNode(ExprNode): + # Convert argument to tuple. Used for normalising + # the * argument of a function call. + # + # arg ExprNode + + subexprs = ['arg'] + is_temp = 1 + + def calculate_constant_result(self): + self.constant_result = tuple(self.arg.constant_result) + + def compile_time_value(self, denv): + arg = self.arg.compile_time_value(denv) + try: + return tuple(arg) + except Exception as e: + self.compile_time_value_error(e) + + def analyse_types(self, env): + self.arg = self.arg.analyse_types(env).coerce_to_pyobject(env) + if self.arg.type is tuple_type: + return self.arg.as_none_safe_node("'NoneType' object is not iterable") + self.type = tuple_type + return self + + def may_be_none(self): + return False + + nogil_check = Node.gil_error + gil_message = "Constructing Python tuple" + + def generate_result_code(self, code): + cfunc = "__Pyx_PySequence_Tuple" if self.arg.type in (py_object_type, tuple_type) else "PySequence_Tuple" + code.putln( + "%s = %s(%s); %s" % ( + self.result(), + cfunc, self.arg.py_result(), + code.error_goto_if_null(self.result(), self.pos))) + self.generate_gotref(code) + + +class MergedDictNode(ExprNode): + # Helper class for keyword arguments and other merged dicts. + # + # keyword_args [DictNode or other ExprNode] + + subexprs = ['keyword_args'] + is_temp = 1 + type = dict_type + reject_duplicates = True + + def calculate_constant_result(self): + result = {} + reject_duplicates = self.reject_duplicates + for item in self.keyword_args: + if item.is_dict_literal: + # process items in order + items = ((key.constant_result, value.constant_result) + for key, value in item.key_value_pairs) + else: + items = item.constant_result.iteritems() + + for key, value in items: + if reject_duplicates and key in result: + raise ValueError("duplicate keyword argument found: %s" % key) + result[key] = value + + self.constant_result = result + + def compile_time_value(self, denv): + result = {} + reject_duplicates = self.reject_duplicates + for item in self.keyword_args: + if item.is_dict_literal: + # process items in order + items = [(key.compile_time_value(denv), value.compile_time_value(denv)) + for key, value in item.key_value_pairs] + else: + items = item.compile_time_value(denv).iteritems() + + try: + for key, value in items: + if reject_duplicates and key in result: + raise ValueError("duplicate keyword argument found: %s" % key) + result[key] = value + except Exception as e: + self.compile_time_value_error(e) + return result + + def type_dependencies(self, env): + return () + + def infer_type(self, env): + return dict_type + + def analyse_types(self, env): + self.keyword_args = [ + arg.analyse_types(env).coerce_to_pyobject(env).as_none_safe_node( + # FIXME: CPython's error message starts with the runtime function name + 'argument after ** must be a mapping, not NoneType') + for arg in self.keyword_args + ] + + return self + + def may_be_none(self): + return False + + gil_message = "Constructing Python dict" + + def generate_evaluation_code(self, code): + code.mark_pos(self.pos) + self.allocate_temp_result(code) + + args = iter(self.keyword_args) + item = next(args) + item.generate_evaluation_code(code) + if item.type is not dict_type: + # CPython supports calling functions with non-dicts, so do we + code.putln('if (likely(PyDict_CheckExact(%s))) {' % + item.py_result()) + + if item.is_dict_literal: + item.make_owned_reference(code) + code.putln("%s = %s;" % (self.result(), item.py_result())) + item.generate_post_assignment_code(code) + else: + if item.result_in_temp(): + # For the fairly plausible special case where item is a temporary + # with a refcount of 1 (so created specifically for us), + # avoid making a copy + code.putln("#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API") + code.putln("if (Py_REFCNT(%s) == 1) {" % item.py_result()) + code.putln("%s = %s;" % (self.result(), item.py_result())) + item.generate_post_assignment_code(code) + code.putln("} else") + code.putln("#endif") + code.putln("{") + code.putln("%s = PyDict_Copy(%s); %s" % ( + self.result(), + item.py_result(), + code.error_goto_if_null(self.result(), item.pos))) + self.generate_gotref(code) + item.generate_disposal_code(code) + if item.result_in_temp(): + code.putln("}") + + if item.type is not dict_type: + code.putln('} else {') + code.globalstate.use_utility_code(UtilityCode.load_cached( + "PyObjectCallOneArg", "ObjectHandling.c")) + code.putln("%s = __Pyx_PyObject_CallOneArg((PyObject*)&PyDict_Type, %s); %s" % ( + self.result(), + item.py_result(), + code.error_goto_if_null(self.result(), self.pos))) + self.generate_gotref(code) + item.generate_disposal_code(code) + code.putln('}') + item.free_temps(code) + + helpers = set() + for item in args: + if item.is_dict_literal: + # inline update instead of creating an intermediate dict + for arg in item.key_value_pairs: + arg.generate_evaluation_code(code) + if self.reject_duplicates: + code.putln("if (unlikely(PyDict_Contains(%s, %s))) {" % ( + self.result(), + arg.key.py_result())) + helpers.add("RaiseDoubleKeywords") + # FIXME: find out function name at runtime! + code.putln('__Pyx_RaiseDoubleKeywordsError("function", %s); %s' % ( + arg.key.py_result(), + code.error_goto(self.pos))) + code.putln("}") + code.put_error_if_neg(arg.key.pos, "PyDict_SetItem(%s, %s, %s)" % ( + self.result(), + arg.key.py_result(), + arg.value.py_result())) + arg.generate_disposal_code(code) + arg.free_temps(code) + else: + item.generate_evaluation_code(code) + if self.reject_duplicates: + # merge mapping into kwdict one by one as we need to check for duplicates + helpers.add("MergeKeywords") + code.put_error_if_neg(item.pos, "__Pyx_MergeKeywords(%s, %s)" % ( + self.result(), item.py_result())) + else: + # simple case, just add all entries + helpers.add("RaiseMappingExpected") + code.putln("if (unlikely(PyDict_Update(%s, %s) < 0)) {" % ( + self.result(), item.py_result())) + code.putln("if (PyErr_ExceptionMatches(PyExc_AttributeError)) " + "__Pyx_RaiseMappingExpectedError(%s);" % item.py_result()) + code.putln(code.error_goto(item.pos)) + code.putln("}") + item.generate_disposal_code(code) + item.free_temps(code) + + for helper in sorted(helpers): + code.globalstate.use_utility_code(UtilityCode.load_cached(helper, "FunctionArguments.c")) + + def annotate(self, code): + for item in self.keyword_args: + item.annotate(code) + + +class AttributeNode(ExprNode): + # obj.attribute + # + # obj ExprNode + # attribute string + # needs_none_check boolean Used if obj is an extension type. + # If set to True, it is known that the type is not None. + # + # Used internally: + # + # is_py_attr boolean Is a Python getattr operation + # member string C name of struct member + # is_called boolean Function call is being done on result + # entry Entry Symbol table entry of attribute + + is_attribute = 1 + subexprs = ['obj'] + + entry = None + is_called = 0 + needs_none_check = True + is_memslice_transpose = False + is_special_lookup = False + is_py_attr = 0 + + def as_cython_attribute(self): + if (isinstance(self.obj, NameNode) and + self.obj.is_cython_module and not + self.attribute == "parallel"): + return self.attribute + + cy = self.obj.as_cython_attribute() + if cy: + return "%s.%s" % (cy, self.attribute) + return None + + def coerce_to(self, dst_type, env): + # If coercing to a generic pyobject and this is a cpdef function + # we can create the corresponding attribute + if dst_type is py_object_type: + entry = self.entry + if entry and entry.is_cfunction and entry.as_variable: + # must be a cpdef function + self.is_temp = 1 + self.entry = entry.as_variable + self.analyse_as_python_attribute(env) + return self + elif entry and entry.is_cfunction and self.obj.type is not Builtin.type_type: + # "bound" cdef function. + # This implementation is likely a little inefficient and could be improved. + # Essentially it does: + # __import__("functools").partial(coerce_to_object(self), self.obj) + from .UtilNodes import EvalWithTempExprNode, ResultRefNode + # take self.obj out to a temp because it's used twice + obj_node = ResultRefNode(self.obj, type=self.obj.type) + obj_node.result_ctype = self.obj.result_ctype + self.obj = obj_node + unbound_node = ExprNode.coerce_to(self, dst_type, env) + utility_code=UtilityCode.load_cached( + "PyMethodNew2Arg", "ObjectHandling.c" + ) + func_type = PyrexTypes.CFuncType( + PyrexTypes.py_object_type, [ + PyrexTypes.CFuncTypeArg("func", PyrexTypes.py_object_type, None), + PyrexTypes.CFuncTypeArg("self", PyrexTypes.py_object_type, None) + ], + ) + binding_call = PythonCapiCallNode( + self.pos, + function_name="__Pyx_PyMethod_New2Arg", + func_type=func_type, + args=[unbound_node, obj_node], + utility_code=utility_code, + ) + complete_call = EvalWithTempExprNode(obj_node, binding_call) + return complete_call.analyse_types(env) + return ExprNode.coerce_to(self, dst_type, env) + + def calculate_constant_result(self): + attr = self.attribute + if attr.startswith("__") and attr.endswith("__"): + return + self.constant_result = getattr(self.obj.constant_result, attr) + + def compile_time_value(self, denv): + attr = self.attribute + if attr.startswith("__") and attr.endswith("__"): + error(self.pos, + "Invalid attribute name '%s' in compile-time expression" % attr) + return None + obj = self.obj.compile_time_value(denv) + try: + return getattr(obj, attr) + except Exception as e: + self.compile_time_value_error(e) + + def type_dependencies(self, env): + return self.obj.type_dependencies(env) + + def infer_type(self, env): + # FIXME: this is way too redundant with analyse_types() + node = self.analyse_as_cimported_attribute_node(env, target=False) + if node is not None: + if node.entry.type and node.entry.type.is_cfunction: + # special-case - function converted to pointer + return PyrexTypes.CPtrType(node.entry.type) + else: + return node.entry.type + node = self.analyse_as_type_attribute(env) + if node is not None: + return node.entry.type + obj_type = self.obj.infer_type(env) + self.analyse_attribute(env, obj_type=obj_type) + if obj_type.is_builtin_type and self.type.is_cfunction: + # special case: C-API replacements for C methods of + # builtin types cannot be inferred as C functions as + # that would prevent their use as bound methods + return py_object_type + elif self.entry and self.entry.is_cmethod: + # special case: bound methods should not be inferred + # as their unbound method types + return py_object_type + return self.type + + def analyse_target_declaration(self, env): + self.is_target = True + + def analyse_target_types(self, env): + node = self.analyse_types(env, target = 1) + if node.type.is_const: + error(self.pos, "Assignment to const attribute '%s'" % self.attribute) + if not node.is_lvalue(): + error(self.pos, "Assignment to non-lvalue of type '%s'" % self.type) + return node + + def analyse_types(self, env, target = 0): + if not self.type: + self.type = PyrexTypes.error_type # default value if it isn't analysed successfully + self.initialized_check = env.directives['initializedcheck'] + node = self.analyse_as_cimported_attribute_node(env, target) + if node is None and not target: + node = self.analyse_as_type_attribute(env) + if node is None: + node = self.analyse_as_ordinary_attribute_node(env, target) + assert node is not None + if (node.is_attribute or node.is_name) and node.entry: + node.entry.used = True + if node.is_attribute: + node.wrap_obj_in_nonecheck(env) + return node + + def analyse_as_cimported_attribute_node(self, env, target): + # Try to interpret this as a reference to an imported + # C const, type, var or function. If successful, mutates + # this node into a NameNode and returns 1, otherwise + # returns 0. + module_scope = self.obj.analyse_as_module(env) + if module_scope: + entry = module_scope.lookup_here(self.attribute) + if entry and not entry.known_standard_library_import and ( + entry.is_cglobal or entry.is_cfunction + or entry.is_type or entry.is_const): + return self.as_name_node(env, entry, target) + if self.is_cimported_module_without_shadow(env): + # TODO: search for submodule + error(self.pos, "cimported module has no attribute '%s'" % self.attribute) + return self + return None + + def analyse_as_type_attribute(self, env): + # Try to interpret this as a reference to an unbound + # C method of an extension type or builtin type. If successful, + # creates a corresponding NameNode and returns it, otherwise + # returns None. + if self.obj.is_string_literal: + return + type = self.obj.analyse_as_type(env) + if type: + if type.is_extension_type or type.is_builtin_type or type.is_cpp_class: + entry = type.scope.lookup_here(self.attribute) + if entry and (entry.is_cmethod or type.is_cpp_class and entry.type.is_cfunction): + if type.is_builtin_type: + if not self.is_called: + # must handle this as Python object + return None + ubcm_entry = entry + else: + ubcm_entry = self._create_unbound_cmethod_entry(type, entry, env) + ubcm_entry.overloaded_alternatives = [ + self._create_unbound_cmethod_entry(type, overloaded_alternative, env) + for overloaded_alternative in entry.overloaded_alternatives + ] + return self.as_name_node(env, ubcm_entry, target=False) + elif type.is_enum or type.is_cpp_enum: + if self.attribute in type.values: + for entry in type.entry.enum_values: + if entry.name == self.attribute: + return self.as_name_node(env, entry, target=False) + else: + error(self.pos, "%s not a known value of %s" % (self.attribute, type)) + elif self.attribute.startswith('__') and self.attribute.endswith('__'): + # Special attribute, look up at runtime. + return None + else: + error(self.pos, "%s not a known value of %s" % (self.attribute, type)) + return None + + def _create_unbound_cmethod_entry(self, type, entry, env): + # Create a temporary entry describing the unbound C method in `entry` + # as an ordinary function. + if entry.func_cname and entry.type.op_arg_struct is None: + cname = entry.func_cname + if entry.type.is_static_method or ( + env.parent_scope and env.parent_scope.is_cpp_class_scope): + ctype = entry.type + elif type.is_cpp_class: + error(self.pos, "%s not a static member of %s" % (entry.name, type)) + ctype = PyrexTypes.error_type + else: + # Fix self type. + ctype = copy.copy(entry.type) + ctype.args = ctype.args[:] + ctype.args[0] = PyrexTypes.CFuncTypeArg('self', type, 'self', None) + else: + cname = "%s->%s" % (type.vtabptr_cname, entry.cname) + ctype = entry.type + ubcm_entry = Symtab.Entry(entry.name, cname, ctype) + ubcm_entry.is_cfunction = 1 + ubcm_entry.func_cname = entry.func_cname + ubcm_entry.is_unbound_cmethod = 1 + ubcm_entry.scope = entry.scope + return ubcm_entry + + def analyse_as_type(self, env): + module_scope = self.obj.analyse_as_module(env) + if module_scope: + return module_scope.lookup_type(self.attribute) + if not self.obj.is_string_literal: + base_type = self.obj.analyse_as_type(env) + if base_type and getattr(base_type, 'scope', None) is not None: + return base_type.scope.lookup_type(self.attribute) + return None + + def analyse_as_extension_type(self, env): + # Try to interpret this as a reference to an extension type + # in a cimported module. Returns the extension type, or None. + module_scope = self.obj.analyse_as_module(env) + if module_scope: + entry = module_scope.lookup_here(self.attribute) + if entry and entry.is_type: + if entry.type.is_extension_type or entry.type.is_builtin_type: + return entry.type + return None + + def analyse_as_module(self, env): + # Try to interpret this as a reference to a cimported module + # in another cimported module. Returns the module scope, or None. + module_scope = self.obj.analyse_as_module(env) + if module_scope: + entry = module_scope.lookup_here(self.attribute) + if entry and entry.as_module: + return entry.as_module + return None + + def as_name_node(self, env, entry, target): + # Create a corresponding NameNode from this node and complete the + # analyse_types phase. + node = NameNode.from_node(self, name=self.attribute, entry=entry) + if target: + node = node.analyse_target_types(env) + else: + node = node.analyse_rvalue_entry(env) + node.entry.used = 1 + return node + + def analyse_as_ordinary_attribute_node(self, env, target): + self.obj = self.obj.analyse_types(env) + self.analyse_attribute(env) + if self.entry and self.entry.is_cmethod and not self.is_called: +# error(self.pos, "C method can only be called") + pass + ## Reference to C array turns into pointer to first element. + #while self.type.is_array: + # self.type = self.type.element_ptr_type() + if self.is_py_attr: + if not target: + self.is_temp = 1 + self.result_ctype = py_object_type + elif target and self.obj.type.is_builtin_type: + error(self.pos, "Assignment to an immutable object field") + elif self.entry and self.entry.is_cproperty: + if not target: + return SimpleCallNode.for_cproperty(self.pos, self.obj, self.entry).analyse_types(env) + # TODO: implement writable C-properties? + error(self.pos, "Assignment to a read-only property") + #elif self.type.is_memoryviewslice and not target: + # self.is_temp = True + return self + + def analyse_attribute(self, env, obj_type = None): + # Look up attribute and set self.type and self.member. + immutable_obj = obj_type is not None # used during type inference + self.is_py_attr = 0 + self.member = self.attribute + if obj_type is None: + if self.obj.type.is_string or self.obj.type.is_pyunicode_ptr: + self.obj = self.obj.coerce_to_pyobject(env) + obj_type = self.obj.type + else: + if obj_type.is_string or obj_type.is_pyunicode_ptr: + obj_type = py_object_type + if obj_type.is_ptr or obj_type.is_array: + obj_type = obj_type.base_type + self.op = "->" + elif obj_type.is_extension_type or obj_type.is_builtin_type: + self.op = "->" + elif obj_type.is_reference and obj_type.is_fake_reference: + self.op = "->" + else: + self.op = "." + if obj_type.has_attributes: + if obj_type.attributes_known(): + entry = obj_type.scope.lookup_here(self.attribute) + if obj_type.is_memoryviewslice and not entry: + if self.attribute == 'T': + self.is_memslice_transpose = True + self.is_temp = True + self.use_managed_ref = True + self.type = self.obj.type.transpose(self.pos) + return + else: + obj_type.declare_attribute(self.attribute, env, self.pos) + entry = obj_type.scope.lookup_here(self.attribute) + if entry and entry.is_member: + entry = None + else: + error(self.pos, + "Cannot select attribute of incomplete type '%s'" + % obj_type) + self.type = PyrexTypes.error_type + return + self.entry = entry + if entry: + if obj_type.is_extension_type and entry.name == "__weakref__": + error(self.pos, "Illegal use of special attribute __weakref__") + + # def methods need the normal attribute lookup + # because they do not have struct entries + # fused function go through assignment synthesis + # (foo = pycfunction(foo_func_obj)) and need to go through + # regular Python lookup as well + if entry.is_cproperty: + self.type = entry.type + return + elif (entry.is_variable and not entry.fused_cfunction) or entry.is_cmethod: + self.type = entry.type + self.member = entry.cname + return + else: + # If it's not a variable or C method, it must be a Python + # method of an extension type, so we treat it like a Python + # attribute. + pass + # If we get here, the base object is not a struct/union/extension + # type, or it is an extension type and the attribute is either not + # declared or is declared as a Python method. Treat it as a Python + # attribute reference. + self.analyse_as_python_attribute(env, obj_type, immutable_obj) + + def analyse_as_python_attribute(self, env, obj_type=None, immutable_obj=False): + if obj_type is None: + obj_type = self.obj.type + # mangle private '__*' Python attributes used inside of a class + self.attribute = env.mangle_class_private_name(self.attribute) + self.member = self.attribute + self.type = py_object_type + self.is_py_attr = 1 + + if not obj_type.is_pyobject and not obj_type.is_error: + # Expose python methods for immutable objects. + if (obj_type.is_string or obj_type.is_cpp_string + or obj_type.is_buffer or obj_type.is_memoryviewslice + or obj_type.is_numeric + or (obj_type.is_ctuple and obj_type.can_coerce_to_pyobject(env)) + or (obj_type.is_struct and obj_type.can_coerce_to_pyobject(env))): + if not immutable_obj: + self.obj = self.obj.coerce_to_pyobject(env) + elif (obj_type.is_cfunction and (self.obj.is_name or self.obj.is_attribute) + and self.obj.entry.as_variable + and self.obj.entry.as_variable.type.is_pyobject): + # might be an optimised builtin function => unpack it + if not immutable_obj: + self.obj = self.obj.coerce_to_pyobject(env) + else: + error(self.pos, + "Object of type '%s' has no attribute '%s'" % + (obj_type, self.attribute)) + + def wrap_obj_in_nonecheck(self, env): + if not env.directives['nonecheck']: + return + + msg = None + format_args = () + if (self.obj.type.is_extension_type and self.needs_none_check and not + self.is_py_attr): + msg = "'NoneType' object has no attribute '%{}s'".format('.30' if len(self.attribute) <= 30 else '') + format_args = (self.attribute,) + elif self.obj.type.is_memoryviewslice: + if self.is_memslice_transpose: + msg = "Cannot transpose None memoryview slice" + else: + entry = self.obj.type.scope.lookup_here(self.attribute) + if entry: + # copy/is_c_contig/shape/strides etc + msg = "Cannot access '%s' attribute of None memoryview slice" + format_args = (entry.name,) + + if msg: + self.obj = self.obj.as_none_safe_node(msg, 'PyExc_AttributeError', + format_args=format_args) + + def nogil_check(self, env): + if self.is_py_attr: + self.gil_error() + + gil_message = "Accessing Python attribute" + + def is_cimported_module_without_shadow(self, env): + return self.obj.is_cimported_module_without_shadow(env) + + def is_simple(self): + if self.obj: + return self.result_in_temp() or self.obj.is_simple() + else: + return NameNode.is_simple(self) + + def is_lvalue(self): + if self.obj: + return True + else: + return NameNode.is_lvalue(self) + + def is_ephemeral(self): + if self.obj: + return self.obj.is_ephemeral() + else: + return NameNode.is_ephemeral(self) + + def calculate_result_code(self): + result = self.calculate_access_code() + if self.entry and self.entry.is_cpp_optional and not self.is_target: + result = "(*%s)" % result + return result + + def calculate_access_code(self): + # Does the job of calculate_result_code but doesn't dereference cpp_optionals + # Therefore allowing access to the holder variable + obj = self.obj + obj_code = obj.result_as(obj.type) + #print "...obj_code =", obj_code ### + if self.entry and self.entry.is_cmethod: + if obj.type.is_extension_type and not self.entry.is_builtin_cmethod: + if self.entry.final_func_cname: + return self.entry.final_func_cname + + if self.type.from_fused: + # If the attribute was specialized through indexing, make + # sure to get the right fused name, as our entry was + # replaced by our parent index node + # (AnalyseExpressionsTransform) + self.member = self.entry.cname + + return "((struct %s *)%s%s%s)->%s" % ( + obj.type.vtabstruct_cname, obj_code, self.op, + obj.type.vtabslot_cname, self.member) + elif self.result_is_used: + return self.member + # Generating no code at all for unused access to optimised builtin + # methods fixes the problem that some optimisations only exist as + # macros, i.e. there is no function pointer to them, so we would + # generate invalid C code here. + return + elif obj.type.is_complex: + return "__Pyx_C%s(%s)" % (self.member.upper(), obj_code) + else: + if obj.type.is_builtin_type and self.entry and self.entry.is_variable: + # accessing a field of a builtin type, need to cast better than result_as() does + obj_code = obj.type.cast_code(obj.result(), to_object_struct = True) + return "%s%s%s" % (obj_code, self.op, self.member) + + def generate_result_code(self, code): + if self.is_py_attr: + if self.is_special_lookup: + code.globalstate.use_utility_code( + UtilityCode.load_cached("PyObjectLookupSpecial", "ObjectHandling.c")) + lookup_func_name = '__Pyx_PyObject_LookupSpecial' + else: + code.globalstate.use_utility_code( + UtilityCode.load_cached("PyObjectGetAttrStr", "ObjectHandling.c")) + lookup_func_name = '__Pyx_PyObject_GetAttrStr' + code.putln( + '%s = %s(%s, %s); %s' % ( + self.result(), + lookup_func_name, + self.obj.py_result(), + code.intern_identifier(self.attribute), + code.error_goto_if_null(self.result(), self.pos))) + self.generate_gotref(code) + elif self.type.is_memoryviewslice: + if self.is_memslice_transpose: + # transpose the slice + for access, packing in self.type.axes: + if access == 'ptr': + error(self.pos, "Transposing not supported for slices " + "with indirect dimensions") + return + + code.putln("%s = %s;" % (self.result(), self.obj.result())) + code.put_incref_memoryviewslice(self.result(), self.type, + have_gil=True) + + T = "__pyx_memslice_transpose(&%s)" % self.result() + code.putln(code.error_goto_if_neg(T, self.pos)) + elif self.initialized_check: + code.putln( + 'if (unlikely(!%s.memview)) {' + 'PyErr_SetString(PyExc_AttributeError,' + '"Memoryview is not initialized");' + '%s' + '}' % (self.result(), code.error_goto(self.pos))) + elif self.entry.is_cpp_optional and self.initialized_check: + if self.is_target: + undereferenced_result = self.result() + else: + assert not self.is_temp # calculate_access_code() only makes sense for non-temps + undereferenced_result = self.calculate_access_code() + unbound_check_code = self.type.cpp_optional_check_for_null_code(undereferenced_result) + code.put_error_if_unbound(self.pos, self.entry, self.in_nogil_context, unbound_check_code=unbound_check_code) + else: + # result_code contains what is needed, but we may need to insert + # a check and raise an exception + if self.obj.type and self.obj.type.is_extension_type: + pass + elif self.entry and self.entry.is_cmethod: + # C method implemented as function call with utility code + code.globalstate.use_entry_utility_code(self.entry) + + def generate_disposal_code(self, code): + if self.is_temp and self.type.is_memoryviewslice and self.is_memslice_transpose: + # mirror condition for putting the memview incref here: + code.put_xdecref_clear(self.result(), self.type, have_gil=True) + else: + ExprNode.generate_disposal_code(self, code) + + def generate_assignment_code(self, rhs, code, overloaded_assignment=False, + exception_check=None, exception_value=None): + self.obj.generate_evaluation_code(code) + if self.is_py_attr: + code.globalstate.use_utility_code( + UtilityCode.load_cached("PyObjectSetAttrStr", "ObjectHandling.c")) + code.put_error_if_neg(self.pos, + '__Pyx_PyObject_SetAttrStr(%s, %s, %s)' % ( + self.obj.py_result(), + code.intern_identifier(self.attribute), + rhs.py_result())) + rhs.generate_disposal_code(code) + rhs.free_temps(code) + elif self.obj.type.is_complex: + code.putln("__Pyx_SET_C%s%s(%s, %s);" % ( + self.member.upper(), + self.obj.type.implementation_suffix, + self.obj.result_as(self.obj.type), + rhs.result_as(self.ctype()))) + rhs.generate_disposal_code(code) + rhs.free_temps(code) + else: + select_code = self.result() + if self.type.is_pyobject and self.use_managed_ref: + rhs.make_owned_reference(code) + rhs.generate_giveref(code) + code.put_gotref(select_code, self.type) + code.put_decref(select_code, self.ctype()) + elif self.type.is_memoryviewslice: + from . import MemoryView + MemoryView.put_assign_to_memviewslice( + select_code, rhs, rhs.result(), self.type, code) + + if not self.type.is_memoryviewslice: + code.putln( + "%s = %s;" % ( + select_code, + rhs.move_result_rhs_as(self.ctype()))) + #rhs.result())) + rhs.generate_post_assignment_code(code) + rhs.free_temps(code) + self.obj.generate_disposal_code(code) + self.obj.free_temps(code) + + def generate_deletion_code(self, code, ignore_nonexisting=False): + self.obj.generate_evaluation_code(code) + if self.is_py_attr or (self.entry.scope.is_property_scope + and '__del__' in self.entry.scope.entries): + code.globalstate.use_utility_code( + UtilityCode.load_cached("PyObjectSetAttrStr", "ObjectHandling.c")) + code.put_error_if_neg(self.pos, + '__Pyx_PyObject_DelAttrStr(%s, %s)' % ( + self.obj.py_result(), + code.intern_identifier(self.attribute))) + else: + error(self.pos, "Cannot delete C attribute of extension type") + self.obj.generate_disposal_code(code) + self.obj.free_temps(code) + + def annotate(self, code): + if self.is_py_attr: + style, text = 'py_attr', 'python attribute (%s)' + else: + style, text = 'c_attr', 'c attribute (%s)' + code.annotate(self.pos, AnnotationItem(style, text % self.type, size=len(self.attribute))) + + def get_known_standard_library_import(self): + module_name = self.obj.get_known_standard_library_import() + if module_name: + return StringEncoding.EncodedString("%s.%s" % (module_name, self.attribute)) + return None + + +#------------------------------------------------------------------- +# +# Constructor nodes +# +#------------------------------------------------------------------- + +class StarredUnpackingNode(ExprNode): + # A starred expression like "*a" + # + # This is only allowed in sequence assignment or construction such as + # + # a, *b = (1,2,3,4) => a = 1 ; b = [2,3,4] + # + # and will be special cased during type analysis (or generate an error + # if it's found at unexpected places). + # + # target ExprNode + + subexprs = ['target'] + is_starred = 1 + type = py_object_type + is_temp = 1 + starred_expr_allowed_here = False + + def __init__(self, pos, target): + ExprNode.__init__(self, pos, target=target) + + def analyse_declarations(self, env): + if not self.starred_expr_allowed_here: + error(self.pos, "starred expression is not allowed here") + self.target.analyse_declarations(env) + + def infer_type(self, env): + return self.target.infer_type(env) + + def analyse_types(self, env): + if not self.starred_expr_allowed_here: + error(self.pos, "starred expression is not allowed here") + self.target = self.target.analyse_types(env) + self.type = self.target.type + return self + + def analyse_target_declaration(self, env): + self.target.analyse_target_declaration(env) + + def analyse_target_types(self, env): + self.target = self.target.analyse_target_types(env) + self.type = self.target.type + return self + + def calculate_result_code(self): + return "" + + def generate_result_code(self, code): + pass + + +class SequenceNode(ExprNode): + # Base class for list and tuple constructor nodes. + # Contains common code for performing sequence unpacking. + # + # args [ExprNode] + # unpacked_items [ExprNode] or None + # coerced_unpacked_items [ExprNode] or None + # mult_factor ExprNode the integer number of content repetitions ([1,2]*3) + + subexprs = ['args', 'mult_factor'] + + is_sequence_constructor = 1 + unpacked_items = None + mult_factor = None + slow = False # trade speed for code size (e.g. use PyTuple_Pack()) + needs_subexpr_disposal = False # set to True in code-generation if we + # didn't steal references to our temps and thus need to dispose + # of them normally. + + + def compile_time_value_list(self, denv): + return [arg.compile_time_value(denv) for arg in self.args] + + def replace_starred_target_node(self): + # replace a starred node in the targets by the contained expression + self.starred_assignment = False + args = [] + for arg in self.args: + if arg.is_starred: + if self.starred_assignment: + error(arg.pos, "more than 1 starred expression in assignment") + self.starred_assignment = True + arg = arg.target + arg.is_starred = True + args.append(arg) + self.args = args + + def analyse_target_declaration(self, env): + self.replace_starred_target_node() + for arg in self.args: + arg.analyse_target_declaration(env) + + def analyse_types(self, env, skip_children=False): + for i, arg in enumerate(self.args): + if not skip_children: + arg = arg.analyse_types(env) + self.args[i] = arg.coerce_to_pyobject(env) + if self.mult_factor: + mult_factor = self.mult_factor.analyse_types(env) + if not mult_factor.type.is_int: + mult_factor = mult_factor.coerce_to_pyobject(env) + self.mult_factor = mult_factor.coerce_to_simple(env) + self.is_temp = 1 + if (env.is_module_scope or env.is_c_class_scope or + (env.is_py_class_scope and env.outer_scope.is_module_scope)): + # TODO - potentially behave differently in loops? + self.slow = True + # not setting self.type here, subtypes do this + return self + + def coerce_to_ctuple(self, dst_type, env): + # ctuples are passed by value and must always be assignable, never const. + dst_type = PyrexTypes.remove_cv_ref(dst_type, remove_fakeref=True) + if self.type == dst_type: + return self + + assert not self.mult_factor + if len(self.args) != dst_type.size: + error(self.pos, "trying to coerce sequence to ctuple of wrong length, expected %d, got %d" % ( + dst_type.size, len(self.args))) + coerced_args = [arg.coerce_to(type, env) for arg, type in zip(self.args, dst_type.components)] + return TupleNode(self.pos, args=coerced_args, type=dst_type, is_temp=True) + + def _create_merge_node_if_necessary(self, env): + self._flatten_starred_args() + if not any(arg.is_starred for arg in self.args): + return self + # convert into MergedSequenceNode by building partial sequences + args = [] + values = [] + for arg in self.args: + if arg.is_starred: + if values: + args.append(TupleNode(values[0].pos, args=values).analyse_types(env, skip_children=True)) + values = [] + args.append(arg.target) + else: + values.append(arg) + if values: + args.append(TupleNode(values[0].pos, args=values).analyse_types(env, skip_children=True)) + node = MergedSequenceNode(self.pos, args, self.type) + if self.mult_factor: + node = binop_node( + self.pos, '*', node, self.mult_factor.coerce_to_pyobject(env), + inplace=True, type=self.type, is_temp=True) + return node + + def _flatten_starred_args(self): + args = [] + for arg in self.args: + if arg.is_starred and arg.target.is_sequence_constructor and not arg.target.mult_factor: + args.extend(arg.target.args) + else: + args.append(arg) + self.args[:] = args + + def may_be_none(self): + return False + + def analyse_target_types(self, env): + if self.mult_factor: + error(self.pos, "can't assign to multiplied sequence") + self.unpacked_items = [] + self.coerced_unpacked_items = [] + self.any_coerced_items = False + for i, arg in enumerate(self.args): + arg = self.args[i] = arg.analyse_target_types(env) + if arg.is_starred: + if not arg.type.assignable_from(list_type): + error(arg.pos, + "starred target must have Python object (list) type") + if arg.type is py_object_type: + arg.type = list_type + unpacked_item = PyTempNode(self.pos, env) + coerced_unpacked_item = unpacked_item.coerce_to(arg.type, env) + if unpacked_item is not coerced_unpacked_item: + self.any_coerced_items = True + self.unpacked_items.append(unpacked_item) + self.coerced_unpacked_items.append(coerced_unpacked_item) + self.type = py_object_type + return self + + def generate_result_code(self, code): + self.generate_operation_code(code) + + def generate_sequence_packing_code(self, code, target=None, plain=False): + if target is None: + target = self.result() + size_factor = c_mult = '' + mult_factor = None + + if self.mult_factor and not plain: + mult_factor = self.mult_factor + if mult_factor.type.is_int: + c_mult = mult_factor.result() + if (isinstance(mult_factor.constant_result, int) and + mult_factor.constant_result > 0): + size_factor = ' * %s' % mult_factor.constant_result + elif mult_factor.type.signed: + size_factor = ' * ((%s<0) ? 0:%s)' % (c_mult, c_mult) + else: + size_factor = ' * (%s)' % (c_mult,) + + if ((self.type is tuple_type or self.type is list_type) and + (self.is_literal or self.slow) and + not c_mult and + len(self.args) > 0): + # use PyTuple_Pack() to avoid generating huge amounts of one-time code + if self.type is list_type: + pack_name = '__Pyx_PyList_Pack' + code.globalstate.use_utility_code( + UtilityCode.load_cached('ListPack', 'ObjectHandling.c') + ) + else: + pack_name = 'PyTuple_Pack' + code.putln('%s = %s(%d, %s); %s' % ( + target, + pack_name, + len(self.args), + ', '.join(arg.py_result() for arg in self.args), + code.error_goto_if_null(target, self.pos))) + code.put_gotref(target, py_object_type) + self.needs_subexpr_disposal = True + elif self.type.is_ctuple: + for i, arg in enumerate(self.args): + code.putln("%s.f%s = %s;" % ( + target, i, arg.result())) + else: + # build the tuple/list step by step, potentially multiplying it as we go + if self.type is list_type: + create_func, set_item_func = 'PyList_New', '__Pyx_PyList_SET_ITEM' + elif self.type is tuple_type: + create_func, set_item_func = 'PyTuple_New', '__Pyx_PyTuple_SET_ITEM' + else: + raise InternalError("sequence packing for unexpected type %s" % self.type) + arg_count = len(self.args) + code.putln("%s = %s(%s%s); %s" % ( + target, create_func, arg_count, size_factor, + code.error_goto_if_null(target, self.pos))) + code.put_gotref(target, py_object_type) + + if c_mult: + # FIXME: can't use a temp variable here as the code may + # end up in the constant building function. Temps + # currently don't work there. + + #counter = code.funcstate.allocate_temp(mult_factor.type, manage_ref=False) + counter = Naming.quick_temp_cname + code.putln('{ Py_ssize_t %s;' % counter) + if arg_count == 1: + offset = counter + else: + offset = '%s * %s' % (counter, arg_count) + code.putln('for (%s=0; %s < %s; %s++) {' % ( + counter, counter, c_mult, counter + )) + self.needs_subexpr_disposal = True + else: + offset = '' + + for i in range(arg_count): + arg = self.args[i] + if c_mult or not arg.result_in_temp(): + code.put_incref(arg.result(), arg.ctype()) + arg.generate_giveref(code) + code.putln("if (%s(%s, %s, %s) != (0)) %s;" % ( + set_item_func, + target, + (offset and i) and ('%s + %s' % (offset, i)) or (offset or i), + arg.py_result(), + code.error_goto(self.pos))) + + if c_mult: + code.putln('}') + #code.funcstate.release_temp(counter) + code.putln('}') + + if mult_factor is not None and mult_factor.type.is_pyobject: + code.putln('{ PyObject* %s = PyNumber_InPlaceMultiply(%s, %s); %s' % ( + Naming.quick_temp_cname, target, mult_factor.py_result(), + code.error_goto_if_null(Naming.quick_temp_cname, self.pos) + )) + code.put_gotref(Naming.quick_temp_cname, py_object_type) + code.put_decref(target, py_object_type) + code.putln('%s = %s;' % (target, Naming.quick_temp_cname)) + code.putln('}') + + def generate_subexpr_disposal_code(self, code): + if self.needs_subexpr_disposal: + super().generate_subexpr_disposal_code(code) + else: + # We call generate_post_assignment_code here instead + # of generate_disposal_code, because values were stored + # in the tuple using a reference-stealing operation. + for arg in self.args: + arg.generate_post_assignment_code(code) + # Should NOT call free_temps -- this is invoked by the default + # generate_evaluation_code which will do that. + if self.mult_factor: + self.mult_factor.generate_disposal_code(code) + + def generate_assignment_code(self, rhs, code, overloaded_assignment=False, + exception_check=None, exception_value=None): + if self.starred_assignment: + self.generate_starred_assignment_code(rhs, code) + else: + self.generate_parallel_assignment_code(rhs, code) + + for item in self.unpacked_items: + item.release(code) + rhs.free_temps(code) + + _func_iternext_type = PyrexTypes.CPtrType(PyrexTypes.CFuncType( + PyrexTypes.py_object_type, [ + PyrexTypes.CFuncTypeArg("it", PyrexTypes.py_object_type, None), + ])) + + def generate_parallel_assignment_code(self, rhs, code): + # Need to work around the fact that generate_evaluation_code + # allocates the temps in a rather hacky way -- the assignment + # is evaluated twice, within each if-block. + for item in self.unpacked_items: + item.allocate(code) + special_unpack = (rhs.type is py_object_type + or rhs.type in (tuple_type, list_type) + or not rhs.type.is_builtin_type) + long_enough_for_a_loop = len(self.unpacked_items) > 3 + + if special_unpack: + self.generate_special_parallel_unpacking_code( + code, rhs, use_loop=long_enough_for_a_loop) + else: + code.putln("{") + self.generate_generic_parallel_unpacking_code( + code, rhs, self.unpacked_items, use_loop=long_enough_for_a_loop) + code.putln("}") + + for value_node in self.coerced_unpacked_items: + value_node.generate_evaluation_code(code) + for i in range(len(self.args)): + self.args[i].generate_assignment_code( + self.coerced_unpacked_items[i], code) + + def generate_special_parallel_unpacking_code(self, code, rhs, use_loop): + sequence_type_test = '1' + none_check = "likely(%s != Py_None)" % rhs.py_result() + if rhs.type is list_type: + sequence_types = ['List'] + get_size_func = "__Pyx_PyList_GET_SIZE" + if rhs.may_be_none(): + sequence_type_test = none_check + elif rhs.type is tuple_type: + sequence_types = ['Tuple'] + get_size_func = "__Pyx_PyTuple_GET_SIZE" + if rhs.may_be_none(): + sequence_type_test = none_check + else: + sequence_types = ['Tuple', 'List'] + get_size_func = "__Pyx_PySequence_SIZE" + tuple_check = 'likely(PyTuple_CheckExact(%s))' % rhs.py_result() + list_check = 'PyList_CheckExact(%s)' % rhs.py_result() + sequence_type_test = "(%s) || (%s)" % (tuple_check, list_check) + + code.putln("if (%s) {" % sequence_type_test) + code.putln("PyObject* sequence = %s;" % rhs.py_result()) + + # list/tuple => check size + code.putln("Py_ssize_t size = %s(sequence);" % get_size_func) + code.putln("if (unlikely(size != %d)) {" % len(self.args)) + code.globalstate.use_utility_code( + UtilityCode.load_cached("RaiseTooManyValuesToUnpack", "ObjectHandling.c")) + code.putln("if (size > %d) __Pyx_RaiseTooManyValuesError(%d);" % ( + len(self.args), len(self.args))) + code.globalstate.use_utility_code( + UtilityCode.load_cached("RaiseNeedMoreValuesToUnpack", "ObjectHandling.c")) + code.putln("else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);") + # < 0 => exception + code.putln(code.error_goto(self.pos)) + code.putln("}") + + code.putln("#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS") + # unpack items from list/tuple in unrolled loop (can't fail) + if len(sequence_types) == 2: + code.putln("if (likely(Py%s_CheckExact(sequence))) {" % sequence_types[0]) + for i, item in enumerate(self.unpacked_items): + if sequence_types[0] == "List": + code.putln(f"{item.result()} = __Pyx_PyList_GetItemRef(sequence, {i});") + code.putln(code.error_goto_if_null(item.result(), self.pos)) + code.put_xgotref(item.result(), item.ctype()) + else: # Tuple + code.putln(f"{item.result()} = PyTuple_GET_ITEM(sequence, {i});") + code.put_incref(item.result(), item.ctype()) + if len(sequence_types) == 2: + code.putln("} else {") + for i, item in enumerate(self.unpacked_items): + if sequence_types[1] == "List": + code.putln(f"{item.result()} = __Pyx_PyList_GetItemRef(sequence, {i});") + code.putln(code.error_goto_if_null(item.result(), self.pos)) + code.put_xgotref(item.result(), item.ctype()) + else: # Tuple + code.putln(f"{item.result()} = PyTuple_GET_ITEM(sequence, {i});") + code.put_incref(item.result(), item.ctype()) + code.putln("}") + + code.putln("#else") + # in non-CPython, use the PySequence protocol (which can fail) + if not use_loop: + for i, item in enumerate(self.unpacked_items): + code.putln("%s = __Pyx_PySequence_ITEM(sequence, %d); %s" % ( + item.result(), i, + code.error_goto_if_null(item.result(), self.pos))) + code.put_gotref(item.result(), item.type) + else: + code.putln("{") + code.putln("Py_ssize_t i;") + code.putln("PyObject** temps[%s] = {%s};" % ( + len(self.unpacked_items), + ','.join(['&%s' % item.result() for item in self.unpacked_items]))) + code.putln("for (i=0; i < %s; i++) {" % len(self.unpacked_items)) + code.putln("PyObject* item = __Pyx_PySequence_ITEM(sequence, i); %s" % ( + code.error_goto_if_null('item', self.pos))) + code.put_gotref('item', py_object_type) + code.putln("*(temps[i]) = item;") + code.putln("}") + code.putln("}") + + code.putln("#endif") + rhs.generate_disposal_code(code) + + if sequence_type_test == '1': + code.putln("}") # all done + elif sequence_type_test == none_check: + # either tuple/list or None => save some code by generating the error directly + code.putln("} else {") + code.globalstate.use_utility_code( + UtilityCode.load_cached("RaiseNoneIterError", "ObjectHandling.c")) + code.putln("__Pyx_RaiseNoneNotIterableError(); %s" % code.error_goto(self.pos)) + code.putln("}") # all done + else: + code.putln("} else {") # needs iteration fallback code + self.generate_generic_parallel_unpacking_code( + code, rhs, self.unpacked_items, use_loop=use_loop) + code.putln("}") + + def generate_generic_parallel_unpacking_code(self, code, rhs, unpacked_items, use_loop, terminate=True): + code.globalstate.use_utility_code( + UtilityCode.load_cached("RaiseNeedMoreValuesToUnpack", "ObjectHandling.c")) + code.globalstate.use_utility_code( + UtilityCode.load_cached("IterFinish", "ObjectHandling.c")) + code.putln("Py_ssize_t index = -1;") # must be at the start of a C block! + + if use_loop: + code.putln("PyObject** temps[%s] = {%s};" % ( + len(self.unpacked_items), + ','.join(['&%s' % item.result() for item in unpacked_items]))) + + iterator_temp = code.funcstate.allocate_temp(py_object_type, manage_ref=True) + code.putln( + "%s = PyObject_GetIter(%s); %s" % ( + iterator_temp, + rhs.py_result(), + code.error_goto_if_null(iterator_temp, self.pos))) + code.put_gotref(iterator_temp, py_object_type) + rhs.generate_disposal_code(code) + + iternext_func = code.funcstate.allocate_temp(self._func_iternext_type, manage_ref=False) + code.putln( + f"{iternext_func} = (CYTHON_COMPILING_IN_LIMITED_API) ? " + f"PyIter_Next : __Pyx_PyObject_GetIterNextFunc({iterator_temp});" + ) + + unpacking_error_label = code.new_label('unpacking_failed') + unpack_code = "%s(%s)" % (iternext_func, iterator_temp) + if use_loop: + code.putln("for (index=0; index < %s; index++) {" % len(unpacked_items)) + code.put("PyObject* item = %s; if (unlikely(!item)) " % unpack_code) + code.put_goto(unpacking_error_label) + code.put_gotref("item", py_object_type) + code.putln("*(temps[index]) = item;") + code.putln("}") + else: + for i, item in enumerate(unpacked_items): + code.put( + "index = %d; %s = %s; if (unlikely(!%s)) " % ( + i, + item.result(), + unpack_code, + item.result())) + code.put_goto(unpacking_error_label) + item.generate_gotref(code) + + if terminate: + code.globalstate.use_utility_code( + UtilityCode.load_cached("UnpackItemEndCheck", "ObjectHandling.c")) + code.put_error_if_neg(self.pos, "__Pyx_IternextUnpackEndCheck(%s, %d)" % ( + unpack_code, + len(unpacked_items))) + code.putln("%s = NULL;" % iternext_func) + code.put_decref_clear(iterator_temp, py_object_type) + + unpacking_done_label = code.new_label('unpacking_done') + code.put_goto(unpacking_done_label) + + code.put_label(unpacking_error_label) + code.put_decref_clear(iterator_temp, py_object_type) + code.putln("%s = NULL;" % iternext_func) + code.putln("if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);") + code.putln(code.error_goto(self.pos)) + code.put_label(unpacking_done_label) + + code.funcstate.release_temp(iternext_func) + if terminate: + code.funcstate.release_temp(iterator_temp) + iterator_temp = None + + return iterator_temp + + def generate_starred_assignment_code(self, rhs, code): + for i, arg in enumerate(self.args): + if arg.is_starred: + starred_target = self.unpacked_items[i] + unpacked_fixed_items_left = self.unpacked_items[:i] + unpacked_fixed_items_right = self.unpacked_items[i+1:] + break + else: + assert False + + iterator_temp = None + if unpacked_fixed_items_left: + for item in unpacked_fixed_items_left: + item.allocate(code) + code.putln('{') + iterator_temp = self.generate_generic_parallel_unpacking_code( + code, rhs, unpacked_fixed_items_left, + use_loop=True, terminate=False) + for i, item in enumerate(unpacked_fixed_items_left): + value_node = self.coerced_unpacked_items[i] + value_node.generate_evaluation_code(code) + code.putln('}') + + starred_target.allocate(code) + target_list = starred_target.result() + code.putln("%s = %s(%s); %s" % ( + target_list, + "__Pyx_PySequence_ListKeepNew" if ( + not iterator_temp and rhs.result_in_temp() and rhs.type in (py_object_type, list_type)) + else "PySequence_List", + iterator_temp or rhs.py_result(), + code.error_goto_if_null(target_list, self.pos))) + starred_target.generate_gotref(code) + + if iterator_temp: + code.put_decref_clear(iterator_temp, py_object_type) + code.funcstate.release_temp(iterator_temp) + else: + rhs.generate_disposal_code(code) + + if unpacked_fixed_items_right: + code.globalstate.use_utility_code( + UtilityCode.load_cached("RaiseNeedMoreValuesToUnpack", "ObjectHandling.c")) + length_temp = code.funcstate.allocate_temp(PyrexTypes.c_py_ssize_t_type, manage_ref=False) + code.putln('%s = __Pyx_PyList_GET_SIZE(%s);' % (length_temp, target_list)) + code.putln("if (unlikely(%s < %d)) {" % (length_temp, len(unpacked_fixed_items_right))) + code.putln("__Pyx_RaiseNeedMoreValuesError(%d+%s); %s" % ( + len(unpacked_fixed_items_left), length_temp, + code.error_goto(self.pos))) + code.putln('}') + + for item in unpacked_fixed_items_right[::-1]: + item.allocate(code) + for i, (item, coerced_arg) in enumerate(zip(unpacked_fixed_items_right[::-1], + self.coerced_unpacked_items[::-1])): + code.putln('#if CYTHON_COMPILING_IN_CPYTHON') + code.putln("%s = PyList_GET_ITEM(%s, %s-%d); " % ( + item.py_result(), target_list, length_temp, i+1)) + # resize the list the hard way + code.putln("((PyVarObject*)%s)->ob_size--;" % target_list) + code.putln('#else') + code.putln("%s = __Pyx_PySequence_ITEM(%s, %s-%d); " % ( + item.py_result(), target_list, length_temp, i+1)) + code.putln('#endif') + item.generate_gotref(code) + coerced_arg.generate_evaluation_code(code) + + code.putln('#if !CYTHON_COMPILING_IN_CPYTHON') + sublist_temp = code.funcstate.allocate_temp(py_object_type, manage_ref=True) + code.putln('%s = PySequence_GetSlice(%s, 0, %s-%d); %s' % ( + sublist_temp, target_list, length_temp, len(unpacked_fixed_items_right), + code.error_goto_if_null(sublist_temp, self.pos))) + code.put_gotref(sublist_temp, py_object_type) + code.funcstate.release_temp(length_temp) + code.put_decref(target_list, py_object_type) + code.putln('%s = %s; %s = NULL;' % (target_list, sublist_temp, sublist_temp)) + code.putln('#else') + code.putln('CYTHON_UNUSED_VAR(%s);' % sublist_temp) + code.funcstate.release_temp(sublist_temp) + code.putln('#endif') + + for i, arg in enumerate(self.args): + arg.generate_assignment_code(self.coerced_unpacked_items[i], code) + + def annotate(self, code): + for arg in self.args: + arg.annotate(code) + if self.unpacked_items: + for arg in self.unpacked_items: + arg.annotate(code) + for arg in self.coerced_unpacked_items: + arg.annotate(code) + + +class TupleNode(SequenceNode): + # Tuple constructor. + + type = tuple_type + is_partly_literal = False + + gil_message = "Constructing Python tuple" + + def infer_type(self, env): + if self.mult_factor or not self.args: + return tuple_type + arg_types = [arg.infer_type(env) for arg in self.args] + if any(type.is_pyobject or type.is_memoryviewslice or type.is_unspecified or type.is_fused + for type in arg_types): + return tuple_type + return env.declare_tuple_type(self.pos, arg_types).type + + def analyse_types(self, env, skip_children=False): + # reset before re-analysing + if self.is_literal: + self.is_literal = False + if self.is_partly_literal: + self.is_partly_literal = False + + if len(self.args) == 0: + self.is_temp = False + self.is_literal = True + return self + + if not skip_children: + for i, arg in enumerate(self.args): + if arg.is_starred: + arg.starred_expr_allowed_here = True + self.args[i] = arg.analyse_types(env) + if (not self.mult_factor and + not any((arg.is_starred or arg.type.is_pyobject or arg.type.is_memoryviewslice or arg.type.is_fused) + for arg in self.args)): + self.type = env.declare_tuple_type(self.pos, (arg.type for arg in self.args)).type + self.is_temp = 1 + return self + + node = SequenceNode.analyse_types(self, env, skip_children=True) + node = node._create_merge_node_if_necessary(env) + if not node.is_sequence_constructor: + return node + + if not all(child.is_literal for child in node.args): + return node + if not node.mult_factor or ( + node.mult_factor.is_literal and + isinstance(node.mult_factor.constant_result, int)): + node.is_temp = False + node.is_literal = True + else: + if not node.mult_factor.type.is_pyobject and not node.mult_factor.type.is_int: + node.mult_factor = node.mult_factor.coerce_to_pyobject(env) + node.is_temp = True + node.is_partly_literal = True + return node + + def analyse_as_type(self, env): + # ctuple type + if not self.args: + return None + item_types = [arg.analyse_as_type(env) for arg in self.args] + if any(t is None for t in item_types): + return None + entry = env.declare_tuple_type(self.pos, item_types) + return entry.type + + def coerce_to(self, dst_type, env): + if self.type.is_ctuple: + if dst_type.is_ctuple and self.type.size == dst_type.size: + return self.coerce_to_ctuple(dst_type, env) + elif dst_type is tuple_type or dst_type is py_object_type: + coerced_args = [arg.coerce_to_pyobject(env) for arg in self.args] + return TupleNode( + self.pos, + args=coerced_args, + type=tuple_type, + mult_factor=self.mult_factor, + is_temp=1, + ).analyse_types(env, skip_children=True) + else: + return self.coerce_to_pyobject(env).coerce_to(dst_type, env) + elif dst_type.is_ctuple and not self.mult_factor: + return self.coerce_to_ctuple(dst_type, env) + else: + return SequenceNode.coerce_to(self, dst_type, env) + + def as_list(self): + t = ListNode(self.pos, args=self.args, mult_factor=self.mult_factor) + if isinstance(self.constant_result, tuple): + t.constant_result = list(self.constant_result) + return t + + def is_simple(self): + # either temp or constant => always simple + return True + + def nonlocally_immutable(self): + # either temp or constant => always safe + return True + + def calculate_result_code(self): + return self.result_code + + def calculate_constant_result(self): + self.constant_result = tuple([ + arg.constant_result for arg in self.args]) + + def compile_time_value(self, denv): + values = self.compile_time_value_list(denv) + try: + return tuple(values) + except Exception as e: + self.compile_time_value_error(e) + + def generate_operation_code(self, code): + if len(self.args) == 0: + self.result_code = code.name_in_module_state(Naming.empty_tuple) + return + + if self.is_literal or self.is_partly_literal: + # The "mult_factor" is part of the deduplication if it is also constant, i.e. when + # we deduplicate the multiplied result. Otherwise, only deduplicate the constant part. + dedup_key = make_dedup_key(self.type, [self.mult_factor if self.is_literal else None] + self.args) + tuple_target = code.get_py_const('tuple', dedup_key=dedup_key) + const_code = code.get_cached_constants_writer(tuple_target) + if const_code is not None: + # constant is not yet initialised + const_code.mark_pos(self.pos) + self.generate_sequence_packing_code(const_code, tuple_target, plain=not self.is_literal) + const_code.put_giveref(tuple_target, py_object_type) + if self.is_literal: + self.result_code = tuple_target + elif self.mult_factor.type.is_int: + code.globalstate.use_utility_code( + UtilityCode.load_cached("PySequenceMultiply", "ObjectHandling.c")) + code.putln('%s = __Pyx_PySequence_Multiply(%s, %s); %s' % ( + self.result(), tuple_target, self.mult_factor.result(), + code.error_goto_if_null(self.result(), self.pos) + )) + self.generate_gotref(code) + else: + code.putln('%s = PyNumber_Multiply(%s, %s); %s' % ( + self.result(), tuple_target, self.mult_factor.py_result(), + code.error_goto_if_null(self.result(), self.pos) + )) + self.generate_gotref(code) + else: + self.type.entry.used = True + self.generate_sequence_packing_code(code) + + +class ListNode(SequenceNode): + # List constructor. + + # obj_conversion_errors [PyrexError] used internally + # orignial_args [ExprNode] used internally + + obj_conversion_errors = [] + type = list_type + in_module_scope = False + + gil_message = "Constructing Python list" + + def type_dependencies(self, env): + return () + + def infer_type(self, env): + # TODO: Infer non-object list arrays. + return list_type + + def analyse_expressions(self, env): + for arg in self.args: + if arg.is_starred: + arg.starred_expr_allowed_here = True + node = SequenceNode.analyse_expressions(self, env) + return node.coerce_to_pyobject(env) + + def analyse_types(self, env): + with local_errors(ignore=True) as errors: + self.original_args = list(self.args) + node = SequenceNode.analyse_types(self, env) + node.obj_conversion_errors = errors + if env.is_module_scope: + self.in_module_scope = True + node = node._create_merge_node_if_necessary(env) + return node + + def coerce_to(self, dst_type, env): + if dst_type.is_pyobject: + for err in self.obj_conversion_errors: + report_error(err) + self.obj_conversion_errors = [] + if not self.type.subtype_of(dst_type): + error(self.pos, "Cannot coerce list to type '%s'" % dst_type) + elif (dst_type.is_array or dst_type.is_ptr) and dst_type.base_type is not PyrexTypes.c_void_type: + array_length = len(self.args) + if self.mult_factor: + if isinstance(self.mult_factor.constant_result, int): + if self.mult_factor.constant_result <= 0: + error(self.pos, "Cannot coerce non-positively multiplied list to '%s'" % dst_type) + else: + array_length *= self.mult_factor.constant_result + else: + error(self.pos, "Cannot coerce dynamically multiplied list to '%s'" % dst_type) + base_type = dst_type.base_type + self.type = PyrexTypes.CArrayType(base_type, array_length) + for i in range(len(self.original_args)): + arg = self.args[i] + if isinstance(arg, CoerceToPyTypeNode): + arg = arg.arg + self.args[i] = arg.coerce_to(base_type, env) + elif dst_type.is_cpp_class: + # TODO(robertwb): Avoid object conversion for vector/list/set. + return TypecastNode(self.pos, operand=self, type=PyrexTypes.py_object_type).coerce_to(dst_type, env) + elif self.mult_factor: + error(self.pos, "Cannot coerce multiplied list to '%s'" % dst_type) + elif dst_type.is_struct: + if len(self.args) > len(dst_type.scope.var_entries): + error(self.pos, "Too many members for '%s'" % dst_type) + else: + if len(self.args) < len(dst_type.scope.var_entries): + warning(self.pos, "Too few members for '%s'" % dst_type, 1) + for i, (arg, member) in enumerate(zip(self.original_args, dst_type.scope.var_entries)): + if isinstance(arg, CoerceToPyTypeNode): + arg = arg.arg + self.args[i] = arg.coerce_to(member.type, env) + self.type = dst_type + elif dst_type.is_ctuple: + return self.coerce_to_ctuple(dst_type, env) + else: + self.type = error_type + error(self.pos, "Cannot coerce list to type '%s'" % dst_type) + return self + + def as_list(self): # dummy for compatibility with TupleNode + return self + + def as_tuple(self): + t = TupleNode(self.pos, args=self.args, mult_factor=self.mult_factor) + if isinstance(self.constant_result, list): + t.constant_result = tuple(self.constant_result) + return t + + def allocate_temp_result(self, code): + if self.type.is_array: + if self.in_module_scope: + self.temp_code = code.funcstate.allocate_temp( + self.type, manage_ref=False, static=True, reusable=False) + else: + # To be valid C++, we must allocate the memory on the stack + # manually and be sure not to reuse it for something else. + # Yes, this means that we leak a temp array variable. + self.temp_code = code.funcstate.allocate_temp( + self.type, manage_ref=False, reusable=False) + else: + SequenceNode.allocate_temp_result(self, code) + + def calculate_constant_result(self): + if self.mult_factor: + raise ValueError() # may exceed the compile time memory + self.constant_result = [ + arg.constant_result for arg in self.args] + + def compile_time_value(self, denv): + l = self.compile_time_value_list(denv) + if self.mult_factor: + l *= self.mult_factor.compile_time_value(denv) + return l + + def generate_operation_code(self, code): + if self.type.is_pyobject: + for err in self.obj_conversion_errors: + report_error(err) + self.generate_sequence_packing_code(code) + elif self.type.is_array: + if self.mult_factor: + code.putln("{") + code.putln("Py_ssize_t %s;" % Naming.quick_temp_cname) + code.putln("for ({i} = 0; {i} < {count}; {i}++) {{".format( + i=Naming.quick_temp_cname, count=self.mult_factor.result())) + offset = '+ (%d * %s)' % (len(self.args), Naming.quick_temp_cname) + else: + offset = '' + for i, arg in enumerate(self.args): + if arg.type.is_array: + code.globalstate.use_utility_code(UtilityCode.load_cached("IncludeStringH", "StringTools.c")) + code.putln("memcpy(&(%s[%s%s]), %s, sizeof(%s[0]));" % ( + self.result(), i, offset, + arg.result(), self.result() + )) + else: + code.putln("%s[%s%s] = %s;" % ( + self.result(), + i, + offset, + arg.result())) + if self.mult_factor: + code.putln("}") + code.putln("}") + elif self.type.is_struct: + for arg, member in zip(self.args, self.type.scope.var_entries): + code.putln("%s.%s = %s;" % ( + self.result(), + member.cname, + arg.result())) + else: + raise InternalError("List type never specified") + + +class ComprehensionNode(ScopedExprNode): + # A list/set/dict comprehension + + child_attrs = ["loop"] + + is_temp = True + constant_result = not_a_constant + + def infer_type(self, env): + return self.type + + def analyse_declarations(self, env): + self.append.target = self # this is used in the PyList_Append of the inner loop + self.init_scope(env) + # setup loop scope + if isinstance(self.loop, Nodes._ForInStatNode): + assert isinstance(self.loop.iterator, ScopedExprNode), self.loop.iterator + self.loop.iterator.init_scope(None, env) + else: + assert isinstance(self.loop, Nodes.ForFromStatNode), self.loop + + def analyse_scoped_declarations(self, env): + self.loop.analyse_declarations(env) + + def analyse_types(self, env): + if not self.has_local_scope: + self.loop = self.loop.analyse_expressions(env) + return self + + def analyse_scoped_expressions(self, env): + if self.has_local_scope: + self.loop = self.loop.analyse_expressions(env) + return self + + def may_be_none(self): + return False + + def generate_result_code(self, code): + self.generate_operation_code(code) + + def generate_operation_code(self, code): + if self.type is Builtin.list_type: + create_code = 'PyList_New(0)' + elif self.type is Builtin.set_type: + create_code = 'PySet_New(NULL)' + elif self.type is Builtin.dict_type: + create_code = 'PyDict_New()' + else: + raise InternalError("illegal type for comprehension: %s" % self.type) + code.putln('%s = %s; %s' % ( + self.result(), create_code, + code.error_goto_if_null(self.result(), self.pos))) + + self.generate_gotref(code) + self.loop.generate_execution_code(code) + + def annotate(self, code): + self.loop.annotate(code) + + +class ComprehensionAppendNode(Node): + # Need to be careful to avoid infinite recursion: + # target must not be in child_attrs/subexprs + + child_attrs = ['expr'] + target = None + + type = PyrexTypes.c_int_type + + def analyse_expressions(self, env): + self.expr = self.expr.analyse_expressions(env) + if not self.expr.type.is_pyobject: + self.expr = self.expr.coerce_to_pyobject(env) + return self + + def generate_execution_code(self, code): + if self.target.type is list_type: + code.globalstate.use_utility_code( + UtilityCode.load_cached("ListCompAppend", "Optimize.c")) + function = "__Pyx_ListComp_Append" + elif self.target.type is set_type: + function = "PySet_Add" + else: + raise InternalError( + "Invalid type for comprehension node: %s" % self.target.type) + + self.expr.generate_evaluation_code(code) + code.putln(code.error_goto_if("%s(%s, (PyObject*)%s)" % ( + function, + self.target.result(), + self.expr.result() + ), self.pos)) + self.expr.generate_disposal_code(code) + self.expr.free_temps(code) + + def generate_function_definitions(self, env, code): + self.expr.generate_function_definitions(env, code) + + def annotate(self, code): + self.expr.annotate(code) + +class DictComprehensionAppendNode(ComprehensionAppendNode): + child_attrs = ['key_expr', 'value_expr'] + + def analyse_expressions(self, env): + self.key_expr = self.key_expr.analyse_expressions(env) + if not self.key_expr.type.is_pyobject: + self.key_expr = self.key_expr.coerce_to_pyobject(env) + self.value_expr = self.value_expr.analyse_expressions(env) + if not self.value_expr.type.is_pyobject: + self.value_expr = self.value_expr.coerce_to_pyobject(env) + return self + + def generate_execution_code(self, code): + self.key_expr.generate_evaluation_code(code) + self.value_expr.generate_evaluation_code(code) + code.putln(code.error_goto_if("PyDict_SetItem(%s, (PyObject*)%s, (PyObject*)%s)" % ( + self.target.result(), + self.key_expr.result(), + self.value_expr.result() + ), self.pos)) + self.key_expr.generate_disposal_code(code) + self.key_expr.free_temps(code) + self.value_expr.generate_disposal_code(code) + self.value_expr.free_temps(code) + + def generate_function_definitions(self, env, code): + self.key_expr.generate_function_definitions(env, code) + self.value_expr.generate_function_definitions(env, code) + + def annotate(self, code): + self.key_expr.annotate(code) + self.value_expr.annotate(code) + + +class InlinedGeneratorExpressionNode(ExprNode): + # An inlined generator expression for which the result is calculated + # inside of the loop and returned as a single, first and only Generator + # return value. + # This will only be created by transforms when replacing safe builtin + # calls on generator expressions. + # + # gen GeneratorExpressionNode the generator, not containing any YieldExprNodes + # orig_func String the name of the builtin function this node replaces + # target ExprNode or None a 'target' for a ComprehensionAppend node + + subexprs = ["gen"] + orig_func = None + target = None + is_temp = True + type = py_object_type + + def __init__(self, pos, gen, comprehension_type=None, **kwargs): + gbody = gen.def_node.gbody + gbody.is_inlined = True + if comprehension_type is not None: + assert comprehension_type in (list_type, set_type, dict_type), comprehension_type + gbody.inlined_comprehension_type = comprehension_type + kwargs.update( + target=RawCNameExprNode(pos, comprehension_type, Naming.retval_cname), + type=comprehension_type, + ) + super().__init__(pos, gen=gen, **kwargs) + + def may_be_none(self): + return self.orig_func not in ('any', 'all', 'sorted') + + def infer_type(self, env): + return self.type + + def analyse_types(self, env): + self.gen = self.gen.analyse_expressions(env) + return self + + def generate_result_code(self, code): + code.putln("%s = __Pyx_Generator_GetInlinedResult(%s); %s" % ( + self.result(), self.gen.result(), + code.error_goto_if_null(self.result(), self.pos))) + self.generate_gotref(code) + + +class MergedSequenceNode(ExprNode): + """ + Merge a sequence of iterables into a set/list/tuple. + + The target collection is determined by self.type, which must be set externally. + + args [ExprNode] + """ + subexprs = ['args'] + is_temp = True + gil_message = "Constructing Python collection" + + def __init__(self, pos, args, type): + if type in (list_type, tuple_type) and args and args[0].is_sequence_constructor: + # construct a list directly from the first argument that we can then extend + if args[0].type is not list_type: + args[0] = ListNode(args[0].pos, args=args[0].args, is_temp=True, mult_factor=args[0].mult_factor) + ExprNode.__init__(self, pos, args=args, type=type) + + def calculate_constant_result(self): + result = [] + for item in self.args: + if item.is_sequence_constructor and item.mult_factor: + if item.mult_factor.constant_result <= 0: + continue + # otherwise, adding each item once should be enough + if item.is_set_literal or item.is_sequence_constructor: + # process items in order + items = (arg.constant_result for arg in item.args) + else: + items = item.constant_result + result.extend(items) + if self.type is set_type: + result = set(result) + elif self.type is tuple_type: + result = tuple(result) + else: + assert self.type is list_type + self.constant_result = result + + def compile_time_value(self, denv): + result = [] + for item in self.args: + if item.is_sequence_constructor and item.mult_factor: + if item.mult_factor.compile_time_value(denv) <= 0: + continue + if item.is_set_literal or item.is_sequence_constructor: + # process items in order + items = (arg.compile_time_value(denv) for arg in item.args) + else: + items = item.compile_time_value(denv) + result.extend(items) + if self.type is set_type: + try: + result = set(result) + except Exception as e: + self.compile_time_value_error(e) + elif self.type is tuple_type: + result = tuple(result) + else: + assert self.type is list_type + return result + + def type_dependencies(self, env): + return () + + def infer_type(self, env): + return self.type + + def analyse_types(self, env): + args = [ + arg.analyse_types(env).coerce_to_pyobject(env).as_none_safe_node( + # FIXME: CPython's error message starts with the runtime function name + 'argument after * must be an iterable, not NoneType') + for arg in self.args + ] + + if len(args) == 1 and args[0].type is self.type: + # strip this intermediate node and use the bare collection + return args[0] + + assert self.type in (set_type, list_type, tuple_type) + + self.args = args + return self + + def may_be_none(self): + return False + + def generate_evaluation_code(self, code): + code.mark_pos(self.pos) + self.allocate_temp_result(code) + + is_set = self.type is set_type + + args = iter(self.args) + item = next(args) + item.generate_evaluation_code(code) + if (is_set and item.is_set_literal or + not is_set and item.is_sequence_constructor and item.type is list_type): + code.putln("%s = %s;" % (self.result(), item.py_result())) + item.generate_post_assignment_code(code) + else: + code.putln("%s = %s(%s); %s" % ( + self.result(), + 'PySet_New' if is_set + else "__Pyx_PySequence_ListKeepNew" if item.result_in_temp() and item.type in (py_object_type, list_type) + else "PySequence_List", + item.py_result(), + code.error_goto_if_null(self.result(), self.pos))) + self.generate_gotref(code) + item.generate_disposal_code(code) + item.free_temps(code) + + helpers = set() + if is_set: + add_func = "PySet_Add" + extend_func = "__Pyx_PySet_Update" + else: + add_func = "__Pyx_ListComp_Append" + extend_func = "__Pyx_PyList_Extend" + + for item in args: + if (is_set and (item.is_set_literal or item.is_sequence_constructor) or + (item.is_sequence_constructor and not item.mult_factor)): + if not is_set and item.args: + helpers.add(("ListCompAppend", "Optimize.c")) + for arg in item.args: + arg.generate_evaluation_code(code) + code.put_error_if_neg(arg.pos, "%s(%s, %s)" % ( + add_func, + self.result(), + arg.py_result())) + arg.generate_disposal_code(code) + arg.free_temps(code) + continue + + if is_set: + helpers.add(("PySet_Update", "Builtins.c")) + else: + helpers.add(("ListExtend", "Optimize.c")) + + item.generate_evaluation_code(code) + code.put_error_if_neg(item.pos, "%s(%s, %s)" % ( + extend_func, + self.result(), + item.py_result())) + item.generate_disposal_code(code) + item.free_temps(code) + + if self.type is tuple_type: + code.putln("{") + code.putln("PyObject *%s = PyList_AsTuple(%s);" % ( + Naming.quick_temp_cname, + self.result())) + code.put_decref(self.result(), py_object_type) + code.putln("%s = %s; %s" % ( + self.result(), + Naming.quick_temp_cname, + code.error_goto_if_null(self.result(), self.pos))) + self.generate_gotref(code) + code.putln("}") + + for helper in sorted(helpers): + code.globalstate.use_utility_code(UtilityCode.load_cached(*helper)) + + def annotate(self, code): + for item in self.args: + item.annotate(code) + + +class SetNode(ExprNode): + """ + Set constructor. + """ + subexprs = ['args'] + type = set_type + is_set_literal = True + gil_message = "Constructing Python set" + + def analyse_types(self, env): + for i in range(len(self.args)): + arg = self.args[i] + arg = arg.analyse_types(env) + self.args[i] = arg.coerce_to_pyobject(env) + self.type = set_type + self.is_temp = 1 + return self + + def may_be_none(self): + return False + + def calculate_constant_result(self): + self.constant_result = {arg.constant_result for arg in self.args} + + def compile_time_value(self, denv): + values = [arg.compile_time_value(denv) for arg in self.args] + try: + return set(values) + except Exception as e: + self.compile_time_value_error(e) + + def generate_evaluation_code(self, code): + for arg in self.args: + arg.generate_evaluation_code(code) + self.allocate_temp_result(code) + code.putln( + "%s = PySet_New(0); %s" % ( + self.result(), + code.error_goto_if_null(self.result(), self.pos))) + self.generate_gotref(code) + for arg in self.args: + code.put_error_if_neg( + self.pos, + "PySet_Add(%s, %s)" % (self.result(), arg.py_result())) + arg.generate_disposal_code(code) + arg.free_temps(code) + + +class DictNode(ExprNode): + # Dictionary constructor. + # + # key_value_pairs [DictItemNode] + # exclude_null_values boolean Do not add NULL values to dict + # + # obj_conversion_errors PyrexError used internally + + subexprs = ['key_value_pairs'] + is_temp = 1 + exclude_null_values = False + type = dict_type + is_dict_literal = True + reject_duplicates = False + + obj_conversion_errors = [] + + @classmethod + def from_pairs(cls, pos, pairs): + return cls(pos, key_value_pairs=[ + DictItemNode(pos, key=k, value=v) for k, v in pairs]) + + def calculate_constant_result(self): + self.constant_result = dict([ + item.constant_result for item in self.key_value_pairs]) + + def compile_time_value(self, denv): + pairs = [(item.key.compile_time_value(denv), item.value.compile_time_value(denv)) + for item in self.key_value_pairs] + try: + return dict(pairs) + except Exception as e: + self.compile_time_value_error(e) + + def type_dependencies(self, env): + return () + + def infer_type(self, env): + # TODO: Infer struct constructors. + return dict_type + + def analyse_types(self, env): + with local_errors(ignore=True) as errors: + self.key_value_pairs = [ + item.analyse_types(env) + for item in self.key_value_pairs + ] + self.obj_conversion_errors = errors + return self + + def may_be_none(self): + return False + + def coerce_to(self, dst_type, env): + dst_type = PyrexTypes.remove_cv_ref(dst_type, remove_fakeref=True) + if dst_type.is_pyobject: + self.release_errors() + if self.type.is_struct_or_union: + if not dict_type.subtype_of(dst_type): + error(self.pos, "Cannot interpret struct as non-dict type '%s'" % dst_type) + return DictNode(self.pos, key_value_pairs=[ + DictItemNode(item.pos, key=item.key.coerce_to_pyobject(env), + value=item.value.coerce_to_pyobject(env)) + for item in self.key_value_pairs]) + if not self.type.subtype_of(dst_type): + error(self.pos, "Cannot interpret dict as type '%s'" % dst_type) + elif dst_type.is_struct_or_union: + self.type = dst_type + if not dst_type.is_struct and len(self.key_value_pairs) != 1: + error(self.pos, "Exactly one field must be specified to convert to union '%s'" % dst_type) + elif dst_type.is_struct and len(self.key_value_pairs) < len(dst_type.scope.var_entries): + warning(self.pos, "Not all members given for struct '%s'" % dst_type, 1) + for item in self.key_value_pairs: + if isinstance(item.key, CoerceToPyTypeNode): + item.key = item.key.arg + if not item.key.is_string_literal: + error(item.key.pos, "Invalid struct field identifier") + item.key = UnicodeNode(item.key.pos, value=StringEncoding.EncodedString("")) + else: + key = str(item.key.value) # converts string literals to unicode in Py3 + member = dst_type.scope.lookup_here(key) + if not member: + error(item.key.pos, "struct '%s' has no field '%s'" % (dst_type, key)) + else: + value = item.value + if isinstance(value, CoerceToPyTypeNode): + value = value.arg + item.value = value.coerce_to(member.type, env) + else: + return super().coerce_to(dst_type, env) + return self + + def release_errors(self): + for err in self.obj_conversion_errors: + report_error(err) + self.obj_conversion_errors = [] + + gil_message = "Constructing Python dict" + + def generate_evaluation_code(self, code): + # Custom method used here because key-value + # pairs are evaluated and used one at a time. + code.mark_pos(self.pos) + self.allocate_temp_result(code) + + is_dict = self.type.is_pyobject + if is_dict: + self.release_errors() + code.putln( + "%s = __Pyx_PyDict_NewPresized(%d); %s" % ( + self.result(), + len(self.key_value_pairs), + code.error_goto_if_null(self.result(), self.pos))) + self.generate_gotref(code) + struct_scope = None + else: + struct_scope = self.type.scope + + keys_seen = set() + key_type = None + needs_error_helper = False + + for item in self.key_value_pairs: + item.generate_evaluation_code(code) + if is_dict: + if self.exclude_null_values: + code.putln('if (%s) {' % item.value.py_result()) + key = item.key + if self.reject_duplicates: + if keys_seen is not None: + # avoid runtime 'in' checks for literals that we can do at compile time + if not key.is_string_literal: + keys_seen = None + elif key.value in keys_seen: + # FIXME: this could be a compile time error, at least in Cython code + keys_seen = None + elif key_type is not type(key.value): + if key_type is None: + key_type = type(key.value) + keys_seen.add(key.value) + else: + # different types => may not be able to compare at compile time + keys_seen = None + else: + keys_seen.add(key.value) + + if keys_seen is None: + code.putln('if (unlikely(PyDict_Contains(%s, %s))) {' % ( + self.result(), key.py_result())) + # currently only used in function calls + needs_error_helper = True + code.putln('__Pyx_RaiseDoubleKeywordsError("function", %s); %s' % ( + key.py_result(), + code.error_goto(item.pos))) + code.putln("} else {") + + code.put_error_if_neg(self.pos, "PyDict_SetItem(%s, %s, %s)" % ( + self.result(), + item.key.py_result(), + item.value.py_result())) + if self.reject_duplicates and keys_seen is None: + code.putln('}') + if self.exclude_null_values: + code.putln('}') + else: + member = struct_scope.lookup_here(item.key.value) + assert member is not None, f"struct member {item.key.value} not found, error was not handled during coercion" + key_cname = member.cname + value_cname = item.value.result() + if item.value.type.is_array: + code.globalstate.use_utility_code(UtilityCode.load_cached("IncludeStringH", "StringTools.c")) + code.putln(f"memcpy({self.result()}.{key_cname}, {value_cname}, sizeof({value_cname}));") + else: + code.putln(f"{self.result()}.{key_cname} = {value_cname};") + item.generate_disposal_code(code) + item.free_temps(code) + + if needs_error_helper: + code.globalstate.use_utility_code( + UtilityCode.load_cached("RaiseDoubleKeywords", "FunctionArguments.c")) + + def annotate(self, code): + for item in self.key_value_pairs: + item.annotate(code) + + def as_python_dict(self): + # returns a dict with constant keys and Node values + # (only works on DictNodes where the keys are ConstNodes or PyConstNode) + return {key.value: value for key, value in self.key_value_pairs} + + +class DictItemNode(ExprNode): + # Represents a single item in a DictNode + # + # key ExprNode + # value ExprNode + subexprs = ['key', 'value'] + + nogil_check = None # Parent DictNode takes care of it + + def calculate_constant_result(self): + self.constant_result = ( + self.key.constant_result, self.value.constant_result) + + def analyse_types(self, env): + self.key = self.key.analyse_types(env) + self.value = self.value.analyse_types(env) + self.key = self.key.coerce_to_pyobject(env) + self.value = self.value.coerce_to_pyobject(env) + return self + + def generate_evaluation_code(self, code): + self.key.generate_evaluation_code(code) + self.value.generate_evaluation_code(code) + + def generate_disposal_code(self, code): + self.key.generate_disposal_code(code) + self.value.generate_disposal_code(code) + + def free_temps(self, code): + self.key.free_temps(code) + self.value.free_temps(code) + + def __iter__(self): + return iter([self.key, self.value]) + + +class SortedDictKeysNode(ExprNode): + # build sorted list of dict keys, e.g. for dir() + subexprs = ['arg'] + + is_temp = True + + def __init__(self, arg): + ExprNode.__init__(self, arg.pos, arg=arg) + self.type = Builtin.list_type + + def analyse_types(self, env): + arg = self.arg.analyse_types(env) + if arg.type is Builtin.dict_type: + arg = arg.as_none_safe_node( + "'NoneType' object is not iterable") + self.arg = arg + return self + + def may_be_none(self): + return False + + def generate_result_code(self, code): + dict_result = self.arg.py_result() + if self.arg.type is Builtin.dict_type: + code.putln('%s = PyDict_Keys(%s); %s' % ( + self.result(), dict_result, + code.error_goto_if_null(self.result(), self.pos))) + self.generate_gotref(code) + else: + # originally used PyMapping_Keys() here, but that may return a tuple + code.globalstate.use_utility_code(UtilityCode.load_cached( + 'PyObjectCallMethod0', 'ObjectHandling.c')) + keys_cname = code.intern_identifier(StringEncoding.EncodedString("keys")) + code.putln('%s = __Pyx_PyObject_CallMethod0(%s, %s); %s' % ( + self.result(), dict_result, keys_cname, + code.error_goto_if_null(self.result(), self.pos))) + self.generate_gotref(code) + code.putln("if (unlikely(!PyList_Check(%s))) {" % self.result()) + self.generate_decref_set(code, "PySequence_List(%s)" % self.result()) + code.putln(code.error_goto_if_null(self.result(), self.pos)) + self.generate_gotref(code) + code.putln("}") + code.put_error_if_neg( + self.pos, 'PyList_Sort(%s)' % self.py_result()) + + +class SortedListNode(_TempModifierNode): + """Sorts a newly created Python list in place. + """ + type = list_type + + def generate_result_code(self, code): + code.putln(code.error_goto_if_neg(f"PyList_Sort({self.arg.result()})", self.pos)) + + +class ModuleNameMixin: + def get_py_mod_name(self, code): + return code.get_py_string_const( + self.module_name, identifier=True) + + def get_py_qualified_name(self, code): + return code.get_py_string_const( + self.qualname, identifier=True) + + +class ClassNode(ExprNode, ModuleNameMixin): + # Helper class used in the implementation of Python + # class definitions. Constructs a class object given + # a name, tuple of bases and class dictionary. + # + # name EncodedString Name of the class + # class_def_node PyClassDefNode PyClassDefNode defining this class + # doc ExprNode or None Doc string + # module_name EncodedString Name of defining module + + subexprs = ['doc'] + type = py_object_type + is_temp = True + + def analyse_annotations(self, env): + pass + + def infer_type(self, env): + # TODO: could return 'type' in some cases + return py_object_type + + def analyse_types(self, env): + if self.doc: + self.doc = self.doc.analyse_types(env) + self.doc = self.doc.coerce_to_pyobject(env) + env.use_utility_code(UtilityCode.load_cached("CreateClass", "ObjectHandling.c")) + return self + + def may_be_none(self): + return True + + gil_message = "Constructing Python class" + + def generate_result_code(self, code): + class_def_node = self.class_def_node + cname = code.intern_identifier(self.name) + + if self.doc: + code.put_error_if_neg(self.pos, + 'PyDict_SetItem(%s, %s, %s)' % ( + class_def_node.dict.py_result(), + code.intern_identifier( + StringEncoding.EncodedString("__doc__")), + self.doc.py_result())) + py_mod_name = self.get_py_mod_name(code) + qualname = self.get_py_qualified_name(code) + code.putln( + '%s = __Pyx_CreateClass(%s, %s, %s, %s, %s); %s' % ( + self.result(), + class_def_node.bases.py_result(), + class_def_node.dict.py_result(), + cname, + qualname, + py_mod_name, + code.error_goto_if_null(self.result(), self.pos))) + self.generate_gotref(code) + + +class Py3ClassNode(ExprNode): + # Helper class used in the implementation of Python3+ + # class definitions. Constructs a class object given + # a name, tuple of bases and class dictionary. + # + # name EncodedString Name of the class + # module_name EncodedString Name of defining module + # class_def_node PyClassDefNode PyClassDefNode defining this class + # calculate_metaclass bool should call CalculateMetaclass() + # allow_py2_metaclass bool should look for Py2 metaclass + # force_type bool always create a "new style" class, even with no bases + + subexprs = [] + type = py_object_type + force_type = False + is_temp = True + + def infer_type(self, env): + # TODO: could return 'type' in some cases + return py_object_type + + def analyse_types(self, env): + return self + + def may_be_none(self): + return True + + gil_message = "Constructing Python class" + + def analyse_annotations(self, env): + from .AutoDocTransforms import AnnotationWriter + position = self.class_def_node.pos + dict_items = [ + DictItemNode( + entry.pos, + key=IdentifierStringNode(entry.pos, value=entry.name), + value=entry.annotation.string + ) + for entry in env.entries.values() if entry.annotation + ] + # Annotations dict shouldn't exist for classes which don't declare any. + if dict_items: + annotations_dict = DictNode(position, key_value_pairs=dict_items) + lhs = NameNode(position, name=StringEncoding.EncodedString("__annotations__")) + lhs.entry = env.lookup_here(lhs.name) or env.declare_var(lhs.name, dict_type, position) + node = SingleAssignmentNode(position, lhs=lhs, rhs=annotations_dict) + node.analyse_declarations(env) + self.class_def_node.body.stats.insert(0, node) + + def generate_result_code(self, code): + code.globalstate.use_utility_code(UtilityCode.load_cached("Py3ClassCreate", "ObjectHandling.c")) + cname = code.intern_identifier(self.name) + class_def_node = self.class_def_node + mkw = class_def_node.mkw.py_result() if class_def_node.mkw else 'NULL' + if class_def_node.metaclass: + metaclass = class_def_node.metaclass.py_result() + elif self.force_type: + metaclass = "((PyObject*)&PyType_Type)" + else: + metaclass = "((PyObject*)&__Pyx_DefaultClassType)" + code.putln( + '%s = __Pyx_Py3ClassCreate(%s, %s, %s, %s, %s, %d, %d); %s' % ( + self.result(), + metaclass, + cname, + class_def_node.bases.py_result(), + class_def_node.dict.py_result(), + mkw, + self.calculate_metaclass, + self.allow_py2_metaclass, + code.error_goto_if_null(self.result(), self.pos))) + self.generate_gotref(code) + + +class PyClassMetaclassNode(ExprNode): + # Helper class holds Python3 metaclass object + # + # class_def_node PyClassDefNode PyClassDefNode defining this class + + subexprs = [] + + def analyse_types(self, env): + self.type = py_object_type + self.is_temp = True + return self + + def may_be_none(self): + return True + + def generate_result_code(self, code): + bases = self.class_def_node.bases + mkw = self.class_def_node.mkw + if mkw: + code.globalstate.use_utility_code( + UtilityCode.load_cached("Py3MetaclassGet", "ObjectHandling.c")) + call = "__Pyx_Py3MetaclassGet(%s, %s)" % ( + bases.result(), + mkw.result()) + else: + code.globalstate.use_utility_code( + UtilityCode.load_cached("CalculateMetaclass", "ObjectHandling.c")) + call = "__Pyx_CalculateMetaclass(NULL, %s)" % ( + bases.result()) + code.putln( + "%s = %s; %s" % ( + self.result(), call, + code.error_goto_if_null(self.result(), self.pos))) + self.generate_gotref(code) + + +class PyClassNamespaceNode(ExprNode, ModuleNameMixin): + # Helper class holds Python3 namespace object + # + # All this are not owned by this node + # class_def_node PyClassDefNode PyClassDefNode defining this class + # doc ExprNode or None Doc string (owned) + + subexprs = ['doc'] + + def analyse_types(self, env): + if self.doc: + self.doc = self.doc.analyse_types(env).coerce_to_pyobject(env) + self.type = py_object_type + self.is_temp = 1 + return self + + def may_be_none(self): + return True + + def generate_result_code(self, code): + cname = code.intern_identifier(self.name) + py_mod_name = self.get_py_mod_name(code) + qualname = self.get_py_qualified_name(code) + class_def_node = self.class_def_node + null = "(PyObject *) NULL" + doc_code = self.doc.result() if self.doc else null + mkw = class_def_node.mkw.py_result() if class_def_node.mkw else null + metaclass = class_def_node.metaclass.py_result() if class_def_node.metaclass else null + code.putln( + "%s = __Pyx_Py3MetaclassPrepare(%s, %s, %s, %s, %s, %s, %s); %s" % ( + self.result(), + metaclass, + class_def_node.bases.result(), + cname, + qualname, + mkw, + py_mod_name, + doc_code, + code.error_goto_if_null(self.result(), self.pos))) + self.generate_gotref(code) + + +class ClassCellInjectorNode(ExprNode): + # Initialize CyFunction.func_classobj + is_temp = True + type = py_object_type + subexprs = [] + is_active = False + + def analyse_expressions(self, env): + return self + + def generate_result_code(self, code): + assert self.is_active + code.putln( + '%s = PyList_New(0); %s' % ( + self.result(), + code.error_goto_if_null(self.result(), self.pos))) + self.generate_gotref(code) + + def generate_injection_code(self, code, classobj_cname): + assert self.is_active + code.globalstate.use_utility_code( + UtilityCode.load_cached("CyFunctionClassCell", "CythonFunction.c")) + code.put_error_if_neg(self.pos, '__Pyx_CyFunction_InitClassCell(%s, %s)' % ( + self.result(), classobj_cname)) + + +class ClassCellNode(ExprNode): + # Class Cell for noargs super() + subexprs = [] + is_temp = True + is_generator = False + type = py_object_type + + def analyse_types(self, env): + return self + + def generate_result_code(self, code): + if not self.is_generator: + code.putln('%s = __Pyx_CyFunction_GetClassObj(%s);' % ( + self.result(), + Naming.self_cname)) + else: + code.putln('%s = %s->classobj;' % ( + self.result(), Naming.generator_cname)) + code.putln( + 'if (!%s) { PyErr_SetString(PyExc_RuntimeError, ' + '"super(): empty __class__ cell"); %s }' % ( + self.result(), + code.error_goto(self.pos))) + code.put_incref(self.result(), py_object_type) + + +class PyCFunctionNode(ExprNode, ModuleNameMixin): + # Helper class used in the implementation of Python + # functions. Constructs a PyCFunction object + # from a PyMethodDef struct. + # + # pymethdef_cname string PyMethodDef structure + # binding bool + # def_node DefNode the Python function node + # module_name EncodedString Name of defining module + + subexprs = ['defaults_tuple', 'defaults_kwdict', 'annotations_dict'] + + binding = False + def_node = None + defaults = None + defaults_entry = None + defaults_tuple = None + defaults_kwdict = None + annotations_dict = None + + type = py_object_type + is_temp = 1 + + specialized_cpdefs = None + is_specialization = False + + @classmethod + def from_defnode(cls, node, binding): + return cls( + node.pos, + def_node=node, + pymethdef_cname=node.entry.pymethdef_cname, + binding=binding or node.specialized_cpdefs, + specialized_cpdefs=node.specialized_cpdefs, + ) + + @property + def code_object(self): + return self.def_node.code_object + + def analyse_types(self, env): + if self.binding: + self.analyse_default_args(env) + return self + + def analyse_default_args(self, env): + """ + Handle non-literal function's default arguments. + """ + nonliteral_objects = [] + nonliteral_other = [] + default_args = [] + default_kwargs = [] + annotations = [] + + # For global cpdef functions and def/cpdef methods in cdef classes, we must use global constants + # for default arguments to avoid the dependency on the CyFunction object as 'self' argument + # in the underlying C function. Basically, cpdef functions/methods are static C functions, + # so their optional arguments must be static, too. + # TODO: change CyFunction implementation to pass both function object and owning object for method calls + must_use_constants = env.is_c_class_scope or (self.def_node.is_wrapper and env.is_module_scope) + + for arg in self.def_node.args: + if arg.default: + if not must_use_constants: + if arg.default.is_literal: + arg.default = DefaultLiteralArgNode(arg.pos, arg.default) + if arg.default.type: + arg.default = arg.default.coerce_to(arg.type, env) + else: + arg.is_dynamic = True + if arg.type.is_pyobject: + nonliteral_objects.append(arg) + else: + nonliteral_other.append(arg) + if arg.default.type and arg.default.type.can_coerce_to_pyobject(env): + if arg.kw_only: + default_kwargs.append(arg) + else: + default_args.append(arg) + if arg.annotation: + arg.annotation = arg.annotation.analyse_types(env) + annotations.append((arg.pos, arg.name, arg.annotation.string)) + + for arg in (self.def_node.star_arg, self.def_node.starstar_arg): + if arg and arg.annotation: + arg.annotation = arg.annotation.analyse_types(env) + annotations.append((arg.pos, arg.name, arg.annotation.string)) + + annotation = self.def_node.return_type_annotation + if annotation: + self.def_node.return_type_annotation = annotation.analyse_types(env) + annotations.append((annotation.pos, StringEncoding.EncodedString("return"), + annotation.string)) + + if nonliteral_objects or nonliteral_other: + module_scope = env.global_scope() + types = [] + for arg in nonliteral_objects: + type_ = arg.type + if type_.is_buffer: + type_ = type_.base + types.append(type_) + types += [ arg.type for arg in nonliteral_other ] + self.defaults_entry = module_scope.declare_defaults_c_class(self.pos, types) + defaults_class_scope = self.defaults_entry.type.scope + + # sort by name + arg_entries = sorted(list(defaults_class_scope.entries.items())) + arg_entries = [ e for name, e in arg_entries if name.startswith("arg") ] + self.defaults = [] + for arg, entry in zip(nonliteral_objects + nonliteral_other, arg_entries): + arg.defaults_class_key = entry.cname + self.defaults.append((arg, entry)) + + self.defaults_pyobjects = len(nonliteral_objects) + for arg, entry in self.defaults: + arg.default_value = '%s->%s' % ( + Naming.dynamic_args_cname, entry.cname) + self.def_node.defaults_struct = defaults_class_scope.name + + if default_args or default_kwargs: + if self.defaults_entry is None: + if default_args: + defaults_tuple = TupleNode(self.pos, args=[ + arg.default for arg in default_args]) + self.defaults_tuple = defaults_tuple.analyse_types(env).coerce_to_pyobject(env) + if default_kwargs: + defaults_kwdict = DictNode(self.pos, key_value_pairs=[ + DictItemNode( + arg.pos, + key=IdentifierStringNode(arg.pos, value=arg.name), + value=arg.default) + for arg in default_kwargs]) + self.defaults_kwdict = defaults_kwdict.analyse_types(env) + elif not self.specialized_cpdefs: + # Fused dispatch functions do not support (dynamic) default arguments, only the specialisations do. + if default_args: + defaults_tuple = DefaultsTupleNode( + self.pos, default_args, self.defaults_entry.type.scope) + else: + defaults_tuple = NoneNode(self.pos) + if default_kwargs: + defaults_kwdict = DefaultsKwDictNode( + self.pos, default_kwargs, self.defaults_entry.type.scope) + else: + defaults_kwdict = NoneNode(self.pos) + + defaults_getter = Nodes.DefNode( + self.pos, args=[], star_arg=None, starstar_arg=None, + body=Nodes.ReturnStatNode( + self.pos, return_type=py_object_type, + value=TupleNode( + self.pos, args=[defaults_tuple, defaults_kwdict])), + decorators=None, + name=StringEncoding.EncodedString("__defaults__")) + # defaults getter must never live in class scopes, it's always a module function + module_scope = env.global_scope() + # FIXME: this seems even more hackish than before. + directives_node = Nodes.CompilerDirectivesNode.for_internal(defaults_getter, module_scope) + directives_node.analyse_declarations(module_scope) + directives_node = directives_node.analyse_expressions(module_scope) + defaults_getter = directives_node.body + defaults_getter.body = defaults_getter.body.analyse_expressions( + defaults_getter.local_scope) + defaults_getter.py_wrapper_required = False + defaults_getter.pymethdef_required = False + self.def_node.defaults_getter = defaults_getter + if annotations: + annotations_dict = DictNode(self.pos, key_value_pairs=[ + DictItemNode( + pos, key=IdentifierStringNode(pos, value=name), + value=value) + for pos, name, value in annotations]) + self.annotations_dict = annotations_dict.analyse_types(env) + + def may_be_none(self): + return False + + gil_message = "Constructing Python function" + + def closure_result_code(self): + return "NULL" + + def generate_result_code(self, code): + if self.binding: + self.generate_cyfunction_code(code) + else: + self.generate_pycfunction_code(code) + + def generate_pycfunction_code(self, code): + py_mod_name = self.get_py_mod_name(code) + code.putln( + '%s = PyCFunction_NewEx(&%s, %s, %s); %s' % ( + self.result(), + self.pymethdef_cname, + self.closure_result_code(), + py_mod_name, + code.error_goto_if_null(self.result(), self.pos))) + + self.generate_gotref(code) + + def generate_cyfunction_code(self, code): + if self.specialized_cpdefs: + def_node = self.specialized_cpdefs[0] + else: + def_node = self.def_node + + if self.specialized_cpdefs or self.is_specialization: + code.globalstate.use_utility_code( + UtilityCode.load_cached("FusedFunction", "CythonFunction.c")) + constructor = "__pyx_FusedFunction_New" + else: + code.globalstate.use_utility_code( + UtilityCode.load_cached("CythonFunction", "CythonFunction.c")) + constructor = "__Pyx_CyFunction_New" + + flags = [] + if def_node.is_staticmethod: + flags.append('__Pyx_CYFUNCTION_STATICMETHOD') + elif def_node.is_classmethod: + flags.append('__Pyx_CYFUNCTION_CLASSMETHOD') + + if def_node.local_scope.parent_scope.is_c_class_scope and not def_node.entry.is_anonymous: + flags.append('__Pyx_CYFUNCTION_CCLASS') + + if def_node.is_coroutine: + flags.append('__Pyx_CYFUNCTION_COROUTINE') + + if flags: + flags = ' | '.join(flags) + else: + flags = '0' + + moddict_cname = code.name_in_module_state(Naming.moddict_cname) + self.code_object.generate_result_code(code) + + code.putln( + '%s = %s(&%s, %s, %s, %s, %s, %s, %s); %s' % ( + self.result(), + constructor, + self.pymethdef_cname, + flags, + self.get_py_qualified_name(code), + self.closure_result_code(), + self.get_py_mod_name(code), + moddict_cname, + self.code_object.py_result(), + code.error_goto_if_null(self.result(), self.pos))) + + self.generate_gotref(code) + + if def_node.requires_classobj: + assert code.pyclass_stack, "pyclass_stack is empty" + class_node = code.pyclass_stack[-1] + code.putln( + 'PyList_Append(%s, %s);' % ( + class_node.class_cell.result(), + self.py_result())) + + if self.defaults: + code.putln( + 'if (!__Pyx_CyFunction_InitDefaults(%s, %s)) %s' % ( + self.result(), + code.name_in_module_state(self.defaults_entry.type.typeptr_cname), + code.error_goto(self.pos))) + defaults = '__Pyx_CyFunction_Defaults(struct %s, %s)' % ( + self.defaults_entry.type.objstruct_cname, self.result()) + for arg, entry in self.defaults: + arg.generate_assignment_code(code, target='%s->%s' % ( + defaults, entry.cname)) + + if self.defaults_tuple: + code.putln('__Pyx_CyFunction_SetDefaultsTuple(%s, %s);' % ( + self.result(), self.defaults_tuple.py_result())) + if not self.specialized_cpdefs: + # disable introspection functions for fused dispatcher function since the user never sees it + # TODO: this is mostly disabled because the attributes end up pointing to ones belonging + # to the specializations - ideally this would be fixed instead + if self.defaults_kwdict: + code.putln('__Pyx_CyFunction_SetDefaultsKwDict(%s, %s);' % ( + self.result(), self.defaults_kwdict.py_result())) + if def_node.defaults_getter: + code.putln('__Pyx_CyFunction_SetDefaultsGetter(%s, %s);' % ( + self.result(), def_node.defaults_getter.entry.pyfunc_cname)) + if self.annotations_dict: + code.putln('__Pyx_CyFunction_SetAnnotationsDict(%s, %s);' % ( + self.result(), self.annotations_dict.py_result())) + + +class InnerFunctionNode(PyCFunctionNode): + # Special PyCFunctionNode that depends on a closure class + + binding = True + needs_closure_code = True + + def closure_result_code(self): + if self.needs_closure_code: + return "((PyObject*)%s)" % Naming.cur_scope_cname + return "NULL" + + +class DefFuncLikeNode: + """ + Adapter for CFuncDefNode to give it the same attributes as DefNode in CodeObjects. + """ + is_generator = False + is_coroutine = False + is_asyncgen = False + is_generator_expression = False + + num_posonly_args = 0 + num_kwonly_args = 0 + star_arg = None + starstar_arg = None + + def __init__(self, cfuncdef_node): + self.name = cfuncdef_node.entry.name + self.local_scope = cfuncdef_node.entry.scope + self.args = cfuncdef_node.args + self.pos = cfuncdef_node.pos + self._cfuncdef_node = cfuncdef_node + + @property + def node_positions(self): + return self._cfuncdef_node.node_positions + + @property + def node_positions_to_offset(self): + return self._cfuncdef_node.node_positions_to_offset + + +class CodeObjectNode(ExprNode): + # Create a PyCodeObject for a CyFunction instance. + # + # def_node DefNode the Python function node + # varnames [IdentifierStringNode] a list of all local variable names + + subexprs = ['varnames'] + is_temp = False + result_code = None + + def __init__(self, def_node): + ExprNode.__init__(self, def_node.pos, def_node=def_node) + args = list(def_node.args) + # if we have args/kwargs, then the first two in var_entries are those + local_vars = [arg for arg in def_node.local_scope.var_entries if arg.name] + self.varnames = [ + IdentifierStringNode(arg.pos, value=arg.name) + for arg in args + local_vars + ] + + @classmethod + def for_cfunc(cls, cfuncdef_node): + return cls(DefFuncLikeNode(cfuncdef_node)) + + def may_be_none(self): + return False + + def calculate_result_code(self, code=None): + if self.result_code is None: + self.result_code = code.get_py_codeobj_const(self) + return self.result_code + + def generate_result_code(self, code): + if self.result_code is None: + self.result_code = code.get_py_codeobj_const(self) + + def generate_codeobj(self, code, error_label): + func = self.def_node + first_lineno = self.pos[1] + + func_name_result = code.get_py_string_const(func.name, identifier=True) + # FIXME: better way to get the module file path at module init time? Encoding to use? + file_path = func.pos[0].get_filenametable_entry() + if os.path.isabs(file_path): + file_path = func.pos[0].get_description() + # Always use / as separator + file_path = StringEncoding.EncodedString(pathlib.Path(file_path).as_posix()) + file_path_result = code.get_py_string_const(file_path) + + if func.node_positions: + line_table = StringEncoding.bytes_literal(build_line_table(func.node_positions, first_lineno).encode('iso8859-1'), 'iso8859-1') + line_table_result = code.get_string_const(line_table) + line_table_length = len(line_table) + else: + line_table_result = "NULL" + line_table_length = 0 + + # '(CO_OPTIMIZED | CO_NEWLOCALS)' makes CPython create a new dict for "frame.f_locals". + # See https://github.com/cython/cython/pull/1836 + flags = ['CO_OPTIMIZED', 'CO_NEWLOCALS'] + if func.star_arg: + flags.append('CO_VARARGS') + if func.starstar_arg: + flags.append('CO_VARKEYWORDS') + if func.is_asyncgen: + flags.append('CO_ASYNC_GENERATOR') + elif func.is_coroutine: + flags.append('CO_COROUTINE') + elif func.is_generator: + flags.append('CO_GENERATOR') + + if func.is_generator_expression: + # Only generated arguments from the outermost iterable, nothing user visible. + # 'func.args' is constructed late for these, and they (rightfully) do not appear in 'varnames'. + argcount = 0 + else: + argcount = len(func.args) + + num_posonly_args = func.num_posonly_args # Py3.8+ only + kwonly_argcount = func.num_kwonly_args + nlocals = len(self.varnames) + flags = '(unsigned int)(%s)' % '|'.join(flags) or '0' + + # See "generate_codeobject_constants()" in Code.py. + code.putln("{") + code.putln( + "const __Pyx_PyCode_New_function_description descr = {" + f"{argcount - kwonly_argcount}, " + f"{num_posonly_args}, " + f"{kwonly_argcount}, " + f"{nlocals}, " + f"{flags}, " + f"{first_lineno}, " + f"{line_table_length}" + "};" + ) + + for var in self.varnames: + var.generate_evaluation_code(code) + + varnames = [var.py_result() for var in self.varnames] or ['0'] + code.putln("PyObject* const varnames[] = {%s};" % ', '.join(varnames)) + + for var in self.varnames: + var.generate_disposal_code(code) + var.free_temps(code) + + code.putln( + f"{self.result_code} = __Pyx_PyCode_New(" + f"descr, " + f"varnames, " + f"{file_path_result}, " + f"{func_name_result}, " + f"{line_table_result}, " + f"tuple_dedup_map" + f"); " + f"if (unlikely(!{self.result_code})) goto {error_label};" + ) + code.putln("}") + + +class DefaultLiteralArgNode(ExprNode): + # CyFunction's literal argument default value + # + # Evaluate literal only once. + + subexprs = [] + is_literal = True + is_temp = False + + def __init__(self, pos, arg): + super().__init__(pos) + self.arg = arg + self.constant_result = arg.constant_result + self.type = self.arg.type + self.evaluated = False + + def analyse_types(self, env): + return self + + def generate_result_code(self, code): + pass + + def generate_evaluation_code(self, code): + if not self.evaluated: + self.arg.generate_evaluation_code(code) + self.evaluated = True + + def result(self): + return self.type.cast_code(self.arg.result()) + + +class DefaultNonLiteralArgNode(ExprNode): + # CyFunction's non-literal argument default value + + subexprs = [] + + def __init__(self, pos, arg, defaults_struct): + super().__init__(pos) + self.arg = arg + self.defaults_struct = defaults_struct + + def analyse_types(self, env): + self.type = self.arg.type + self.is_temp = False + return self + + def generate_result_code(self, code): + pass + + def result(self): + return '__Pyx_CyFunction_Defaults(struct %s, %s)->%s' % ( + self.defaults_struct.name, Naming.self_cname, + self.defaults_struct.lookup(self.arg.defaults_class_key).cname) + + +class DefaultsTupleNode(TupleNode): + # CyFunction's __defaults__ tuple + + def __init__(self, pos, defaults, defaults_struct): + args = [] + for arg in defaults: + if not arg.default.is_literal: + arg = DefaultNonLiteralArgNode(pos, arg, defaults_struct) + else: + arg = arg.default + args.append(arg) + super().__init__(pos, args=args) + + def analyse_types(self, env, skip_children=False): + return super().analyse_types(env, skip_children).coerce_to_pyobject(env) + + +class DefaultsKwDictNode(DictNode): + # CyFunction's __kwdefaults__ dict + + def __init__(self, pos, defaults, defaults_struct): + items = [] + for arg in defaults: + name = IdentifierStringNode(arg.pos, value=arg.name) + if not arg.default.is_literal: + arg = DefaultNonLiteralArgNode(pos, arg, defaults_struct) + else: + arg = arg.default + items.append(DictItemNode(arg.pos, key=name, value=arg)) + super().__init__(pos, key_value_pairs=items) + + +class LambdaNode(InnerFunctionNode): + # Lambda expression node (only used as a function reference) + # + # args [CArgDeclNode] formal arguments + # star_arg PyArgDeclNode or None * argument + # starstar_arg PyArgDeclNode or None ** argument + # lambda_name string a module-globally unique lambda name + # result_expr ExprNode + # def_node DefNode the underlying function 'def' node + + child_attrs = ['def_node'] + + name = StringEncoding.EncodedString('') + + def analyse_declarations(self, env): + if hasattr(self, "lambda_name"): + # this if-statement makes it safe to run twice + return + self.lambda_name = self.def_node.lambda_name = env.next_id('lambda') + self.def_node.no_assignment_synthesis = True + self.def_node.pymethdef_required = True + self.def_node.is_cyfunction = True + self.def_node.analyse_declarations(env) + self.pymethdef_cname = self.def_node.entry.pymethdef_cname + env.add_lambda_def(self.def_node) + + def analyse_types(self, env): + self.def_node = self.def_node.analyse_expressions(env) + return super().analyse_types(env) + + def generate_result_code(self, code): + self.def_node.generate_execution_code(code) + super().generate_result_code(code) + + +class GeneratorExpressionNode(LambdaNode): + # A generator expression, e.g. (i for i in range(10)) + # + # Result is a generator. + # + # loop ForStatNode the for-loop, containing a YieldExprNode + # def_node DefNode the underlying generator 'def' node + # call_parameters [ExprNode] (Internal) parameters passed to the DefNode call + + name = StringEncoding.EncodedString('genexpr') + binding = False + + child_attrs = LambdaNode.child_attrs + ["call_parameters"] + subexprs = LambdaNode.subexprs + ["call_parameters"] + + def __init__(self, pos, *args, **kwds): + super().__init__(pos, *args, **kwds) + self.call_parameters = [] + + def analyse_declarations(self, env): + if hasattr(self, "genexpr_name"): + # this if-statement makes it safe to run twice + return + self.genexpr_name = env.next_id('genexpr') + super().analyse_declarations(env) + # No pymethdef required + self.def_node.pymethdef_required = False + self.def_node.py_wrapper_required = False + self.def_node.is_cyfunction = False + # Force genexpr signature + self.def_node.entry.signature = TypeSlots.pyfunction_noargs + # setup loop scope + if isinstance(self.loop, Nodes._ForInStatNode): + assert isinstance(self.loop.iterator, ScopedExprNode) + self.loop.iterator.init_scope(None, env) + else: + assert isinstance(self.loop, Nodes.ForFromStatNode) + + def generate_result_code(self, code): + args_to_call = ([self.closure_result_code()] + + [ cp.result() for cp in self.call_parameters ]) + args_to_call = ", ".join(args_to_call) + code.putln( + '%s = %s(%s); %s' % ( + self.result(), + self.def_node.entry.pyfunc_cname, + args_to_call, + code.error_goto_if_null(self.result(), self.pos))) + self.generate_gotref(code) + + +class YieldExprNode(ExprNode): + # Yield expression node + # + # arg ExprNode the value to return from the generator + # label_num integer yield label number + # is_yield_from boolean is a YieldFromExprNode to delegate to another generator + + subexprs = ['arg'] + type = py_object_type + label_num = 0 + is_yield_from = False + is_await = False + in_async_gen = False + expr_keyword = 'yield' + + def analyse_types(self, env): + if not self.label_num or (self.is_yield_from and self.in_async_gen): + error(self.pos, "'%s' not supported here" % self.expr_keyword) + self.is_temp = 1 + if self.arg is not None: + self.arg = self.arg.analyse_types(env) + if not self.arg.type.is_pyobject: + self.coerce_yield_argument(env) + return self + + def coerce_yield_argument(self, env): + self.arg = self.arg.coerce_to_pyobject(env) + + def generate_evaluation_code(self, code): + if self.arg: + self.arg.generate_evaluation_code(code) + self.arg.make_owned_reference(code) + code.putln( + "%s = %s;" % ( + Naming.retval_cname, + self.arg.result_as(py_object_type))) + self.arg.generate_post_assignment_code(code) + self.arg.free_temps(code) + else: + code.put_init_to_py_none(Naming.retval_cname, py_object_type) + self.generate_yield_code(code) + + def generate_yield_code(self, code): + """ + Generate the code to return the argument in 'Naming.retval_cname' + and to continue at the yield label. + """ + label_num, resume_label = code.new_yield_label( + self.expr_keyword.replace(' ', '_')) + code.use_label(resume_label) + + saved = [] + code.funcstate.closure_temps.reset() + for cname, type, manage_ref in code.funcstate.temps_in_use(): + save_cname = code.funcstate.closure_temps.allocate_temp(type) + saved.append((cname, save_cname, type)) + if type.is_cpp_class: + code.globalstate.use_utility_code( + UtilityCode.load_cached("MoveIfSupported", "CppSupport.cpp")) + cname = "__PYX_STD_MOVE_IF_SUPPORTED(%s)" % cname + else: + code.put_xgiveref(cname, type) + code.putln('%s->%s = %s;' % (Naming.cur_scope_cname, save_cname, cname)) + + profile = code.globalstate.directives['profile'] + linetrace = code.globalstate.directives['linetrace'] + if profile or linetrace: + code.put_trace_yield(Naming.retval_cname, pos=self.pos) + + code.put_xgiveref(Naming.retval_cname, py_object_type) + code.put_finish_refcount_context() + + if code.funcstate.current_except is not None: + # inside of an except block => save away currently handled exception + code.putln("__Pyx_Coroutine_SwapException(%s);" % Naming.generator_cname) + else: + # no exceptions being handled => restore exception state of caller + code.putln("__Pyx_Coroutine_ResetAndClearException(%s);" % Naming.generator_cname) + + code.putln("/* return from %sgenerator, %sing value */" % ( + 'async ' if self.in_async_gen else '', + 'await' if self.is_await else 'yield')) + code.putln("%s->resume_label = %d;" % ( + Naming.generator_cname, label_num)) + if self.in_async_gen and not self.is_await: + # __Pyx__PyAsyncGenValueWrapperNew() steals a reference to the return value + code.putln("return __Pyx__PyAsyncGenValueWrapperNew(%s);" % Naming.retval_cname) + else: + code.putln("return %s;" % Naming.retval_cname) + + code.put_label(resume_label) + + if profile or linetrace: + code.put_trace_resume(self.pos) + + for cname, save_cname, type in saved: + save_cname = "%s->%s" % (Naming.cur_scope_cname, save_cname) + if type.is_cpp_class: + save_cname = "__PYX_STD_MOVE_IF_SUPPORTED(%s)" % save_cname + code.putln('%s = %s;' % (cname, save_cname)) + if type.is_pyobject: + code.putln('%s = 0;' % save_cname) + code.put_xgotref(cname, type) + elif type.is_memoryviewslice: + code.putln('%s.memview = NULL; %s.data = NULL;' % (save_cname, save_cname)) + self.generate_sent_value_handling_code(code, Naming.sent_value_cname) + if self.result_is_used: + self.allocate_temp_result(code) + code.put('%s = %s; ' % (self.result(), Naming.sent_value_cname)) + code.put_incref(self.result(), py_object_type) + + def generate_sent_value_handling_code(self, code, value_cname): + code.putln(code.error_goto_if_null(value_cname, self.pos)) + + +class _YieldDelegationExprNode(YieldExprNode): + def yield_from_func(self, code): + raise NotImplementedError() + + def generate_evaluation_code(self, code, source_cname=None, decref_source=False): + if source_cname is None: + self.arg.generate_evaluation_code(code) + result_temp = code.funcstate.allocate_temp(PyrexTypes.PySendResult_type, manage_ref=False) + code.putln("%s = %s(%s, %s, &%s);" % ( + result_temp, + self.yield_from_func(code), + Naming.generator_cname, + self.arg.py_result() if source_cname is None else source_cname, + Naming.retval_cname)) + + if source_cname is None: + self.arg.generate_disposal_code(code) + self.arg.free_temps(code) + elif decref_source: + code.put_decref_clear(source_cname, py_object_type) + + code.putln("if (likely(%s == PYGEN_NEXT)) {" % result_temp) + code.put_gotref(Naming.retval_cname, py_object_type) + code.funcstate.release_temp(result_temp) # before generating the yield code + self.generate_yield_code(code) + code.putln("} else if (likely(%s == PYGEN_RETURN)) {" % result_temp) + code.put_gotref(Naming.retval_cname, py_object_type) + if self.result_is_used: + self.fetch_iteration_result(code) + else: + code.put_decref_clear(Naming.retval_cname, py_object_type) + code.putln("} else {") + self.propagate_exception(code) + code.putln("}") + + def propagate_exception(self, code): + # YieldExprNode has allocated the result temp for us + code.put_xgotref(Naming.retval_cname, py_object_type) + code.putln(code.error_goto(self.pos)) + + def fetch_iteration_result(self, code): + # YieldExprNode has allocated the result temp for us + code.putln("%s = %s; %s = NULL;" % ( + self.result(), + Naming.retval_cname, + Naming.retval_cname, + )) + + +class YieldFromExprNode(_YieldDelegationExprNode): + # "yield from GEN" expression + is_yield_from = True + expr_keyword = 'yield from' + + def coerce_yield_argument(self, env): + if not self.arg.type.is_string: + # FIXME: support C arrays and C++ iterators? + error(self.pos, "yielding from non-Python object not supported") + self.arg = self.arg.coerce_to_pyobject(env) + + def yield_from_func(self, code): + code.globalstate.use_utility_code(UtilityCode.load_cached("GeneratorYieldFrom", "Coroutine.c")) + return "__Pyx_Generator_Yield_From" + + +class AwaitExprNode(_YieldDelegationExprNode): + # 'await' expression node + # + # arg ExprNode the Awaitable value to await + # label_num integer yield label number + + is_await = True + expr_keyword = 'await' + + def coerce_yield_argument(self, env): + if self.arg is not None: + # FIXME: use same check as in YieldFromExprNode.coerce_yield_argument() ? + self.arg = self.arg.coerce_to_pyobject(env) + + def yield_from_func(self, code): + code.globalstate.use_utility_code(UtilityCode.load_cached("CoroutineYieldFrom", "Coroutine.c")) + return "__Pyx_Coroutine_Yield_From" + + +class AwaitIterNextExprNode(AwaitExprNode): + # 'await' expression node as part of 'async for' iteration + # + # Breaks out of loop on StopAsyncIteration exception. + + def _generate_break(self, code): + code.putln("PyObject* exc_type = __Pyx_PyErr_CurrentExceptionType();") + code.putln("if (unlikely(exc_type && (exc_type == PyExc_StopAsyncIteration || (" + " exc_type != PyExc_StopIteration && exc_type != PyExc_GeneratorExit &&" + " __Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopAsyncIteration))))) {") + code.putln("PyErr_Clear();") + code.putln("break;") + code.putln("}") + + def propagate_exception(self, code): + self._generate_break(code) + super().propagate_exception(code) + + def generate_sent_value_handling_code(self, code, value_cname): + assert code.break_label, "AwaitIterNextExprNode outside of 'async for' loop" + code.putln("if (unlikely(!%s)) {" % value_cname) + self._generate_break(code) + # all non-break exceptions are errors, as in parent class + code.putln(code.error_goto(self.pos)) + code.putln("}") + + +class GlobalsExprNode(AtomicExprNode): + type = dict_type + is_temp = 1 + + def analyse_types(self, env): + env.use_utility_code(Builtin.globals_utility_code) + return self + + gil_message = "Constructing globals dict" + + def may_be_none(self): + return False + + def generate_result_code(self, code): + code.putln('%s = __Pyx_Globals(); %s' % ( + self.result(), + code.error_goto_if_null(self.result(), self.pos))) + self.generate_gotref(code) + + +class LocalsDictItemNode(DictItemNode): + def analyse_types(self, env): + self.key = self.key.analyse_types(env) + self.value = self.value.analyse_types(env) + self.key = self.key.coerce_to_pyobject(env) + if self.value.type.can_coerce_to_pyobject(env): + self.value = self.value.coerce_to_pyobject(env) + else: + self.value = None + return self + + +class FuncLocalsExprNode(DictNode): + def __init__(self, pos, env): + local_vars = sorted([ + entry.name for entry in env.entries.values() if entry.name]) + items = [LocalsDictItemNode( + pos, key=IdentifierStringNode(pos, value=var), + value=NameNode(pos, name=var, allow_null=True)) + for var in local_vars] + DictNode.__init__(self, pos, key_value_pairs=items, + exclude_null_values=True) + + def analyse_types(self, env): + node = super().analyse_types(env) + node.key_value_pairs = [ i for i in node.key_value_pairs + if i.value is not None ] + return node + + +class PyClassLocalsExprNode(AtomicExprNode): + def __init__(self, pos, pyclass_dict): + AtomicExprNode.__init__(self, pos) + self.pyclass_dict = pyclass_dict + + def analyse_types(self, env): + self.type = self.pyclass_dict.type + self.is_temp = False + return self + + def may_be_none(self): + return False + + def result(self): + return self.pyclass_dict.result() + + def generate_result_code(self, code): + pass + + +def LocalsExprNode(pos, scope_node, env): + if env.is_module_scope: + return GlobalsExprNode(pos) + if env.is_py_class_scope: + return PyClassLocalsExprNode(pos, scope_node.dict) + return FuncLocalsExprNode(pos, env) + + +#------------------------------------------------------------------- +# +# Unary operator nodes +# +#------------------------------------------------------------------- + +compile_time_unary_operators = { + 'not': operator.not_, + '~': operator.inv, + '-': operator.neg, + '+': operator.pos, +} + +class UnopNode(ExprNode): + # operator string + # operand ExprNode + # + # Processing during analyse_expressions phase: + # + # analyse_c_operation + # Called when the operand is not a pyobject. + # - Check operand type and coerce if needed. + # - Determine result type and result code fragment. + # - Allocate temporary for result if needed. + + subexprs = ['operand'] + infix = True + is_inc_dec_op = False + + def calculate_constant_result(self): + func = compile_time_unary_operators[self.operator] + self.constant_result = func(self.operand.constant_result) + + def compile_time_value(self, denv): + func = compile_time_unary_operators.get(self.operator) + if not func: + error(self.pos, + "Unary '%s' not supported in compile-time expression" + % self.operator) + operand = self.operand.compile_time_value(denv) + try: + return func(operand) + except Exception as e: + self.compile_time_value_error(e) + + def infer_type(self, env): + operand_type = self.operand.infer_type(env) + if operand_type.is_cpp_class or operand_type.is_ptr: + cpp_type = operand_type.find_cpp_operation_type(self.operator) + if cpp_type is not None: + return cpp_type + return self.infer_unop_type(env, operand_type) + + def infer_unop_type(self, env, operand_type): + if operand_type.is_pyobject and not operand_type.is_builtin_type: + return py_object_type + else: + return operand_type + + def may_be_none(self): + if self.operand.type and self.operand.type.is_builtin_type: + if self.operand.type is not type_type: + return False + return ExprNode.may_be_none(self) + + def analyse_types(self, env): + self.operand = self.operand.analyse_types(env) + if self.is_pythran_operation(env): + self.type = PythranExpr(pythran_unaryop_type(self.operator, self.operand.type)) + self.is_temp = 1 + elif self.is_py_operation(): + self.coerce_operand_to_pyobject(env) + self.type = py_object_type + self.is_temp = 1 + elif self.is_cpp_operation(): + self.analyse_cpp_operation(env) + else: + self.analyse_c_operation(env) + return self + + def check_const(self): + return self.operand.check_const() + + def is_py_operation(self): + return self.operand.type.is_pyobject or self.operand.type.is_ctuple + + def is_pythran_operation(self, env): + np_pythran = has_np_pythran(env) + op_type = self.operand.type + return np_pythran and (op_type.is_buffer or op_type.is_pythran_expr) + + def nogil_check(self, env): + if self.is_py_operation(): + self.gil_error() + + def is_cpp_operation(self): + type = self.operand.type + return type.is_cpp_class + + def coerce_operand_to_pyobject(self, env): + self.operand = self.operand.coerce_to_pyobject(env) + + def generate_result_code(self, code): + if self.type.is_pythran_expr: + code.putln("// Pythran unaryop") + code.putln("__Pyx_call_destructor(%s);" % self.result()) + code.putln("new (&%s) decltype(%s){%s%s};" % ( + self.result(), + self.result(), + self.operator, + self.operand.pythran_result())) + elif self.operand.type.is_pyobject: + self.generate_py_operation_code(code) + elif self.is_temp: + if self.is_cpp_operation() and self.exception_check == '+': + translate_cpp_exception(code, self.pos, + "%s = %s %s;" % (self.result(), self.operator, self.operand.result()), + self.result() if self.type.is_pyobject else None, + self.exception_value, self.in_nogil_context) + else: + code.putln("%s = %s %s;" % (self.result(), self.operator, self.operand.result())) + + def generate_py_operation_code(self, code): + function = self.py_operation_function(code) + code.putln( + "%s = %s(%s); %s" % ( + self.result(), + function, + self.operand.py_result(), + code.error_goto_if_null(self.result(), self.pos))) + self.generate_gotref(code) + + def type_error(self): + if not self.operand.type.is_error: + error(self.pos, "Invalid operand type for '%s' (%s)" % + (self.operator, self.operand.type)) + self.type = PyrexTypes.error_type + + def analyse_cpp_operation(self, env, overload_check=True): + operand_types = [self.operand.type] + if self.is_inc_dec_op and not self.is_prefix: + operand_types.append(PyrexTypes.c_int_type) + entry = env.lookup_operator_for_types(self.pos, self.operator, operand_types) + if overload_check and not entry: + self.type_error() + return + if entry: + self.exception_check = entry.type.exception_check + self.exception_value = entry.type.exception_value + if self.exception_check == '+': + self.is_temp = True + if needs_cpp_exception_conversion(self): + env.use_utility_code(UtilityCode.load_cached("CppExceptionConversion", "CppSupport.cpp")) + else: + self.exception_check = '' + self.exception_value = '' + if self.is_inc_dec_op and not self.is_prefix: + cpp_type = self.operand.type.find_cpp_operation_type( + self.operator, operand_type=PyrexTypes.c_int_type + ) + else: + cpp_type = self.operand.type.find_cpp_operation_type(self.operator) + if overload_check and cpp_type is None: + error(self.pos, "'%s' operator not defined for %s" % ( + self.operator, type)) + self.type_error() + return + self.type = cpp_type + + +class NotNode(UnopNode): + # 'not' operator + # + # operand ExprNode + operator = '!' + + type = PyrexTypes.c_bint_type + + def calculate_constant_result(self): + self.constant_result = not self.operand.constant_result + + def compile_time_value(self, denv): + operand = self.operand.compile_time_value(denv) + try: + return not operand + except Exception as e: + self.compile_time_value_error(e) + + def infer_unop_type(self, env, operand_type): + return PyrexTypes.c_bint_type + + def analyse_types(self, env): + self.operand = self.operand.analyse_types(env) + operand_type = self.operand.type + if operand_type.is_cpp_class: + self.analyse_cpp_operation(env) + else: + self.operand = self.operand.coerce_to_boolean(env) + return self + + def calculate_result_code(self): + return "(!%s)" % self.operand.result() + + +class UnaryPlusNode(UnopNode): + # unary '+' operator + + operator = '+' + + def analyse_c_operation(self, env): + self.type = PyrexTypes.widest_numeric_type( + self.operand.type, PyrexTypes.c_int_type) + + def py_operation_function(self, code): + return "PyNumber_Positive" + + def calculate_result_code(self): + if self.is_cpp_operation(): + return "(+%s)" % self.operand.result() + else: + return self.operand.result() + + +class UnaryMinusNode(UnopNode): + # unary '-' operator + + operator = '-' + + def analyse_c_operation(self, env): + if self.operand.type.is_numeric: + self.type = PyrexTypes.widest_numeric_type( + self.operand.type, PyrexTypes.c_int_type) + elif self.operand.type.is_enum: + self.type = PyrexTypes.c_int_type + else: + self.type_error() + if self.type.is_complex: + self.infix = False + + def py_operation_function(self, code): + return "PyNumber_Negative" + + def calculate_result_code(self): + if self.infix: + return "(-%s)" % self.operand.result() + else: + return "%s(%s)" % (self.operand.type.unary_op('-'), self.operand.result()) + + def get_constant_c_result_code(self): + value = self.operand.get_constant_c_result_code() + if value: + return "(-%s)" % value + +class TildeNode(UnopNode): + # unary '~' operator + + def analyse_c_operation(self, env): + if self.operand.type.is_int: + self.type = PyrexTypes.widest_numeric_type( + self.operand.type, PyrexTypes.c_int_type) + elif self.operand.type.is_enum: + self.type = PyrexTypes.c_int_type + else: + self.type_error() + + def py_operation_function(self, code): + return "PyNumber_Invert" + + def calculate_result_code(self): + return "(~%s)" % self.operand.result() + + +class CUnopNode(UnopNode): + + def is_py_operation(self): + return False + +class DereferenceNode(CUnopNode): + # unary * operator + + operator = '*' + + def infer_unop_type(self, env, operand_type): + if operand_type.is_ptr: + return operand_type.base_type + else: + return PyrexTypes.error_type + + def analyse_c_operation(self, env): + if self.operand.type.is_ptr: + if env.is_cpp: + self.type = PyrexTypes.CReferenceType(self.operand.type.base_type) + else: + self.type = self.operand.type.base_type + else: + self.type_error() + + def calculate_result_code(self): + return "(*%s)" % self.operand.result() + + +class DecrementIncrementNode(CUnopNode): + # unary ++/-- operator + is_inc_dec_op = True + + def type_error(self): + if not self.operand.type.is_error: + if self.is_prefix: + error(self.pos, "No match for 'operator%s' (operand type is '%s')" % + (self.operator, self.operand.type)) + else: + error(self.pos, "No 'operator%s(int)' declared for postfix '%s' (operand type is '%s')" % + (self.operator, self.operator, self.operand.type)) + self.type = PyrexTypes.error_type + + def analyse_c_operation(self, env): + if self.operand.type.is_numeric: + self.type = PyrexTypes.widest_numeric_type( + self.operand.type, PyrexTypes.c_int_type) + elif self.operand.type.is_ptr: + self.type = self.operand.type + else: + self.type_error() + + def calculate_result_code(self): + if self.is_prefix: + return "(%s%s)" % (self.operator, self.operand.result()) + else: + return "(%s%s)" % (self.operand.result(), self.operator) + +def inc_dec_constructor(is_prefix, operator): + return lambda pos, **kwds: DecrementIncrementNode(pos, is_prefix=is_prefix, operator=operator, **kwds) + + +class AmpersandNode(CUnopNode): + # The C address-of operator. + # + # operand ExprNode + operator = '&' + + def infer_unop_type(self, env, operand_type): + return PyrexTypes.c_ptr_type(operand_type) + + def analyse_types(self, env): + self.operand = self.operand.analyse_types(env) + argtype = self.operand.type + if argtype.is_cpp_class: + self.analyse_cpp_operation(env, overload_check=False) + if not (argtype.is_cfunction or argtype.is_reference or self.operand.is_addressable()): + if argtype.is_memoryviewslice: + self.error("Cannot take address of memoryview slice") + else: + self.error("Taking address of non-lvalue (type %s)" % argtype) + return self + if argtype.is_pyobject: + self.error("Cannot take address of Python %s" % ( + "variable '%s'" % self.operand.name if self.operand.is_name else + "object attribute '%s'" % self.operand.attribute if self.operand.is_attribute else + "object")) + return self + if not argtype.is_cpp_class or not self.type: + self.type = PyrexTypes.c_ptr_type(argtype) + return self + + def check_const(self): + return self.operand.check_const_addr() + + def error(self, mess): + error(self.pos, mess) + self.type = PyrexTypes.error_type + self.result_code = "" + + def calculate_result_code(self): + return "(&%s)" % self.operand.result() + + def generate_result_code(self, code): + if (self.operand.type.is_cpp_class and self.exception_check == '+'): + translate_cpp_exception(code, self.pos, + "%s = %s %s;" % (self.result(), self.operator, self.operand.result()), + self.result() if self.type.is_pyobject else None, + self.exception_value, self.in_nogil_context) + + +unop_node_classes = { + "+": UnaryPlusNode, + "-": UnaryMinusNode, + "~": TildeNode, +} + +def unop_node(pos, operator, operand): + # Construct unnop node of appropriate class for + # given operator. + if isinstance(operand, IntNode) and operator == '-': + return IntNode(pos = operand.pos, value = str(-Utils.str_to_number(operand.value)), + longness=operand.longness, unsigned=operand.unsigned) + elif isinstance(operand, UnopNode) and operand.operator == operator in '+-': + warning(pos, "Python has no increment/decrement operator: %s%sx == %s(%sx) == x" % ((operator,)*4), 5) + return unop_node_classes[operator](pos, + operator = operator, + operand = operand) + + +class TypecastNode(ExprNode): + # C type cast + # + # operand ExprNode + # base_type CBaseTypeNode + # declarator CDeclaratorNode + # typecheck boolean + # + # If used from a transform, one can if wanted specify the attribute + # "type" directly and leave base_type and declarator to None + + subexprs = ['operand'] + base_type = declarator = type = None + + def type_dependencies(self, env): + return () + + def infer_type(self, env): + if self.type is None: + base_type = self.base_type.analyse(env) + _, self.type = self.declarator.analyse(base_type, env) + return self.type + + def analyse_types(self, env): + if self.type is None: + base_type = self.base_type.analyse(env) + _, self.type = self.declarator.analyse(base_type, env) + if self.operand.has_constant_result(): + # Must be done after self.type is resolved. + self.calculate_constant_result() + if self.type.is_cfunction: + error(self.pos, + "Cannot cast to a function type") + self.type = PyrexTypes.error_type + self.operand = self.operand.analyse_types(env) + if self.type is PyrexTypes.c_bint_type: + # short circuit this to a coercion + return self.operand.coerce_to_boolean(env) + to_py = self.type.is_pyobject + from_py = self.operand.type.is_pyobject + if from_py and not to_py and self.operand.is_ephemeral(): + if not self.type.is_numeric and not self.type.is_cpp_class: + error(self.pos, "Casting temporary Python object to non-numeric non-Python type") + if to_py and not from_py: + if self.type is bytes_type and self.operand.type.is_int: + return CoerceIntToBytesNode(self.operand, env) + elif self.operand.type.can_coerce_to_pyobject(env): + self.result_ctype = py_object_type + self.operand = self.operand.coerce_to(self.type, env) + else: + if self.operand.type.is_ptr: + if not (self.operand.type.base_type.is_void or self.operand.type.base_type.is_struct): + error(self.pos, "Python objects cannot be cast from pointers of primitive types") + else: + # Should this be an error? + warning(self.pos, "No conversion from %s to %s, python object pointer used." % ( + self.operand.type, self.type)) + self.operand = self.operand.coerce_to_simple(env) + elif from_py and not to_py: + if self.type.create_from_py_utility_code(env): + self.operand = self.operand.coerce_to(self.type, env) + elif self.type.is_ptr: + if not (self.type.base_type.is_void or self.type.base_type.is_struct): + error(self.pos, "Python objects cannot be cast to pointers of primitive types") + else: + warning(self.pos, "No conversion from %s to %s, python object pointer used." % ( + self.type, self.operand.type)) + elif from_py and to_py: + if self.typecheck: + self.operand = PyTypeTestNode(self.operand, self.type, env, notnone=True) + elif isinstance(self.operand, SliceIndexNode): + # This cast can influence the created type of string slices. + self.operand = self.operand.coerce_to(self.type, env) + elif self.type.is_complex and self.operand.type.is_complex: + self.operand = self.operand.coerce_to_simple(env) + elif self.operand.type.is_fused: + self.operand = self.operand.coerce_to(self.type, env) + #self.type = self.operand.type + if self.type.is_ptr and self.type.base_type.is_cfunction and self.type.base_type.nogil: + op_type = self.operand.type + if op_type.is_ptr: + op_type = op_type.base_type + if op_type.is_cfunction and not op_type.nogil: + warning(self.pos, + "Casting a GIL-requiring function into a nogil function circumvents GIL validation", 1) + return self + + def is_simple(self): + # either temp or a C cast => no side effects other than the operand's + return self.operand.is_simple() + + def is_ephemeral(self): + # either temp or a C cast => no side effects other than the operand's + return self.operand.is_ephemeral() + + def nonlocally_immutable(self): + return self.is_temp or self.operand.nonlocally_immutable() + + def nogil_check(self, env): + if self.type and self.type.is_pyobject and self.is_temp: + self.gil_error() + + def check_const(self): + return self.operand.check_const() + + def calculate_constant_result(self): + self.constant_result = self.calculate_result_code(self.operand.constant_result) + + def calculate_result_code(self, operand_result = None): + if operand_result is None: + operand_result = self.operand.result() + if self.type.is_complex: + operand_result = self.operand.result() + if self.operand.type.is_complex: + real_part = self.type.real_type.cast_code( + self.operand.type.real_code(operand_result)) + imag_part = self.type.real_type.cast_code( + self.operand.type.imag_code(operand_result)) + else: + real_part = self.type.real_type.cast_code(operand_result) + imag_part = "0" + return "%s(%s, %s)" % ( + self.type.from_parts, + real_part, + imag_part) + else: + return self.type.cast_code(operand_result) + + def get_constant_c_result_code(self): + operand_result = self.operand.get_constant_c_result_code() + if operand_result: + return self.type.cast_code(operand_result) + + def result_as(self, type): + if self.type.is_pyobject and not self.is_temp: + # Optimise away some unnecessary casting + return self.operand.result_as(type) + else: + return ExprNode.result_as(self, type) + + def generate_result_code(self, code): + if self.is_temp: + code.putln( + "%s = (PyObject *)%s;" % ( + self.result(), + self.operand.result())) + code.put_incref(self.result(), self.ctype()) + + +ERR_START = "Start may not be given" +ERR_NOT_STOP = "Stop must be provided to indicate shape" +ERR_STEPS = ("Strides may only be given to indicate contiguity. " + "Consider slicing it after conversion") +ERR_NOT_POINTER = "Can only create cython.array from pointer or array" +ERR_BASE_TYPE = "Pointer base type does not match cython.array base type" + + +class CythonArrayNode(ExprNode): + """ + Used when a pointer of base_type is cast to a memoryviewslice with that + base type. i.e. + + p + + creates a fortran-contiguous cython.array. + + We leave the type set to object so coercions to object are more efficient + and less work. Acquiring a memoryviewslice from this will be just as + efficient. ExprNode.coerce_to() will do the additional typecheck on + self.compile_time_type + + This also handles my_c_array + + + operand ExprNode the thing we're casting + base_type_node MemoryViewSliceTypeNode the cast expression node + """ + + subexprs = ['operand', 'shapes'] + + shapes = None + is_temp = True + mode = "c" + array_dtype = None + + shape_type = PyrexTypes.c_py_ssize_t_type + + def analyse_types(self, env): + from . import MemoryView + + self.operand = self.operand.analyse_types(env) + if self.array_dtype: + array_dtype = self.array_dtype + else: + array_dtype = self.base_type_node.base_type_node.analyse(env) + axes = self.base_type_node.axes + + self.type = error_type + self.shapes = [] + ndim = len(axes) + + # Base type of the pointer or C array we are converting + base_type = self.operand.type + + if not self.operand.type.is_ptr and not self.operand.type.is_array: + error(self.operand.pos, ERR_NOT_POINTER) + return self + + # Dimension sizes of C array + array_dimension_sizes = [] + if base_type.is_array: + while base_type.is_array: + array_dimension_sizes.append(base_type.size) + base_type = base_type.base_type + elif base_type.is_ptr: + base_type = base_type.base_type + else: + error(self.pos, "unexpected base type %s found" % base_type) + return self + + if not (base_type.same_as(array_dtype) or base_type.is_void): + error(self.operand.pos, ERR_BASE_TYPE) + return self + elif self.operand.type.is_array and len(array_dimension_sizes) != ndim: + error(self.operand.pos, + "Expected %d dimensions, array has %d dimensions" % + (ndim, len(array_dimension_sizes))) + return self + + # Verify the start, stop and step values + # In case of a C array, use the size of C array in each dimension to + # get an automatic cast + for axis_no, axis in enumerate(axes): + if not axis.start.is_none: + error(axis.start.pos, ERR_START) + return self + + if axis.stop.is_none: + if array_dimension_sizes: + dimsize = array_dimension_sizes[axis_no] + axis.stop = IntNode(self.pos, value=str(dimsize), + constant_result=dimsize, + type=PyrexTypes.c_int_type) + else: + error(axis.pos, ERR_NOT_STOP) + return self + + axis.stop = axis.stop.analyse_types(env) + shape = axis.stop.coerce_to(self.shape_type, env) + if not shape.is_literal: + shape.coerce_to_temp(env) + + self.shapes.append(shape) + + first_or_last = axis_no in (0, ndim - 1) + if not axis.step.is_none and first_or_last: + # '1' in the first or last dimension denotes F or C contiguity + axis.step = axis.step.analyse_types(env) + if (not axis.step.type.is_int and axis.step.is_literal and not + axis.step.type.is_error): + error(axis.step.pos, "Expected an integer literal") + return self + + if axis.step.compile_time_value(env) != 1: + error(axis.step.pos, ERR_STEPS) + return self + + if axis_no == 0: + self.mode = "fortran" + + elif not axis.step.is_none and not first_or_last: + # step provided in some other dimension + error(axis.step.pos, ERR_STEPS) + return self + + if not self.operand.is_name: + self.operand = self.operand.coerce_to_temp(env) + + axes = [('direct', 'follow')] * len(axes) + if self.mode == "fortran": + axes[0] = ('direct', 'contig') + else: + axes[-1] = ('direct', 'contig') + + self.coercion_type = PyrexTypes.MemoryViewSliceType(array_dtype, axes) + self.coercion_type.validate_memslice_dtype(self.pos) + self.type = self.get_cython_array_type(env) + MemoryView.use_cython_array_utility_code(env) + env.use_utility_code( + MemoryView.get_typeinfo_to_format_code(env.context.shared_utility_qualified_name) + ) + return self + + def allocate_temp_result(self, code): + if self.temp_code: + raise RuntimeError("temp allocated multiple times") + + self.temp_code = code.funcstate.allocate_temp(self.type, True) + + def infer_type(self, env): + return self.get_cython_array_type(env) + + def get_cython_array_type(self, env): + cython_scope = env.context.cython_scope + cython_scope.load_cythonscope() + return cython_scope.viewscope.lookup("array").type + + def generate_result_code(self, code): + from . import Buffer + + shapes = [self.shape_type.cast_code(shape.result()) + for shape in self.shapes] + dtype = self.coercion_type.dtype + + shapes_temp = code.funcstate.allocate_temp(py_object_type, True) + format_temp = code.funcstate.allocate_temp(py_object_type, True) + format_ptr_temp = code.funcstate.allocate_temp(c_char_ptr_type, True) + + itemsize = "sizeof(%s)" % dtype.empty_declaration_code() + type_info = Buffer.get_type_information_cname(code, dtype) + + if self.operand.type.is_ptr: + code.putln("if (!%s) {" % self.operand.result()) + code.putln( 'PyErr_SetString(PyExc_ValueError,' + '"Cannot create cython.array from NULL pointer");') + code.putln(code.error_goto(self.operand.pos)) + code.putln("}") + + code.putln("%s = __pyx_format_from_typeinfo(&%s); %s" % ( + format_temp, + type_info, + code.error_goto_if_null(format_temp, self.pos), + )) + code.put_gotref(format_temp, py_object_type) + + buildvalue_fmt = " __PYX_BUILD_PY_SSIZE_T " * len(shapes) + code.putln('%s = Py_BuildValue("(" %s ")", %s); %s' % ( + shapes_temp, + buildvalue_fmt, + ", ".join(shapes), + code.error_goto_if_null(shapes_temp, self.pos), + )) + code.put_gotref(shapes_temp, py_object_type) + + + code.putln("#if CYTHON_COMPILING_IN_LIMITED_API") + code.putln('%s = PyBytes_AsString(%s); %s' % ( + format_ptr_temp, format_temp, + code.error_goto_if_null(format_ptr_temp, self.pos), + )) + code.putln("#else") + code.putln('%s = PyBytes_AS_STRING(%s);' % ( + format_ptr_temp, format_temp, + )) + code.putln("#endif") + + code.putln('%s = __pyx_array_new(%s, %s, %s, "%s", (char *) %s); %s' % ( + self.result(), + shapes_temp, itemsize, format_ptr_temp, self.mode, self.operand.result(), + code.error_goto_if_null(self.result(), self.pos), + )) + self.generate_gotref(code) + + def dispose(temp): + code.put_decref_clear(temp, py_object_type) + code.funcstate.release_temp(temp) + + dispose(shapes_temp) + dispose(format_temp) + code.funcstate.release_temp(format_ptr_temp) + + @classmethod + def from_carray(cls, src_node, env): + """ + Given a C array type, return a CythonArrayNode + """ + pos = src_node.pos + base_type = src_node.type + + none_node = NoneNode(pos) + axes = [] + + while base_type.is_array: + axes.append(SliceNode(pos, start=none_node, stop=none_node, + step=none_node)) + base_type = base_type.base_type + axes[-1].step = IntNode(pos, value="1", is_c_literal=True) + + memslicenode = Nodes.MemoryViewSliceTypeNode(pos, axes=axes, + base_type_node=base_type) + result = CythonArrayNode(pos, base_type_node=memslicenode, + operand=src_node, array_dtype=base_type) + result = result.analyse_types(env) + return result + +class SizeofNode(ExprNode): + # Abstract base class for sizeof(x) expression nodes. + + type = PyrexTypes.c_size_t_type + + def check_const(self): + return True + + def generate_result_code(self, code): + pass + + +class SizeofTypeNode(SizeofNode): + # C sizeof function applied to a type + # + # base_type CBaseTypeNode + # declarator CDeclaratorNode + + subexprs = [] + arg_type = None + + def analyse_types(self, env): + # we may have incorrectly interpreted a dotted name as a type rather than an attribute + # this could be better handled by more uniformly treating types as runtime-available objects + if 0 and self.base_type.module_path: + path = self.base_type.module_path + obj = env.lookup(path[0]) + if obj.as_module is None: + operand = NameNode(pos=self.pos, name=path[0]) + for attr in path[1:]: + operand = AttributeNode(pos=self.pos, obj=operand, attribute=attr) + operand = AttributeNode(pos=self.pos, obj=operand, attribute=self.base_type.name) + node = SizeofVarNode(self.pos, operand=operand).analyse_types(env) + return node + if self.arg_type is None: + base_type = self.base_type.analyse(env) + _, arg_type = self.declarator.analyse(base_type, env) + self.arg_type = arg_type + self.check_type() + return self + + def check_type(self): + arg_type = self.arg_type + if not arg_type: + return + if arg_type.is_pyobject and not arg_type.is_extension_type: + error(self.pos, "Cannot take sizeof Python object") + elif arg_type.is_void: + error(self.pos, "Cannot take sizeof void") + elif not arg_type.is_complete(): + error(self.pos, "Cannot take sizeof incomplete type '%s'" % arg_type) + + def calculate_result_code(self): + if self.arg_type.is_extension_type: + # the size of the pointer is boring + # we want the size of the actual struct + arg_code = self.arg_type.declaration_code("", deref=1) + else: + arg_code = self.arg_type.empty_declaration_code() + return "(sizeof(%s))" % arg_code + + +class SizeofVarNode(SizeofNode): + # C sizeof function applied to a variable + # + # operand ExprNode + + subexprs = ['operand'] + + def analyse_types(self, env): + # We may actually be looking at a type rather than a variable... + # If we are, traditional analysis would fail... + operand_as_type = self.operand.analyse_as_type(env) + if operand_as_type: + self.arg_type = operand_as_type + if self.arg_type.is_fused: + try: + self.arg_type = self.arg_type.specialize(env.fused_to_specific) + except CannotSpecialize: + error(self.operand.pos, + "Type cannot be specialized since it is not a fused argument to this function") + self.__class__ = SizeofTypeNode + self.check_type() + else: + self.operand = self.operand.analyse_types(env) + return self + + def calculate_result_code(self): + return "(sizeof(%s))" % self.operand.result() + + def generate_result_code(self, code): + pass + + +class TypeidNode(ExprNode): + # C++ typeid operator applied to a type or variable + # + # operand ExprNode + # arg_type ExprNode + # is_variable boolean + + subexprs = ['operand'] + + arg_type = None + is_variable = None + is_temp = 1 + + def get_type_info_type(self, env): + env_module = env + while not env_module.is_module_scope: + env_module = env_module.outer_scope + typeinfo_module = env_module.find_module('libcpp.typeinfo', self.pos) + typeinfo_entry = typeinfo_module.lookup('type_info') + return PyrexTypes.CFakeReferenceType(PyrexTypes.c_const_or_volatile_type(typeinfo_entry.type, is_const=True)) + + cpp_message = 'typeid operator' + + def analyse_types(self, env): + if not self.type: + self.type = PyrexTypes.error_type # default value if it isn't analysed successfully + self.cpp_check(env) + type_info = self.get_type_info_type(env) + if not type_info: + self.error("The 'libcpp.typeinfo' module must be cimported to use the typeid() operator") + return self + if self.operand is None: + return self # already analysed, no need to repeat + self.type = type_info + as_type = self.operand.analyse_as_specialized_type(env) + if as_type: + self.arg_type = as_type + self.is_type = True + self.operand = None # nothing further uses self.operand - will only cause problems if its used in code generation + else: + self.arg_type = self.operand.analyse_types(env) + self.is_type = False + self.operand = None # nothing further uses self.operand - will only cause problems if its used in code generation + if self.arg_type.type.is_pyobject: + self.error("Cannot use typeid on a Python object") + return self + elif self.arg_type.type.is_void: + self.error("Cannot use typeid on void") + return self + elif not self.arg_type.type.is_complete(): + self.error("Cannot use typeid on incomplete type '%s'" % self.arg_type.type) + return self + env.use_utility_code(UtilityCode.load_cached("CppExceptionConversion", "CppSupport.cpp")) + return self + + def error(self, mess): + error(self.pos, mess) + self.type = PyrexTypes.error_type + self.result_code = "" + + def check_const(self): + return True + + def calculate_result_code(self): + return self.temp_code + + def generate_result_code(self, code): + if self.is_type: + arg_code = self.arg_type.empty_declaration_code() + else: + arg_code = self.arg_type.result() + translate_cpp_exception(code, self.pos, + "%s = typeid(%s);" % (self.temp_code, arg_code), + None, None, self.in_nogil_context) + +class TypeofNode(ExprNode): + # Compile-time type of an expression, as a string. + # + # operand ExprNode + # literal UnicodeNode # internal + + literal = None + type = py_object_type + + subexprs = ['literal'] # 'operand' will be ignored after type analysis! + + def analyse_types(self, env): + self.operand = self.operand.analyse_types(env) + value = StringEncoding.EncodedString(str(self.operand.type)) #self.operand.type.typeof_name()) + literal = UnicodeNode(self.pos, value=value) + literal = literal.analyse_types(env) + self.literal = literal.coerce_to_pyobject(env) + return self + + def analyse_as_type(self, env): + self.operand = self.operand.analyse_types(env) + return self.operand.type + + def may_be_none(self): + return False + + def generate_evaluation_code(self, code): + self.literal.generate_evaluation_code(code) + + def calculate_result_code(self): + return self.literal.calculate_result_code() + +#------------------------------------------------------------------- +# +# Binary operator nodes +# +#------------------------------------------------------------------- + +try: + matmul_operator = operator.matmul +except AttributeError: + def matmul_operator(a, b): + try: + func = a.__matmul__ + except AttributeError: + func = b.__rmatmul__ + return func(a, b) + +compile_time_binary_operators = { + '<': operator.lt, + '<=': operator.le, + '==': operator.eq, + '!=': operator.ne, + '>=': operator.ge, + '>': operator.gt, + 'is': operator.is_, + 'is_not': operator.is_not, + '+': operator.add, + '&': operator.and_, + '/': operator.truediv, + '//': operator.floordiv, + '<<': operator.lshift, + '%': operator.mod, + '*': operator.mul, + '|': operator.or_, + '**': operator.pow, + '>>': operator.rshift, + '-': operator.sub, + '^': operator.xor, + '@': matmul_operator, + 'in': lambda x, seq: x in seq, + 'not_in': lambda x, seq: x not in seq, +} + +def get_compile_time_binop(node): + func = compile_time_binary_operators.get(node.operator) + if not func: + error(node.pos, + "Binary '%s' not supported in compile-time expression" + % node.operator) + return func + + +class BinopNode(ExprNode): + # operator string + # operand1 ExprNode + # operand2 ExprNode + # + # Processing during analyse_expressions phase: + # + # analyse_c_operation + # Called when neither operand is a pyobject. + # - Check operand types and coerce if needed. + # - Determine result type and result code fragment. + # - Allocate temporary for result if needed. + + subexprs = ['operand1', 'operand2'] + inplace = False + + def calculate_constant_result(self): + func = compile_time_binary_operators[self.operator] + self.constant_result = func( + self.operand1.constant_result, + self.operand2.constant_result) + + def compile_time_value(self, denv): + func = get_compile_time_binop(self) + operand1 = self.operand1.compile_time_value(denv) + operand2 = self.operand2.compile_time_value(denv) + try: + return func(operand1, operand2) + except Exception as e: + self.compile_time_value_error(e) + + def infer_type(self, env): + return self.result_type(self.operand1.infer_type(env), + self.operand2.infer_type(env), env) + + def analyse_types(self, env): + self.operand1 = self.operand1.analyse_types(env) + self.operand2 = self.operand2.analyse_types(env) + return self.analyse_operation(env) + + def analyse_operation(self, env): + if self.is_pythran_operation(env): + self.type = self.result_type(self.operand1.type, + self.operand2.type, env) + assert self.type.is_pythran_expr + self.is_temp = 1 + elif self.is_py_operation(): + self.coerce_operands_to_pyobjects(env) + self.type = self.result_type(self.operand1.type, + self.operand2.type, env) + self.is_temp = 1 + if not self.type.is_pyobject: + original_type, self.type = self.type, py_object_type + # Hopefully this can be optimized out in some cases + return self.coerce_to(original_type, env) + + elif self.is_cpp_operation(): + self.analyse_cpp_operation(env) + else: + self.analyse_c_operation(env) + return self # when modifying this function, remember that the + # DivNode and ModNode expect it to return either self, or something + # that wraps self - they relying on modifying self afterwards. + + def is_py_operation(self): + return self.is_py_operation_types(self.operand1.type, self.operand2.type) + + def is_py_operation_types(self, type1, type2): + return type1.is_pyobject or type2.is_pyobject or type1.is_ctuple or type2.is_ctuple + + def is_pythran_operation(self, env): + return self.is_pythran_operation_types(self.operand1.type, self.operand2.type, env) + + def is_pythran_operation_types(self, type1, type2, env): + # Support only expr op supported_type, or supported_type op expr + return has_np_pythran(env) and \ + (is_pythran_supported_operation_type(type1) and is_pythran_supported_operation_type(type2)) and \ + (is_pythran_expr(type1) or is_pythran_expr(type2)) + + def is_cpp_operation(self): + return (self.operand1.type.is_cpp_class + or self.operand2.type.is_cpp_class) + + def analyse_cpp_operation(self, env): + entry = env.lookup_operator(self.operator, [self.operand1, self.operand2]) + if not entry: + self.type_error() + return + func_type = entry.type + self.exception_check = func_type.exception_check + self.exception_value = func_type.exception_value + if self.exception_check == '+': + # Used by NumBinopNodes to break up expressions involving multiple + # operators so that exceptions can be handled properly. + self.is_temp = 1 + if needs_cpp_exception_conversion(self): + env.use_utility_code(UtilityCode.load_cached("CppExceptionConversion", "CppSupport.cpp")) + if func_type.is_ptr: + func_type = func_type.base_type + if len(func_type.args) == 1: + self.operand2 = self.operand2.coerce_to(func_type.args[0].type, env) + else: + self.operand1 = self.operand1.coerce_to(func_type.args[0].type, env) + self.operand2 = self.operand2.coerce_to(func_type.args[1].type, env) + self.type = func_type.return_type + + def result_type(self, type1, type2, env): + if self.is_pythran_operation_types(type1, type2, env): + return PythranExpr(pythran_binop_type(self.operator, type1, type2)) + if self.is_py_operation_types(type1, type2): + if type2.is_string: + type2 = Builtin.bytes_type + elif type2.is_pyunicode_ptr: + type2 = Builtin.unicode_type + if type1.is_string: + type1 = Builtin.bytes_type + elif type1.is_pyunicode_ptr: + type1 = Builtin.unicode_type + if type1.is_builtin_type or type2.is_builtin_type: + if type1 is type2 and type1 is not type_type and self.operator in '**%+|&^': + # FIXME: at least these operators should be safe - others? + return type1 + result_type = self.infer_builtin_types_operation(type1, type2) + if result_type is not None: + return result_type + return py_object_type + elif type1.is_error or type2.is_error: + return PyrexTypes.error_type + else: + return self.compute_c_result_type(type1, type2) + + def infer_builtin_types_operation(self, type1, type2): + return None + + def nogil_check(self, env): + if self.is_py_operation(): + self.gil_error() + + def coerce_operands_to_pyobjects(self, env): + self.operand1 = self.operand1.coerce_to_pyobject(env) + self.operand2 = self.operand2.coerce_to_pyobject(env) + + def check_const(self): + return self.operand1.check_const() and self.operand2.check_const() + + def is_ephemeral(self): + return (super().is_ephemeral() or + self.operand1.is_ephemeral() or self.operand2.is_ephemeral()) + + def generate_result_code(self, code): + type1 = self.operand1.type + type2 = self.operand2.type + if self.type.is_pythran_expr: + code.putln("// Pythran binop") + code.putln("__Pyx_call_destructor(%s);" % self.result()) + if self.operator == '**': + code.putln("new (&%s) decltype(%s){pythonic::numpy::functor::power{}(%s, %s)};" % ( + self.result(), + self.result(), + self.operand1.pythran_result(), + self.operand2.pythran_result())) + else: + code.putln("new (&%s) decltype(%s){%s %s %s};" % ( + self.result(), + self.result(), + self.operand1.pythran_result(), + self.operator, + self.operand2.pythran_result())) + elif type1.is_pyobject or type2.is_pyobject: + function = self.py_operation_function(code) + extra_args = ", Py_None" if self.operator == '**' else "" + op1_result = self.operand1.py_result() if type1.is_pyobject else self.operand1.result() + op2_result = self.operand2.py_result() if type2.is_pyobject else self.operand2.result() + code.putln( + "%s = %s(%s, %s%s); %s" % ( + self.result(), + function, + op1_result, + op2_result, + extra_args, + code.error_goto_if_null(self.result(), self.pos))) + self.generate_gotref(code) + elif self.is_temp: + # C++ overloaded operators with exception values are currently all + # handled through temporaries. + if self.is_cpp_operation() and self.exception_check == '+': + translate_cpp_exception(code, self.pos, + "%s = %s;" % (self.result(), self.calculate_result_code()), + self.result() if self.type.is_pyobject else None, + self.exception_value, self.in_nogil_context) + else: + code.putln("%s = %s;" % (self.result(), self.calculate_result_code())) + + def type_error(self): + if not (self.operand1.type.is_error + or self.operand2.type.is_error): + error(self.pos, "Invalid operand types for '%s' (%s; %s)" % + (self.operator, self.operand1.type, + self.operand2.type)) + self.type = PyrexTypes.error_type + + +class CBinopNode(BinopNode): + + def analyse_types(self, env): + node = BinopNode.analyse_types(self, env) + if node.is_py_operation(): + node.type = PyrexTypes.error_type + return node + + def py_operation_function(self, code): + return "" + + def calculate_result_code(self): + return "(%s %s %s)" % ( + self.operand1.result(), + self.operator, + self.operand2.result()) + + def compute_c_result_type(self, type1, type2): + cpp_type = None + if type1.is_cpp_class or type1.is_ptr: + cpp_type = type1.find_cpp_operation_type(self.operator, type2) + if cpp_type is None and (type2.is_cpp_class or type2.is_ptr): + cpp_type = type2.find_cpp_operation_type(self.operator, type1) + # FIXME: do we need to handle other cases here? + return cpp_type + + +def c_binop_constructor(operator): + def make_binop_node(pos, **operands): + return CBinopNode(pos, operator=operator, **operands) + return make_binop_node + +class NumBinopNode(BinopNode): + # Binary operation taking numeric arguments. + + infix = True + overflow_check = False + overflow_bit_node = None + + def analyse_c_operation(self, env): + type1 = self.operand1.type + type2 = self.operand2.type + self.type = self.compute_c_result_type(type1, type2) + if not self.type: + self.type_error() + return + if self.type.is_complex: + self.infix = False + if (self.type.is_int + and env.directives['overflowcheck'] + and self.operator in self.overflow_op_names): + if (self.operator in ('+', '*') + and self.operand1.has_constant_result() + and not self.operand2.has_constant_result()): + self.operand1, self.operand2 = self.operand2, self.operand1 + self.overflow_check = True + self.overflow_fold = env.directives['overflowcheck.fold'] + self.func = self.type.overflow_check_binop( + self.overflow_op_names[self.operator], + env, + const_rhs = self.operand2.has_constant_result()) + self.is_temp = True + if not self.infix or (type1.is_numeric and type2.is_numeric): + self.operand1 = self.operand1.coerce_to(self.type, env) + self.operand2 = self.operand2.coerce_to(self.type, env) + + def compute_c_result_type(self, type1, type2): + if self.c_types_okay(type1, type2): + widest_type = PyrexTypes.widest_numeric_type(type1, type2) + if widest_type is PyrexTypes.c_bint_type: + if self.operator not in '|^&': + # False + False == 0 # not False! + widest_type = PyrexTypes.c_int_type + else: + widest_type = PyrexTypes.widest_numeric_type( + widest_type, PyrexTypes.c_int_type) + return widest_type + else: + return None + + def infer_builtin_types_operation(self, type1, type2): + if type1.is_builtin_type: + return PyrexTypes.result_type_of_builtin_operation(type1, type2) + else: + return PyrexTypes.result_type_of_builtin_operation(type2, type1) + + def may_be_none(self): + if self.type and self.type.is_builtin_type: + # if we know the result type, we know the operation, so it can't be None + return False + type1 = self.operand1.type + type2 = self.operand2.type + if type1 and type1.is_builtin_type and type2 and type2.is_builtin_type: + # XXX: I can't think of any case where a binary operation + # on builtin types evaluates to None - add a special case + # here if there is one. + return False + return super().may_be_none() + + def get_constant_c_result_code(self): + value1 = self.operand1.get_constant_c_result_code() + value2 = self.operand2.get_constant_c_result_code() + if value1 and value2: + return "(%s %s %s)" % (value1, self.operator, value2) + else: + return None + + def c_types_okay(self, type1, type2): + #print "NumBinopNode.c_types_okay:", type1, type2 ### + return (type1.is_numeric or type1.is_enum) \ + and (type2.is_numeric or type2.is_enum) + + def generate_evaluation_code(self, code): + if self.overflow_check: + self.overflow_bit_node = self + self.overflow_bit = code.funcstate.allocate_temp(PyrexTypes.c_int_type, manage_ref=False) + code.putln("%s = 0;" % self.overflow_bit) + super().generate_evaluation_code(code) + if self.overflow_check: + code.putln("if (unlikely(%s)) {" % self.overflow_bit) + code.putln('PyErr_SetString(PyExc_OverflowError, "value too large");') + code.putln(code.error_goto(self.pos)) + code.putln("}") + code.funcstate.release_temp(self.overflow_bit) + + def calculate_result_code(self): + if self.overflow_bit_node is not None: + return "%s(%s, %s, &%s)" % ( + self.func, + self.operand1.result(), + self.operand2.result(), + self.overflow_bit_node.overflow_bit) + elif self.type.is_cpp_class or self.infix: + if is_pythran_expr(self.type): + result1, result2 = self.operand1.pythran_result(), self.operand2.pythran_result() + else: + result1, result2 = self.operand1.result(), self.operand2.result() + return "(%s %s %s)" % (result1, self.operator, result2) + else: + func = self.type.binary_op(self.operator) + if func is None: + error(self.pos, "binary operator %s not supported for %s" % (self.operator, self.type)) + return "%s(%s, %s)" % ( + func, + self.operand1.result(), + self.operand2.result()) + + def is_py_operation_types(self, type1, type2): + return (type1.is_unicode_char or + type2.is_unicode_char or + BinopNode.is_py_operation_types(self, type1, type2)) + + def py_operation_function(self, code): + function_name = self.py_functions[self.operator] + if self.inplace: + function_name = function_name.replace('PyNumber_', 'PyNumber_InPlace') + return function_name + + py_functions = { + "|": "PyNumber_Or", + "^": "PyNumber_Xor", + "&": "PyNumber_And", + "<<": "PyNumber_Lshift", + ">>": "PyNumber_Rshift", + "+": "PyNumber_Add", + "-": "PyNumber_Subtract", + "*": "PyNumber_Multiply", + "@": "__Pyx_PyNumber_MatrixMultiply", + "/": "__Pyx_PyNumber_Divide", + "//": "PyNumber_FloorDivide", + "%": "PyNumber_Remainder", + "**": "PyNumber_Power", + } + + overflow_op_names = { + "+": "add", + "-": "sub", + "*": "mul", + "<<": "lshift", + } + + +class IntBinopNode(NumBinopNode): + # Binary operation taking integer arguments. + + def c_types_okay(self, type1, type2): + #print "IntBinopNode.c_types_okay:", type1, type2 ### + return (type1.is_int or type1.is_enum) \ + and (type2.is_int or type2.is_enum) + + +class BitwiseOrNode(IntBinopNode): + # '|' operator. + + def analyse_pytyping_modifiers(self, env): + if self.operand1.is_none or self.operand2.is_none: + return ['typing.Optional'] + + def _analyse_bitwise_or_none(self, env, operand_node): + """Analyse annotations in form `[...] | None` and `None | [...]`""" + with env.new_c_type_context(False): + ttype = operand_node.analyse_as_type(env) + if not ttype: + return None + if not ttype.can_be_optional(): + # If ttype cannot be optional we need to return an equivalent Python type allowing None. + # If it cannot be mapped to a Python type, we must error out. + if ttype.equivalent_type and not operand_node.as_cython_attribute(): + return ttype.equivalent_type + else: + error(operand_node.pos, f"'[...] | None' cannot be applied to type {ttype}") + return ttype + + def analyse_as_type(self, env): + if self.operand1.is_none: + return self._analyse_bitwise_or_none(env, self.operand2) + elif self.operand2.is_none: + return self._analyse_bitwise_or_none(env, self.operand1) + return None + + +class AddNode(NumBinopNode): + # '+' operator. + + def is_py_operation_types(self, type1, type2): + if type1.is_string and type2.is_string or type1.is_pyunicode_ptr and type2.is_pyunicode_ptr: + return 1 + else: + return NumBinopNode.is_py_operation_types(self, type1, type2) + + def infer_builtin_types_operation(self, type1, type2): + # b'abc' + 'abc' raises an exception in Py3, + # so we can safely infer a mix here. + string_types = (bytes_type, bytearray_type, unicode_type) + if type1 in string_types and type2 in string_types: + return string_types[max(string_types.index(type1), + string_types.index(type2))] + return super().infer_builtin_types_operation(type1, type2) + + def compute_c_result_type(self, type1, type2): + #print "AddNode.compute_c_result_type:", type1, self.operator, type2 ### + if (type1.is_ptr or type1.is_array) and (type2.is_int or type2.is_enum): + return type1 + elif (type2.is_ptr or type2.is_array) and (type1.is_int or type1.is_enum): + return type2 + else: + return NumBinopNode.compute_c_result_type( + self, type1, type2) + + def py_operation_function(self, code): + type1, type2 = self.operand1.type, self.operand2.type + func = None + if type1 is unicode_type or type2 is unicode_type: + if type1 is unicode_type and type2 is unicode_type: + is_unicode_concat = True + elif isinstance(self.operand1, FormattedValueNode) or isinstance(self.operand2, FormattedValueNode): + # Assume that even if we don't know the second type, it's going to be a string. + is_unicode_concat = True + else: + # Operation depends on the second type. + is_unicode_concat = False + + if is_unicode_concat: + if self.inplace or self.operand1.result_in_temp(): + code.globalstate.use_utility_code( + UtilityCode.load_cached("UnicodeConcatInPlace", "ObjectHandling.c")) + func = '__Pyx_PyUnicode_Concat' + + if func: + # any necessary utility code will be got by "NumberAdd" in generate_evaluation_code + if self.inplace or self.operand1.result_in_temp(): + func += 'InPlace' # upper case to indicate unintuitive macro + if self.operand1.may_be_none() or self.operand2.may_be_none(): + func += 'Safe' + return func + + return super().py_operation_function(code) + + +class SubNode(NumBinopNode): + # '-' operator. + + def compute_c_result_type(self, type1, type2): + if (type1.is_ptr or type1.is_array) and (type2.is_int or type2.is_enum): + return type1 + elif (type1.is_ptr or type1.is_array) and (type2.is_ptr or type2.is_array): + return PyrexTypes.c_ptrdiff_t_type + else: + return NumBinopNode.compute_c_result_type( + self, type1, type2) + + +class MulNode(NumBinopNode): + # '*' operator. + is_sequence_mul = False + + def analyse_types(self, env): + self.operand1 = self.operand1.analyse_types(env) + self.operand2 = self.operand2.analyse_types(env) + self.is_sequence_mul = self.calculate_is_sequence_mul() + + # TODO: we could also optimise the case of "[...] * 2 * n", i.e. with an existing 'mult_factor' + if self.is_sequence_mul: + operand1 = self.operand1 + operand2 = self.operand2 + if operand1.is_sequence_constructor and operand1.mult_factor is None: + return self.analyse_sequence_mul(env, operand1, operand2) + elif operand2.is_sequence_constructor and operand2.mult_factor is None: + return self.analyse_sequence_mul(env, operand2, operand1) + elif operand1.type in builtin_sequence_types: + self.operand2 = operand2.coerce_to_index(env) + elif operand2.type in builtin_sequence_types: + self.operand1 = operand1.coerce_to_index(env) + + return self.analyse_operation(env) + + @staticmethod + def is_builtin_seqmul_type(type): + return type.is_builtin_type and type in builtin_sequence_types and type is not memoryview_type + + def calculate_is_sequence_mul(self): + type1 = self.operand1.type + type2 = self.operand2.type + if type1 is Builtin.int_type or type1.is_int: + # normalise to (X * int) + type1, type2 = type2, type1 + if type2 is Builtin.int_type or type2.is_int: + if type1.is_string or type1.is_ctuple: + return True + if self.is_builtin_seqmul_type(type1): + return True + return False + + def analyse_sequence_mul(self, env, seq, mult): + assert seq.mult_factor is None + seq = seq.coerce_to_pyobject(env) + seq.mult_factor = mult.coerce_to_index(env) + return seq.analyse_types(env) + + def coerce_operands_to_pyobjects(self, env): + if self.is_sequence_mul: + # Keep operands as they are, but ctuples must become Python tuples to multiply them. + if self.operand1.type.is_ctuple: + self.operand1 = self.operand1.coerce_to_pyobject(env) + elif self.operand2.type.is_ctuple: + self.operand2 = self.operand2.coerce_to_pyobject(env) + return + super().coerce_operands_to_pyobjects(env) + + def is_py_operation_types(self, type1, type2): + return self.is_sequence_mul or super().is_py_operation_types(type1, type2) + + def py_operation_function(self, code): + if self.is_sequence_mul: + code.globalstate.use_utility_code( + UtilityCode.load_cached("PySequenceMultiply", "ObjectHandling.c")) + return "__Pyx_PySequence_Multiply" if self.operand1.type.is_pyobject else "__Pyx_PySequence_Multiply_Left" + return super().py_operation_function(code) + + def infer_builtin_types_operation(self, type1, type2): + # let's assume that whatever builtin type you multiply a builtin sequence type with + # will either return a sequence of the same type or fail with an exception + if type1.is_builtin_type and type2.is_builtin_type: + if self.is_builtin_seqmul_type(type1): + return type1 + if self.is_builtin_seqmul_type(type2): + return type2 + # multiplication of containers/numbers with an integer value + # always (?) returns the same type + if type1.is_int: + return type2 + if type2.is_int: + return type1 + return super().infer_builtin_types_operation(type1, type2) + + +class MatMultNode(NumBinopNode): + # '@' operator. + + def is_py_operation_types(self, type1, type2): + return True + + def infer_builtin_types_operation(self, type1, type2): + # We really don't know anything about this operation. + return None + + def generate_evaluation_code(self, code): + code.globalstate.use_utility_code(UtilityCode.load_cached("MatrixMultiply", "ObjectHandling.c")) + super().generate_evaluation_code(code) + + +class DivNode(NumBinopNode): + # '/' or '//' operator. + + cdivision = None + truedivision = None # == "unknown" if operator == '/' + ctruedivision = False + cdivision_warnings = False + zerodivision_check = None + + def find_compile_time_binary_operator(self, op1, op2): + func = compile_time_binary_operators[self.operator] + if self.operator == '/' and self.truedivision is None: + # => true div for floats, floor div for integers + if isinstance(op1, int) and isinstance(op2, int): + func = compile_time_binary_operators['//'] + return func + + def calculate_constant_result(self): + op1 = self.operand1.constant_result + op2 = self.operand2.constant_result + func = self.find_compile_time_binary_operator(op1, op2) + self.constant_result = func(op1, op2) + + def compile_time_value(self, denv): + operand1 = self.operand1.compile_time_value(denv) + operand2 = self.operand2.compile_time_value(denv) + func = self.find_compile_time_binary_operator(operand1, operand2) + try: + return func(operand1, operand2) + except Exception as e: + self.compile_time_value_error(e) + + def _check_truedivision(self, env): + if self.cdivision or env.directives['cdivision']: + self.ctruedivision = False + else: + self.ctruedivision = self.truedivision + + def infer_type(self, env): + self._check_truedivision(env) + return self.result_type( + self.operand1.infer_type(env), + self.operand2.infer_type(env), env) + + def infer_builtin_types_operation(self, type1, type2): + result_type = super().infer_builtin_types_operation(type1, type2) + if result_type is not None and self.operator == '/': + if self.truedivision or self.ctruedivision: + # Result of truedivision is not an integer + if result_type is Builtin.int_type: + return PyrexTypes.c_double_type + elif result_type.is_int: + return PyrexTypes.widest_numeric_type(PyrexTypes.c_double_type, result_type) + elif result_type is Builtin.int_type or result_type.is_int: + # Cannot infer 'int' since the result might be a 'float' in Python 3 + result_type = None + return result_type + + def analyse_operation(self, env): + self._check_truedivision(env) + result = NumBinopNode.analyse_operation(self, env) + + # The assumption here is that result is either 'self' or a coercion + # node containing 'self'. Thus it is reasonable to keep manipulating + # 'self' even if it's been replaced as the eventual result. + + if self.is_cpp_operation(): + self.cdivision = True + if not self.type.is_pyobject: + self.zerodivision_check = ( + self.cdivision is None and not env.directives['cdivision'] + and (not self.operand2.has_constant_result() or + self.operand2.constant_result == 0)) + if self.zerodivision_check or env.directives['cdivision_warnings']: + # Need to check ahead of time to warn or raise zero division error + self.operand1 = self.operand1.coerce_to_simple(env) + self.operand2 = self.operand2.coerce_to_simple(env) + return result # should either be self, or wrap self + + def compute_c_result_type(self, type1, type2): + if self.operator == '/' and self.ctruedivision and not type1.is_cpp_class and not type2.is_cpp_class: + if not type1.is_float and not type2.is_float: + widest_type = PyrexTypes.widest_numeric_type(type1, PyrexTypes.c_double_type) + widest_type = PyrexTypes.widest_numeric_type(type2, widest_type) + return widest_type + return NumBinopNode.compute_c_result_type(self, type1, type2) + + def zero_division_message(self): + if self.type.is_int: + return "integer division or modulo by zero" + else: + return "float division" + + def generate_evaluation_code(self, code): + if not self.type.is_pyobject and not self.type.is_complex: + if self.cdivision is None: + self.cdivision = ( + code.globalstate.directives['cdivision'] + or self.type.is_float + or ((self.type.is_numeric or self.type.is_enum) and not self.type.signed) + ) + if not self.cdivision: + code.globalstate.use_utility_code( + UtilityCode.load_cached("DivInt", "CMath.c").specialize(self.type)) + NumBinopNode.generate_evaluation_code(self, code) + self.generate_div_warning_code(code) + + def generate_div_warning_code(self, code): + in_nogil = self.in_nogil_context + if not self.type.is_pyobject: + if self.zerodivision_check: + if not self.infix: + zero_test = "%s(%s)" % (self.type.unary_op('zero'), self.operand2.result()) + else: + zero_test = "%s == 0" % self.operand2.result() + code.putln("if (unlikely(%s)) {" % zero_test) + if in_nogil: + code.put_ensure_gil() + code.putln('PyErr_SetString(PyExc_ZeroDivisionError, "%s");' % self.zero_division_message()) + if in_nogil: + code.put_release_ensured_gil() + code.putln(code.error_goto(self.pos)) + code.putln("}") + if self.type.is_int and self.type.signed and self.operator != '%': + code.globalstate.use_utility_code(UtilityCode.load_cached("UnaryNegOverflows", "Overflow.c")) + if self.operand2.type.signed == 2: + # explicitly signed, no runtime check needed + minus1_check = 'unlikely(%s == -1)' % self.operand2.result() + else: + type_of_op2 = self.operand2.type.empty_declaration_code() + minus1_check = '(!(((%s)-1) > 0)) && unlikely(%s == (%s)-1)' % ( + type_of_op2, self.operand2.result(), type_of_op2) + code.putln("else if (sizeof(%s) == sizeof(long) && %s " + " && unlikely(__Pyx_UNARY_NEG_WOULD_OVERFLOW(%s))) {" % ( + self.type.empty_declaration_code(), + minus1_check, + self.operand1.result())) + if in_nogil: + code.put_ensure_gil() + code.putln('PyErr_SetString(PyExc_OverflowError, "value too large to perform division");') + if in_nogil: + code.put_release_ensured_gil() + code.putln(code.error_goto(self.pos)) + code.putln("}") + if code.globalstate.directives['cdivision_warnings'] and self.operator != '/': + code.globalstate.use_utility_code( + UtilityCode.load_cached("CDivisionWarning", "CMath.c")) + code.putln("if (unlikely((%s < 0) ^ (%s < 0))) {" % ( + self.operand1.result(), + self.operand2.result())) + warning_code = "__Pyx_cdivision_warning(%(FILENAME)s, %(LINENO)s)" % { + 'FILENAME': Naming.filename_cname, + 'LINENO': Naming.lineno_cname, + } + + if in_nogil: + result_code = 'result' + code.putln("int %s;" % result_code) + code.put_ensure_gil() + code.putln(code.set_error_info(self.pos, used=True)) + code.putln("%s = %s;" % (result_code, warning_code)) + code.put_release_ensured_gil() + else: + result_code = warning_code + code.putln(code.set_error_info(self.pos, used=True)) + + code.put("if (unlikely(%s)) " % result_code) + code.put_goto(code.error_label) + code.putln("}") + + def calculate_result_code(self): + if self.type.is_complex or self.is_cpp_operation(): + return NumBinopNode.calculate_result_code(self) + + op1 = self.operand1.result() + op2 = self.operand2.result() + + if self.type.is_float and self.operator == '//': + return f"floor({op1} / {op2})" + elif self.truedivision or self.cdivision: + if self.truedivision: + if self.type != self.operand1.type: + op1 = self.type.cast_code(op1) + if self.type != self.operand2.type: + op2 = self.type.cast_code(op2) + return f"({op1} / {op2})" + else: + b_is_constant = self.operand2.has_constant_result() + return f"__Pyx_div_{self.type.specialization_name()}({op1}, {op2}, {bool(b_is_constant):d})" + + +_find_formatting_types = re.compile( + br"%" + br"(?:%|" # %% + br"(?:\([^)]+\))?" # %(name) + br"[-+#,0-9 ]*([a-z])" # %.2f etc. + br")").findall + +# These format conversion types can never trigger a Unicode string conversion in Py2. +_safe_bytes_formats = frozenset({ + # Excludes 's' and 'r', which can generate non-bytes strings. + b'd', b'i', b'o', b'u', b'x', b'X', b'e', b'E', b'f', b'F', b'g', b'G', b'c', b'b', b'a', +}) + + +class ModNode(DivNode): + # '%' operator. + + def is_py_operation_types(self, type1, type2): + return (type1.is_string + or type2.is_string + or NumBinopNode.is_py_operation_types(self, type1, type2)) + + def infer_builtin_types_operation(self, type1, type2): + if type1 in (unicode_type, bytes_type, bytearray_type): + # 'None % xyz' may be implemented by the RHS, but everything else will do string formatting. + if type2.is_builtin_type or not type2.is_pyobject or not self.operand1.may_be_none(): + return type1 + return super().infer_builtin_types_operation(type1, type2) + + def zero_division_message(self): + if self.type.is_int: + return "integer division or modulo by zero" + else: + return "float divmod()" + + def analyse_operation(self, env): + result = DivNode.analyse_operation(self, env) + # The assumption here is that result is either 'self' or a coercion + # node containing 'self'. Thus it is reasonable to keep manipulating + # 'self' even if it's been replaced as the eventual result. + if not self.type.is_pyobject: + if self.cdivision is None: + self.cdivision = env.directives['cdivision'] or not self.type.signed + if not self.cdivision and not self.type.is_int and not self.type.is_float: + error(self.pos, "mod operator not supported for type '%s'" % self.type) + return result # should either be self, or wrap self + + def generate_evaluation_code(self, code): + if not self.type.is_pyobject and not self.cdivision: + if self.type.is_int: + code.globalstate.use_utility_code( + UtilityCode.load_cached("ModInt", "CMath.c").specialize(self.type)) + else: # float + code.globalstate.use_utility_code( + UtilityCode.load_cached("ModFloat", "CMath.c").specialize( + self.type, math_h_modifier=self.type.math_h_modifier)) + # NOTE: skipping over DivNode here + NumBinopNode.generate_evaluation_code(self, code) + self.generate_div_warning_code(code) + + def calculate_result_code(self): + op1 = self.operand1.result() + op2 = self.operand2.result() + + if self.cdivision: + if self.type.is_float: + return f"fmod{self.type.math_h_modifier}({op1}, {op2})" + else: + return f"({op1} % {op2})" + else: + b_is_constant = self.operand2.has_constant_result() + return f"__Pyx_mod_{self.type.specialization_name()}({op1}, {op2}, {bool(b_is_constant):d})" + + def py_operation_function(self, code): + type1, type2 = self.operand1.type, self.operand2.type + # ("..." % x) must call "x.__rmod__()" for string subtypes. + if type1 is unicode_type: + if self.operand1.may_be_none() or ( + type2.is_extension_type and type2.subtype_of(type1) or + type2 is py_object_type and not isinstance(self.operand2, CoerceToPyTypeNode)): + return '__Pyx_PyUnicode_FormatSafe' + else: + return 'PyUnicode_Format' + return super().py_operation_function(code) + + +class PowNode(NumBinopNode): + # '**' operator. + + is_cpow = None + type_was_inferred = False # was the result type affected by cpow==False? + # Intended to allow it to be changed if the node is coerced. + + def _check_cpow(self, env): + if self.is_cpow is not None: + return # already set + self.is_cpow = env.directives['cpow'] + + def infer_type(self, env): + self._check_cpow(env) + return super().infer_type(env) + + def analyse_types(self, env): + self._check_cpow(env) + return super().analyse_types(env) + + def infer_builtin_types_operation(self, type1, type2): + # TODO + return None + + def analyse_c_operation(self, env): + NumBinopNode.analyse_c_operation(self, env) + if self.type.is_complex: + if self.type.real_type.is_float: + self.operand1 = self.operand1.coerce_to(self.type, env) + self.operand2 = self.operand2.coerce_to(self.type, env) + self.pow_func = self.type.binary_op('**') + else: + error(self.pos, "complex int powers not supported") + self.pow_func = "" + elif self.type.is_float: + self.pow_func = "pow" + self.type.math_h_modifier + elif self.type.is_int: + self.pow_func = "__Pyx_pow_%s" % self.type.empty_declaration_code().replace(' ', '_') + env.use_utility_code( + UtilityCode.load_cached("IntPow", "CMath.c").specialize( + func_name=self.pow_func, + type=self.type.empty_declaration_code(), + signed=self.type.signed and 1 or 0)) + elif not self.type.is_error: + error(self.pos, "got unexpected types for C power operator: %s, %s" % + (self.operand1.type, self.operand2.type)) + + def compute_c_result_type(self, type1, type2): + from numbers import Real + c_result_type = None + op1_is_definitely_positive = ( + self.operand1.has_constant_result() + and self.operand1.constant_result >= 0 + ) or ( + type1.is_int and type1.signed == 0 # definitely unsigned + ) + type2_is_int = type2.is_int or ( + self.operand2.has_constant_result() and + isinstance(self.operand2.constant_result, Real) and + int(self.operand2.constant_result) == self.operand2.constant_result + ) + needs_widening = False + if self.is_cpow: + c_result_type = super().compute_c_result_type(type1, type2) + if not self.operand2.has_constant_result(): + needs_widening = ( + isinstance(self.operand2.constant_result, int) and self.operand2.constant_result < 0 + ) + elif op1_is_definitely_positive or type2_is_int: # cpow==False + # if type2 is an integer then we can't end up going from real to complex + c_result_type = super().compute_c_result_type(type1, type2) + if not self.operand2.has_constant_result(): + needs_widening = type2.is_int and type2.signed + if needs_widening: + self.type_was_inferred = True + else: + needs_widening = ( + isinstance(self.operand2.constant_result, int) and self.operand2.constant_result < 0 + ) + elif self.c_types_okay(type1, type2): + # Allowable result types are double or complex double. + # Return the special "soft complex" type to store it as a + # complex number but with specialized coercions to Python + c_result_type = PyrexTypes.soft_complex_type + self.type_was_inferred = True + if needs_widening: + c_result_type = PyrexTypes.widest_numeric_type(c_result_type, PyrexTypes.c_double_type) + return c_result_type + + def calculate_result_code(self): + # Work around MSVC overloading ambiguity. + def typecast(operand): + if self.type == operand.type: + return operand.result() + else: + return self.type.cast_code(operand.result()) + return "%s(%s, %s)" % ( + self.pow_func, + typecast(self.operand1), + typecast(self.operand2)) + + def py_operation_function(self, code): + if (self.type.is_pyobject and + self.operand1.constant_result == 2 and + isinstance(self.operand1.constant_result, int) and + self.operand2.type is py_object_type): + code.globalstate.use_utility_code(UtilityCode.load_cached('PyNumberPow2', 'Optimize.c')) + if self.inplace: + return '__Pyx_PyNumber_InPlacePowerOf2' + else: + return '__Pyx_PyNumber_PowerOf2' + return super().py_operation_function(code) + + def coerce_to(self, dst_type, env): + if dst_type == self.type: + return self + if (self.is_cpow is None and self.type_was_inferred and + (dst_type.is_float or dst_type.is_int)): + # if we're trying to coerce this directly to a C float or int + # then fall back to the cpow == True behaviour since this is + # almost certainly the user intent. + # However, ensure that the operand types are suitable C types + if self.type is PyrexTypes.soft_complex_type: + def check_types(operand, recurse=True): + if operand.type.is_float or operand.type.is_int: + return True, operand + if recurse and isinstance(operand, CoerceToComplexNode): + return check_types(operand.arg, recurse=False), operand.arg + return False, None + msg_detail = "a non-complex C numeric type" + elif dst_type.is_int: + def check_types(operand): + if operand.type.is_int: + return True, operand + else: + # int, int doesn't seem to involve coercion nodes + return False, None + msg_detail = "an integer C numeric type" + else: + def check_types(operand): + return False, None + check_op1, op1 = check_types(self.operand1) + check_op2, op2 = check_types(self.operand2) + if check_op1 and check_op2: + warning(self.pos, "Treating '**' as if 'cython.cpow(True)' since it " + "is directly assigned to a %s. " + "This is likely to be fragile and we recommend setting " + "'cython.cpow' explicitly." % msg_detail) + self.is_cpow = True + self.operand1 = op1 + self.operand2 = op2 + result = self.analyse_types(env) + if result.type != dst_type: + result = result.coerce_to(dst_type, env) + return result + return super().coerce_to(dst_type, env) + + +class BoolBinopNode(ExprNode): + """ + Short-circuiting boolean operation. + + Note that this node provides the same code generation method as + BoolBinopResultNode to simplify expression nesting. + + operator string "and"/"or" + operand1 BoolBinopNode/BoolBinopResultNode left operand + operand2 BoolBinopNode/BoolBinopResultNode right operand + """ + subexprs = ['operand1', 'operand2'] + is_temp = True + operator = None + operand1 = None + operand2 = None + + def infer_type(self, env): + type1 = self.operand1.infer_type(env) + type2 = self.operand2.infer_type(env) + return PyrexTypes.independent_spanning_type(type1, type2) + + def may_be_none(self): + if self.operator == 'or': + return self.operand2.may_be_none() + else: + return self.operand1.may_be_none() or self.operand2.may_be_none() + + def calculate_constant_result(self): + operand1 = self.operand1.constant_result + operand2 = self.operand2.constant_result + if self.operator == 'and': + self.constant_result = operand1 and operand2 + else: + self.constant_result = operand1 or operand2 + + def compile_time_value(self, denv): + operand1 = self.operand1.compile_time_value(denv) + operand2 = self.operand2.compile_time_value(denv) + if self.operator == 'and': + return operand1 and operand2 + else: + return operand1 or operand2 + + def is_ephemeral(self): + return self.operand1.is_ephemeral() or self.operand2.is_ephemeral() + + def analyse_types(self, env): + # Note: we do not do any coercion here as we most likely do not know the final type anyway. + # We even accept to set self.type to ErrorType if both operands do not have a spanning type. + # The coercion to the final type and to a "simple" value is left to coerce_to(). + operand1 = self.operand1.analyse_types(env) + operand2 = self.operand2.analyse_types(env) + self.type = PyrexTypes.independent_spanning_type( + operand1.type, operand2.type) + self.operand1 = self._wrap_operand(operand1, env) + self.operand2 = self._wrap_operand(operand2, env) + return self + + def _wrap_operand(self, operand, env): + if not isinstance(operand, (BoolBinopNode, BoolBinopResultNode)): + operand = BoolBinopResultNode(operand, self.type, env) + return operand + + def wrap_operands(self, env): + """ + Must get called by transforms that want to create a correct BoolBinopNode + after the type analysis phase. + """ + self.operand1 = self._wrap_operand(self.operand1, env) + self.operand2 = self._wrap_operand(self.operand2, env) + + def coerce_to_boolean(self, env): + return self.coerce_to(PyrexTypes.c_bint_type, env) + + def coerce_to(self, dst_type, env): + operand1 = self.operand1.coerce_to(dst_type, env) + operand2 = self.operand2.coerce_to(dst_type, env) + return BoolBinopNode.from_node( + self, type=dst_type, + operator=self.operator, + operand1=operand1, operand2=operand2) + + def generate_bool_evaluation_code(self, code, final_result_temp, final_result_type, and_label, or_label, end_label, fall_through): + code.mark_pos(self.pos) + + outer_labels = (and_label, or_label) + if self.operator == 'and': + my_label = and_label = code.new_label('next_and') + else: + my_label = or_label = code.new_label('next_or') + self.operand1.generate_bool_evaluation_code( + code, final_result_temp, final_result_type, and_label, or_label, end_label, my_label) + + and_label, or_label = outer_labels + + code.put_label(my_label) + self.operand2.generate_bool_evaluation_code( + code, final_result_temp, final_result_type, and_label, or_label, end_label, fall_through) + + def generate_evaluation_code(self, code): + self.allocate_temp_result(code) + result_type = PyrexTypes.py_object_type if self.type.is_pyobject else self.type + or_label = and_label = None + end_label = code.new_label('bool_binop_done') + self.generate_bool_evaluation_code(code, self.result(), result_type, and_label, or_label, end_label, end_label) + code.put_label(end_label) + + gil_message = "Truth-testing Python object" + + def check_const(self): + return self.operand1.check_const() and self.operand2.check_const() + + def generate_subexpr_disposal_code(self, code): + pass # nothing to do here, all done in generate_evaluation_code() + + def free_subexpr_temps(self, code): + pass # nothing to do here, all done in generate_evaluation_code() + + def generate_operand1_test(self, code): + # Generate code to test the truth of the first operand. + if self.type.is_pyobject: + test_result = code.funcstate.allocate_temp( + PyrexTypes.c_bint_type, manage_ref=False) + code.putln( + "%s = __Pyx_PyObject_IsTrue(%s); %s" % ( + test_result, + self.operand1.py_result(), + code.error_goto_if_neg(test_result, self.pos))) + else: + test_result = self.operand1.result() + return (test_result, self.type.is_pyobject) + + +class BoolBinopResultNode(ExprNode): + """ + Intermediate result of a short-circuiting and/or expression. + Tests the result for 'truthiness' and takes care of coercing the final result + of the overall expression to the target type. + + Note that this node provides the same code generation method as + BoolBinopNode to simplify expression nesting. + + arg ExprNode the argument to test + value ExprNode the coerced result value node + """ + + subexprs = ['arg', 'value'] + is_temp = True + arg = None + value = None + + def __init__(self, arg, result_type, env): + # using 'arg' multiple times, so it must be a simple/temp value + arg = arg.coerce_to_simple(env) + # wrap in ProxyNode, in case a transform wants to replace self.arg later + arg = ProxyNode(arg) + super().__init__( + arg.pos, arg=arg, type=result_type, + value=CloneNode(arg).coerce_to(result_type, env)) + + def coerce_to_boolean(self, env): + return self.coerce_to(PyrexTypes.c_bint_type, env) + + def coerce_to(self, dst_type, env): + # unwrap, coerce, rewrap + arg = self.arg.arg + if dst_type is PyrexTypes.c_bint_type: + arg = arg.coerce_to_boolean(env) + # TODO: unwrap more coercion nodes? + return BoolBinopResultNode(arg, dst_type, env) + + def nogil_check(self, env): + # let's leave all errors to BoolBinopNode + pass + + def generate_operand_test(self, code): + # Generate code to test the truth of the first operand. + if self.arg.type.is_pyobject: + test_result = code.funcstate.allocate_temp( + PyrexTypes.c_bint_type, manage_ref=False) + code.putln( + "%s = __Pyx_PyObject_IsTrue(%s); %s" % ( + test_result, + self.arg.py_result(), + code.error_goto_if_neg(test_result, self.pos))) + else: + test_result = self.arg.result() + return (test_result, self.arg.type.is_pyobject) + + def generate_bool_evaluation_code(self, code, final_result_temp, final_result_type, and_label, or_label, end_label, fall_through): + code.mark_pos(self.pos) + + # x => x + # x and ... or ... => next 'and' / 'or' + # False ... or x => next 'or' + # True and x => next 'and' + # True or x => True (operand) + + self.arg.generate_evaluation_code(code) + if and_label or or_label: + test_result, uses_temp = self.generate_operand_test(code) + if uses_temp and (and_label and or_label): + # cannot become final result => free early + # disposal: uses_temp and (and_label and or_label) + self.arg.generate_disposal_code(code) + sense = '!' if or_label else '' + code.putln("if (%s%s) {" % (sense, test_result)) + if uses_temp: + code.funcstate.release_temp(test_result) + if not uses_temp or not (and_label and or_label): + # disposal: (not uses_temp) or {not (and_label and or_label) [if]} + self.arg.generate_disposal_code(code) + + if or_label and or_label != fall_through: + # value is false => short-circuit to next 'or' + code.put_goto(or_label) + if and_label: + # value is true => go to next 'and' + if or_label: + code.putln("} else {") + if not uses_temp: + # disposal: (not uses_temp) and {(and_label and or_label) [else]} + self.arg.generate_disposal_code(code) + if and_label != fall_through: + code.put_goto(and_label) + + if not and_label or not or_label: + # if no next 'and' or 'or', we provide the result + if and_label or or_label: + code.putln("} else {") + self.value.generate_evaluation_code(code) + self.value.make_owned_reference(code) + code.putln("%s = %s;" % (final_result_temp, self.value.result_as(final_result_type))) + self.value.generate_post_assignment_code(code) + # disposal: {not (and_label and or_label) [else]} + self.arg.generate_disposal_code(code) + self.value.free_temps(code) + if end_label != fall_through: + code.put_goto(end_label) + + if and_label or or_label: + code.putln("}") + self.arg.free_temps(code) + + def analyse_types(self, env): + return self + + +class CondExprNode(ExprNode): + # Short-circuiting conditional expression. + # + # test ExprNode + # true_val ExprNode + # false_val ExprNode + + true_val = None + false_val = None + is_temp = True + + subexprs = ['test', 'true_val', 'false_val'] + + def type_dependencies(self, env): + return self.true_val.type_dependencies(env) + self.false_val.type_dependencies(env) + + def infer_type(self, env): + return PyrexTypes.independent_spanning_type( + self.true_val.infer_type(env), + self.false_val.infer_type(env)) + + def calculate_constant_result(self): + if self.test.constant_result: + self.constant_result = self.true_val.constant_result + else: + self.constant_result = self.false_val.constant_result + + def is_ephemeral(self): + return self.true_val.is_ephemeral() or self.false_val.is_ephemeral() + + def analyse_types(self, env): + self.test = self.test.analyse_temp_boolean_expression(env) + self.true_val = self.true_val.analyse_types(env) + self.false_val = self.false_val.analyse_types(env) + return self.analyse_result_type(env) + + def analyse_result_type(self, env): + true_val_type = self.true_val.type + false_val_type = self.false_val.type + self.type = PyrexTypes.independent_spanning_type(true_val_type, false_val_type) + + if self.type.is_reference: + self.type = PyrexTypes.CFakeReferenceType(self.type.ref_base_type) + if self.type.is_pyobject: + self.result_ctype = py_object_type + elif self.type.is_ptr: + if self.true_val.is_ephemeral(): + error(self.true_val.pos, "Unsafe C derivative of temporary Python reference used in conditional expression") + if self.false_val.is_ephemeral(): + error(self.false_val.pos, "Unsafe C derivative of temporary Python reference used in conditional expression") + + if true_val_type.is_pyobject or false_val_type.is_pyobject or self.type.is_pyobject: + if true_val_type != self.type: + self.true_val = self.true_val.coerce_to(self.type, env) + if false_val_type != self.type: + self.false_val = self.false_val.coerce_to(self.type, env) + + if self.type.is_error: + self.type_error() + return self + + def coerce_to_index(self, env): + if not self.true_val.type.is_int: + self.true_val = self.true_val.coerce_to_index(env) + if not self.false_val.type.is_int: + self.false_val = self.false_val.coerce_to_index(env) + self.result_ctype = None + out = self.analyse_result_type(env) + if not out.type.is_int: + # fall back to ordinary coercion since we haven't ended as the correct type + if out is self: + out = super(CondExprNode, out).coerce_to_index(env) + else: + # I believe `analyse_result_type` always returns a CondExprNode but + # handle the opposite case just in case + out = out.coerce_to_index(env) + return out + + def coerce_to(self, dst_type, env): + if self.true_val.type != dst_type: + self.true_val = self.true_val.coerce_to(dst_type, env) + if self.false_val.type != dst_type: + self.false_val = self.false_val.coerce_to(dst_type, env) + self.result_ctype = None + out = self.analyse_result_type(env) + if out.type != dst_type: + # fall back to ordinary coercion since we haven't ended as the correct type + if out is self: + out = super(CondExprNode, out).coerce_to(dst_type, env) + else: + # I believe `analyse_result_type` always returns a CondExprNode but + # handle the opposite case just in case + out = out.coerce_to(dst_type, env) + return out + + def type_error(self): + if not (self.true_val.type.is_error or self.false_val.type.is_error): + error(self.pos, "Incompatible types in conditional expression (%s; %s)" % + (self.true_val.type, self.false_val.type)) + self.type = PyrexTypes.error_type + + def check_const(self): + return (self.test.check_const() + and self.true_val.check_const() + and self.false_val.check_const()) + + def generate_evaluation_code(self, code): + # Because subexprs may not be evaluated we can use a more optimal + # subexpr allocation strategy than the default, so override evaluation_code. + + code.mark_pos(self.pos) + self.allocate_temp_result(code) + self.test.generate_evaluation_code(code) + code.putln("if (%s) {" % self.test.result()) + self.eval_and_get(code, self.true_val) + code.putln("} else {") + self.eval_and_get(code, self.false_val) + code.putln("}") + self.test.generate_disposal_code(code) + self.test.free_temps(code) + + def eval_and_get(self, code, expr): + expr.generate_evaluation_code(code) + if self.type.is_memoryviewslice: + expr.make_owned_memoryviewslice(code) + else: + expr.make_owned_reference(code) + code.putln('%s = %s;' % (self.result(), expr.result_as(self.ctype()))) + expr.generate_post_assignment_code(code) + expr.free_temps(code) + + def generate_subexpr_disposal_code(self, code): + pass # done explicitly above (cleanup must separately happen within the if/else blocks) + + def free_subexpr_temps(self, code): + pass # done explicitly above (cleanup must separately happen within the if/else blocks) + + +richcmp_constants = { + "<" : "Py_LT", + "<=": "Py_LE", + "==": "Py_EQ", + "!=": "Py_NE", + "<>": "Py_NE", + ">" : "Py_GT", + ">=": "Py_GE", + # the following are faked by special compare functions + "in" : "Py_EQ", + "not_in": "Py_NE", +} + +class CmpNode: + # Mixin class containing code common to PrimaryCmpNodes + # and CascadedCmpNodes. + + special_bool_cmp_function = None + special_bool_cmp_utility_code = None + special_bool_extra_args = [] + + def infer_type(self, env): + # TODO: Actually implement this (after merging with -unstable). + return py_object_type + + def calculate_cascaded_constant_result(self, operand1_result): + func = compile_time_binary_operators[self.operator] + operand2_result = self.operand2.constant_result + if (isinstance(operand1_result, any_string_type) and + isinstance(operand2_result, any_string_type) and + type(operand1_result) != type(operand2_result)): + # string comparison of different types isn't portable + return + + if self.operator in ('in', 'not_in'): + if isinstance(self.operand2, (ListNode, TupleNode, SetNode)): + if not self.operand2.args: + self.constant_result = self.operator == 'not_in' + return + elif isinstance(self.operand2, ListNode) and not self.cascade: + # tuples are more efficient to store than lists + self.operand2 = self.operand2.as_tuple() + elif isinstance(self.operand2, DictNode): + if not self.operand2.key_value_pairs: + self.constant_result = self.operator == 'not_in' + return + + self.constant_result = func(operand1_result, operand2_result) + + def cascaded_compile_time_value(self, operand1, denv): + func = get_compile_time_binop(self) + operand2 = self.operand2.compile_time_value(denv) + try: + result = func(operand1, operand2) + except Exception as e: + self.compile_time_value_error(e) + result = None + if result: + cascade = self.cascade + if cascade: + result = result and cascade.cascaded_compile_time_value(operand2, denv) + return result + + def is_cpp_comparison(self): + return self.operand1.type.is_cpp_class or self.operand2.type.is_cpp_class + + def find_common_int_type(self, env, op, operand1, operand2): + # type1 != type2 and at least one of the types is not a C int + type1 = operand1.type + type2 = operand2.type + type1_can_be_int = False + type2_can_be_int = False + + if operand1.is_string_literal and operand1.can_coerce_to_char_literal(): + type1_can_be_int = True + if operand2.is_string_literal and operand2.can_coerce_to_char_literal(): + type2_can_be_int = True + + if type1.is_int: + if type2_can_be_int: + return type1 + elif type2.is_int: + if type1_can_be_int: + return type2 + elif type1_can_be_int: + if type2_can_be_int: + if Builtin.unicode_type in (type1, type2): + return PyrexTypes.c_py_ucs4_type + else: + return PyrexTypes.c_uchar_type + + return None + + def find_common_type(self, env, op, operand1, common_type=None): + operand2 = self.operand2 + type1 = operand1.type + type2 = operand2.type + + new_common_type = None + + # try to use numeric comparisons where possible + if type1.is_complex or type2.is_complex: + if (op not in ('==', '!=') + and (type1.is_complex or type1.is_numeric) + and (type2.is_complex or type2.is_numeric)): + error(self.pos, "complex types are unordered") + new_common_type = error_type + elif type1.is_pyobject: + new_common_type = Builtin.complex_type if type1.subtype_of(Builtin.complex_type) else py_object_type + elif type2.is_pyobject: + new_common_type = Builtin.complex_type if type2.subtype_of(Builtin.complex_type) else py_object_type + else: + new_common_type = PyrexTypes.widest_numeric_type(type1, type2) + elif type1.is_numeric and type2.is_numeric: + new_common_type = PyrexTypes.widest_numeric_type(type1, type2) + elif common_type is None or not common_type.is_pyobject: + new_common_type = self.find_common_int_type(env, op, operand1, operand2) + + if new_common_type is None: + # fall back to generic type compatibility tests + if type1.is_ctuple or type2.is_ctuple: + new_common_type = py_object_type + elif type1 == type2: + new_common_type = type1 + elif type1.is_pyobject or type2.is_pyobject: + if type2.is_numeric or type2.is_string: + if operand2.check_for_coercion_error(type1, env): + new_common_type = error_type + else: + new_common_type = py_object_type + elif type1.is_numeric or type1.is_string: + if operand1.check_for_coercion_error(type2, env): + new_common_type = error_type + else: + new_common_type = py_object_type + elif py_object_type.assignable_from(type1) and py_object_type.assignable_from(type2): + new_common_type = py_object_type + else: + # one Python type and one non-Python type, not assignable + self.invalid_types_error(operand1, op, operand2) + new_common_type = error_type + elif type1.assignable_from(type2): + new_common_type = type1 + elif type2.assignable_from(type1): + new_common_type = type2 + else: + # C types that we couldn't handle up to here are an error + self.invalid_types_error(operand1, op, operand2) + new_common_type = error_type + + if new_common_type.is_string and (isinstance(operand1, BytesNode) or + isinstance(operand2, BytesNode)): + # special case when comparing char* to bytes literal: must + # compare string values! + new_common_type = bytes_type + + # recursively merge types + if common_type is None or new_common_type.is_error: + common_type = new_common_type + else: + # we could do a lot better by splitting the comparison + # into a non-Python part and a Python part, but this is + # safer for now + common_type = PyrexTypes.spanning_type(common_type, new_common_type) + + if self.cascade: + common_type = self.cascade.find_common_type(env, self.operator, operand2, common_type) + + return common_type + + def invalid_types_error(self, operand1, op, operand2): + error(self.pos, "Invalid types for '%s' (%s, %s)" % + (op, operand1.type, operand2.type)) + + def is_python_comparison(self): + return (not self.is_ptr_contains() + and not self.is_c_string_contains() + and (self.has_python_operands() + or (self.cascade and self.cascade.is_python_comparison()) + or self.operator in ('in', 'not_in'))) + + def coerce_operands_to(self, dst_type, env): + operand2 = self.operand2 + if operand2.type != dst_type: + self.operand2 = operand2.coerce_to(dst_type, env) + if self.cascade: + self.cascade.coerce_operands_to(dst_type, env) + + def is_python_result(self): + return ((self.has_python_operands() and + self.special_bool_cmp_function is None and + self.operator not in ('is', 'is_not', 'in', 'not_in') and + not self.is_c_string_contains() and + not self.is_ptr_contains()) + or (self.cascade and self.cascade.is_python_result())) + + def is_c_string_contains(self): + return self.operator in ('in', 'not_in') and \ + ((self.operand1.type.is_int + and (self.operand2.type.is_string or self.operand2.type is bytes_type)) or + (self.operand1.type.is_unicode_char + and self.operand2.type is unicode_type)) + + def is_ptr_contains(self): + if self.operator in ('in', 'not_in'): + container_type = self.operand2.type + return (container_type.is_ptr or container_type.is_array) \ + and not container_type.is_string + + def find_special_bool_compare_function(self, env, operand1, result_is_bool=False): + # note: currently operand1 must get coerced to a Python object if we succeed here! + if self.operator in ('==', '!='): + type1, type2 = operand1.type, self.operand2.type + if result_is_bool or (type1.is_builtin_type and type2.is_builtin_type): + if type1 is Builtin.unicode_type or type2 is Builtin.unicode_type: + self.special_bool_cmp_utility_code = UtilityCode.load_cached("UnicodeEquals", "StringTools.c") + self.special_bool_cmp_function = "__Pyx_PyUnicode_Equals" + return True + elif type1 is Builtin.bytes_type or type2 is Builtin.bytes_type: + self.special_bool_cmp_utility_code = UtilityCode.load_cached("BytesEquals", "StringTools.c") + self.special_bool_cmp_function = "__Pyx_PyBytes_Equals" + return True + elif result_is_bool: + from .Optimize import optimise_numeric_binop + result = optimise_numeric_binop( + "Eq" if self.operator == "==" else "Ne", + self, + PyrexTypes.c_bint_type, + operand1, + self.operand2 + ) + if result: + (self.special_bool_cmp_function, + self.special_bool_cmp_utility_code, + self.special_bool_extra_args, + _) = result + return True + elif self.operator in ('in', 'not_in'): + if self.operand2.type is Builtin.dict_type: + self.operand2 = self.operand2.as_none_safe_node("'NoneType' object is not iterable") + self.special_bool_cmp_utility_code = UtilityCode.load_cached("PyDictContains", "ObjectHandling.c") + self.special_bool_cmp_function = "__Pyx_PyDict_ContainsTF" + return True + elif self.operand2.type is Builtin.set_type: + self.operand2 = self.operand2.as_none_safe_node("'NoneType' object is not iterable") + self.special_bool_cmp_utility_code = UtilityCode.load_cached("PySetContains", "ObjectHandling.c") + self.special_bool_cmp_function = "__Pyx_PySet_ContainsTF" + return True + elif self.operand2.type is Builtin.unicode_type: + self.operand2 = self.operand2.as_none_safe_node("'NoneType' object is not iterable") + self.special_bool_cmp_utility_code = UtilityCode.load_cached("PyUnicodeContains", "StringTools.c") + self.special_bool_cmp_function = "__Pyx_PyUnicode_ContainsTF" + return True + else: + if not self.operand2.type.is_pyobject: + self.operand2 = self.operand2.coerce_to_pyobject(env) + self.special_bool_cmp_utility_code = UtilityCode.load_cached("PySequenceContains", "ObjectHandling.c") + self.special_bool_cmp_function = "__Pyx_PySequence_ContainsTF" + return True + return False + + def generate_operation_code(self, code, result_code, + operand1, op, operand2): + if self.type.is_pyobject: + error_clause = code.error_goto_if_null + got_ref = "__Pyx_XGOTREF(%s); " % result_code + if self.special_bool_cmp_function: + code.globalstate.use_utility_code( + UtilityCode.load_cached("PyBoolOrNullFromLong", "ObjectHandling.c")) + coerce_result = "__Pyx_PyBoolOrNull_FromLong" + else: + coerce_result = "__Pyx_PyBool_FromLong" + else: + error_clause = code.error_goto_if_neg + got_ref = "" + coerce_result = "" + + if self.special_bool_cmp_function: + if operand1.type.is_pyobject: + result1 = operand1.py_result() + else: + result1 = operand1.result() + if operand2.type.is_pyobject: + result2 = operand2.py_result() + else: + result2 = operand2.result() + special_bool_extra_args_result = ", ".join([ + extra_arg.result() for extra_arg in self.special_bool_extra_args + ]) + if self.special_bool_cmp_utility_code: + code.globalstate.use_utility_code(self.special_bool_cmp_utility_code) + code.putln( + "%s = %s(%s(%s, %s, %s)); %s%s" % ( + result_code, + coerce_result, + self.special_bool_cmp_function, + result1, result2, + special_bool_extra_args_result if self.special_bool_extra_args else richcmp_constants[op], + got_ref, + error_clause(result_code, self.pos))) + + elif operand1.type.is_pyobject and op not in ('is', 'is_not'): + assert op not in ('in', 'not_in'), op + assert self.type.is_pyobject or self.type is PyrexTypes.c_bint_type + code.putln("%s = PyObject_RichCompare%s(%s, %s, %s); %s%s" % ( + result_code, + "" if self.type.is_pyobject else "Bool", + operand1.py_result(), + operand2.py_result(), + richcmp_constants[op], + got_ref, + error_clause(result_code, self.pos))) + + elif operand1.type.is_complex: + code.putln("%s = %s(%s%s(%s, %s));" % ( + result_code, + coerce_result, + op == "!=" and "!" or "", + operand1.type.unary_op('eq'), + operand1.result(), + operand2.result())) + + else: + type1 = operand1.type + type2 = operand2.type + if (type1.is_extension_type or type2.is_extension_type) \ + and not type1.same_as(type2): + common_type = py_object_type + elif type1.is_numeric: + common_type = PyrexTypes.widest_numeric_type(type1, type2) + else: + common_type = type1 + code1 = operand1.result_as(common_type) + code2 = operand2.result_as(common_type) + statement = "%s = %s(%s %s %s);" % ( + result_code, + coerce_result, + code1, + self.c_operator(op), + code2) + if self.is_cpp_comparison() and self.exception_check == '+': + translate_cpp_exception( + code, + self.pos, + statement, + result_code if self.type.is_pyobject else None, + self.exception_value, + self.in_nogil_context) + else: + code.putln(statement) + + def c_operator(self, op): + if op == 'is': + return "==" + elif op == 'is_not': + return "!=" + else: + return op + +class PrimaryCmpNode(ExprNode, CmpNode): + # Non-cascaded comparison or first comparison of + # a cascaded sequence. + # + # operator string + # operand1 ExprNode + # operand2 ExprNode + # cascade CascadedCmpNode + + # We don't use the subexprs mechanism, because + # things here are too complicated for it to handle. + # Instead, we override all the framework methods + # which use it. + + child_attrs = ['operand1', 'operand2', 'coerced_operand2', 'cascade', + 'special_bool_extra_args'] + + cascade = None + coerced_operand2 = None + is_memslice_nonecheck = False + + def infer_type(self, env): + type1 = self.operand1.infer_type(env) + type2 = self.operand2.infer_type(env) + + if is_pythran_expr(type1) or is_pythran_expr(type2): + if is_pythran_supported_type(type1) and is_pythran_supported_type(type2): + return PythranExpr(pythran_binop_type(self.operator, type1, type2)) + + # TODO: implement this for other types. + return py_object_type + + def type_dependencies(self, env): + return () + + def calculate_constant_result(self): + assert not self.cascade + self.calculate_cascaded_constant_result(self.operand1.constant_result) + + def compile_time_value(self, denv): + operand1 = self.operand1.compile_time_value(denv) + return self.cascaded_compile_time_value(operand1, denv) + + def unify_cascade_type(self): + cdr = self.cascade + while cdr: + cdr.type = self.type + cdr = cdr.cascade + + def analyse_types(self, env): + self.operand1 = self.operand1.analyse_types(env) + self.operand2 = self.operand2.analyse_types(env) + if self.is_cpp_comparison(): + self.analyse_cpp_comparison(env) + if self.cascade: + error(self.pos, "Cascading comparison not yet supported for cpp types.") + return self + + type1 = self.operand1.type + type2 = self.operand2.type + if is_pythran_expr(type1) or is_pythran_expr(type2): + if is_pythran_supported_type(type1) and is_pythran_supported_type(type2): + self.type = PythranExpr(pythran_binop_type(self.operator, type1, type2)) + self.is_pycmp = False + return self + + if self.analyse_memoryviewslice_comparison(env): + return self + + if self.cascade: + self.cascade = self.cascade.analyse_types(env) + + if self.operator in ('in', 'not_in'): + if self.is_c_string_contains(): + self.is_pycmp = False + common_type = None + if self.cascade: + error(self.pos, "Cascading comparison not yet supported for 'int_val in string'.") + return self + if self.operand2.type is unicode_type: + env.use_utility_code(UtilityCode.load_cached("PyUCS4InUnicode", "StringTools.c")) + else: + if self.operand1.type is PyrexTypes.c_uchar_type: + self.operand1 = self.operand1.coerce_to(PyrexTypes.c_char_type, env) + if self.operand2.type is not bytes_type: + self.operand2 = self.operand2.coerce_to(bytes_type, env) + env.use_utility_code(UtilityCode.load_cached("BytesContains", "StringTools.c")) + self.operand2 = self.operand2.as_none_safe_node( + "argument of type 'NoneType' is not iterable") + elif self.is_ptr_contains(): + if self.cascade: + error(self.pos, "Cascading comparison not supported for 'val in sliced pointer'.") + self.type = PyrexTypes.c_bint_type + # Will be transformed by IterationTransform + return self + elif self.find_special_bool_compare_function(env, self.operand1): + if not self.operand1.type.is_pyobject: + self.operand1 = self.operand1.coerce_to_pyobject(env) + common_type = None # if coercion needed, the method call above has already done it + self.is_pycmp = False # result is bint + else: + common_type = py_object_type + self.is_pycmp = True + elif self.find_special_bool_compare_function(env, self.operand1): + if not self.operand1.type.is_pyobject: + self.operand1 = self.operand1.coerce_to_pyobject(env) + common_type = None # if coercion needed, the method call above has already done it + self.is_pycmp = False # result is bint + else: + common_type = self.find_common_type(env, self.operator, self.operand1) + self.is_pycmp = common_type.is_pyobject + + if common_type is not None and not common_type.is_error: + if self.operand1.type != common_type: + self.operand1 = self.operand1.coerce_to(common_type, env) + self.coerce_operands_to(common_type, env) + + if self.cascade: + self.operand2 = self.operand2.coerce_to_simple(env) + self.cascade.coerce_cascaded_operands_to_temp(env) + operand2 = self.cascade.optimise_comparison(self.operand2, env) + if operand2 is not self.operand2: + self.coerced_operand2 = operand2 + if self.is_python_result(): + self.type = PyrexTypes.py_object_type + else: + self.type = PyrexTypes.c_bint_type + self.unify_cascade_type() + if self.is_pycmp or self.cascade or self.special_bool_cmp_function: + # 1) owned reference, 2) reused value, 3) potential function error return value + self.is_temp = 1 + return self + + def analyse_cpp_comparison(self, env): + type1 = self.operand1.type + type2 = self.operand2.type + self.is_pycmp = False + entry = env.lookup_operator(self.operator, [self.operand1, self.operand2]) + if entry is None: + error(self.pos, "Invalid types for '%s' (%s, %s)" % + (self.operator, type1, type2)) + self.type = PyrexTypes.error_type + self.result_code = "" + return + func_type = entry.type + if func_type.is_ptr: + func_type = func_type.base_type + self.exception_check = func_type.exception_check + self.exception_value = func_type.exception_value + if self.exception_check == '+': + self.is_temp = True + if needs_cpp_exception_conversion(self): + env.use_utility_code(UtilityCode.load_cached("CppExceptionConversion", "CppSupport.cpp")) + if len(func_type.args) == 1: + self.operand2 = self.operand2.coerce_to(func_type.args[0].type, env) + else: + self.operand1 = self.operand1.coerce_to(func_type.args[0].type, env) + self.operand2 = self.operand2.coerce_to(func_type.args[1].type, env) + self.type = func_type.return_type + + def analyse_memoryviewslice_comparison(self, env): + have_none = self.operand1.is_none or self.operand2.is_none + have_slice = (self.operand1.type.is_memoryviewslice or + self.operand2.type.is_memoryviewslice) + ops = ('==', '!=', 'is', 'is_not') + if have_slice and have_none and self.operator in ops: + self.is_pycmp = False + self.type = PyrexTypes.c_bint_type + self.is_memslice_nonecheck = True + return True + + return False + + def coerce_to_boolean(self, env): + if self.is_pycmp: + # coercing to bool => may allow for more efficient comparison code + if self.find_special_bool_compare_function( + env, self.operand1, result_is_bool=True): + self.is_pycmp = False + self.type = PyrexTypes.c_bint_type + self.is_temp = 1 + if self.cascade: + operand2 = self.cascade.optimise_comparison( + self.operand2, env, result_is_bool=True) + if operand2 is not self.operand2: + self.coerced_operand2 = operand2 + self.unify_cascade_type() + return self + # TODO: check if we can optimise parts of the cascade here + return ExprNode.coerce_to_boolean(self, env) + + def has_python_operands(self): + return (self.operand1.type.is_pyobject + or self.operand2.type.is_pyobject) + + def check_const(self): + if self.cascade: + self.not_const() + return False + else: + return self.operand1.check_const() and self.operand2.check_const() + + def calculate_result_code(self): + operand1, operand2 = self.operand1, self.operand2 + if operand1.type.is_complex: + if self.operator == "!=": + negation = "!" + else: + negation = "" + return "(%s%s(%s, %s))" % ( + negation, + operand1.type.binary_op('=='), + operand1.result(), + operand2.result()) + elif self.is_c_string_contains(): + if operand2.type is unicode_type: + method = "__Pyx_UnicodeContainsUCS4" + else: + method = "__Pyx_BytesContains" + if self.operator == "not_in": + negation = "!" + else: + negation = "" + return "(%s%s(%s, %s))" % ( + negation, + method, + operand2.result(), + operand1.result()) + else: + if is_pythran_expr(self.type): + result1, result2 = operand1.pythran_result(), operand2.pythran_result() + else: + result1, result2 = operand1.result(), operand2.result() + if self.is_memslice_nonecheck: + if operand1.type.is_memoryviewslice: + result1 = "((PyObject *) %s.memview)" % result1 + else: + result2 = "((PyObject *) %s.memview)" % result2 + + return "(%s %s %s)" % ( + result1, + self.c_operator(self.operator), + result2) + + def generate_evaluation_code(self, code): + self.operand1.generate_evaluation_code(code) + self.operand2.generate_evaluation_code(code) + for extra_arg in self.special_bool_extra_args: + extra_arg.generate_evaluation_code(code) + if self.is_temp: + self.allocate_temp_result(code) + self.generate_operation_code(code, self.result(), + self.operand1, self.operator, self.operand2) + if self.cascade: + self.cascade.generate_evaluation_code( + code, self.result(), self.coerced_operand2 or self.operand2, + needs_evaluation=self.coerced_operand2 is not None) + self.operand1.generate_disposal_code(code) + self.operand1.free_temps(code) + self.operand2.generate_disposal_code(code) + self.operand2.free_temps(code) + + def generate_subexpr_disposal_code(self, code): + # If this is called, it is a non-cascaded cmp, + # so only need to dispose of the two main operands. + self.operand1.generate_disposal_code(code) + self.operand2.generate_disposal_code(code) + + def free_subexpr_temps(self, code): + # If this is called, it is a non-cascaded cmp, + # so only need to dispose of the two main operands. + self.operand1.free_temps(code) + self.operand2.free_temps(code) + + def annotate(self, code): + self.operand1.annotate(code) + self.operand2.annotate(code) + if self.cascade: + self.cascade.annotate(code) + + +class CascadedCmpNode(Node, CmpNode): + # A CascadedCmpNode is not a complete expression node. It + # hangs off the side of another comparison node, shares + # its left operand with that node, and shares its result + # with the PrimaryCmpNode at the head of the chain. + # + # operator string + # operand2 ExprNode + # cascade CascadedCmpNode + + child_attrs = ['operand2', 'coerced_operand2', 'cascade', + 'special_bool_extra_args'] + + cascade = None + coerced_operand2 = None + constant_result = constant_value_not_set # FIXME: where to calculate this? + + def infer_type(self, env): + # TODO: Actually implement this (after merging with -unstable). + return py_object_type + + def type_dependencies(self, env): + return () + + def has_constant_result(self): + return self.constant_result is not constant_value_not_set and \ + self.constant_result is not not_a_constant + + def analyse_types(self, env): + self.operand2 = self.operand2.analyse_types(env) + if self.cascade: + self.cascade = self.cascade.analyse_types(env) + return self + + def has_python_operands(self): + return self.operand2.type.is_pyobject + + def is_cpp_comparison(self): + # cascaded comparisons aren't currently implemented for c++ classes. + return False + + def optimise_comparison(self, operand1, env, result_is_bool=False): + if self.find_special_bool_compare_function(env, operand1, result_is_bool): + self.is_pycmp = False + self.type = PyrexTypes.c_bint_type + if not operand1.type.is_pyobject: + operand1 = operand1.coerce_to_pyobject(env) + if self.cascade: + operand2 = self.cascade.optimise_comparison(self.operand2, env, result_is_bool) + if operand2 is not self.operand2: + self.coerced_operand2 = operand2 + return operand1 + + def coerce_operands_to_pyobjects(self, env): + self.operand2 = self.operand2.coerce_to_pyobject(env) + if self.operand2.type is dict_type and self.operator in ('in', 'not_in'): + self.operand2 = self.operand2.as_none_safe_node("'NoneType' object is not iterable") + if self.cascade: + self.cascade.coerce_operands_to_pyobjects(env) + + def coerce_cascaded_operands_to_temp(self, env): + if self.cascade: + #self.operand2 = self.operand2.coerce_to_temp(env) #CTT + self.operand2 = self.operand2.coerce_to_simple(env) + self.cascade.coerce_cascaded_operands_to_temp(env) + + def generate_evaluation_code(self, code, result, operand1, needs_evaluation=False): + if self.type.is_pyobject: + code.putln("if (__Pyx_PyObject_IsTrue(%s)) {" % result) + code.put_decref(result, self.type) + else: + code.putln("if (%s) {" % result) + if needs_evaluation: + operand1.generate_evaluation_code(code) + self.operand2.generate_evaluation_code(code) + for extra_arg in self.special_bool_extra_args: + extra_arg.generate_evaluation_code(code) + self.generate_operation_code(code, result, + operand1, self.operator, self.operand2) + if self.cascade: + self.cascade.generate_evaluation_code( + code, result, self.coerced_operand2 or self.operand2, + needs_evaluation=self.coerced_operand2 is not None) + if needs_evaluation: + operand1.generate_disposal_code(code) + operand1.free_temps(code) + # Cascaded cmp result is always temp + self.operand2.generate_disposal_code(code) + self.operand2.free_temps(code) + code.putln("}") + + def annotate(self, code): + self.operand2.annotate(code) + if self.cascade: + self.cascade.annotate(code) + + +binop_node_classes = { + "or": BoolBinopNode, + "and": BoolBinopNode, + "|": BitwiseOrNode, + "^": IntBinopNode, + "&": IntBinopNode, + "<<": IntBinopNode, + ">>": IntBinopNode, + "+": AddNode, + "-": SubNode, + "*": MulNode, + "@": MatMultNode, + "/": DivNode, + "//": DivNode, + "%": ModNode, + "**": PowNode, +} + + +def binop_node(pos, operator, operand1, operand2, inplace=False, **kwargs): + # Construct binop node of appropriate class for + # given operator. + return binop_node_classes[operator]( + pos, + operator=operator, + operand1=operand1, + operand2=operand2, + inplace=inplace, + **kwargs) + + +#------------------------------------------------------------------- +# +# Coercion nodes +# +# Coercion nodes are special in that they are created during +# the analyse_types phase of parse tree processing. +# Their __init__ methods consequently incorporate some aspects +# of that phase. +# +#------------------------------------------------------------------- + +class CoercionNode(ExprNode): + # Abstract base class for coercion nodes. + # + # arg ExprNode node being coerced + + subexprs = ['arg'] + constant_result = not_a_constant + + def __init__(self, arg): + super().__init__(arg.pos) + self.arg = arg + if debug_coercion: + print("%s Coercing %s" % (self, self.arg)) + + def calculate_constant_result(self): + # constant folding can break type coercion, so this is disabled + pass + + def annotate(self, code): + self.arg.annotate(code) + if self.arg.type != self.type: + file, line, col = self.pos + code.annotate((file, line, col-1), AnnotationItem( + style='coerce', tag='coerce', text='[%s] to [%s]' % (self.arg.type, self.type))) + + def analyse_types(self, env): + return self + + +class CoerceToMemViewSliceNode(CoercionNode): + """ + Coerce an object to a memoryview slice. This holds a new reference in + a managed temp. + """ + + def __init__(self, arg, dst_type, env): + assert dst_type.is_memoryviewslice + assert not arg.type.is_memoryviewslice + CoercionNode.__init__(self, arg) + self.type = dst_type + self.is_temp = 1 + self.use_managed_ref = True + self.arg = arg + self.type.create_from_py_utility_code(env) + + def generate_result_code(self, code): + code.putln(self.type.from_py_call_code( + self.arg.py_result(), + self.result(), + self.pos, + code + )) + + +class CastNode(CoercionNode): + # Wrap a node in a C type cast. + + def __init__(self, arg, new_type): + CoercionNode.__init__(self, arg) + self.type = new_type + + def may_be_none(self): + return self.arg.may_be_none() + + def calculate_result_code(self): + return self.arg.result_as(self.type) + + def generate_result_code(self, code): + pass + + +class PyTypeTestNode(CoercionNode): + # This node is used to check that a generic Python + # object is an instance of a particular extension type. + # This node borrows the result of its argument node. + + exact_builtin_type = True + + def __init__(self, arg, dst_type, env, notnone=False): + # The arg is known to be a Python object, and + # the dst_type is known to be an extension type. + assert dst_type.is_extension_type or dst_type.is_builtin_type, \ + "PyTypeTest for %s against non extension type %s" % (arg.type, dst_type) + CoercionNode.__init__(self, arg) + self.type = dst_type + self.result_ctype = arg.ctype() + self.notnone = notnone + + nogil_check = Node.gil_error + gil_message = "Python type test" + + def analyse_types(self, env): + return self + + def may_be_none(self): + if self.notnone: + return False + return self.arg.may_be_none() + + def is_simple(self): + return self.arg.is_simple() + + def result_in_temp(self): + return self.arg.result_in_temp() + + def is_ephemeral(self): + return self.arg.is_ephemeral() + + def nonlocally_immutable(self): + return self.arg.nonlocally_immutable() + + def coerce_to_temp(self, env): + self.arg = self.arg.coerce_to_temp(env) + return self + + def reanalyse(self): + if self.type != self.arg.type or not self.arg.result_in_temp(): + return self + if not self.type.typeobj_is_available(): + return self + if self.arg.may_be_none() and self.notnone: + return self.arg.as_none_safe_node("Cannot convert NoneType to %.200s" % self.type.name) + return self.arg + + def calculate_constant_result(self): + # FIXME + pass + + def calculate_result_code(self): + return self.arg.result() + + def generate_result_code(self, code): + if self.type.typeobj_is_available(): + allow_none = not self.notnone + if self.type.is_builtin_type: + type_test = self.type.type_test_code( + code.funcstate.scope, + self.arg.py_result(), + allow_none, + exact=self.exact_builtin_type, + ) + code.globalstate.use_utility_code(UtilityCode.load_cached( + "RaiseUnexpectedTypeError", "ObjectHandling.c")) + else: + type_test = self.type.type_test_code( + code.funcstate.scope, + self.arg.py_result(), + allow_none, + ) + code.globalstate.use_utility_code( + UtilityCode.load_cached("ExtTypeTest", "ObjectHandling.c")) + code.putln("if (!(%s)) %s" % ( + type_test, code.error_goto(self.pos))) + else: + error(self.pos, "Cannot test type of extern C class " + "without type object name specification") + + def generate_post_assignment_code(self, code): + self.arg.generate_post_assignment_code(code) + + def allocate_temp_result(self, code): + pass + + def release_temp_result(self, code): + pass + + def free_temps(self, code): + self.arg.free_temps(code) + + def free_subexpr_temps(self, code): + self.arg.free_subexpr_temps(code) + + +class NoneCheckNode(_TempModifierNode): + # This node is used to check that a Python object is not None and + # raises an appropriate exception (as specified by the creating + # transform). + + is_nonecheck = True + type = None + + def __init__(self, arg, exception_type_cname, exception_message, + exception_format_args=()): + super().__init__(arg.pos, arg) + self.type = arg.type + self.result_ctype = arg.ctype() + self.exception_type_cname = exception_type_cname + self.exception_message = exception_message + self.exception_format_args = tuple(exception_format_args or ()) + + nogil_check = None # this node only guards an operation that would fail already + + def analyse_types(self, env): + # Always already analysed. + # FIXME: We should rather avoid calling analyse_types() again after the first analysis. + return self + + def may_be_none(self): + return False + + def condition(self): + if self.type.is_pyobject: + return self.arg.py_result() + elif self.type.is_memoryviewslice: + return "((PyObject *) %s.memview)" % self.arg.result() + else: + raise Exception("unsupported type") + + @classmethod + def generate(cls, arg, code, exception_message, + exception_type_cname="PyExc_TypeError", exception_format_args=(), in_nogil_context=False): + node = cls(arg, exception_type_cname, exception_message, exception_format_args) + node.in_nogil_context = in_nogil_context + node.put_nonecheck(code) + + @classmethod + def generate_if_needed(cls, arg, code, exception_message, + exception_type_cname="PyExc_TypeError", exception_format_args=(), in_nogil_context=False): + if arg.may_be_none(): + cls.generate(arg, code, exception_message, exception_type_cname, exception_format_args, in_nogil_context) + + def put_nonecheck(self, code): + code.putln( + "if (unlikely(%s == Py_None)) {" % self.condition()) + + if self.in_nogil_context: + code.put_ensure_gil() + + escape = StringEncoding.escape_byte_string + if self.exception_format_args: + code.putln('PyErr_Format(%s, "%s", %s);' % ( + self.exception_type_cname, + StringEncoding.escape_byte_string( + self.exception_message.encode('UTF-8')), + ', '.join([ '"%s"' % escape(str(arg).encode('UTF-8')) + for arg in self.exception_format_args ]))) + else: + code.putln('PyErr_SetString(%s, "%s");' % ( + self.exception_type_cname, + escape(self.exception_message.encode('UTF-8')))) + + if self.in_nogil_context: + code.put_release_ensured_gil() + + code.putln(code.error_goto(self.pos)) + code.putln("}") + + def generate_result_code(self, code): + self.put_nonecheck(code) + + +class CoerceToPyTypeNode(CoercionNode): + # This node is used to convert a C data type + # to a Python object. + + type = py_object_type + target_type = py_object_type + is_temp = 1 + + def __init__(self, arg, env, type=py_object_type): + if not arg.type.create_to_py_utility_code(env): + error(arg.pos, "Cannot convert '%s' to Python object" % arg.type) + elif arg.type.is_complex: + # special case: complex coercion is so complex that it + # uses a macro ("__pyx_PyComplex_FromComplex()"), for + # which the argument must be simple + arg = arg.coerce_to_simple(env) + CoercionNode.__init__(self, arg) + if type is py_object_type: + # be specific about some known types + if arg.type.is_string or arg.type.is_cpp_string: + self.type = default_str_type(env) + elif arg.type.is_pyunicode_ptr or arg.type.is_unicode_char: + self.type = unicode_type + elif arg.type.is_complex: + self.type = Builtin.complex_type + self.target_type = self.type + elif arg.type.is_string or arg.type.is_cpp_string: + if (type not in (bytes_type, bytearray_type) + and not env.directives['c_string_encoding']): + error(arg.pos, + "default encoding required for conversion from '%s' to '%s'" % + (arg.type, type)) + self.type = self.target_type = type + else: + # FIXME: check that the target type and the resulting type are compatible + self.target_type = type + + gil_message = "Converting to Python object" + + def may_be_none(self): + # FIXME: is this always safe? + return False + + def coerce_to_boolean(self, env): + arg_type = self.arg.type + if (arg_type == PyrexTypes.c_bint_type or + (arg_type.is_pyobject and arg_type.name == 'bool')): + return self.arg.coerce_to_temp(env) + else: + return CoerceToBooleanNode(self, env) + + def coerce_to_index(self, env): + return self.arg.coerce_to_index(env) + + def analyse_types(self, env): + # The arg is always already analysed + return self + + def generate_result_code(self, code): + code.putln('%s; %s' % ( + self.arg.type.to_py_call_code( + self.arg.result(), + self.result(), + self.target_type), + code.error_goto_if_null(self.result(), self.pos))) + + self.generate_gotref(code) + + +class CoerceIntToBytesNode(CoerceToPyTypeNode): + # This node is used to convert a C int type to a Python bytes + # object. + + is_temp = 1 + + def __init__(self, arg, env): + arg = arg.coerce_to_simple(env) + CoercionNode.__init__(self, arg) + self.type = Builtin.bytes_type + + def generate_result_code(self, code): + arg = self.arg + arg_result = arg.result() + if arg.type not in (PyrexTypes.c_char_type, + PyrexTypes.c_uchar_type, + PyrexTypes.c_schar_type): + if arg.type.signed: + code.putln("if ((%s < 0) || (%s > 255)) {" % ( + arg_result, arg_result)) + else: + code.putln("if (%s > 255) {" % arg_result) + code.putln('PyErr_SetString(PyExc_OverflowError, ' + '"value too large to pack into a byte"); %s' % ( + code.error_goto(self.pos))) + code.putln('}') + temp = None + if arg.type is not PyrexTypes.c_char_type: + temp = code.funcstate.allocate_temp(PyrexTypes.c_char_type, manage_ref=False) + code.putln("%s = (char)%s;" % (temp, arg_result)) + arg_result = temp + code.putln('%s = PyBytes_FromStringAndSize(&%s, 1); %s' % ( + self.result(), + arg_result, + code.error_goto_if_null(self.result(), self.pos))) + if temp is not None: + code.funcstate.release_temp(temp) + self.generate_gotref(code) + + +class CoerceFromPyTypeNode(CoercionNode): + # This node is used to convert a Python object + # to a C data type. + + # Allow 'None' to map to a difference C value independent of the coercion, e.g. to 'NULL' or '0'. + special_none_cvalue = None + + def __init__(self, result_type, arg, env): + CoercionNode.__init__(self, arg) + self.type = result_type + self.is_temp = 1 + if not result_type.create_from_py_utility_code(env): + error(arg.pos, + "Cannot convert Python object to '%s'" % result_type) + if self.type.is_string or self.type.is_pyunicode_ptr: + if self.arg.is_name and self.arg.entry and self.arg.entry.is_pyglobal: + warning(arg.pos, + "Obtaining '%s' from externally modifiable global Python value" % result_type, + level=1) + if self.type.is_pyunicode_ptr: + warning(arg.pos, + "Py_UNICODE* has been removed in Python 3.12. This conversion to a " + "Py_UNICODE* will no longer compile in the latest Python versions. " + "Use Python C API functions like PyUnicode_AsWideCharString if you " + "need to obtain a wchar_t* on Windows (and free the string manually after use).", + level=1) + + def analyse_types(self, env): + # The arg is always already analysed + return self + + def is_ephemeral(self): + return (self.type.is_ptr and not self.type.is_array) and self.arg.is_ephemeral() + + def generate_result_code(self, code): + from_py_function = None + # for certain source types, we can do better than the generic coercion + if self.type.is_string and self.arg.type is bytes_type: + if self.type.from_py_function.startswith('__Pyx_PyObject_As'): + from_py_function = '__Pyx_PyBytes' + self.type.from_py_function[len('__Pyx_PyObject'):] + NoneCheckNode.generate_if_needed(self.arg, code, "expected bytes, NoneType found") + + code.putln(self.type.from_py_call_code( + self.arg.py_result(), self.result(), self.pos, code, + from_py_function=from_py_function, + special_none_cvalue=self.special_none_cvalue, + )) + if self.type.is_pyobject: + self.generate_gotref(code) + + def nogil_check(self, env): + error(self.pos, "Coercion from Python not allowed without the GIL") + + +class CoerceToBooleanNode(CoercionNode): + # This node is used when a result needs to be used + # in a boolean context. + + type = PyrexTypes.c_bint_type + + # Note that all of these need a check if CYTHON_ASSUME_SAFE_SIZE is false. + # They should also all return something compatible with Py_ssize_t + # (i.e. Py_ssize_t or a smaller int type). + _special_builtins = { + Builtin.list_type: '__Pyx_PyList_GET_SIZE', + Builtin.tuple_type: '__Pyx_PyTuple_GET_SIZE', + Builtin.set_type: '__Pyx_PySet_GET_SIZE', + Builtin.frozenset_type: '__Pyx_PySet_GET_SIZE', + Builtin.bytes_type: '__Pyx_PyBytes_GET_SIZE', + Builtin.bytearray_type: '__Pyx_PyByteArray_GET_SIZE', + Builtin.unicode_type: '__Pyx_PyUnicode_IS_TRUE', + } + + def __init__(self, arg, env): + CoercionNode.__init__(self, arg) + if arg.type.is_pyobject: + self.is_temp = 1 + + def nogil_check(self, env): + if self.arg.type.is_pyobject and self._special_builtins.get(self.arg.type) is None: + self.gil_error() + + gil_message = "Truth-testing Python object" + + def check_const(self): + if self.is_temp: + self.not_const() + return False + return self.arg.check_const() + + def calculate_result_code(self): + return "(%s != 0)" % self.arg.result() + + def generate_result_code(self, code): + if not self.is_temp: + return + test_func = self._special_builtins.get(self.arg.type) + if test_func is not None: + if self.arg.may_be_none(): + code.putln(f"if ({self.arg.py_result()} == Py_None) {self.result()} = 0;") + code.putln("else") + code.putln("{") + # Be aware that __Pyx_PyUnicode_IS_TRUE isn't strictly returning a size (but it does + # return an int which fits into a Py_ssize_t). + code.putln(f"Py_ssize_t {Naming.quick_temp_cname} = {test_func}({self.arg.py_result()});") + code.putln(code.error_goto_if( + f"((!CYTHON_ASSUME_SAFE_SIZE) && {Naming.quick_temp_cname} < 0)", self.pos)) + code.putln(f"{self.result()} = ({Naming.quick_temp_cname} != 0);") + code.putln("}") + code.putln() + else: + code.putln( + "%s = __Pyx_PyObject_IsTrue(%s); %s" % ( + self.result(), + self.arg.py_result(), + code.error_goto_if_neg(self.result(), self.pos))) + + def analyse_types(self, env): + return self + + +class CoerceToComplexNode(CoercionNode): + + def __init__(self, arg, dst_type, env): + if arg.type.is_complex: + arg = arg.coerce_to_simple(env) + self.type = dst_type + CoercionNode.__init__(self, arg) + dst_type.create_declaration_utility_code(env) + + def calculate_result_code(self): + if self.arg.type.is_complex: + real_part = self.arg.type.real_code(self.arg.result()) + imag_part = self.arg.type.imag_code(self.arg.result()) + else: + real_part = self.arg.result() + imag_part = "0" + return "%s(%s, %s)" % ( + self.type.from_parts, + real_part, + imag_part) + + def generate_result_code(self, code): + pass + + def analyse_types(self, env): + return self + + +def coerce_from_soft_complex(arg, dst_type, env): + from .UtilNodes import HasNoGilNode + cfunc_type = PyrexTypes.CFuncType( + PyrexTypes.c_double_type, + [ PyrexTypes.CFuncTypeArg("value", PyrexTypes.soft_complex_type, None), + PyrexTypes.CFuncTypeArg("have_gil", PyrexTypes.c_bint_type, None) ], + exception_value=-1, + exception_check=True, + nogil=True # We can acquire the GIL internally on failure + ) + call = PythonCapiCallNode( + arg.pos, + "__Pyx_SoftComplexToDouble", + cfunc_type, + utility_code = UtilityCode.load_cached("SoftComplexToDouble", "Complex.c"), + args = [arg, HasNoGilNode(arg.pos)], + ) + call = call.analyse_types(env) + if call.type != dst_type: + call = call.coerce_to(dst_type, env) + return call + + +class CoerceToTempNode(CoercionNode): + # This node is used to force the result of another node + # to be stored in a temporary. It is only used if the + # argument node's result is not already in a temporary. + + def __init__(self, arg, env): + CoercionNode.__init__(self, arg) + self.type = self.arg.type.as_argument_type() + self.constant_result = self.arg.constant_result + self.is_temp = 1 + if self.type.is_pyobject: + self.result_ctype = py_object_type + + gil_message = "Creating temporary Python reference" + + def analyse_types(self, env): + # The arg is always already analysed + return self + + def may_be_none(self): + return self.arg.may_be_none() + + def coerce_to_boolean(self, env): + self.arg = self.arg.coerce_to_boolean(env) + if self.arg.is_simple(): + return self.arg + self.type = self.arg.type + self.result_ctype = self.type + return self + + def generate_result_code(self, code): + #self.arg.generate_evaluation_code(code) # Already done + # by generic generate_subexpr_evaluation_code! + code.putln("%s = %s;" % ( + self.result(), self.arg.result_as(self.ctype()))) + if self.use_managed_ref: + if not self.type.is_memoryviewslice: + code.put_incref(self.result(), self.ctype()) + else: + code.put_incref_memoryviewslice(self.result(), self.type, + have_gil=not self.in_nogil_context) + + +class ProxyNode(CoercionNode): + """ + A node that should not be replaced by transforms or other means, + and hence can be useful to wrap the argument to a clone node + + MyNode -> ProxyNode -> ArgNode + CloneNode -^ + """ + + nogil_check = None + + def __init__(self, arg): + super().__init__(arg) + self.constant_result = arg.constant_result + self.update_type_and_entry() + + def analyse_types(self, env): + self.arg = self.arg.analyse_expressions(env) + self.update_type_and_entry() + return self + + def infer_type(self, env): + return self.arg.infer_type(env) + + def update_type_and_entry(self): + type = getattr(self.arg, 'type', None) + if type: + self.type = type + self.result_ctype = self.arg.result_ctype + arg_entry = getattr(self.arg, 'entry', None) + if arg_entry: + self.entry = arg_entry + + def generate_result_code(self, code): + self.arg.generate_result_code(code) + + def result(self): + return self.arg.result() + + def is_simple(self): + return self.arg.is_simple() + + def may_be_none(self): + return self.arg.may_be_none() + + def generate_evaluation_code(self, code): + self.arg.generate_evaluation_code(code) + + def generate_disposal_code(self, code): + self.arg.generate_disposal_code(code) + + def free_temps(self, code): + self.arg.free_temps(code) + +class CloneNode(CoercionNode): + # This node is employed when the result of another node needs + # to be used multiple times. The argument node's result must + # be in a temporary. This node "borrows" the result from the + # argument node, and does not generate any evaluation or + # disposal code for it. The original owner of the argument + # node is responsible for doing those things. + + subexprs = [] # Arg is not considered a subexpr + nogil_check = None + + def __init__(self, arg): + CoercionNode.__init__(self, arg) + self.constant_result = arg.constant_result + type = getattr(arg, 'type', None) + if type: + self.type = type + self.result_ctype = arg.result_ctype + arg_entry = getattr(arg, 'entry', None) + if arg_entry: + self.entry = arg_entry + + def result(self): + return self.arg.result() + + def may_be_none(self): + return self.arg.may_be_none() + + def type_dependencies(self, env): + return self.arg.type_dependencies(env) + + def infer_type(self, env): + return self.arg.infer_type(env) + + def analyse_types(self, env): + self.type = self.arg.type + self.result_ctype = self.arg.result_ctype + self.is_temp = 1 + arg_entry = getattr(self.arg, 'entry', None) + if arg_entry: + self.entry = arg_entry + return self + + def coerce_to(self, dest_type, env): + if self.arg.is_literal: + return self.arg.coerce_to(dest_type, env) + return super().coerce_to(dest_type, env) + + def is_simple(self): + return True # result is always in a temp (or a name) + + def generate_evaluation_code(self, code): + pass + + def generate_result_code(self, code): + pass + + def generate_disposal_code(self, code): + pass + + def generate_post_assignment_code(self, code): + # if we're assigning from a CloneNode then it's "giveref"ed away, so it does + # need a matching incref (ideally this should happen before the assignment though) + if self.is_temp: # should usually be true + code.put_incref(self.result(), self.ctype()) + + def free_temps(self, code): + pass + + +class CppOptionalTempCoercion(CoercionNode): + """ + Used only in CoerceCppTemps - handles cases the temp is actually a OptionalCppClassType (and thus needs dereferencing when on the rhs) + """ + is_temp = False + + @property + def type(self): + return self.arg.type + + def calculate_result_code(self): + return "(*%s)" % self.arg.result() + + def generate_result_code(self, code): + pass + + def generate_bool_evaluation_code(self, *args, **kwds): + # This is enough of a corner-case that it probably isn't worth + # the corner-case of supporting it right now. + error(self.pos, "Using C++ classes in boolean binary operators with " + "the 'cpp_locals' directive is not currently supported.") + + def _make_move_result_rhs(self, result, optional=False): + # this wouldn't normally get moved (because it isn't a temp), but force it to be because it + # is a thin wrapper around a temp + return super()._make_move_result_rhs(result, optional=False) + + +class CMethodSelfCloneNode(CloneNode): + # Special CloneNode for the self argument of builtin C methods + # that accepts subtypes of the builtin type. This is safe only + # for 'final' subtypes, as subtypes of the declared type may + # override the C method. + + def coerce_to(self, dst_type, env): + if dst_type.is_builtin_type and self.type.subtype_of(dst_type): + return self + return CloneNode.coerce_to(self, dst_type, env) + + +class ModuleRefNode(ExprNode): + # Simple returns the module object + + type = py_object_type + is_temp = False + subexprs = [] + + def analyse_types(self, env): + return self + + def may_be_none(self): + return False + + def calculate_result_code(self): + return Naming.module_cname + + def generate_result_code(self, code): + pass + +class DocstringRefNode(ExprNode): + # Extracts the docstring of the body element + + subexprs = ['body'] + type = py_object_type + is_temp = True + + def __init__(self, pos, body): + ExprNode.__init__(self, pos) + assert body.type.is_pyobject + self.body = body + + def analyse_types(self, env): + return self + + def generate_result_code(self, code): + code.putln('%s = __Pyx_GetAttr(%s, %s); %s' % ( + self.result(), self.body.result(), + code.intern_identifier(StringEncoding.EncodedString("__doc__")), + code.error_goto_if_null(self.result(), self.pos))) + self.generate_gotref(code) + + +class AnnotationNode(ExprNode): + # Deals with the two possible uses of an annotation. + # 1. The post PEP-563 use where an annotation is stored + # as a string + # 2. The Cython use where the annotation can indicate an + # object type + # + # Doesn't handle the pre PEP-563 version where the + # annotation is evaluated into a Python Object. + + subexprs = [] + + # 'untyped' is set for fused specializations: + # Once a fused function has been created we don't want + # annotations to override an already set type. + untyped = False + + def __init__(self, pos, expr, string=None): + """string is expected to already be a UnicodeNode or None""" + ExprNode.__init__(self, pos) + if string is None: + # import doesn't work at top of file? + from .AutoDocTransforms import AnnotationWriter + string_value = StringEncoding.EncodedString( + AnnotationWriter(description="annotation").write(expr)) + string = UnicodeNode(pos, value=string_value) + self.string = string + self.expr = expr + + def analyse_types(self, env): + return self # nothing needs doing + + def analyse_as_type(self, env): + # for compatibility when used as a return_type_node, have this interface too + return self.analyse_type_annotation(env)[1] + + def _warn_on_unknown_annotation(self, env, annotation): + """Method checks for cases when user should be warned that annotation contains unknown types.""" + if isinstance(annotation, SliceIndexNode): + annotation = annotation.base + if annotation.is_name: + # Validate annotation in form `var: type` + if not env.lookup(annotation.name): + warning(annotation.pos, + "Unknown type declaration '%s' in annotation, ignoring" % self.string.value, level=1) + elif annotation.is_attribute and annotation.obj.is_name: + # Validate annotation in form `var: module.type` + if not env.lookup(annotation.obj.name): + # `module` is undeclared + warning(annotation.pos, + "Unknown type declaration '%s' in annotation, ignoring" % self.string.value, level=1) + elif annotation.obj.is_cython_module: + # `module` is cython + module_scope = annotation.obj.analyse_as_module(env) + if module_scope and not module_scope.lookup_type(annotation.attribute): + error(annotation.pos, + "Unknown type declaration '%s' in annotation" % self.string.value) + else: + module_scope = annotation.obj.analyse_as_module(env) + if module_scope and module_scope.pxd_file_loaded: + warning(annotation.pos, + "Unknown type declaration '%s' in annotation, ignoring" % self.string.value, level=1) + else: + warning(annotation.pos, "Unknown type declaration in annotation, ignoring") + + def analyse_type_annotation(self, env, assigned_value=None): + if self.untyped: + # Already applied as a fused type, not re-evaluating it here. + return [], None + annotation = self.expr + explicit_pytype = explicit_ctype = False + if annotation.is_dict_literal: + warning(annotation.pos, + "Dicts should no longer be used as type annotations. Use 'cython.int' etc. directly.", level=1) + for name, value in annotation.key_value_pairs: + if not name.is_string_literal: + continue + if name.value in ('type', b'type'): + explicit_pytype = True + if not explicit_ctype: + annotation = value + elif name.value in ('ctype', b'ctype'): + explicit_ctype = True + annotation = value + if explicit_pytype and explicit_ctype: + warning(annotation.pos, "Duplicate type declarations found in signature annotation", level=1) + elif isinstance(annotation, TupleNode): + warning(annotation.pos, + "Tuples cannot be declared as simple tuples of types. Use 'tuple[type1, type2, ...]'.", level=1) + return [], None + + with env.new_c_type_context(in_c_type_context=explicit_ctype): + arg_type = annotation.analyse_as_type(env) + + if arg_type is None: + self._warn_on_unknown_annotation(env, annotation) + return [], arg_type + + if annotation.is_string_literal: + warning(annotation.pos, + "Strings should no longer be used for type declarations. Use 'cython.int' etc. directly.", + level=1) + if explicit_pytype and not explicit_ctype and not (arg_type.is_pyobject or arg_type.equivalent_type): + warning(annotation.pos, + "Python type declaration in signature annotation does not refer to a Python type") + if arg_type.is_complex: + # creating utility code needs to be special-cased for complex types + arg_type.create_declaration_utility_code(env) + + # Check for declaration modifiers, e.g. "typing.Optional[...]" or "dataclasses.InitVar[...]" + modifiers = annotation.analyse_pytyping_modifiers(env) if annotation.is_subscript or isinstance(annotation, BitwiseOrNode) else [] + + return modifiers, arg_type + + +class AssignmentExpressionNode(ExprNode): + """ + Also known as a named expression or the walrus operator + + Arguments + lhs - NameNode - not stored directly as an attribute of the node + rhs - ExprNode + + Attributes + rhs - ExprNode + assignment - SingleAssignmentNode + """ + # subexprs and child_attrs are intentionally different here, because the assignment is not an expression + subexprs = ["rhs"] + child_attrs = ["rhs", "assignment"] # This order is important for control-flow (i.e. xdecref) to be right + + is_temp: bool = False + rhs: Optional[ExprNode] = None + assignment: SingleAssignmentNode + assignment_is_independent: bool = False + + def __init__(self, pos, lhs: NameNode, rhs: ExprNode, **kwds): + super().__init__(pos, **kwds) + self.assignment = SingleAssignmentNode( + pos, lhs=lhs, rhs=rhs, is_assignment_expression=True) + + @property + def type(self): + if self.rhs is not None: + return self.rhs.type + return self.assignment.rhs.type + + @property + def target_name(self): + return self.assignment.lhs.name + + def infer_type(self, env): + rhs = self.rhs or self.assignment.rhs + return rhs.infer_type(env) + + def analyse_declarations(self, env): + self.assignment.analyse_declarations(env) + + def analyse_types(self, env): + # we're trying to generate code that looks roughly like: + # __pyx_t_1 = rhs + # lhs = __pyx_t_1 + # __pyx_t_1 + # (plus any reference counting that's needed) + + self.assignment = self.assignment.analyse_types(env) + rhs = self.assignment.rhs + if not rhs.result_in_temp(): + if rhs.is_literal: + # For literals we can optimize by just using the literal twice + # + # We aren't including `self.rhs.is_name` in this optimization + # because that goes wrong for assignment expressions run in + # parallel. e.g. `(a := b) + (b := a + c)`) + # This is a special case of https://github.com/cython/cython/issues/4146 + # TODO - once that's fixed general revisit this code and possibly + # use coerce_to_simple + self.rhs = copy.copy(self.assignment.rhs) + self.assignment_is_independent = True + else: + # for anything but the simplest cases (where it can be used directly) + # we convert rhs to a temp, because CloneNode requires arg to be a temp + rhs = rhs.coerce_to_temp(env) + if not self.assignment_is_independent: + self.rhs = ProxyNode(rhs) + self.assignment.rhs = CloneNode(self.rhs) + self.rhs.arg = self.rhs.arg.coerce_to_temp(env) + + # TODO - there's a missed optimization in the code generation stage + # if self.rhs.arg is temp: an incref/decref pair can be removed + # (but needs a general mechanism to do that) + + if self.type.is_memoryviewslice and self.assignment_is_independent: + # In "put_assign_to_memviewslice", memoryviews don't generate reference + # counting on assignment from temp. That lack of reference counting + # essentially happens twice (since we use the temp twice), which we want to + # avoid. Therefore, present the clone node as "not a temp". + self.assignment.rhs.is_temp = False + return self + + def coerce_to(self, dst_type, env): + if self.assignment_is_independent: + # rhs and assignment don't share a node, so just behave normally + self.rhs = self.rhs.coerce_to(dst_type, env) + return self + if dst_type == self.assignment.rhs.type: + assert self.rhs is not None + # in this quite common case (for example, when both lhs, and self are being coerced to Python) + # we can optimize the coercion out by sharing it between + # this and the assignment + old_rhs_arg = self.rhs.arg + if isinstance(old_rhs_arg, CoerceToTempNode): + old_rhs_arg = old_rhs_arg.arg + rhs_arg = old_rhs_arg.coerce_to(dst_type, env) + if rhs_arg is not old_rhs_arg: + self.rhs.arg = rhs_arg + self.rhs.update_type_and_entry() + # clean up the old coercion node that the assignment has likely generated + if (isinstance(self.assignment.rhs, CoercionNode) + and not isinstance(self.assignment.rhs, CloneNode)): + self.assignment.rhs = self.assignment.rhs.arg + self.assignment.rhs.type = self.assignment.rhs.arg.type + return self + return super().coerce_to(dst_type, env) + + def calculate_result_code(self): + return self.rhs.result() + + def generate_result_code(self, code): + # we have to do this manually because it isn't a subexpression + self.assignment.generate_execution_code(code) + + +class FirstArgumentForCriticalSectionNode(ExprNode): + # This class exists to pass the first argument of a function + # to a critical_section. Mostly just to defer analysis since + # func.args isn't available for cdef functions until the + # analyse_declarations stage + # + # func_node - FuncDefNode + + subexprs = ['name_node'] + + name_node = None + type = PyrexTypes.py_object_type + + def analyse_declarations(self, env): + if len(self.func_node.args) < 1: + error(self.pos, "critical_section directive can only be applied to a function with one or more positional arguments") + return + self.name_node = NameNode(self.pos, name=self.func_node.args[0].declared_name()) + self.name_node.analyse_declarations(env) + self.type = self.name_node.type + + def analyse_expressions(self, env): + # At this stage, just substitute the name node + if self.name_node: + return self.name_node.analyse_expressions(env) + return self # error earlier diff --git a/venv/lib/python3.10/site-packages/Cython/Compiler/FlowControl.pxd b/venv/lib/python3.10/site-packages/Cython/Compiler/FlowControl.pxd new file mode 100644 index 0000000000000000000000000000000000000000..3c8fa3dde23201c6ddb5d1b3fdc765bbcf2f86a6 --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Compiler/FlowControl.pxd @@ -0,0 +1,97 @@ +cimport cython + +from .Visitor cimport CythonTransform, TreeVisitor + +cdef class ControlBlock: + cdef public set children + cdef public set parents + cdef public set positions + cdef public list stats + cdef public dict gen + cdef public set bounded + + # Big integer bitsets + cdef public object i_input + cdef public object i_output + cdef public object i_gen + cdef public object i_kill + cdef public object i_state + + cpdef bint empty(self) + cpdef detach(self) + cpdef add_child(self, block) + +cdef class ExitBlock(ControlBlock): + cpdef bint empty(self) + +cdef class NameAssignment: + cdef public bint is_arg + cdef public bint is_deletion + cdef public object lhs + cdef public object rhs + cdef public object entry + cdef public object pos + cdef public set refs + cdef public object bit + cdef public object inferred_type + cdef public object rhs_scope + +cdef class AssignmentList: + cdef public object bit + cdef public object mask + cdef public list stats + +cdef class AssignmentCollector(TreeVisitor): + cdef list assignments + +@cython.final +cdef class ControlFlow: + cdef public set blocks + cdef public set entries + cdef public list loops + cdef public list exceptions + + cdef public ControlBlock entry_point + cdef public ExitBlock exit_point + cdef public ControlBlock block + + cdef public dict assmts + + cdef public Py_ssize_t in_try_block + + cpdef newblock(self, ControlBlock parent=*) + cpdef nextblock(self, ControlBlock parent=*) + cpdef bint is_tracked(self, entry) + cpdef bint is_statically_assigned(self, entry) + cpdef mark_position(self, node) + cpdef mark_assignment(self, lhs, rhs, entry, rhs_scope=*) + cpdef mark_argument(self, lhs, rhs, entry) + cpdef mark_deletion(self, node, entry) + cpdef mark_reference(self, node, entry) + cpdef normalize(self) + cpdef initialize(self) + cpdef set map_one(self, istate, entry) + cdef reaching_definitions(self) + +cdef class Uninitialized: + pass + +cdef class Unknown: + pass + +cdef class MessageCollection: + cdef set messages + +@cython.final +cdef class ControlFlowAnalysis(CythonTransform): + cdef object gv_ctx + cdef object constant_folder + cdef set reductions + cdef list stack # a stack of (env, flow) tuples + cdef object env + cdef ControlFlow flow + cdef object object_expr + cdef bint in_inplace_assignment + + cpdef mark_assignment(self, lhs, rhs=*, rhs_scope=*) + cpdef mark_position(self, node) diff --git a/venv/lib/python3.10/site-packages/Cython/Compiler/FlowControl.py b/venv/lib/python3.10/site-packages/Cython/Compiler/FlowControl.py new file mode 100644 index 0000000000000000000000000000000000000000..e3c0caf5a50775cd9c2c7a14332e9fe67916fe60 --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Compiler/FlowControl.py @@ -0,0 +1,1455 @@ +# cython: auto_pickle=True + + +import cython +cython.declare(PyrexTypes=object, ExprNodes=object, Nodes=object, Builtin=object, + Options=object, TreeVisitor=object, CythonTransform=object, + InternalError=object, error=object, warning=object, + fake_rhs_expr=object, TypedExprNode=object) + +from . import Builtin +from . import ExprNodes +from . import Nodes +from . import Options +from . import PyrexTypes + +from .Visitor import TreeVisitor, CythonTransform +from .Errors import error, warning, InternalError + + +class TypedExprNode(ExprNodes.ExprNode): + # Used for declaring assignments of a specified type without a known entry. + def __init__(self, type, may_be_none=None, pos=None): + super().__init__(pos) + self.type = type + self._may_be_none = may_be_none + + def may_be_none(self): + return self._may_be_none != False + +# Fake rhs to silence "unused variable" warning +fake_rhs_expr = TypedExprNode(PyrexTypes.unspecified_type) + + +class ControlBlock: + """Control flow graph node. Sequence of assignments and name references. + + children set of children nodes + parents set of parent nodes + positions set of position markers + + stats list of block statements + gen dict of assignments generated by this block + bounded set of entries that are definitely bounded in this block + + Example: + + a = 1 + b = a + c # 'c' is already bounded or exception here + + stats = [Assignment(a), NameReference(a), NameReference(c), + Assignment(b)] + gen = {Entry(a): Assignment(a), Entry(b): Assignment(b)} + bounded = {Entry(a), Entry(c)} + + """ + + def __init__(self): + self.children = set() + self.parents = set() + self.positions = set() + + self.stats = [] + self.gen = {} + self.bounded = set() + + self.i_input = 0 + self.i_output = 0 + self.i_gen = 0 + self.i_kill = 0 + self.i_state = 0 + + def empty(self): + return (not self.stats and not self.positions) + + def detach(self): + """Detach block from parents and children.""" + for child in self.children: + child.parents.remove(self) + for parent in self.parents: + parent.children.remove(self) + self.parents.clear() + self.children.clear() + + def add_child(self, block): + self.children.add(block) + block.parents.add(self) + + +class ExitBlock(ControlBlock): + """Non-empty exit point block.""" + + def empty(self): + return False + + +class AssignmentList: + def __init__(self): + self.stats = [] + + +class ControlFlow: + """Control-flow graph. + + entry_point ControlBlock entry point for this graph + exit_point ControlBlock normal exit point + block ControlBlock current block + blocks set children nodes + entries set tracked entries + loops list stack for loop descriptors + exceptions list stack for exception descriptors + in_try_block int track if we're in a try...except or try...finally block + """ + + def __init__(self): + self.blocks = set() + self.entries = set() + self.loops = [] + self.exceptions = [] + + self.entry_point = ControlBlock() + self.exit_point = ExitBlock() + self.blocks.add(self.exit_point) + self.block = self.entry_point + self.in_try_block = 0 + + def newblock(self, parent=None): + """Create floating block linked to `parent` if given. + + NOTE: Block is NOT added to self.blocks + """ + block = ControlBlock() + self.blocks.add(block) + if parent: + parent.add_child(block) + return block + + def nextblock(self, parent=None): + """Create block children block linked to current or `parent` if given. + + NOTE: Block is added to self.blocks + """ + block = ControlBlock() + self.blocks.add(block) + if parent: + parent.add_child(block) + elif self.block: + self.block.add_child(block) + self.block = block + return self.block + + def is_tracked(self, entry): + if entry.is_anonymous: + return False + return (entry.is_local or entry.is_pyclass_attr or entry.is_arg or + entry.from_closure or entry.in_closure or + entry.error_on_uninitialized) + + def is_statically_assigned(self, entry): + if (entry.is_local and entry.is_variable and + (entry.type.is_struct_or_union or + entry.type.is_complex or + entry.type.is_array or + entry.type.is_cython_lock_type or + (entry.type.is_cpp_class and not entry.is_cpp_optional))): + # stack allocated structured variable => never uninitialised + return True + return False + + def mark_position(self, node): + """Mark position, will be used to draw graph nodes.""" + if self.block: + self.block.positions.add(node.pos[:2]) + + def mark_assignment(self, lhs, rhs, entry, rhs_scope=None): + if self.block and self.is_tracked(entry): + assignment = NameAssignment(lhs, rhs, entry, rhs_scope=rhs_scope) + self.block.stats.append(assignment) + self.block.gen[entry] = assignment + self.entries.add(entry) + + def mark_argument(self, lhs, rhs, entry): + if self.block and self.is_tracked(entry): + assignment = Argument(lhs, rhs, entry) + self.block.stats.append(assignment) + self.block.gen[entry] = assignment + self.entries.add(entry) + + def mark_deletion(self, node, entry): + if self.block and self.is_tracked(entry): + assignment = NameDeletion(node, entry) + self.block.stats.append(assignment) + self.block.gen[entry] = Uninitialized + self.entries.add(entry) + + def mark_reference(self, node, entry): + if self.block and self.is_tracked(entry): + self.block.stats.append(NameReference(node, entry)) + ## XXX: We don't track expression evaluation order so we can't use + ## XXX: successful reference as initialization sign. + ## # Local variable is definitely bound after this reference + ## if not node.allow_null: + ## self.block.bounded.add(entry) + self.entries.add(entry) + + def normalize(self): + """Delete unreachable and orphan blocks.""" + queue = {self.entry_point} + visited = set() + while queue: + root = queue.pop() + visited.add(root) + for child in root.children: + if child not in visited: + queue.add(child) + + unreachable: set = self.blocks - visited + block: ControlBlock + for block in unreachable: + block.detach() + + visited.remove(self.entry_point) + + parent: ControlBlock + for block in visited: + if block.empty(): + for parent in block.parents: # Re-parent + for child in block.children: + parent.add_child(child) + block.detach() + unreachable.add(block) + self.blocks -= unreachable + + def initialize(self): + """Set initial state, map assignments to bits.""" + self.assmts = {} + assmts: AssignmentList + block: ControlBlock + + bit: int = 1 + for entry in self.entries: + assmts = AssignmentList() + assmts.mask = assmts.bit = bit + self.assmts[entry] = assmts + bit <<= 1 + + for block in self.blocks: + for stat in block.stats: + if isinstance(stat, NameAssignment): + stat.bit = bit + assmts = self.assmts[stat.entry] + assmts.stats.append(stat) + assmts.mask |= bit + bit <<= 1 + + for block in self.blocks: + for entry, stat in block.gen.items(): + assmts = self.assmts[entry] + if stat is Uninitialized: + block.i_gen |= assmts.bit + else: + block.i_gen |= stat.bit + block.i_kill |= assmts.mask + block.i_output = block.i_gen + for entry in block.bounded: + block.i_kill |= self.assmts[entry].bit + + for assmts in self.assmts.values(): + self.entry_point.i_gen |= assmts.bit + self.entry_point.i_output = self.entry_point.i_gen + + def map_one(self, istate, entry): + ret = set() + assmts: AssignmentList = self.assmts[entry] + if istate & assmts.bit: + if self.is_statically_assigned(entry): + ret.add(StaticAssignment(entry)) + elif entry.from_closure: + ret.add(Unknown) + else: + ret.add(Uninitialized) + + assmt: NameAssignment + for assmt in assmts.stats: + if istate & assmt.bit: + ret.add(assmt) + return ret + + def reaching_definitions(self): + """Per-block reaching definitions analysis.""" + block: ControlBlock + parent: ControlBlock + + dirty = True + while dirty: + dirty = False + for block in self.blocks: + i_input = 0 + for parent in block.parents: + i_input |= parent.i_output + i_output = (i_input & ~block.i_kill) | block.i_gen + if i_output != block.i_output: + dirty = True + block.i_input = i_input + block.i_output = i_output + + +class LoopDescr: + def __init__(self, next_block, loop_block): + self.next_block = next_block + self.loop_block = loop_block + self.exceptions = [] + + +class ExceptionDescr: + """Exception handling helper. + + entry_point ControlBlock Exception handling entry point + finally_enter ControlBlock Normal finally clause entry point + finally_exit ControlBlock Normal finally clause exit point + """ + + def __init__(self, entry_point, finally_enter=None, finally_exit=None): + self.entry_point = entry_point + self.finally_enter = finally_enter + self.finally_exit = finally_exit + + +class NameAssignment: + def __init__(self, lhs, rhs, entry, rhs_scope=None): + if lhs.cf_state is None: + lhs.cf_state = set() + self.lhs = lhs + self.rhs = rhs + self.entry = entry + self.pos = lhs.pos + self.refs = set() + self.is_arg = False + self.is_deletion = False + self.inferred_type = None + # For generator expression targets, the rhs can have a different scope than the lhs. + self.rhs_scope = rhs_scope + + def __repr__(self): + return '%s(entry=%r)' % (self.__class__.__name__, self.entry) + + def infer_type(self): + self.inferred_type = self.rhs.infer_type(self.rhs_scope or self.entry.scope) + return self.inferred_type + + def type_dependencies(self): + return self.rhs.type_dependencies(self.rhs_scope or self.entry.scope) + + @property + def type(self): + if not self.entry.type.is_unspecified: + return self.entry.type + return self.inferred_type + + +class StaticAssignment(NameAssignment): + """Initialised at declaration time, e.g. stack allocation.""" + def __init__(self, entry): + if not entry.type.is_pyobject: + may_be_none = False + else: + may_be_none = None # unknown + lhs = TypedExprNode( + entry.type, may_be_none=may_be_none, pos=entry.pos) + super().__init__(lhs, lhs, entry) + + def infer_type(self): + return self.entry.type + + def type_dependencies(self): + return () + + +class Argument(NameAssignment): + def __init__(self, lhs, rhs, entry): + NameAssignment.__init__(self, lhs, rhs, entry) + self.is_arg = True + + +class NameDeletion(NameAssignment): + def __init__(self, lhs, entry): + NameAssignment.__init__(self, lhs, lhs, entry) + self.is_deletion = True + + def infer_type(self): + inferred_type = self.rhs.infer_type(self.entry.scope) + if (not inferred_type.is_pyobject + and inferred_type.can_coerce_to_pyobject(self.entry.scope)): + return PyrexTypes.py_object_type + self.inferred_type = inferred_type + return inferred_type + + +class Uninitialized: + """Definitely not initialised yet.""" + + +class Unknown: + """Coming from outer closure, might be initialised or not.""" + + +class NameReference: + def __init__(self, node, entry): + if node.cf_state is None: + node.cf_state = set() + self.node = node + self.entry = entry + self.pos = node.pos + + def __repr__(self): + return '%s(entry=%r)' % (self.__class__.__name__, self.entry) + + +class ControlFlowState(list): + # Keeps track of Node's entry assignments + # + # cf_is_null [boolean] It is uninitialized + # cf_maybe_null [boolean] May be uninitialized + # is_single [boolean] Has only one assignment at this point + + cf_maybe_null = False + cf_is_null = False + is_single = False + + def __init__(self, state): + if Uninitialized in state: + state.discard(Uninitialized) + self.cf_maybe_null = True + if not state: + self.cf_is_null = True + elif Unknown in state: + state.discard(Unknown) + self.cf_maybe_null = True + else: + if len(state) == 1: + self.is_single = True + # XXX: Remove fake_rhs_expr + super().__init__( + [i for i in state if i.rhs is not fake_rhs_expr]) + + def one(self): + return self[0] + + +class GVContext: + """Graphviz subgraph object.""" + + def __init__(self): + self.blockids = {} + self.nextid = 0 + self.children = [] + self.sources = {} + + def add(self, child): + self.children.append(child) + + def nodeid(self, block): + if block not in self.blockids: + self.blockids[block] = 'block%d' % self.nextid + self.nextid += 1 + return self.blockids[block] + + def extract_sources(self, block): + if not block.positions: + return '' + start = min(block.positions) + stop = max(block.positions) + srcdescr = start[0] + if srcdescr not in self.sources: + self.sources[srcdescr] = list(srcdescr.get_lines()) + lines = self.sources[srcdescr] + return '\\n'.join([l.strip() for l in lines[start[1] - 1:stop[1]]]) + + def render(self, fp, name, annotate_defs=False): + """Render graphviz dot graph""" + fp.write('digraph %s {\n' % name) + fp.write(' node [shape=box];\n') + for child in self.children: + child.render(fp, self, annotate_defs) + fp.write('}\n') + + def escape(self, text): + return text.replace('"', '\\"').replace('\n', '\\n') + + +class GV: + """Graphviz DOT renderer.""" + + def __init__(self, name, flow): + self.name = name + self.flow = flow + + def render(self, fp, ctx, annotate_defs=False): + fp.write(' subgraph %s {\n' % self.name) + for block in self.flow.blocks: + label = ctx.extract_sources(block) + if annotate_defs: + for stat in block.stats: + if isinstance(stat, NameAssignment): + label += '\n %s [%s %s]' % ( + stat.entry.name, 'deletion' if stat.is_deletion else 'definition', stat.pos[1]) + elif isinstance(stat, NameReference): + if stat.entry: + label += '\n %s [reference %s]' % (stat.entry.name, stat.pos[1]) + if not label: + label = 'empty' + pid = ctx.nodeid(block) + fp.write(' %s [label="%s"];\n' % (pid, ctx.escape(label))) + for block in self.flow.blocks: + pid = ctx.nodeid(block) + for child in block.children: + fp.write(' %s -> %s;\n' % (pid, ctx.nodeid(child))) + fp.write(' }\n') + + +class MessageCollection: + """Collect error/warnings messages first then sort""" + def __init__(self): + self.messages = set() + + def error(self, pos, message): + self.messages.add((pos, True, message)) + + def warning(self, pos, message): + self.messages.add((pos, False, message)) + + def report(self): + for pos, is_error, message in sorted(self.messages): + if is_error: + error(pos, message) + else: + warning(pos, message, 2) + + +@cython.cfunc +def check_definitions(flow: ControlFlow, compiler_directives: dict): + flow.initialize() + flow.reaching_definitions() + + # Track down state + assignments = set() + # Node to entry map + references = {} + assmt_nodes = set() + + block: ControlBlock + assmt: NameAssignment + for block in flow.blocks: + i_state = block.i_input + for stat in block.stats: + i_assmts = flow.assmts[stat.entry] + state = flow.map_one(i_state, stat.entry) + if isinstance(stat, NameAssignment): + stat.lhs.cf_state.update(state) + assmt_nodes.add(stat.lhs) + i_state = i_state & ~i_assmts.mask + if stat.is_deletion: + i_state |= i_assmts.bit + else: + i_state |= stat.bit + assignments.add(stat) + if stat.rhs is not fake_rhs_expr: + stat.entry.cf_assignments.append(stat) + elif isinstance(stat, NameReference): + references[stat.node] = stat.entry + stat.entry.cf_references.append(stat) + stat.node.cf_state.update(state) + ## if not stat.node.allow_null: + ## i_state &= ~i_assmts.bit + ## # after successful read, the state is known to be initialised + state.discard(Uninitialized) + state.discard(Unknown) + for assmt in state: + assmt.refs.add(stat) + + # Check variable usage + warn_maybe_uninitialized = compiler_directives['warn.maybe_uninitialized'] + warn_unused_result = compiler_directives['warn.unused_result'] + warn_unused = compiler_directives['warn.unused'] + warn_unused_arg = compiler_directives['warn.unused_arg'] + + messages = MessageCollection() + + # assignment hints + for node in assmt_nodes: + if Uninitialized in node.cf_state: + node.cf_maybe_null = True + if len(node.cf_state) == 1: + node.cf_is_null = True + else: + node.cf_is_null = False + elif Unknown in node.cf_state: + node.cf_maybe_null = True + else: + node.cf_is_null = False + node.cf_maybe_null = False + + # Find uninitialized references and cf-hints + for node, entry in references.items(): + if Uninitialized in node.cf_state: + node.cf_maybe_null = True + if (not entry.from_closure and len(node.cf_state) == 1 + and entry.name not in entry.scope.scope_predefined_names): + node.cf_is_null = True + if (node.allow_null or entry.from_closure + or entry.is_pyclass_attr or entry.type.is_error): + pass # Can be uninitialized here + elif node.cf_is_null and not entry.in_closure: + if entry.error_on_uninitialized or ( + Options.error_on_uninitialized and ( + entry.type.is_pyobject or entry.type.is_unspecified)): + messages.error( + node.pos, + "local variable '%s' referenced before assignment" + % entry.name) + else: + messages.warning( + node.pos, + "local variable '%s' referenced before assignment" + % entry.name) + elif warn_maybe_uninitialized: + msg = "local variable '%s' might be referenced before assignment" % entry.name + if entry.in_closure: + msg += " (maybe initialized inside a closure)" + messages.warning( + node.pos, + msg) + elif Unknown in node.cf_state: + # TODO: better cross-closure analysis to know when inner functions + # are being called before a variable is being set, and when + # a variable is known to be set before even defining the + # inner function, etc. + node.cf_maybe_null = True + else: + node.cf_is_null = False + node.cf_maybe_null = False + + # Unused result + for assmt in assignments: + if (not assmt.refs and not assmt.entry.is_pyclass_attr + and not assmt.entry.in_closure): + if assmt.entry.cf_references and warn_unused_result: + if assmt.is_arg: + messages.warning(assmt.pos, "Unused argument value '%s'" % + assmt.entry.name) + else: + messages.warning(assmt.pos, "Unused result in '%s'" % + assmt.entry.name) + assmt.lhs.cf_used = False + + # Unused entries + for entry in flow.entries: + if (not entry.cf_references + and not entry.is_pyclass_attr): + if entry.name != '_' and not entry.name.startswith('unused'): + # '_' is often used for unused variables, e.g. in loops + if entry.is_arg: + if warn_unused_arg: + messages.warning(entry.pos, "Unused argument '%s'" % + entry.name) + else: + if warn_unused: + messages.warning(entry.pos, "Unused entry '%s'" % + entry.name) + entry.cf_used = False + + messages.report() + + for node in assmt_nodes: + node.cf_state = ControlFlowState(node.cf_state) + for node in references: + node.cf_state = ControlFlowState(node.cf_state) + + +class AssignmentCollector(TreeVisitor): + def __init__(self): + super().__init__() + self.assignments = [] + + def visit_Node(self): + self._visitchildren(self, None, None) + + def visit_SingleAssignmentNode(self, node): + self.assignments.append((node.lhs, node.rhs)) + + def visit_CascadedAssignmentNode(self, node): + for lhs in node.lhs_list: + self.assignments.append((lhs, node.rhs)) + + +class ControlFlowAnalysis(CythonTransform): + + def find_in_stack(self, env): + if env == self.env: + return self.flow + for e, flow in reversed(self.stack): + if e is env: + return flow + assert False + + def visit_ModuleNode(self, node): + dot_output = self.current_directives['control_flow.dot_output'] + self.gv_ctx = GVContext() if dot_output else None + + from .Optimize import ConstantFolding + self.constant_folder = ConstantFolding() + + # Set of NameNode reductions + self.reductions = set() + + self.in_inplace_assignment = False + self.env = node.scope + self.flow = ControlFlow() + self.stack = [] # a stack of (env, flow) tuples + self.object_expr = TypedExprNode(PyrexTypes.py_object_type, may_be_none=True) + self.visitchildren(node) + + check_definitions(self.flow, self.current_directives) + + if dot_output: + annotate_defs = self.current_directives['control_flow.dot_annotate_defs'] + with open(dot_output, 'w') as fp: + self.gv_ctx.render(fp, 'module', annotate_defs=annotate_defs) + return node + + def visit_FuncDefNode(self, node): + for arg in node.args: + if arg.default: + self.visitchildren(arg) + self.visitchildren(node, ('decorators',)) + self.stack.append((self.env, self.flow)) + self.env = node.local_scope + self.flow = ControlFlow() + + # Collect all entries + for entry in node.local_scope.entries.values(): + if self.flow.is_tracked(entry): + self.flow.entries.add(entry) + + self.mark_position(node) + # Function body block + self.flow.nextblock() + + for arg in node.args: + self._visit(arg) + if node.star_arg: + self.flow.mark_argument(node.star_arg, + TypedExprNode(Builtin.tuple_type, + may_be_none=False), + node.star_arg.entry) + if node.starstar_arg: + self.flow.mark_argument(node.starstar_arg, + TypedExprNode(Builtin.dict_type, + may_be_none=False), + node.starstar_arg.entry) + self._visit(node.body) + # Workaround for generators + if node.is_generator: + self._visit(node.gbody.body) + + # Exit point + if self.flow.block: + self.flow.block.add_child(self.flow.exit_point) + + # Cleanup graph + self.flow.normalize() + check_definitions(self.flow, self.current_directives) + self.flow.blocks.add(self.flow.entry_point) + + if self.gv_ctx is not None: + self.gv_ctx.add(GV(node.local_scope.name, self.flow)) + + self.env, self.flow = self.stack.pop() + return node + + def visit_DefNode(self, node): + node.used = True + return self.visit_FuncDefNode(node) + + def visit_GeneratorBodyDefNode(self, node): + return node + + def visit_CTypeDefNode(self, node): + return node + + def mark_assignment(self, lhs, rhs=None, rhs_scope=None): + if not self.flow.block: + return + if self.flow.exceptions: + exc_descr = self.flow.exceptions[-1] + self.flow.block.add_child(exc_descr.entry_point) + self.flow.nextblock() + + if not rhs: + rhs = self.object_expr + if lhs.is_name: + if lhs.entry is not None: + entry = lhs.entry + else: + entry = self.env.lookup(lhs.name) + if entry is None: # TODO: This shouldn't happen... + return + self.flow.mark_assignment(lhs, rhs, entry, rhs_scope=rhs_scope) + elif lhs.is_sequence_constructor: + for i, arg in enumerate(lhs.args): + if arg.is_starred: + # "a, *b = x" assigns a list to "b" + item_node = TypedExprNode(Builtin.list_type, may_be_none=False, pos=arg.pos) + elif rhs is self.object_expr: + item_node = rhs + else: + item_node = rhs.inferable_item_node(i) + self.mark_assignment(arg, item_node, rhs_scope=rhs_scope) + else: + self._visit(lhs) + + if self.flow.exceptions: + exc_descr = self.flow.exceptions[-1] + self.flow.block.add_child(exc_descr.entry_point) + self.flow.nextblock() + + def mark_position(self, node): + """Mark position if DOT output is enabled.""" + if self.current_directives['control_flow.dot_output']: + self.flow.mark_position(node) + + def visit_FromImportStatNode(self, node): + for name, target in node.items: + if name != "*": + self.mark_assignment(target) + self.visitchildren(node) + return node + + def visit_AssignmentNode(self, node): + raise InternalError("Unhandled assignment node %s" % type(node)) + + def visit_SingleAssignmentNode(self, node): + self._visit(node.rhs) + self.mark_assignment(node.lhs, node.rhs) + return node + + def visit_CascadedAssignmentNode(self, node): + self._visit(node.rhs) + for lhs in node.lhs_list: + self.mark_assignment(lhs, node.rhs) + return node + + def visit_ParallelAssignmentNode(self, node): + collector = AssignmentCollector() + collector.visitchildren(node) + for lhs, rhs in collector.assignments: + self._visit(rhs) + for lhs, rhs in collector.assignments: + self.mark_assignment(lhs, rhs) + return node + + def visit_InPlaceAssignmentNode(self, node): + self.in_inplace_assignment = True + self.visitchildren(node) + self.in_inplace_assignment = False + self.mark_assignment(node.lhs, self.constant_folder(node.create_binop_node())) + return node + + def visit_DelStatNode(self, node): + for arg in node.args: + if arg.is_name: + entry = arg.entry or self.env.lookup(arg.name) + if entry.in_closure or entry.from_closure: + error(arg.pos, + "can not delete variable '%s' " + "referenced in nested scope" % entry.name) + if not node.ignore_nonexisting: + self._visit(arg) # mark reference + self.flow.mark_deletion(arg, entry) + else: + self._visit(arg) + return node + + def visit_CArgDeclNode(self, node): + entry = self.env.lookup(node.name) + if entry: + may_be_none = not node.not_none + self.flow.mark_argument( + node, TypedExprNode(entry.type, may_be_none), entry) + return node + + def visit_NameNode(self, node): + if self.flow.block: + entry = node.entry or self.env.lookup(node.name) + if entry: + self.flow.mark_reference(node, entry) + + if entry in self.reductions and not self.in_inplace_assignment: + error(node.pos, + "Cannot read reduction variable in loop body") + + return node + + def visit_StatListNode(self, node): + if self.flow.block: + for stat in node.stats: + self._visit(stat) + if not self.flow.block: + stat.is_terminator = True + break + return node + + def visit_Node(self, node): + self.visitchildren(node) + self.mark_position(node) + return node + + def visit_SizeofVarNode(self, node): + return node + + def visit_TypeidNode(self, node): + return node + + def visit_IfStatNode(self, node): + next_block = self.flow.newblock() + parent = self.flow.block + # If clauses + for clause in node.if_clauses: + parent = self.flow.nextblock(parent) + self._visit(clause.condition) + self.flow.nextblock() + self._visit(clause.body) + if self.flow.block: + self.flow.block.add_child(next_block) + # Else clause + if node.else_clause: + self.flow.nextblock(parent=parent) + self._visit(node.else_clause) + if self.flow.block: + self.flow.block.add_child(next_block) + else: + parent.add_child(next_block) + + if next_block.parents: + self.flow.block = next_block + else: + self.flow.block = None + return node + + def visit_AssertStatNode(self, node): + """Essentially an if-condition that wraps a RaiseStatNode. + """ + self.mark_position(node) + next_block = self.flow.newblock() + parent = self.flow.block + # failure case + parent = self.flow.nextblock(parent) + self._visit(node.condition) + self.flow.nextblock() + self._visit(node.exception) + if self.flow.block: + self.flow.block.add_child(next_block) + parent.add_child(next_block) + if next_block.parents: + self.flow.block = next_block + else: + self.flow.block = None + return node + + def visit_WhileStatNode(self, node): + condition_block = self.flow.nextblock() + next_block = self.flow.newblock() + # Condition block + self.flow.loops.append(LoopDescr(next_block, condition_block)) + if node.condition: + self._visit(node.condition) + # Body block + self.flow.nextblock() + self._visit(node.body) + self.flow.loops.pop() + # Loop it + if self.flow.block: + self.flow.block.add_child(condition_block) + self.flow.block.add_child(next_block) + # Else clause + if node.else_clause: + self.flow.nextblock(parent=condition_block) + self._visit(node.else_clause) + if self.flow.block: + self.flow.block.add_child(next_block) + else: + condition_block.add_child(next_block) + + if next_block.parents: + self.flow.block = next_block + else: + self.flow.block = None + return node + + def mark_forloop_target(self, node): + # TODO: Remove redundancy with range optimization... + is_special = False + sequence = node.iterator.sequence + target = node.target + env = node.iterator.expr_scope or self.env + if isinstance(sequence, ExprNodes.SimpleCallNode): + function = sequence.function + if sequence.self is None and function.is_name: + entry = env.lookup(function.name) + if not entry or entry.is_builtin: + if function.name == 'reversed' and len(sequence.args) == 1: + sequence = sequence.args[0] + elif function.name == 'enumerate' and len(sequence.args) == 1: + if target.is_sequence_constructor and len(target.args) == 2: + iterator = sequence.args[0] + if iterator.is_name: + iterator_type = iterator.infer_type(env) + if iterator_type.is_builtin_type: + # assume that builtin types have a length within Py_ssize_t + self.mark_assignment( + target.args[0], + ExprNodes.IntNode(target.pos, value='PY_SSIZE_T_MAX', + type=PyrexTypes.c_py_ssize_t_type), + rhs_scope=node.iterator.expr_scope) + target = target.args[1] + sequence = sequence.args[0] + if isinstance(sequence, ExprNodes.SimpleCallNode): + function = sequence.function + if sequence.self is None and function.is_name: + entry = env.lookup(function.name) + if not entry or entry.is_builtin: + if function.name in ('range', 'xrange'): + is_special = True + for arg in sequence.args[:2]: + self.mark_assignment(target, arg, rhs_scope=node.iterator.expr_scope) + if len(sequence.args) > 2: + self.mark_assignment(target, self.constant_folder( + ExprNodes.binop_node(node.pos, + '+', + sequence.args[0], + sequence.args[2])), + rhs_scope=node.iterator.expr_scope) + + if not is_special: + # A for-loop basically translates to subsequent calls to + # __getitem__(), so using an IndexNode here allows us to + # naturally infer the base type of pointers, C arrays, + # Python strings, etc., while correctly falling back to an + # object type when the base type cannot be handled. + + self.mark_assignment(target, node.item, rhs_scope=node.iterator.expr_scope) + + def mark_parallel_forloop_assignment(self, node): + target = node.target + for arg in node.args[:2]: + self.mark_assignment(target, arg) + if len(node.args) > 2: + self.mark_assignment(target, self.constant_folder( + ExprNodes.binop_node(node.pos, + '+', + node.args[0], + node.args[2]))) + if not node.args: + # Almost certainly an error + self.mark_assignment(target) + + def visit_AsyncForStatNode(self, node): + return self.visit_ForInStatNode(node) + + def visit_ForInStatNode(self, node): + condition_block = self.flow.nextblock() + next_block = self.flow.newblock() + # Condition with iterator + self.flow.loops.append(LoopDescr(next_block, condition_block)) + self._visit(node.iterator) + # Target assignment + self.flow.nextblock() + + if isinstance(node, Nodes.ForInStatNode): + self.mark_forloop_target(node) + elif isinstance(node, Nodes.AsyncForStatNode): + # not entirely correct, but good enough for now + self.mark_assignment(node.target, node.item) + elif isinstance(node, Nodes.ParallelRangeNode): # Parallel + self.mark_parallel_forloop_assignment(node) + else: + assert False, type(node) + + # Body block + if isinstance(node, Nodes.ParallelRangeNode): + # In case of an invalid + self._delete_privates(node, exclude=node.target.entry) + + self.flow.nextblock() + self._visit(node.body) + self.flow.loops.pop() + + # Loop it + if self.flow.block: + self.flow.block.add_child(condition_block) + # Else clause + if node.else_clause: + self.flow.nextblock(parent=condition_block) + self._visit(node.else_clause) + if self.flow.block: + self.flow.block.add_child(next_block) + else: + condition_block.add_child(next_block) + + if next_block.parents: + self.flow.block = next_block + else: + self.flow.block = None + return node + + def _delete_privates(self, node, exclude=None): + for private_node in node.assigned_nodes: + if not exclude or private_node.entry is not exclude: + self.flow.mark_deletion(private_node, private_node.entry) + + def visit_ParallelRangeNode(self, node): + reductions = self.reductions + + # if node.target is None or not a NameNode, an error will have + # been previously issued + if hasattr(node.target, 'entry'): + self.reductions = set(reductions) + + for private_node in node.assigned_nodes: + private_node.entry.error_on_uninitialized = True + pos, reduction = node.assignments[private_node.entry] + if reduction: + self.reductions.add(private_node.entry) + + node = self.visit_ForInStatNode(node) + + self.reductions = reductions + return node + + def visit_ParallelWithBlockNode(self, node): + for private_node in node.assigned_nodes: + private_node.entry.error_on_uninitialized = True + + self._delete_privates(node) + self.visitchildren(node) + self._delete_privates(node) + + return node + + def visit_ForFromStatNode(self, node): + condition_block = self.flow.nextblock() + next_block = self.flow.newblock() + # Condition with iterator + self.flow.loops.append(LoopDescr(next_block, condition_block)) + self._visit(node.bound1) + self._visit(node.bound2) + if node.step is not None: + self._visit(node.step) + # Target assignment + self.flow.nextblock() + self.mark_assignment(node.target, node.bound1) + if node.step is not None: + self.mark_assignment(node.target, self.constant_folder( + ExprNodes.binop_node(node.pos, '+', node.bound1, node.step))) + # Body block + self.flow.nextblock() + self._visit(node.body) + self.flow.loops.pop() + # Loop it + if self.flow.block: + self.flow.block.add_child(condition_block) + # Else clause + if node.else_clause: + self.flow.nextblock(parent=condition_block) + self._visit(node.else_clause) + if self.flow.block: + self.flow.block.add_child(next_block) + else: + condition_block.add_child(next_block) + + if next_block.parents: + self.flow.block = next_block + else: + self.flow.block = None + return node + + def visit_LoopNode(self, node): + raise InternalError("Generic loops are not supported") + + def visit_WithTargetAssignmentStatNode(self, node): + self.mark_assignment(node.lhs, node.with_node.enter_call) + return node + + def visit_WithStatNode(self, node): + self._visit(node.manager) + self._visit(node.enter_call) + self._visit(node.body) + return node + + def visit_TryExceptStatNode(self, node): + # After exception handling + next_block = self.flow.newblock() + # Body block + self.flow.newblock() + # Exception entry point + entry_point = self.flow.newblock() + self.flow.exceptions.append(ExceptionDescr(entry_point)) + self.flow.nextblock() + ## XXX: links to exception handling point should be added by + ## XXX: children nodes + self.flow.block.add_child(entry_point) + self.flow.nextblock() + self.flow.in_try_block += 1 + self._visit(node.body) + self.flow.in_try_block -= 1 + self.flow.exceptions.pop() + + # After exception + if self.flow.block: + if node.else_clause: + self.flow.nextblock() + self._visit(node.else_clause) + if self.flow.block: + self.flow.block.add_child(next_block) + + for clause in node.except_clauses: + self.flow.block = entry_point + if clause.pattern: + for pattern in clause.pattern: + self._visit(pattern) + else: + # TODO: handle * pattern + pass + entry_point = self.flow.newblock(parent=self.flow.block) + self.flow.nextblock() + if clause.target: + self.mark_assignment(clause.target) + self._visit(clause.body) + if self.flow.block: + self.flow.block.add_child(next_block) + + if self.flow.exceptions: + entry_point.add_child(self.flow.exceptions[-1].entry_point) + + if next_block.parents: + self.flow.block = next_block + else: + self.flow.block = None + return node + + def visit_TryFinallyStatNode(self, node): + body_block = self.flow.nextblock() + + # Exception entry point + entry_point = self.flow.newblock() + self.flow.block = entry_point + self._visit(node.finally_except_clause) + + if self.flow.block and self.flow.exceptions: + self.flow.block.add_child(self.flow.exceptions[-1].entry_point) + + # Normal execution + finally_enter = self.flow.newblock() + self.flow.block = finally_enter + self._visit(node.finally_clause) + finally_exit = self.flow.block + + descr = ExceptionDescr(entry_point, finally_enter, finally_exit) + self.flow.exceptions.append(descr) + if self.flow.loops: + self.flow.loops[-1].exceptions.append(descr) + self.flow.block = body_block + body_block.add_child(entry_point) + self.flow.nextblock() + self.flow.in_try_block += 1 + self._visit(node.body) + self.flow.in_try_block -= 1 + self.flow.exceptions.pop() + if self.flow.loops: + self.flow.loops[-1].exceptions.pop() + + if self.flow.block: + self.flow.block.add_child(finally_enter) + if finally_exit: + self.flow.block = self.flow.nextblock(parent=finally_exit) + else: + self.flow.block = None + return node + + def visit_RaiseStatNode(self, node): + self.mark_position(node) + self.visitchildren(node) + if self.flow.exceptions: + self.flow.block.add_child(self.flow.exceptions[-1].entry_point) + self.flow.block = None + if self.flow.in_try_block: + node.in_try_block = True + return node + + def visit_ReraiseStatNode(self, node): + self.mark_position(node) + if self.flow.exceptions: + self.flow.block.add_child(self.flow.exceptions[-1].entry_point) + self.flow.block = None + return node + + def visit_ReturnStatNode(self, node): + self.mark_position(node) + self.visitchildren(node) + + outer_exception_handlers = iter(self.flow.exceptions[::-1]) + for handler in outer_exception_handlers: + if handler.finally_enter: + self.flow.block.add_child(handler.finally_enter) + if handler.finally_exit: + # 'return' goes to function exit, or to the next outer 'finally' clause + exit_point = self.flow.exit_point + for next_handler in outer_exception_handlers: + if next_handler.finally_enter: + exit_point = next_handler.finally_enter + break + handler.finally_exit.add_child(exit_point) + break + else: + if self.flow.block: + self.flow.block.add_child(self.flow.exit_point) + self.flow.block = None + return node + + def visit_BreakStatNode(self, node): + if not self.flow.loops: + #error(node.pos, "break statement not inside loop") + return node + loop = self.flow.loops[-1] + self.mark_position(node) + for exception in loop.exceptions[::-1]: + if exception.finally_enter: + self.flow.block.add_child(exception.finally_enter) + if exception.finally_exit: + exception.finally_exit.add_child(loop.next_block) + break + else: + self.flow.block.add_child(loop.next_block) + self.flow.block = None + return node + + def visit_ContinueStatNode(self, node): + if not self.flow.loops: + #error(node.pos, "continue statement not inside loop") + return node + loop = self.flow.loops[-1] + self.mark_position(node) + for exception in loop.exceptions[::-1]: + if exception.finally_enter: + self.flow.block.add_child(exception.finally_enter) + if exception.finally_exit: + exception.finally_exit.add_child(loop.loop_block) + break + else: + self.flow.block.add_child(loop.loop_block) + self.flow.block = None + return node + + def visit_ComprehensionNode(self, node): + if node.expr_scope: + self.stack.append((self.env, self.flow)) + self.env = node.expr_scope + # Skip append node here + self._visit(node.loop) + if node.expr_scope: + self.env, _ = self.stack.pop() + return node + + def visit_ScopedExprNode(self, node): + # currently this is written to deal with these two types + # (with comprehensions covered in their own function) + assert isinstance(node, (ExprNodes.IteratorNode, ExprNodes.AsyncIteratorNode)), node + if node.expr_scope: + self.stack.append((self.env, self.flow)) + self.flow = self.find_in_stack(node.expr_scope) + self.env = node.expr_scope + self.visitchildren(node) + if node.expr_scope: + self.env, self.flow = self.stack.pop() + return node + + def visit_PyClassDefNode(self, node): + self.visitchildren(node, ('dict', 'metaclass', + 'mkw', 'bases', 'class_result')) + self.flow.mark_assignment(node.target, node.classobj, + self.env.lookup(node.target.name)) + self.stack.append((self.env, self.flow)) + self.env = node.scope + self.flow.nextblock() + if node.doc_node: + self.flow.mark_assignment(node.doc_node, fake_rhs_expr, node.doc_node.entry) + self.visitchildren(node, ('body',)) + self.flow.nextblock() + self.env, _ = self.stack.pop() + return node + + def visit_CClassDefNode(self, node): + # just make sure the nodes scope is findable in-case there is a list comprehension in it + self.stack.append((node.scope, self.flow)) + self.visitchildren(node) + self.stack.pop() + return node + + def visit_AmpersandNode(self, node): + if node.operand.is_name: + # Fake assignment to silence warning + self.mark_assignment(node.operand, fake_rhs_expr) + self.visitchildren(node) + return node + + def visit_BoolBinopNode(self, node): + # Note - I don't believe BoolBinopResultNode needs special handling beyond this + assert len(node.subexprs) == 2 # operand1 and operand2 only + + next_block = self.flow.newblock() + parent = self.flow.block + + self._visit(node.operand1) + + self.flow.nextblock() + self._visit(node.operand2) + if self.flow.block: + self.flow.block.add_child(next_block) + + parent.add_child(next_block) + + if next_block.parents: + self.flow.block = next_block + else: + self.flow.block = None + return node + + def visit_CondExprNode(self, node): + assert len(node.subexprs) == 3 + self._visit(node.test) + parent = self.flow.block + next_block = self.flow.newblock() + self.flow.nextblock() + self._visit(node.true_val) + if self.flow.block: + self.flow.block.add_child(next_block) + self.flow.nextblock(parent=parent) + self._visit(node.false_val) + if self.flow.block: + self.flow.block.add_child(next_block) + + if next_block.parents: + self.flow.block = next_block + else: + self.flow.block = None + return node diff --git a/venv/lib/python3.10/site-packages/Cython/Compiler/FusedNode.py b/venv/lib/python3.10/site-packages/Cython/Compiler/FusedNode.py new file mode 100644 index 0000000000000000000000000000000000000000..88fc397ff7a35e17e88ba1bdb92fc2602e6df374 --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Compiler/FusedNode.py @@ -0,0 +1,1003 @@ +import copy + +from . import (ExprNodes, PyrexTypes, MemoryView, + ParseTreeTransforms, StringEncoding, Errors, + Naming) +from .ExprNodes import CloneNode, CodeObjectNode, ProxyNode, TupleNode +from .Nodes import FuncDefNode, StatListNode, DefNode +from ..Utils import OrderedSet +from .Errors import error, CannotSpecialize + + +class FusedCFuncDefNode(StatListNode): + """ + This node replaces a function with fused arguments. It deep-copies the + function for every permutation of fused types, and allocates a new local + scope for it. It keeps track of the original function in self.node, and + the entry of the original function in the symbol table is given the + 'fused_cfunction' attribute which points back to us. + Then when a function lookup occurs (to e.g. call it), the call can be + dispatched to the right function. + + node FuncDefNode the original function + nodes [FuncDefNode] list of copies of node with different specific types + py_func DefNode the fused python function subscriptable from + Python space + __signatures__ A DictNode mapping signature specialization strings + to PyCFunction nodes + resulting_fused_function PyCFunction for the fused DefNode that delegates + to specializations + fused_func_assignment Assignment of the fused function to the function name + defaults_tuple TupleNode of defaults (letting PyCFunctionNode build + defaults would result in many different tuples) + specialized_pycfuncs List of synthesized pycfunction nodes for the + specializations + + fused_compound_types All fused (compound) types (e.g. floating[:]) + """ + + __signatures__ = None + resulting_fused_function = None + fused_func_assignment = None + py_func = None + defaults_tuple = None + decorators = None + + child_attrs = StatListNode.child_attrs + [ + '__signatures__', 'resulting_fused_function', 'fused_func_assignment'] + + def __init__(self, node, env): + super().__init__(node.pos) + + self.nodes = [] + self.node = node + + is_def = isinstance(self.node, DefNode) + if is_def: + # self.node.decorators = [] + self.copy_def(env) + else: + self.copy_cdef(env) + + # Perform some sanity checks. If anything fails, it's a bug + for n in self.nodes: + assert not n.entry.type.is_fused + assert not n.local_scope.return_type.is_fused + if node.return_type.is_fused: + assert not n.return_type.is_fused + + if not is_def and n.cfunc_declarator.optional_arg_count: + assert n.type.op_arg_struct + + node.entry.fused_cfunction = self + # Copy the nodes as AnalyseDeclarationsTransform will prepend + # self.py_func to self.stats, as we only want specialized + # CFuncDefNodes in self.nodes + self.stats = self.nodes[:] + + def copy_def(self, env): + """ + Create a copy of the original def or lambda function for specialized + versions. + """ + fused_compound_types = PyrexTypes.unique( + [arg.type for arg in self.node.args if arg.type.is_fused]) + fused_types = self._get_fused_base_types(fused_compound_types) + permutations = PyrexTypes.get_all_specialized_permutations(fused_types) + + self.fused_compound_types = fused_compound_types + + if self.node.entry in env.pyfunc_entries: + env.pyfunc_entries.remove(self.node.entry) + + for cname, fused_to_specific in permutations: + copied_node = copy.deepcopy(self.node) + # keep signature object identity for special casing in DefNode.analyse_declarations() + copied_node.entry.signature = self.node.entry.signature + + self._specialize_function_args(copied_node.args, fused_to_specific) + copied_node.return_type = self.node.return_type.specialize( + fused_to_specific) + copied_node.code_object = CodeObjectNode(copied_node) + copied_node.analyse_declarations(env) + # copied_node.is_staticmethod = self.node.is_staticmethod + # copied_node.is_classmethod = self.node.is_classmethod + self.create_new_local_scope(copied_node, env, fused_to_specific) + self.specialize_copied_def(copied_node, cname, self.node.entry, + fused_to_specific, fused_compound_types) + + PyrexTypes.specialize_entry(copied_node.entry, cname) + copied_node.entry.used = True + env.entries[copied_node.entry.name] = copied_node.entry + + specialised_type_names = [ + sarg.type.declaration_code('', for_display=True) + for (farg, sarg) in zip(self.node.args, copied_node.args) + if farg.type.is_fused + ] + copied_node.name = StringEncoding.EncodedString(f"{copied_node.name}[{','.join(specialised_type_names)}]") + + if not self.replace_fused_typechecks(copied_node): + break + + self.orig_py_func = self.node + self.py_func = self.make_fused_cpdef(self.node, env, is_def=True) + + def copy_cdef(self, env): + """ + Create a copy of the original c(p)def function for all specialized + versions. + """ + permutations = self.node.type.get_all_specialized_permutations() + # print 'Node %s has %d specializations:' % (self.node.entry.name, + # len(permutations)) + # import pprint; pprint.pprint([d for cname, d in permutations]) + + # Prevent copying of the python function + self.orig_py_func = orig_py_func = self.node.py_func + self.node.py_func = None + if orig_py_func: + env.pyfunc_entries.remove(orig_py_func.entry) + + fused_types = self.node.type.get_fused_types() + self.fused_compound_types = fused_types + + new_cfunc_entries = [] + for cname, fused_to_specific in permutations: + copied_node = copy.deepcopy(self.node) + + # Make the types in our CFuncType specific. + try: + type = copied_node.type.specialize(fused_to_specific) + except CannotSpecialize: + # unlike for the argument types, specializing the return type can fail + error(copied_node.pos, "Return type is a fused type that cannot " + "be determined from the function arguments") + self.py_func = None # this is just to let the compiler exit gracefully + return + entry = copied_node.entry + type.specialize_entry(entry, cname) + + # Reuse existing Entries (e.g. from .pxd files). + for orig_entry in env.cfunc_entries: + if entry.cname == orig_entry.cname and type.same_as_resolved_type(orig_entry.type): + copied_node.entry = orig_entry + if not copied_node.entry.func_cname: + copied_node.entry.func_cname = entry.func_cname + entry = orig_entry + type = orig_entry.type + break + else: + new_cfunc_entries.append(entry) + + copied_node.type = type + entry.type, type.entry = type, entry + + entry.used = (entry.used or + self.node.entry.defined_in_pxd or + env.is_c_class_scope or + entry.is_cmethod) + + if self.node.cfunc_declarator.optional_arg_count: + self.node.cfunc_declarator.declare_optional_arg_struct( + type, env, fused_cname=cname) + + copied_node.return_type = type.return_type + self.create_new_local_scope(copied_node, env, fused_to_specific) + + # Make the argument types in the CFuncDeclarator specific + self._specialize_function_args(copied_node.cfunc_declarator.args, + fused_to_specific) + + # If a cpdef, declare all specialized cpdefs (this + # also calls analyse_declarations) + copied_node.declare_cpdef_wrapper(env) + if copied_node.py_func: + env.pyfunc_entries.remove(copied_node.py_func.entry) + + self.specialize_copied_def( + copied_node.py_func, cname, self.node.entry.as_variable, + fused_to_specific, fused_types) + + if not self.replace_fused_typechecks(copied_node): + break + + # replace old entry with new entries + if self.node.entry in env.cfunc_entries: + cindex = env.cfunc_entries.index(self.node.entry) + env.cfunc_entries[cindex:cindex+1] = new_cfunc_entries + else: + env.cfunc_entries.extend(new_cfunc_entries) + + if orig_py_func: + self.py_func = self.make_fused_cpdef(orig_py_func, env, + is_def=False) + else: + self.py_func = orig_py_func + + def _get_fused_base_types(self, fused_compound_types): + """ + Get a list of unique basic fused types, from a list of + (possibly) compound fused types. + """ + base_types = [] + seen = set() + for fused_type in fused_compound_types: + fused_type.get_fused_types(result=base_types, seen=seen) + return base_types + + def _specialize_function_args(self, args, fused_to_specific): + for arg in args: + if arg.type.is_fused: + arg.type = arg.type.specialize(fused_to_specific) + if arg.type.is_memoryviewslice: + arg.type.validate_memslice_dtype(arg.pos) + if arg.annotation: + # TODO might be nice if annotations were specialized instead? + # (Or might be hard to do reliably) + arg.annotation.untyped = True + + def create_new_local_scope(self, node, env, f2s): + """ + Create a new local scope for the copied node and append it to + self.nodes. A new local scope is needed because the arguments with the + fused types are already in the local scope, and we need the specialized + entries created after analyse_declarations on each specialized version + of the (CFunc)DefNode. + f2s is a dict mapping each fused type to its specialized version + """ + node.create_local_scope(env) + node.local_scope.fused_to_specific = f2s + + # This is copied from the original function, set it to false to + # stop recursion + node.has_fused_arguments = False + self.nodes.append(node) + + def specialize_copied_def(self, node, cname, py_entry, f2s, fused_compound_types): + """Specialize the copy of a DefNode given the copied node, + the specialization cname and the original DefNode entry""" + fused_types = self._get_fused_base_types(fused_compound_types) + type_strings = [ + PyrexTypes.specialization_signature_string(fused_type, f2s) + for fused_type in fused_types + ] + + node.specialized_signature_string = '|'.join(type_strings) + + node.entry.pymethdef_cname = PyrexTypes.get_fused_cname( + cname, node.entry.pymethdef_cname) + node.entry.doc = py_entry.doc + node.entry.doc_cname = py_entry.doc_cname + + def replace_fused_typechecks(self, copied_node): + """ + Branch-prune fused type checks like + + if fused_t is int: + ... + + Returns whether an error was issued and whether we should stop in + in order to prevent a flood of errors. + """ + num_errors = Errors.get_errors_count() + transform = ParseTreeTransforms.ReplaceFusedTypeChecks( + copied_node.local_scope) + transform(copied_node) + + if Errors.get_errors_count() > num_errors: + return False + + return True + + def _fused_instance_checks(self, normal_types, pyx_code, env): + """ + Generate Cython code for instance checks, matching an object to + specialized types. + """ + for specialized_type in normal_types: + # all_numeric = all_numeric and specialized_type.is_numeric + py_type_name = specialized_type.py_type_name() + pyx_code.context.update( + py_type_name=py_type_name, + specialized_type_name=specialized_type.specialization_string, + ) + pyx_code.put_chunk( + """ + if isinstance(arg, {{py_type_name}}): + dest_sig[{{dest_sig_idx}}] = '{{specialized_type_name}}'; break + """) + + def _dtype_name(self, dtype): + name = str(dtype).replace('_', '__').replace(' ', '_') + if dtype.is_typedef: + name = Naming.fused_dtype_prefix + name + return name + + def _dtype_type(self, dtype): + if dtype.is_typedef: + return self._dtype_name(dtype) + return str(dtype) + + def _sizeof_dtype(self, dtype): + if dtype.is_pyobject: + return 'sizeof(void *)' + else: + return "sizeof(%s)" % self._dtype_type(dtype) + + def _buffer_check_numpy_dtype_setup_cases(self, pyx_code): + "Setup some common cases to match dtypes against specializations" + with pyx_code.indenter("if kind in u'iu':"): + pyx_code.putln("pass") + pyx_code.named_insertion_point("dtype_int") + + with pyx_code.indenter("elif kind == u'f':"): + pyx_code.putln("pass") + pyx_code.named_insertion_point("dtype_float") + + with pyx_code.indenter("elif kind == u'c':"): + pyx_code.putln("pass") + pyx_code.named_insertion_point("dtype_complex") + + match = "dest_sig[{{dest_sig_idx}}] = '{{specialized_type_name}}'" + no_match = "dest_sig[{{dest_sig_idx}}] = None" + def _buffer_check_numpy_dtype(self, pyx_code, specialized_buffer_types, pythran_types): + """ + Match a numpy dtype object to the individual specializations. + """ + self._buffer_check_numpy_dtype_setup_cases(pyx_code) + + for specialized_type in pythran_types+specialized_buffer_types: + final_type = specialized_type + if specialized_type.is_pythran_expr: + specialized_type = specialized_type.org_buffer + dtype = specialized_type.dtype + pyx_code.context.update( + itemsize_match=self._sizeof_dtype(dtype) + " == itemsize", + signed_match="not (%s_is_signed ^ dtype_signed)" % self._dtype_name(dtype), + dtype=dtype, + specialized_type_name=final_type.specialization_string) + + dtypes = [ + (dtype.is_int, pyx_code['dtype_int']), + (dtype.is_float, pyx_code['dtype_float']), + (dtype.is_complex, pyx_code['dtype_complex']) + ] + + for dtype_category, codewriter in dtypes: + if not dtype_category: + continue + cond = '{{itemsize_match}} and (arg.ndim) == %d' % ( + specialized_type.ndim,) + if dtype.is_int: + cond += ' and {{signed_match}}' + + if final_type.is_pythran_expr: + cond += ' and arg_is_pythran_compatible' + + with codewriter.indenter("if %s:" % cond): + #codewriter.putln("print 'buffer match found based on numpy dtype'") + codewriter.putln(self.match) + codewriter.putln("break") + + def _buffer_parse_format_string_check(self, pyx_code, decl_code, + specialized_type, env): + """ + For each specialized type, try to coerce the object to a memoryview + slice of that type. This means obtaining a buffer and parsing the + format string. + TODO: separate buffer acquisition from format parsing + """ + dtype = specialized_type.dtype + if specialized_type.is_buffer: + axes = [('direct', 'strided')] * specialized_type.ndim + else: + axes = specialized_type.axes + + memslice_type = PyrexTypes.MemoryViewSliceType(dtype, axes) + memslice_type.create_from_py_utility_code(env) + pyx_code.context.update( + coerce_from_py_func=memslice_type.from_py_function, + dtype=dtype) + decl_code.putln( + "{{memviewslice_cname}} {{coerce_from_py_func}}(object, int)") + + pyx_code.context.update( + specialized_type_name=specialized_type.specialization_string, + sizeof_dtype=self._sizeof_dtype(dtype), + ndim_dtype=specialized_type.ndim) + + # use the memoryview object to check itemsize and ndim. + # In principle it could check more, but these are the easiest to do quickly + pyx_code.put_chunk( + """ + # try {{dtype}} + if (((itemsize == -1 and arg_as_memoryview.itemsize == {{sizeof_dtype}}) + or itemsize == {{sizeof_dtype}}) + and arg_as_memoryview.ndim == {{ndim_dtype}}): + memslice = {{coerce_from_py_func}}(arg_as_memoryview, 0) + if memslice.memview: + __PYX_XCLEAR_MEMVIEW(&memslice, 1) + # print 'found a match for the buffer through format parsing' + %s + break + else: + __pyx_PyErr_Clear() + """ % self.match) + + def _buffer_checks(self, buffer_types, pythran_types, pyx_code, decl_code, accept_none, env): + """ + Generate Cython code to match objects to buffer specializations. + First try to get a numpy dtype object and match it against the individual + specializations. If that fails, try naively to coerce the object + to each specialization, which obtains the buffer each time and tries + to match the format string. + """ + # The first thing to find a match in this loop breaks out of the loop + pyx_code.put_chunk( + """ + """ + ("arg_is_pythran_compatible = False" if pythran_types else "") + """ + if ndarray is not None: + if isinstance(arg, ndarray): + dtype = arg.dtype + """ + ("arg_is_pythran_compatible = True" if pythran_types else "") + """ + elif __pyx_memoryview_check(arg): + arg_base = arg.base + if isinstance(arg_base, ndarray): + dtype = arg_base.dtype + else: + dtype = None + else: + dtype = None + + itemsize = -1 + if dtype is not None: + itemsize = dtype.itemsize + kind = ord(dtype.kind) + dtype_signed = kind == u'i' + """) + pyx_code.indent(2) + if pythran_types: + pyx_code.put_chunk( + """ + # Pythran only supports the endianness of the current compiler + byteorder = dtype.byteorder + if byteorder == "<" and not __Pyx_Is_Little_Endian(): + arg_is_pythran_compatible = False + elif byteorder == ">" and __Pyx_Is_Little_Endian(): + arg_is_pythran_compatible = False + if arg_is_pythran_compatible: + cur_stride = itemsize + shape = arg.shape + strides = arg.strides + for i in range(arg.ndim-1, -1, -1): + if (strides[i]) != cur_stride: + arg_is_pythran_compatible = False + break + cur_stride *= shape[i] + else: + arg_is_pythran_compatible = not (arg.flags.f_contiguous and (arg.ndim) > 1) + """) + self._buffer_check_numpy_dtype(pyx_code, buffer_types, pythran_types) + pyx_code.dedent(2) + + if accept_none: + # If None is acceptable, then Cython <3.0 matched None with the + # first type. This behaviour isn't ideal, but keep it for backwards + # compatibility. Better behaviour would be to see if subsequent + # arguments give a stronger match. + pyx_code.context.update( + specialized_type_name=buffer_types[0].specialization_string + ) + pyx_code.put_chunk( + """ + if arg is None: + %s + break + """ % self.match) + + # creating a Cython memoryview from a Python memoryview avoids the + # need to get the buffer multiple times, and we can + # also use it to check itemsizes etc + pyx_code.put_chunk( + """ + try: + arg_as_memoryview = memoryview(arg) + except (ValueError, TypeError): + pass + """) + with pyx_code.indenter("else:"): + for specialized_type in buffer_types: + self._buffer_parse_format_string_check( + pyx_code, decl_code, specialized_type, env) + + def _buffer_declarations(self, pyx_code, decl_code, all_buffer_types, pythran_types): + """ + If we have any buffer specializations, write out some variable + declarations and imports. + """ + decl_code.put_chunk( + """ + ctypedef struct {{memviewslice_cname}}: + void *memview + + void __PYX_XCLEAR_MEMVIEW({{memviewslice_cname}} *, int have_gil) + bint __pyx_memoryview_check(object) + """) + + pyx_code['local_variable_declarations'].put_chunk( + """ + cdef {{memviewslice_cname}} memslice + cdef Py_ssize_t itemsize + cdef bint dtype_signed + cdef Py_UCS4 kind + + itemsize = -1 + """) + + if pythran_types: + pyx_code['local_variable_declarations'].put_chunk(""" + cdef bint arg_is_pythran_compatible + cdef Py_ssize_t cur_stride + """) + + pyx_code['imports'].put_chunk( + """ + cdef type ndarray + ndarray = __Pyx_ImportNumPyArrayTypeIfAvailable() + """) + + pyx_code['imports'].put_chunk( + """ + cdef memoryview arg_as_memoryview + """ + ) + + seen_typedefs = set() + seen_int_dtypes = set() + for buffer_type in all_buffer_types: + dtype = buffer_type.dtype + dtype_name = self._dtype_name(dtype) + if dtype.is_typedef: + if dtype_name not in seen_typedefs: + seen_typedefs.add(dtype_name) + decl_code.putln( + 'ctypedef %s %s "%s"' % (dtype.resolve(), dtype_name, + dtype.empty_declaration_code())) + + if buffer_type.dtype.is_int: + if str(dtype) not in seen_int_dtypes: + seen_int_dtypes.add(str(dtype)) + pyx_code.context.update(dtype_name=dtype_name, + dtype_type=self._dtype_type(dtype)) + pyx_code['local_variable_declarations'].put_chunk( + """ + cdef bint {{dtype_name}}_is_signed + {{dtype_name}}_is_signed = not (<{{dtype_type}}> -1 > 0) + """) + + def _split_fused_types(self, arg): + """ + Specialize fused types and split into normal types and buffer types. + """ + specialized_types = PyrexTypes.get_specialized_types(arg.type) + + # Prefer long over int, etc by sorting (see type classes in PyrexTypes.py) + specialized_types.sort() + + seen_py_type_names = set() + normal_types, buffer_types, pythran_types = [], [], [] + has_object_fallback = False + for specialized_type in specialized_types: + py_type_name = specialized_type.py_type_name() + if py_type_name: + if py_type_name in seen_py_type_names: + continue + seen_py_type_names.add(py_type_name) + if py_type_name == 'object': + has_object_fallback = True + else: + normal_types.append(specialized_type) + elif specialized_type.is_pythran_expr: + pythran_types.append(specialized_type) + elif specialized_type.is_buffer or specialized_type.is_memoryviewslice: + buffer_types.append(specialized_type) + + return normal_types, buffer_types, pythran_types, has_object_fallback + + def _unpack_argument(self, pyx_code): + pyx_code.put_chunk( + """ + # PROCESSING ARGUMENT {{arg_tuple_idx}} + if {{arg_tuple_idx}} < len(args): + arg = (args)[{{arg_tuple_idx}}] + elif kwargs is not None and '{{arg.name}}' in kwargs: + arg = (kwargs)['{{arg.name}}'] + else: + {{if arg.default}} + arg = (defaults)[{{default_idx}}] + {{else}} + {{if arg_tuple_idx < min_positional_args}} + raise TypeError("Expected at least %d argument%s, got %d" % ( + {{min_positional_args}}, {{'"s"' if min_positional_args != 1 else '""'}}, len(args))) + {{else}} + raise TypeError("Missing keyword-only argument: '%s'" % "{{arg.default}}") + {{endif}} + {{endif}} + """) + + def _fused_signature_index(self, pyx_code): + """ + Generate Cython code for constructing a persistent nested dictionary index of + fused type specialization signatures. + """ + # Note on thread-safety: + # Filling in "fused_sigindex" should only happen once. However, in a multi-threaded + # environment it's possible that multiple threads can all start to fill it in + # independently (especially on freehtreading builds). + # Therefore: + # * "_fused_sigindex_ref" is a list of length 1 where the first element is either None, + # or a dictionary of signatures to lookup. + # * We rely on being able to get/set list elements atomically (which is true on + # freethreading and regular Python). + # * It doesn't really matter if multiple threads start generating their own version + # of this - the contents will end up the same. The main point is that no thread + # sees a half filled-in sigindex + pyx_code.put_chunk( + """ + fused_sigindex = _fused_sigindex_ref[0] + if fused_sigindex is None: + fused_sigindex = {} + for sig in signatures: + sigindex_node = fused_sigindex + *sig_series, last_type = sig.strip('()').split('|') + for sig_type in sig_series: + if sig_type not in sigindex_node: + sigindex_node[sig_type] = sigindex_node = {} + else: + sigindex_node = sigindex_node[sig_type] + sigindex_node[last_type] = sig + _fused_sigindex_ref[0] = fused_sigindex + """ + ) + + def make_fused_cpdef(self, orig_py_func, env, is_def): + """ + This creates the function that is indexable from Python and does + runtime dispatch based on the argument types. The function gets the + arg tuple and kwargs dict (or None) and the defaults tuple + as arguments from the Binding Fused Function's tp_call. + """ + from . import TreeFragment, Code, UtilityCode + + fused_types = self._get_fused_base_types([ + arg.type for arg in self.node.args if arg.type.is_fused]) + + context = { + 'memviewslice_cname': MemoryView.memviewslice_cname, + 'func_args': self.node.args, + 'n_fused': len(fused_types), + 'min_positional_args': + self.node.num_required_args - self.node.num_required_kw_args + if is_def else + sum(1 for arg in self.node.args if arg.default is None), + 'name': orig_py_func.entry.name, + } + + pyx_code = Code.PyxCodeWriter(context=context) + decl_code = Code.PyxCodeWriter(context=context) + decl_code.put_chunk( + """ + cdef extern from *: + void __pyx_PyErr_Clear "PyErr_Clear" () + type __Pyx_ImportNumPyArrayTypeIfAvailable() + int __Pyx_Is_Little_Endian() + """) + decl_code.indent() + + pyx_code.put_chunk( + """ + def __pyx_fused_cpdef(signatures, args, kwargs, defaults, _fused_sigindex_ref=[None]): + # FIXME: use a typed signature - currently fails badly because + # default arguments inherit the types we specify here! + + cdef list search_list + cdef dict sigindex_node + + dest_sig = [None] * {{n_fused}} + + if kwargs is not None and not kwargs: + kwargs = None + + cdef Py_ssize_t i + + # instance check body + """) + + pyx_code.indent() # indent following code to function body + pyx_code.named_insertion_point("imports") + pyx_code.named_insertion_point("local_variable_declarations") + + fused_index = 0 + default_idx = 0 + all_buffer_types = OrderedSet() + seen_fused_types = set() + for i, arg in enumerate(self.node.args): + if arg.type.is_fused: + arg_fused_types = arg.type.get_fused_types() + if len(arg_fused_types) > 1: + raise NotImplementedError("Determination of more than one fused base " + "type per argument is not implemented.") + fused_type = arg_fused_types[0] + + if arg.type.is_fused and fused_type not in seen_fused_types: + seen_fused_types.add(fused_type) + + context.update( + arg_tuple_idx=i, + arg=arg, + dest_sig_idx=fused_index, + default_idx=default_idx, + ) + + normal_types, buffer_types, pythran_types, has_object_fallback = self._split_fused_types(arg) + self._unpack_argument(pyx_code) + + # 'unrolled' loop, first match breaks out of it + with pyx_code.indenter("while 1:"): + if normal_types: + self._fused_instance_checks(normal_types, pyx_code, env) + if buffer_types or pythran_types: + env.use_utility_code(Code.UtilityCode.load_cached("IsLittleEndian", "ModuleSetupCode.c")) + self._buffer_checks( + buffer_types, pythran_types, pyx_code, decl_code, + arg.accept_none, env) + if has_object_fallback: + pyx_code.context.update(specialized_type_name='object') + pyx_code.putln(self.match) + else: + pyx_code.putln(self.no_match) + pyx_code.putln("break") + + fused_index += 1 + all_buffer_types.update(buffer_types) + all_buffer_types.update(ty.org_buffer for ty in pythran_types) + + if arg.default: + default_idx += 1 + + if all_buffer_types: + self._buffer_declarations(pyx_code, decl_code, all_buffer_types, pythran_types) + env.use_utility_code(Code.UtilityCode.load_cached("Import", "ImportExport.c")) + env.use_utility_code(Code.UtilityCode.load_cached("ImportNumPyArray", "ImportExport.c")) + + self._fused_signature_index(pyx_code) + + pyx_code.put_chunk( + """ + sigindex_matches = [] + sigindex_candidates = [fused_sigindex] + + for dst_type in dest_sig: + found_matches = [] + found_candidates = [] + # Make two separate lists: One for signature sub-trees + # with at least one definite match, and another for + # signature sub-trees with only ambiguous matches + # (where `dest_sig[i] is None`). + if dst_type is None: + for sn in sigindex_matches: + found_matches.extend(( sn).values()) + for sn in sigindex_candidates: + found_candidates.extend(( sn).values()) + else: + for search_list in (sigindex_matches, sigindex_candidates): + for sn in search_list: + type_match = ( sn).get(dst_type) + if type_match is not None: + found_matches.append(type_match) + sigindex_matches = found_matches + sigindex_candidates = found_candidates + if not (found_matches or found_candidates): + break + + candidates = sigindex_matches + + if not candidates: + raise TypeError("No matching signature found") + elif len(candidates) > 1: + raise TypeError("Function call with ambiguous argument types") + else: + return (signatures)[candidates[0]] + """) + + fragment_code = pyx_code.getvalue() + # print decl_code.getvalue() + # print fragment_code + from .Optimize import ConstantFolding + fragment = TreeFragment.TreeFragment( + fragment_code, level='module', pipeline=[ConstantFolding()]) + ast = TreeFragment.SetPosTransform(self.node.pos)(fragment.root) + UtilityCode.declare_declarations_in_scope( + decl_code.getvalue(), env.global_scope()) + ast.scope = env + # FIXME: for static methods of cdef classes, we build the wrong signature here: first arg becomes 'self' + ast.analyse_declarations(env) + py_func = ast.stats[-1] # the DefNode + self.fragment_scope = ast.scope + + if isinstance(self.node, DefNode): + py_func.specialized_cpdefs = self.nodes[:] + else: + py_func.specialized_cpdefs = [n.py_func for n in self.nodes] + + return py_func + + def update_fused_defnode_entry(self, env): + copy_attributes = ( + 'name', 'pos', 'cname', 'func_cname', 'pyfunc_cname', + 'pymethdef_cname', 'doc', 'doc_cname', 'is_member', + 'scope' + ) + + entry = self.py_func.entry + + for attr in copy_attributes: + setattr(entry, attr, + getattr(self.orig_py_func.entry, attr)) + + self.py_func.name = self.orig_py_func.name + self.py_func.doc = self.orig_py_func.doc + + env.entries.pop('__pyx_fused_cpdef', None) + if isinstance(self.node, DefNode): + env.entries[entry.name] = entry + else: + env.entries[entry.name].as_variable = entry + + env.pyfunc_entries.append(entry) + + self.py_func.entry.fused_cfunction = self + def_nodes = [] + for node in self.nodes: + if isinstance(self.node, DefNode): + def_nodes.append(node) + node.fused_py_func = self.py_func + else: + def_nodes.append(node.py_func) + node.py_func.fused_py_func = self.py_func + node.entry.as_variable = entry + + self.synthesize_defnodes(def_nodes) + + def analyse_expressions(self, env): + """ + Analyse the expressions. Take care to only evaluate default arguments + once and clone the result for all specializations + """ + for fused_compound_type in self.fused_compound_types: + for fused_type in fused_compound_type.get_fused_types(): + for specialization_type in fused_type.types: + if specialization_type.is_complex: + specialization_type.create_declaration_utility_code(env) + + if self.py_func: + self.__signatures__ = self.__signatures__.analyse_expressions(env) + self.py_func = self.py_func.analyse_expressions(env) + self.resulting_fused_function = self.resulting_fused_function.analyse_expressions(env) + self.fused_func_assignment = self.fused_func_assignment.analyse_expressions(env) + + self.defaults = defaults = [] + + for arg in self.node.args: + if arg.default: + arg.default = arg.default.analyse_expressions(env) + if arg.default.is_literal: + defaults.append(copy.copy(arg.default)) + else: + # coerce the argument to temp since CloneNode really requires a temp + defaults.append(ProxyNode(arg.default.coerce_to_temp(env))) + else: + defaults.append(None) + + for i, stat in enumerate(self.stats): + stat = self.stats[i] = stat.analyse_expressions(env) + if isinstance(stat, FuncDefNode) and stat is not self.py_func: + # the dispatcher specifically doesn't want its defaults overriding + for arg, default in zip(stat.args, defaults): + if default is not None: + if default.is_literal: + arg.default = default.coerce_to(arg.type, env) + else: + arg.default = CloneNode(default).analyse_expressions(env).coerce_to(arg.type, env) + + if self.py_func: + args = [CloneNode(default) for default in defaults if default] + self.defaults_tuple = TupleNode(self.pos, args=args) + self.defaults_tuple = self.defaults_tuple.analyse_types(env, skip_children=True).coerce_to_pyobject(env) + self.defaults_tuple = ProxyNode(self.defaults_tuple) + + fused_func = self.resulting_fused_function.arg + fused_func.defaults_tuple = CloneNode(self.defaults_tuple) + + for i, pycfunc in enumerate(self.specialized_pycfuncs): + pycfunc = self.specialized_pycfuncs[i] = pycfunc.analyse_types(env) + pycfunc.defaults_tuple = CloneNode(self.defaults_tuple) + return self + + def synthesize_defnodes(self, nodes): + """ + Create the __signatures__ dict of PyCFunctionNode specializations. + """ + # For the moment, fused functions do not support METH_FASTCALL + for node in nodes: + node.entry.signature.use_fastcall = False + + signatures = [StringEncoding.EncodedString(node.specialized_signature_string) + for node in nodes] + keys = [ExprNodes.UnicodeNode(node.pos, value=sig) + for node, sig in zip(nodes, signatures)] + values = [ExprNodes.PyCFunctionNode.from_defnode(node, binding=True) + for node in nodes] + + self.__signatures__ = ExprNodes.DictNode.from_pairs(self.pos, zip(keys, values)) + + self.specialized_pycfuncs = values + for pycfuncnode in values: + pycfuncnode.is_specialization = True + # use code object from first defnode to get as close to a correct signature as possible + self.py_func.code_object = CodeObjectNode(nodes[0]) + + def generate_function_definitions(self, env, code): + if self.py_func: + self.py_func.pymethdef_required = True + self.fused_func_assignment.generate_function_definitions(env, code) + + from . import Options + for stat in self.stats: + if isinstance(stat, FuncDefNode) and ( + stat.entry.used or + (Options.cimport_from_pyx and not stat.entry.visibility == 'extern')): + code.mark_pos(stat.pos) + stat.generate_function_definitions(env, code) + + def generate_execution_code(self, code): + # Note: all def function specialization are wrapped in PyCFunction + # nodes in the self.__signatures__ dictnode. + for default in self.defaults: + if default is not None: + default.generate_evaluation_code(code) + + if self.py_func: + self.defaults_tuple.generate_evaluation_code(code) + + super().generate_execution_code(code) + + if self.__signatures__: + self.__signatures__.generate_evaluation_code(code) + self.resulting_fused_function.generate_evaluation_code(code) + + code.putln( + "((__pyx_FusedFunctionObject *) %s)->__signatures__ = %s;" % + (self.resulting_fused_function.result(), + self.__signatures__.result())) + self.__signatures__.generate_giveref(code) + self.__signatures__.generate_post_assignment_code(code) + self.__signatures__.free_temps(code) + + self.fused_func_assignment.generate_execution_code(code) + + # Dispose of results + self.resulting_fused_function.generate_disposal_code(code) + self.resulting_fused_function.free_temps(code) + self.defaults_tuple.generate_disposal_code(code) + self.defaults_tuple.free_temps(code) + + for default in self.defaults: + if default is not None: + default.generate_disposal_code(code) + default.free_temps(code) + + def annotate(self, code): + for stat in self.stats: + stat.annotate(code) diff --git a/venv/lib/python3.10/site-packages/Cython/Compiler/Future.py b/venv/lib/python3.10/site-packages/Cython/Compiler/Future.py new file mode 100644 index 0000000000000000000000000000000000000000..8de10c0cb583f206808269ce6dbcf7fcb59c39b4 --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Compiler/Future.py @@ -0,0 +1,16 @@ +def _get_feature(name): + import __future__ + # fall back to a unique fake object for earlier Python versions or Python 3 + return getattr(__future__, name, object()) + +unicode_literals = _get_feature("unicode_literals") +with_statement = _get_feature("with_statement") # dummy +division = _get_feature("division") +print_function = _get_feature("print_function") +absolute_import = _get_feature("absolute_import") +nested_scopes = _get_feature("nested_scopes") # dummy +generators = _get_feature("generators") # dummy +generator_stop = _get_feature("generator_stop") +annotations = _get_feature("annotations") + +del _get_feature diff --git a/venv/lib/python3.10/site-packages/Cython/Compiler/Interpreter.py b/venv/lib/python3.10/site-packages/Cython/Compiler/Interpreter.py new file mode 100644 index 0000000000000000000000000000000000000000..fb0f8c255d054c4f59bed2a18875b804323a1d4d --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Compiler/Interpreter.py @@ -0,0 +1,57 @@ +""" +This module deals with interpreting the parse tree as Python +would have done, in the compiler. + +For now this only covers parse tree to value conversion of +compile-time values. +""" + + +from .ExprNodes import DictNode +from .Errors import CompileError + + +class EmptyScope: + def lookup(self, name): + return None + +empty_scope = EmptyScope() + +def interpret_compiletime_options(optlist, optdict, type_env=None, type_args=()): + """ + Tries to interpret a list of compile time option nodes. + The result will be a tuple (optlist, optdict) but where + all expression nodes have been interpreted. The result is + in the form of tuples (value, pos). + + optlist is a list of nodes, while optdict is a DictNode (the + result optdict is a dict) + + If type_env is set, all type nodes will be analysed and the resulting + type set. Otherwise only interpretateable ExprNodes + are allowed, other nodes raises errors. + + A CompileError will be raised if there are problems. + """ + + def interpret(node, ix): + if ix in type_args: + if type_env: + type = node.analyse_as_type(type_env) + if not type: + raise CompileError(node.pos, "Invalid type.") + return (type, node.pos) + else: + raise CompileError(node.pos, "Type not allowed here.") + return (node.compile_time_value(empty_scope), node.pos) + + if optlist: + optlist = [interpret(x, ix) for ix, x in enumerate(optlist)] + if optdict: + assert isinstance(optdict, DictNode) + new_optdict = {} + for item in optdict.key_value_pairs: + new_key, dummy = interpret(item.key, None) + new_optdict[new_key] = interpret(item.value, item.key.value) + optdict = new_optdict + return (optlist, new_optdict) diff --git a/venv/lib/python3.10/site-packages/Cython/Compiler/Lexicon.py b/venv/lib/python3.10/site-packages/Cython/Compiler/Lexicon.py new file mode 100644 index 0000000000000000000000000000000000000000..a391ffce4309eba752def72f52ab2bc6d806096b --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Compiler/Lexicon.py @@ -0,0 +1,348 @@ +# cython: py2_import=True +# +# Cython Scanner - Lexical Definitions +# + + +raw_prefixes = "rR" +bytes_prefixes = "bB" +string_prefixes = "fFuU" + bytes_prefixes +char_prefixes = "cC" +any_string_prefix = raw_prefixes + string_prefixes + char_prefixes +IDENT = 'IDENT' + + +def make_lexicon(): + from ..Plex import \ + Str, Any, AnyBut, AnyChar, Rep, Rep1, Opt, Bol, Eol, Eof, \ + TEXT, IGNORE, Method, State, Lexicon, Range + + nonzero_digit = Any("123456789") + digit = Any("0123456789") + bindigit = Any("01") + octdigit = Any("01234567") + hexdigit = Any("0123456789ABCDEFabcdef") + indentation = Bol + Rep(Any(" \t")) + + # The list of valid unicode identifier characters are pretty slow to generate at runtime, + # and require Python3, so are just included directly here + # (via the generated code block at the bottom of the file) + unicode_start_character = (Any(unicode_start_ch_any) | Range(unicode_start_ch_range)) + unicode_continuation_character = ( + unicode_start_character | + Any(unicode_continuation_ch_any) | Range(unicode_continuation_ch_range)) + + def underscore_digits(d): + return Rep1(d) + Rep(Str("_") + Rep1(d)) + + def prefixed_digits(prefix, digits): + return prefix + Opt(Str("_")) + underscore_digits(digits) + + decimal = underscore_digits(digit) + dot = Str(".") + exponent = Any("Ee") + Opt(Any("+-")) + decimal + decimal_fract = (decimal + dot + Opt(decimal)) | (dot + decimal) + + #name = letter + Rep(letter | digit) + name = unicode_start_character + Rep(unicode_continuation_character) + intconst = (prefixed_digits(nonzero_digit, digit) | # decimal literals with underscores must not start with '0' + (Str("0") + (prefixed_digits(Any("Xx"), hexdigit) | + prefixed_digits(Any("Oo"), octdigit) | + prefixed_digits(Any("Bb"), bindigit) )) | + underscore_digits(Str('0')) # 0_0_0_0... is allowed as a decimal literal + | Rep1(digit) # FIXME: remove these Py2 style decimal/octal literals (PY_VERSION_HEX < 3) + ) + intsuffix = (Opt(Any("Uu")) + Opt(Any("Ll")) + Opt(Any("Ll"))) | (Opt(Any("Ll")) + Opt(Any("Ll")) + Opt(Any("Uu"))) + intliteral = intconst + intsuffix + fltconst = (decimal_fract + Opt(exponent)) | (decimal + exponent) + imagconst = (intconst | fltconst) + Any("jJ") + + # invalid combinations of prefixes are caught in p_string_literal + beginstring = Opt(Rep(Any(string_prefixes + raw_prefixes)) | + Any(char_prefixes) + ) + (Str("'") | Str('"') | Str("'''") | Str('"""')) + two_oct = octdigit + octdigit + three_oct = octdigit + octdigit + octdigit + two_hex = hexdigit + hexdigit + four_hex = two_hex + two_hex + escapeseq = Str("\\") + (two_oct | three_oct | + # Unicode character names are [A-Z \-] + # https://www.unicode.org/versions/Unicode16.0.0/core-spec/chapter-4/ + # Although Python itself is case agnostic + Str('N{') + Rep(Range('azAZ') | Any('- ')) + Str('}') | + Str('u') + four_hex | Str('x') + two_hex | + Str('U') + four_hex + four_hex | AnyChar) + + bra = Any("([{") + ket = Any(")]}") + ellipsis = Str("...") + punct = Any(":,;+-*/|&<>=.%`~^?!@") + diphthong = Str("==", "<>", "!=", "<=", ">=", "<<", ">>", "**", "//", + "+=", "-=", "*=", "/=", "%=", "|=", "^=", "&=", + "<<=", ">>=", "**=", "//=", "->", "@=", "&&", "||", ':=') + spaces = Rep1(Any(" \t\f")) + escaped_newline = Str("\\\n") + lineterm = Eol + Opt(Str("\n")) + + comment = Str("#") + Rep(AnyBut("\n")) + + return Lexicon([ + (name, Method('normalize_ident')), + (intliteral, Method('strip_underscores', symbol='INT')), + (fltconst, Method('strip_underscores', symbol='FLOAT')), + (imagconst, Method('strip_underscores', symbol='IMAG')), + (ellipsis | punct | diphthong, TEXT), + + (bra, Method('open_bracket_action')), + (ket, Method('close_bracket_action')), + (lineterm, Method('newline_action')), + + (beginstring, Method('begin_string_action')), + + (comment, IGNORE), + (spaces, IGNORE), + (escaped_newline, IGNORE), + + State('INDENT', [ + (comment + lineterm, Method('commentline')), + (Opt(spaces) + Opt(comment) + lineterm, IGNORE), + (indentation, Method('indentation_action')), + (Eof, Method('eof_action')) + ]), + + State('SQ_STRING', [ + (escapeseq, 'ESCAPE'), + (Rep1(AnyBut("'\"\n\\")), 'CHARS'), + (Str('"'), 'CHARS'), + (Str("\n"), Method('unclosed_string_action')), + (Str("'"), Method('end_string_action')), + (Eof, 'EOF') + ]), + + State('DQ_STRING', [ + (escapeseq, 'ESCAPE'), + (Rep1(AnyBut('"\n\\')), 'CHARS'), + (Str("'"), 'CHARS'), + (Str("\n"), Method('unclosed_string_action')), + (Str('"'), Method('end_string_action')), + (Eof, 'EOF') + ]), + + State('TSQ_STRING', [ + (escapeseq, 'ESCAPE'), + (Rep1(AnyBut("'\"\n\\")), 'CHARS'), + (Any("'\""), 'CHARS'), + (Str("\n"), 'NEWLINE'), + (Str("'''"), Method('end_string_action')), + (Eof, 'EOF') + ]), + + State('TDQ_STRING', [ + (escapeseq, 'ESCAPE'), + (Rep1(AnyBut('"\'\n\\')), 'CHARS'), + (Any("'\""), 'CHARS'), + (Str("\n"), 'NEWLINE'), + (Str('"""'), Method('end_string_action')), + (Eof, 'EOF') + ]), + + (Eof, Method('eof_action')) + ], + + # FIXME: Plex 1.9 needs different args here from Plex 1.1.4 + #debug_flags = scanner_debug_flags, + #debug_file = scanner_dump_file + ) + + +# BEGIN GENERATED CODE +# Generated with 'cython-generate-lexicon.py' based on Unicode 16.0.0: +# cpython 3.14.0rc1 free-threading build (main, Jul 25 2025, 19:13:08) [GCC 14.2.1 20250220 [revision 9ffecde121af883b60bbe60d00425036bc873048]] + +unicode_start_ch_any = ( + "\u005f\u00aa\u00b5\u00ba\u02ec\u02ee\u037f\u0386\u038c\u0559\u06d5" + "\u06ff\u0710\u07b1\u07fa\u081a\u0824\u0828\u093d\u0950\u09b2\u09bd" + "\u09ce\u09fc\u0a5e\u0abd\u0ad0\u0af9\u0b3d\u0b71\u0b83\u0b9c\u0bd0" + "\u0c3d\u0c5d\u0c80\u0cbd\u0d3d\u0d4e\u0dbd\u0e32\u0e84\u0ea5\u0eb2" + "\u0ebd\u0ec6\u0f00\u103f\u1061\u108e\u10c7\u10cd\u1258\u12c0\u17d7" + "\u17dc\u18aa\u1aa7\u1cfa\u1f59\u1f5b\u1f5d\u1fbe\u2071\u207f\u2102" + "\u2107\u2115\u2124\u2126\u2128\u214e\u2d27\u2d2d\u2d6f\ua7d3\ua8fb" + "\ua9cf\uaa7a\uaab1\uaac0\uaac2\ufb1d\ufb3e\ufe71\ufe73\ufe77\ufe79" + "\ufe7b\ufe7d\U00010808\U0001083c\U00010a00\U00010f27\U00011075\U00011144\U00011147\U00011176\U000111da" + "\U000111dc\U00011288\U0001133d\U00011350\U0001138b\U0001138e\U000113b7\U000113d1\U000113d3\U000114c7\U00011644" + "\U000116b8\U00011909\U0001193f\U00011941\U000119e1\U000119e3\U00011a00\U00011a3a\U00011a50\U00011a9d\U00011c40" + "\U00011d46\U00011d98\U00011f02\U00011fb0\U00016f50\U00016fe3\U0001b132\U0001b155\U0001d4a2\U0001d4bb\U0001d546" + "\U0001e14e\U0001e5f0\U0001e94b\U0001ee24\U0001ee27\U0001ee39\U0001ee3b\U0001ee42\U0001ee47\U0001ee49\U0001ee4b" + "\U0001ee54\U0001ee57\U0001ee59\U0001ee5b\U0001ee5d\U0001ee5f\U0001ee64\U0001ee7e" +) +unicode_start_ch_range = ( + "\u0041\u005a\u0061\u007a\u00c0\u00d6\u00d8\u00f6\u00f8\u02c1\u02c6" + "\u02d1\u02e0\u02e4\u0370\u0374\u0376\u0377\u037b\u037d\u0388\u038a" + "\u038e\u03a1\u03a3\u03f5\u03f7\u0481\u048a\u052f\u0531\u0556\u0560" + "\u0588\u05d0\u05ea\u05ef\u05f2\u0620\u064a\u066e\u066f\u0671\u06d3" + "\u06e5\u06e6\u06ee\u06ef\u06fa\u06fc\u0712\u072f\u074d\u07a5\u07ca" + "\u07ea\u07f4\u07f5\u0800\u0815\u0840\u0858\u0860\u086a\u0870\u0887" + "\u0889\u088e\u08a0\u08c9\u0904\u0939\u0958\u0961\u0971\u0980\u0985" + "\u098c\u098f\u0990\u0993\u09a8\u09aa\u09b0\u09b6\u09b9\u09dc\u09dd" + "\u09df\u09e1\u09f0\u09f1\u0a05\u0a0a\u0a0f\u0a10\u0a13\u0a28\u0a2a" + "\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a59\u0a5c\u0a72\u0a74" + "\u0a85\u0a8d\u0a8f\u0a91\u0a93\u0aa8\u0aaa\u0ab0\u0ab2\u0ab3\u0ab5" + "\u0ab9\u0ae0\u0ae1\u0b05\u0b0c\u0b0f\u0b10\u0b13\u0b28\u0b2a\u0b30" + "\u0b32\u0b33\u0b35\u0b39\u0b5c\u0b5d\u0b5f\u0b61\u0b85\u0b8a\u0b8e" + "\u0b90\u0b92\u0b95\u0b99\u0b9a\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8\u0baa" + "\u0bae\u0bb9\u0c05\u0c0c\u0c0e\u0c10\u0c12\u0c28\u0c2a\u0c39\u0c58" + "\u0c5a\u0c60\u0c61\u0c85\u0c8c\u0c8e\u0c90\u0c92\u0ca8\u0caa\u0cb3" + "\u0cb5\u0cb9\u0cdd\u0cde\u0ce0\u0ce1\u0cf1\u0cf2\u0d04\u0d0c\u0d0e" + "\u0d10\u0d12\u0d3a\u0d54\u0d56\u0d5f\u0d61\u0d7a\u0d7f\u0d85\u0d96" + "\u0d9a\u0db1\u0db3\u0dbb\u0dc0\u0dc6\u0e01\u0e30\u0e40\u0e46\u0e81" + "\u0e82\u0e86\u0e8a\u0e8c\u0ea3\u0ea7\u0eb0\u0ec0\u0ec4\u0edc\u0edf" + "\u0f40\u0f47\u0f49\u0f6c\u0f88\u0f8c\u1000\u102a\u1050\u1055\u105a" + "\u105d\u1065\u1066\u106e\u1070\u1075\u1081\u10a0\u10c5\u10d0\u10fa" + "\u10fc\u1248\u124a\u124d\u1250\u1256\u125a\u125d\u1260\u1288\u128a" + "\u128d\u1290\u12b0\u12b2\u12b5\u12b8\u12be\u12c2\u12c5\u12c8\u12d6" + "\u12d8\u1310\u1312\u1315\u1318\u135a\u1380\u138f\u13a0\u13f5\u13f8" + "\u13fd\u1401\u166c\u166f\u167f\u1681\u169a\u16a0\u16ea\u16ee\u16f8" + "\u1700\u1711\u171f\u1731\u1740\u1751\u1760\u176c\u176e\u1770\u1780" + "\u17b3\u1820\u1878\u1880\u18a8\u18b0\u18f5\u1900\u191e\u1950\u196d" + "\u1970\u1974\u1980\u19ab\u19b0\u19c9\u1a00\u1a16\u1a20\u1a54\u1b05" + "\u1b33\u1b45\u1b4c\u1b83\u1ba0\u1bae\u1baf\u1bba\u1be5\u1c00\u1c23" + "\u1c4d\u1c4f\u1c5a\u1c7d\u1c80\u1c8a\u1c90\u1cba\u1cbd\u1cbf\u1ce9" + "\u1cec\u1cee\u1cf3\u1cf5\u1cf6\u1d00\u1dbf\u1e00\u1f15\u1f18\u1f1d" + "\u1f20\u1f45\u1f48\u1f4d\u1f50\u1f57\u1f5f\u1f7d\u1f80\u1fb4\u1fb6" + "\u1fbc\u1fc2\u1fc4\u1fc6\u1fcc\u1fd0\u1fd3\u1fd6\u1fdb\u1fe0\u1fec" + "\u1ff2\u1ff4\u1ff6\u1ffc\u2090\u209c\u210a\u2113\u2118\u211d\u212a" + "\u2139\u213c\u213f\u2145\u2149\u2160\u2188\u2c00\u2ce4\u2ceb\u2cee" + "\u2cf2\u2cf3\u2d00\u2d25\u2d30\u2d67\u2d80\u2d96\u2da0\u2da6\u2da8" + "\u2dae\u2db0\u2db6\u2db8\u2dbe\u2dc0\u2dc6\u2dc8\u2dce\u2dd0\u2dd6" + "\u2dd8\u2dde\u3005\u3007\u3021\u3029\u3031\u3035\u3038\u303c\u3041" + "\u3096\u309d\u309f\u30a1\u30fa\u30fc\u30ff\u3105\u312f\u3131\u318e" + "\u31a0\u31bf\u31f0\u31ff\u3400\u4dbf\u4e00\ua48c\ua4d0\ua4fd\ua500" + "\ua60c\ua610\ua61f\ua62a\ua62b\ua640\ua66e\ua67f\ua69d\ua6a0\ua6ef" + "\ua717\ua71f\ua722\ua788\ua78b\ua7cd\ua7d0\ua7d1\ua7d5\ua7dc\ua7f2" + "\ua801\ua803\ua805\ua807\ua80a\ua80c\ua822\ua840\ua873\ua882\ua8b3" + "\ua8f2\ua8f7\ua8fd\ua8fe\ua90a\ua925\ua930\ua946\ua960\ua97c\ua984" + "\ua9b2\ua9e0\ua9e4\ua9e6\ua9ef\ua9fa\ua9fe\uaa00\uaa28\uaa40\uaa42" + "\uaa44\uaa4b\uaa60\uaa76\uaa7e\uaaaf\uaab5\uaab6\uaab9\uaabd\uaadb" + "\uaadd\uaae0\uaaea\uaaf2\uaaf4\uab01\uab06\uab09\uab0e\uab11\uab16" + "\uab20\uab26\uab28\uab2e\uab30\uab5a\uab5c\uab69\uab70\uabe2\uac00" + "\ud7a3\ud7b0\ud7c6\ud7cb\ud7fb\uf900\ufa6d\ufa70\ufad9\ufb00\ufb06" + "\ufb13\ufb17\ufb1f\ufb28\ufb2a\ufb36\ufb38\ufb3c\ufb40\ufb41\ufb43" + "\ufb44\ufb46\ufbb1\ufbd3\ufc5d\ufc64\ufd3d\ufd50\ufd8f\ufd92\ufdc7" + "\ufdf0\ufdf9\ufe7f\ufefc\uff21\uff3a\uff41\uff5a\uff66\uff9d\uffa0" + "\uffbe\uffc2\uffc7\uffca\uffcf\uffd2\uffd7\uffda\uffdc\U00010000\U0001000b" + "\U0001000d\U00010026\U00010028\U0001003a\U0001003c\U0001003d\U0001003f\U0001004d\U00010050\U0001005d\U00010080" + "\U000100fa\U00010140\U00010174\U00010280\U0001029c\U000102a0\U000102d0\U00010300\U0001031f\U0001032d\U0001034a" + "\U00010350\U00010375\U00010380\U0001039d\U000103a0\U000103c3\U000103c8\U000103cf\U000103d1\U000103d5\U00010400" + "\U0001049d\U000104b0\U000104d3\U000104d8\U000104fb\U00010500\U00010527\U00010530\U00010563\U00010570\U0001057a" + "\U0001057c\U0001058a\U0001058c\U00010592\U00010594\U00010595\U00010597\U000105a1\U000105a3\U000105b1\U000105b3" + "\U000105b9\U000105bb\U000105bc\U000105c0\U000105f3\U00010600\U00010736\U00010740\U00010755\U00010760\U00010767" + "\U00010780\U00010785\U00010787\U000107b0\U000107b2\U000107ba\U00010800\U00010805\U0001080a\U00010835\U00010837" + "\U00010838\U0001083f\U00010855\U00010860\U00010876\U00010880\U0001089e\U000108e0\U000108f2\U000108f4\U000108f5" + "\U00010900\U00010915\U00010920\U00010939\U00010980\U000109b7\U000109be\U000109bf\U00010a10\U00010a13\U00010a15" + "\U00010a17\U00010a19\U00010a35\U00010a60\U00010a7c\U00010a80\U00010a9c\U00010ac0\U00010ac7\U00010ac9\U00010ae4" + "\U00010b00\U00010b35\U00010b40\U00010b55\U00010b60\U00010b72\U00010b80\U00010b91\U00010c00\U00010c48\U00010c80" + "\U00010cb2\U00010cc0\U00010cf2\U00010d00\U00010d23\U00010d4a\U00010d65\U00010d6f\U00010d85\U00010e80\U00010ea9" + "\U00010eb0\U00010eb1\U00010ec2\U00010ec4\U00010f00\U00010f1c\U00010f30\U00010f45\U00010f70\U00010f81\U00010fb0" + "\U00010fc4\U00010fe0\U00010ff6\U00011003\U00011037\U00011071\U00011072\U00011083\U000110af\U000110d0\U000110e8" + "\U00011103\U00011126\U00011150\U00011172\U00011183\U000111b2\U000111c1\U000111c4\U00011200\U00011211\U00011213" + "\U0001122b\U0001123f\U00011240\U00011280\U00011286\U0001128a\U0001128d\U0001128f\U0001129d\U0001129f\U000112a8" + "\U000112b0\U000112de\U00011305\U0001130c\U0001130f\U00011310\U00011313\U00011328\U0001132a\U00011330\U00011332" + "\U00011333\U00011335\U00011339\U0001135d\U00011361\U00011380\U00011389\U00011390\U000113b5\U00011400\U00011434" + "\U00011447\U0001144a\U0001145f\U00011461\U00011480\U000114af\U000114c4\U000114c5\U00011580\U000115ae\U000115d8" + "\U000115db\U00011600\U0001162f\U00011680\U000116aa\U00011700\U0001171a\U00011740\U00011746\U00011800\U0001182b" + "\U000118a0\U000118df\U000118ff\U00011906\U0001190c\U00011913\U00011915\U00011916\U00011918\U0001192f\U000119a0" + "\U000119a7\U000119aa\U000119d0\U00011a0b\U00011a32\U00011a5c\U00011a89\U00011ab0\U00011af8\U00011bc0\U00011be0" + "\U00011c00\U00011c08\U00011c0a\U00011c2e\U00011c72\U00011c8f\U00011d00\U00011d06\U00011d08\U00011d09\U00011d0b" + "\U00011d30\U00011d60\U00011d65\U00011d67\U00011d68\U00011d6a\U00011d89\U00011ee0\U00011ef2\U00011f04\U00011f10" + "\U00011f12\U00011f33\U00012000\U00012399\U00012400\U0001246e\U00012480\U00012543\U00012f90\U00012ff0\U00013000" + "\U0001342f\U00013441\U00013446\U00013460\U000143fa\U00014400\U00014646\U00016100\U0001611d\U00016800\U00016a38" + "\U00016a40\U00016a5e\U00016a70\U00016abe\U00016ad0\U00016aed\U00016b00\U00016b2f\U00016b40\U00016b43\U00016b63" + "\U00016b77\U00016b7d\U00016b8f\U00016d40\U00016d6c\U00016e40\U00016e7f\U00016f00\U00016f4a\U00016f93\U00016f9f" + "\U00016fe0\U00016fe1\U00017000\U000187f7\U00018800\U00018cd5\U00018cff\U00018d08\U0001aff0\U0001aff3\U0001aff5" + "\U0001affb\U0001affd\U0001affe\U0001b000\U0001b122\U0001b150\U0001b152\U0001b164\U0001b167\U0001b170\U0001b2fb" + "\U0001bc00\U0001bc6a\U0001bc70\U0001bc7c\U0001bc80\U0001bc88\U0001bc90\U0001bc99\U0001d400\U0001d454\U0001d456" + "\U0001d49c\U0001d49e\U0001d49f\U0001d4a5\U0001d4a6\U0001d4a9\U0001d4ac\U0001d4ae\U0001d4b9\U0001d4bd\U0001d4c3" + "\U0001d4c5\U0001d505\U0001d507\U0001d50a\U0001d50d\U0001d514\U0001d516\U0001d51c\U0001d51e\U0001d539\U0001d53b" + "\U0001d53e\U0001d540\U0001d544\U0001d54a\U0001d550\U0001d552\U0001d6a5\U0001d6a8\U0001d6c0\U0001d6c2\U0001d6da" + "\U0001d6dc\U0001d6fa\U0001d6fc\U0001d714\U0001d716\U0001d734\U0001d736\U0001d74e\U0001d750\U0001d76e\U0001d770" + "\U0001d788\U0001d78a\U0001d7a8\U0001d7aa\U0001d7c2\U0001d7c4\U0001d7cb\U0001df00\U0001df1e\U0001df25\U0001df2a" + "\U0001e030\U0001e06d\U0001e100\U0001e12c\U0001e137\U0001e13d\U0001e290\U0001e2ad\U0001e2c0\U0001e2eb\U0001e4d0" + "\U0001e4eb\U0001e5d0\U0001e5ed\U0001e7e0\U0001e7e6\U0001e7e8\U0001e7eb\U0001e7ed\U0001e7ee\U0001e7f0\U0001e7fe" + "\U0001e800\U0001e8c4\U0001e900\U0001e943\U0001ee00\U0001ee03\U0001ee05\U0001ee1f\U0001ee21\U0001ee22\U0001ee29" + "\U0001ee32\U0001ee34\U0001ee37\U0001ee4d\U0001ee4f\U0001ee51\U0001ee52\U0001ee61\U0001ee62\U0001ee67\U0001ee6a" + "\U0001ee6c\U0001ee72\U0001ee74\U0001ee77\U0001ee79\U0001ee7c\U0001ee80\U0001ee89\U0001ee8b\U0001ee9b\U0001eea1" + "\U0001eea3\U0001eea5\U0001eea9\U0001eeab\U0001eebb\U00020000\U0002a6df\U0002a700\U0002b739\U0002b740\U0002b81d" + "\U0002b820\U0002cea1\U0002ceb0\U0002ebe0\U0002ebf0\U0002ee5d\U0002f800\U0002fa1d\U00030000\U0003134a\U00031350" + "\U000323af" +) +unicode_continuation_ch_any = ( + "\u00b7\u0387\u05bf\u05c7\u0670\u0711\u07fd\u09bc\u09d7\u09fe\u0a3c" + "\u0a51\u0a75\u0abc\u0b3c\u0b82\u0bd7\u0c3c\u0cbc\u0cf3\u0d57\u0dca" + "\u0dd6\u0e31\u0eb1\u0f35\u0f37\u0f39\u0fc6\u17dd\u18a9\u1ced\u1cf4" + "\u2054\u20e1\u2d7f\u30fb\ua66f\ua802\ua806\ua80b\ua82c\ua9e5\uaa43" + "\uaab0\uaac1\ufb1e\uff3f\uff65\U000101fd\U000102e0\U00010a3f\U000110c2\U00011173\U0001123e" + "\U00011241\U00011357\U000113c2\U000113c5\U000113d2\U0001145e\U00011940\U000119e4\U00011a47\U00011d3a\U00011d47" + "\U00011f03\U00013440\U00016f4f\U00016fe4\U0001da75\U0001da84\U0001e08f\U0001e2ae" +) +unicode_continuation_ch_range = ( + "\u0030\u0039\u0300\u036f\u0483\u0487\u0591\u05bd\u05c1\u05c2\u05c4" + "\u05c5\u0610\u061a\u064b\u0669\u06d6\u06dc\u06df\u06e4\u06e7\u06e8" + "\u06ea\u06ed\u06f0\u06f9\u0730\u074a\u07a6\u07b0\u07c0\u07c9\u07eb" + "\u07f3\u0816\u0819\u081b\u0823\u0825\u0827\u0829\u082d\u0859\u085b" + "\u0897\u089f\u08ca\u08e1\u08e3\u0903\u093a\u093c\u093e\u094f\u0951" + "\u0957\u0962\u0963\u0966\u096f\u0981\u0983\u09be\u09c4\u09c7\u09c8" + "\u09cb\u09cd\u09e2\u09e3\u09e6\u09ef\u0a01\u0a03\u0a3e\u0a42\u0a47" + "\u0a48\u0a4b\u0a4d\u0a66\u0a71\u0a81\u0a83\u0abe\u0ac5\u0ac7\u0ac9" + "\u0acb\u0acd\u0ae2\u0ae3\u0ae6\u0aef\u0afa\u0aff\u0b01\u0b03\u0b3e" + "\u0b44\u0b47\u0b48\u0b4b\u0b4d\u0b55\u0b57\u0b62\u0b63\u0b66\u0b6f" + "\u0bbe\u0bc2\u0bc6\u0bc8\u0bca\u0bcd\u0be6\u0bef\u0c00\u0c04\u0c3e" + "\u0c44\u0c46\u0c48\u0c4a\u0c4d\u0c55\u0c56\u0c62\u0c63\u0c66\u0c6f" + "\u0c81\u0c83\u0cbe\u0cc4\u0cc6\u0cc8\u0cca\u0ccd\u0cd5\u0cd6\u0ce2" + "\u0ce3\u0ce6\u0cef\u0d00\u0d03\u0d3b\u0d3c\u0d3e\u0d44\u0d46\u0d48" + "\u0d4a\u0d4d\u0d62\u0d63\u0d66\u0d6f\u0d81\u0d83\u0dcf\u0dd4\u0dd8" + "\u0ddf\u0de6\u0def\u0df2\u0df3\u0e33\u0e3a\u0e47\u0e4e\u0e50\u0e59" + "\u0eb3\u0ebc\u0ec8\u0ece\u0ed0\u0ed9\u0f18\u0f19\u0f20\u0f29\u0f3e" + "\u0f3f\u0f71\u0f84\u0f86\u0f87\u0f8d\u0f97\u0f99\u0fbc\u102b\u103e" + "\u1040\u1049\u1056\u1059\u105e\u1060\u1062\u1064\u1067\u106d\u1071" + "\u1074\u1082\u108d\u108f\u109d\u135d\u135f\u1369\u1371\u1712\u1715" + "\u1732\u1734\u1752\u1753\u1772\u1773\u17b4\u17d3\u17e0\u17e9\u180b" + "\u180d\u180f\u1819\u1920\u192b\u1930\u193b\u1946\u194f\u19d0\u19da" + "\u1a17\u1a1b\u1a55\u1a5e\u1a60\u1a7c\u1a7f\u1a89\u1a90\u1a99\u1ab0" + "\u1abd\u1abf\u1ace\u1b00\u1b04\u1b34\u1b44\u1b50\u1b59\u1b6b\u1b73" + "\u1b80\u1b82\u1ba1\u1bad\u1bb0\u1bb9\u1be6\u1bf3\u1c24\u1c37\u1c40" + "\u1c49\u1c50\u1c59\u1cd0\u1cd2\u1cd4\u1ce8\u1cf7\u1cf9\u1dc0\u1dff" + "\u200c\u200d\u203f\u2040\u20d0\u20dc\u20e5\u20f0\u2cef\u2cf1\u2de0" + "\u2dff\u302a\u302f\u3099\u309a\ua620\ua629\ua674\ua67d\ua69e\ua69f" + "\ua6f0\ua6f1\ua823\ua827\ua880\ua881\ua8b4\ua8c5\ua8d0\ua8d9\ua8e0" + "\ua8f1\ua8ff\ua909\ua926\ua92d\ua947\ua953\ua980\ua983\ua9b3\ua9c0" + "\ua9d0\ua9d9\ua9f0\ua9f9\uaa29\uaa36\uaa4c\uaa4d\uaa50\uaa59\uaa7b" + "\uaa7d\uaab2\uaab4\uaab7\uaab8\uaabe\uaabf\uaaeb\uaaef\uaaf5\uaaf6" + "\uabe3\uabea\uabec\uabed\uabf0\uabf9\ufe00\ufe0f\ufe20\ufe2f\ufe33" + "\ufe34\ufe4d\ufe4f\uff10\uff19\uff9e\uff9f\U00010376\U0001037a\U000104a0\U000104a9" + "\U00010a01\U00010a03\U00010a05\U00010a06\U00010a0c\U00010a0f\U00010a38\U00010a3a\U00010ae5\U00010ae6\U00010d24" + "\U00010d27\U00010d30\U00010d39\U00010d40\U00010d49\U00010d69\U00010d6d\U00010eab\U00010eac\U00010efc\U00010eff" + "\U00010f46\U00010f50\U00010f82\U00010f85\U00011000\U00011002\U00011038\U00011046\U00011066\U00011070\U00011073" + "\U00011074\U0001107f\U00011082\U000110b0\U000110ba\U000110f0\U000110f9\U00011100\U00011102\U00011127\U00011134" + "\U00011136\U0001113f\U00011145\U00011146\U00011180\U00011182\U000111b3\U000111c0\U000111c9\U000111cc\U000111ce" + "\U000111d9\U0001122c\U00011237\U000112df\U000112ea\U000112f0\U000112f9\U00011300\U00011303\U0001133b\U0001133c" + "\U0001133e\U00011344\U00011347\U00011348\U0001134b\U0001134d\U00011362\U00011363\U00011366\U0001136c\U00011370" + "\U00011374\U000113b8\U000113c0\U000113c7\U000113ca\U000113cc\U000113d0\U000113e1\U000113e2\U00011435\U00011446" + "\U00011450\U00011459\U000114b0\U000114c3\U000114d0\U000114d9\U000115af\U000115b5\U000115b8\U000115c0\U000115dc" + "\U000115dd\U00011630\U00011640\U00011650\U00011659\U000116ab\U000116b7\U000116c0\U000116c9\U000116d0\U000116e3" + "\U0001171d\U0001172b\U00011730\U00011739\U0001182c\U0001183a\U000118e0\U000118e9\U00011930\U00011935\U00011937" + "\U00011938\U0001193b\U0001193e\U00011942\U00011943\U00011950\U00011959\U000119d1\U000119d7\U000119da\U000119e0" + "\U00011a01\U00011a0a\U00011a33\U00011a39\U00011a3b\U00011a3e\U00011a51\U00011a5b\U00011a8a\U00011a99\U00011bf0" + "\U00011bf9\U00011c2f\U00011c36\U00011c38\U00011c3f\U00011c50\U00011c59\U00011c92\U00011ca7\U00011ca9\U00011cb6" + "\U00011d31\U00011d36\U00011d3c\U00011d3d\U00011d3f\U00011d45\U00011d50\U00011d59\U00011d8a\U00011d8e\U00011d90" + "\U00011d91\U00011d93\U00011d97\U00011da0\U00011da9\U00011ef3\U00011ef6\U00011f00\U00011f01\U00011f34\U00011f3a" + "\U00011f3e\U00011f42\U00011f50\U00011f5a\U00013447\U00013455\U0001611e\U00016139\U00016a60\U00016a69\U00016ac0" + "\U00016ac9\U00016af0\U00016af4\U00016b30\U00016b36\U00016b50\U00016b59\U00016d70\U00016d79\U00016f51\U00016f87" + "\U00016f8f\U00016f92\U00016ff0\U00016ff1\U0001bc9d\U0001bc9e\U0001ccf0\U0001ccf9\U0001cf00\U0001cf2d\U0001cf30" + "\U0001cf46\U0001d165\U0001d169\U0001d16d\U0001d172\U0001d17b\U0001d182\U0001d185\U0001d18b\U0001d1aa\U0001d1ad" + "\U0001d242\U0001d244\U0001d7ce\U0001d7ff\U0001da00\U0001da36\U0001da3b\U0001da6c\U0001da9b\U0001da9f\U0001daa1" + "\U0001daaf\U0001e000\U0001e006\U0001e008\U0001e018\U0001e01b\U0001e021\U0001e023\U0001e024\U0001e026\U0001e02a" + "\U0001e130\U0001e136\U0001e140\U0001e149\U0001e2ec\U0001e2f9\U0001e4ec\U0001e4f9\U0001e5ee\U0001e5ef\U0001e5f1" + "\U0001e5fa\U0001e8d0\U0001e8d6\U0001e944\U0001e94a\U0001e950\U0001e959\U0001fbf0\U0001fbf9\U000e0100\U000e01ef" +) + +# END GENERATED CODE diff --git a/venv/lib/python3.10/site-packages/Cython/Compiler/LineTable.cpython-310-x86_64-linux-gnu.so b/venv/lib/python3.10/site-packages/Cython/Compiler/LineTable.cpython-310-x86_64-linux-gnu.so new file mode 100644 index 0000000000000000000000000000000000000000..22b76820075bee21762cea0ed1a96d357fc2ded1 Binary files /dev/null and b/venv/lib/python3.10/site-packages/Cython/Compiler/LineTable.cpython-310-x86_64-linux-gnu.so differ diff --git a/venv/lib/python3.10/site-packages/Cython/Compiler/LineTable.py b/venv/lib/python3.10/site-packages/Cython/Compiler/LineTable.py new file mode 100644 index 0000000000000000000000000000000000000000..5378cfa4561a064592a2c0aac2cd79d11132ac14 --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Compiler/LineTable.py @@ -0,0 +1,114 @@ +""" +Build a line table for CodeObjects, according to PEP-626 / Python 3.11. + +See https://github.com/python/cpython/blob/1054a755a3016f95fcd24b3ad20e8ed9048b7939/InternalDocs/locations.md +See https://github.com/python/cpython/blob/1054a755a3016f95fcd24b3ad20e8ed9048b7939/Python/assemble.c#L192 +""" + +import cython + + +def build_line_table(positions, firstlineno): + # positions is a list of four-tuples (start_lineno, end_lineno, start_col_offset, end_col_offset) + table_bytes = [] + last_lineno = firstlineno + for position_info in positions: + last_lineno = encode_single_position(table_bytes, position_info, last_lineno) + linetable = ''.join(table_bytes) + + """ + # Hacky debug helper code for the line table generation. + code_obj = build_line_table.__code__.replace(co_linetable=linetable.encode('latin1'), co_firstlineno=firstlineno) + print() + print(repr(linetable)) + print(positions) + print(list(code_obj.co_positions())) + """ + + return linetable + + +@cython.cfunc +def encode_single_position(table_bytes: list, position_info: tuple, last_lineno: cython.int) -> cython.int: + start_lineno: cython.int + end_lineno: cython.int + start_column: cython.int + end_column: cython.int + + start_lineno, end_lineno, start_column, end_column = position_info + assert start_lineno >= last_lineno, f"{start_lineno} >= {last_lineno}" # positions should be sorted + + last_lineno_delta: cython.int = start_lineno - last_lineno + + if end_lineno == start_lineno: + # All in one line, can try short forms. + if last_lineno_delta == 0 and start_column < 80 and 0 <= (end_column - start_column) < 16: + # Short format (code 0-9): still on same line, small column offset + encode_location_short(table_bytes, start_column, end_column) + return end_lineno + elif 0 <= last_lineno_delta < 3 and start_column < 128 and end_column < 128: + # One line format (code 10-12): small line offsets / larger column offsets + encode_location_oneline(table_bytes, last_lineno_delta, start_column, end_column) + return end_lineno + + # Store in long format (code 14) + encode_location_start(table_bytes, 14) + # Since we sort positions, negative line deltas should never occur ==> inline encode_varint_signed() + encode_varint(table_bytes, last_lineno_delta << 1) + encode_varint(table_bytes, end_lineno - start_lineno) + encode_varint(table_bytes, start_column + 1) + encode_varint(table_bytes, end_column + 1) + return end_lineno + + +@cython.exceptval(-1, check=False) +@cython.cfunc +def encode_location_start(table_bytes: list, code: cython.int) -> cython.int: + # "Instruction" size is always 1 + # 128 | (code << 3) | (length - 1) + table_bytes.append(chr(128 | (code << 3))) + return 0 + + +@cython.exceptval(-1, check=False) +@cython.cfunc +def encode_location_short(table_bytes: list, start_column: cython.int, end_column: cython.int) -> cython.int: + low_bits: cython.int = start_column & 7 + code: cython.int = start_column >> 3 + # inlined encode_location_start() + table_bytes.append(f"{128 | (code << 3):c}{(low_bits << 4) | (end_column - start_column):c}") + return 0 + + +@cython.exceptval(-1, check=False) +@cython.cfunc +def encode_location_oneline(table_bytes: list, line_delta: cython.int, start_column: cython.int, end_column: cython.int) -> cython.int: + code: cython.int = 10 + line_delta + # inlined encode_location_start() + table_bytes.append(f"{128 | (code << 3):c}{start_column:c}{end_column:c}") + return 0 + + +""" +# Since we sort positions, negative line deltas should not occur. +@cython.cfunc +def encode_varint_signed(table_bytes: list, value: cython.int) -> cython.int: + # (unsigned int)(-val) has undefined behavior for INT_MIN + uval: cython.uint = cython.cast(cython.uint, value) if cython.compiled else value + if value < 0: + uval = ((0 - uval) << 1) | 1 + else: + uval = uval << 1 + encode_varint(table_bytes, uval) +""" + + +@cython.exceptval(-1, check=False) +@cython.cfunc +def encode_varint(table_bytes: list, value: cython.uint) -> cython.int: + assert value > 0 or value == 0 + while value >= 64: + table_bytes.append(chr(64 | (value & 63))) + value >>= 6 + table_bytes.append(chr(value)) + return 0 diff --git a/venv/lib/python3.10/site-packages/Cython/Compiler/Main.py b/venv/lib/python3.10/site-packages/Cython/Compiler/Main.py new file mode 100644 index 0000000000000000000000000000000000000000..d54aa10b4fdb65fb05d9115b40e6931cb10b1cec --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Compiler/Main.py @@ -0,0 +1,853 @@ +# +# Cython Top Level +# + + +import os +import re +import sys +import io + +if sys.version_info[:2] < (3, 8): + sys.stderr.write("Sorry, Cython requires Python 3.8+, found %d.%d\n" % tuple(sys.version_info[:2])) + sys.exit(1) + +# Do not import Parsing here, import it when needed, because Parsing imports +# Nodes, which globally needs debug command line options initialized to set a +# conditional metaclass. These options are processed by CmdLine called from +# main() in this file. +# import Parsing +from . import Errors +from .StringEncoding import EncodedString +from .Scanning import PyrexScanner, FileSourceDescriptor +from .Errors import PyrexError, CompileError, error, warning +from .Symtab import ModuleScope +from .. import Utils +from . import Options +from .Options import CompilationOptions, default_options +from .CmdLine import parse_command_line +from .Lexicon import (unicode_start_ch_any, unicode_continuation_ch_any, + unicode_start_ch_range, unicode_continuation_ch_range) + + +def _make_range_re(chrs): + out = [] + for i in range(0, len(chrs), 2): + out.append("{}-{}".format(chrs[i], chrs[i+1])) + return "".join(out) + +# py2 version looked like r"[A-Za-z_][A-Za-z0-9_]*(\.[A-Za-z_][A-Za-z0-9_]*)*$" +module_name_pattern = "[{0}{1}][{0}{2}{1}{3}]*".format( + unicode_start_ch_any, _make_range_re(unicode_start_ch_range), + unicode_continuation_ch_any, + _make_range_re(unicode_continuation_ch_range)) +module_name_pattern = re.compile("{0}(\\.{0})*$".format(module_name_pattern)) + + +standard_include_path = os.path.abspath( + os.path.join(os.path.dirname(os.path.dirname(__file__)), 'Includes')) + + +class Context: + # This class encapsulates the context needed for compiling + # one or more Cython implementation files along with their + # associated and imported declaration files. It includes + # the root of the module import namespace and the list + # of directories to search for include files. + # + # modules {string : ModuleScope} + # include_directories [string] + # future_directives [object] + # language_level int currently 2 or 3 for Python 2/3 + + cython_scope = None + language_level = None # warn when not set but default to Py2 + + def __init__(self, include_directories, compiler_directives, cpp=False, + language_level=None, options=None): + # cython_scope is a hack, set to False by subclasses, in order to break + # an infinite loop. + # Better code organization would fix it. + + from . import Builtin, CythonScope + self.modules = {"__builtin__" : Builtin.builtin_scope} + self.cython_scope = CythonScope.create_cython_scope(self) + self.modules["cython"] = self.cython_scope + self.include_directories = include_directories + self.future_directives = set() + self.compiler_directives = compiler_directives + self.cpp = cpp + self.options = options + + self.pxds = {} # full name -> node tree + self.utility_pxds = {} # pxd name -> node tree + self._interned = {} # (type(value), value, *key_args) -> interned_value + + if language_level is not None: + self.set_language_level(language_level) + + self.legacy_implicit_noexcept = self.compiler_directives.get('legacy_implicit_noexcept', False) + + self.gdb_debug_outputwriter = None + + @classmethod + def from_options(cls, options): + return cls(options.include_path, options.compiler_directives, + options.cplus, options.language_level, options=options) + + @property + def shared_utility_qualified_name(self): + return self.options.shared_utility_qualified_name if self.options else None + + def set_language_level(self, level): + from .Future import print_function, unicode_literals, absolute_import, division, generator_stop + future_directives = set() + if level == '3str': + level = 3 + else: + level = int(level) + if level >= 3: + future_directives.update([unicode_literals, print_function, absolute_import, division, generator_stop]) + self.language_level = level + self.future_directives = future_directives + if level >= 3: + self.modules['builtins'] = self.modules['__builtin__'] + + def intern_ustring(self, value, encoding=None): + key = (EncodedString, value, encoding) + try: + return self._interned[key] + except KeyError: + pass + value = EncodedString(value) + if encoding: + value.encoding = encoding + self._interned[key] = value + return value + + # pipeline creation functions can now be found in Pipeline.py + + def process_pxd(self, source_desc, scope, module_name): + from . import Pipeline + if isinstance(source_desc, FileSourceDescriptor) and source_desc._file_type == 'pyx': + source = CompilationSource(source_desc, module_name, os.getcwd()) + result_sink = create_default_resultobj(source, self.options) + pipeline = Pipeline.create_pyx_as_pxd_pipeline(self, result_sink) + result = Pipeline.run_pipeline(pipeline, source) + elif source_desc.in_utility_code: + from . import ParseTreeTransforms + transform = ParseTreeTransforms.CnameDirectivesTransform(self) + pipeline = Pipeline.create_pxd_pipeline(self, scope, module_name) + pipeline = Pipeline.insert_into_pipeline( + pipeline, transform, + before=ParseTreeTransforms.InterpretCompilerDirectives) + result = Pipeline.run_pipeline(pipeline, source_desc) + else: + pipeline = Pipeline.create_pxd_pipeline(self, scope, module_name) + result = Pipeline.run_pipeline(pipeline, source_desc) + return result + + def nonfatal_error(self, exc): + return Errors.report_error(exc) + + def _split_qualified_name(self, qualified_name, relative_import=False): + # Splits qualified_name into parts in form of 2-tuples: (PART_NAME, IS_PACKAGE). + qualified_name_parts = qualified_name.split('.') + last_part = qualified_name_parts.pop() + qualified_name_parts = [(p, True) for p in qualified_name_parts] + if last_part != '__init__': + # If Last part is __init__, then it is omitted. Otherwise, we need to check whether we can find + # __init__.pyx/__init__.py file to determine if last part is package or not. + is_package = False + for suffix in ('.py', '.pyx'): + path = self.search_include_directories( + qualified_name, suffix=suffix, source_pos=None, source_file_path=None, sys_path=not relative_import) + if path: + is_package = self._is_init_file(path) + break + + qualified_name_parts.append((last_part, is_package)) + return qualified_name_parts + + @staticmethod + def _is_init_file(path): + return os.path.basename(path) in ('__init__.pyx', '__init__.py', '__init__.pxd') if path else False + + @staticmethod + def _check_pxd_filename(pos, pxd_pathname, qualified_name): + if not pxd_pathname: + return + pxd_filename = os.path.basename(pxd_pathname) + if '.' in qualified_name and qualified_name == os.path.splitext(pxd_filename)[0]: + warning(pos, "Dotted filenames ('%s') are deprecated." + " Please use the normal Python package directory layout." % pxd_filename, level=1) + + def find_module(self, module_name, from_module=None, pos=None, need_pxd=1, + absolute_fallback=True, relative_import=False): + # Finds and returns the module scope corresponding to + # the given relative or absolute module name. If this + # is the first time the module has been requested, finds + # the corresponding .pxd file and process it. + # If from_module is not None, it must be a module scope, + # and the module will first be searched for relative to + # that module, provided its name is not a dotted name. + debug_find_module = 0 + if debug_find_module: + print("Context.find_module: module_name = %s, from_module = %s, pos = %s, need_pxd = %s" % ( + module_name, from_module, pos, need_pxd)) + + scope = None + pxd_pathname = None + if from_module: + if module_name: + # from .module import ... + qualified_name = from_module.qualify_name(module_name) + else: + # from . import ... + qualified_name = from_module.qualified_name + scope = from_module + from_module = None + else: + qualified_name = module_name + + if not module_name_pattern.match(qualified_name): + raise CompileError(pos or (module_name, 0, 0), + "'%s' is not a valid module name" % module_name) + + if from_module: + if debug_find_module: + print("...trying relative import") + scope = from_module.lookup_submodule(module_name) + if not scope: + pxd_pathname = self.find_pxd_file(qualified_name, pos, sys_path=not relative_import) + self._check_pxd_filename(pos, pxd_pathname, qualified_name) + if pxd_pathname: + is_package = self._is_init_file(pxd_pathname) + scope = from_module.find_submodule(module_name, as_package=is_package) + if not scope: + if debug_find_module: + print("...trying absolute import") + if absolute_fallback: + qualified_name = module_name + scope = self + for name, is_package in self._split_qualified_name(qualified_name, relative_import=relative_import): + scope = scope.find_submodule(name, as_package=is_package) + if debug_find_module: + print("...scope = %s" % scope) + if not scope.pxd_file_loaded: + if debug_find_module: + print("...pxd not loaded") + if not pxd_pathname: + if debug_find_module: + print("...looking for pxd file") + # Only look in sys.path if we are explicitly looking + # for a .pxd file. + pxd_pathname = self.find_pxd_file(qualified_name, pos, sys_path=need_pxd and not relative_import) + self._check_pxd_filename(pos, pxd_pathname, qualified_name) + if debug_find_module: + print("......found %s" % pxd_pathname) + if not pxd_pathname and need_pxd: + # Set pxd_file_loaded such that we don't need to + # look for the non-existing pxd file next time. + scope.pxd_file_loaded = True + package_pathname = self.search_include_directories( + qualified_name, suffix=".py", source_pos=pos, sys_path=not relative_import) + if package_pathname and package_pathname.endswith(Utils.PACKAGE_FILES): + pass + else: + error(pos, "'%s.pxd' not found" % qualified_name.replace('.', os.sep)) + if pxd_pathname: + scope.pxd_file_loaded = True + try: + if debug_find_module: + print("Context.find_module: Parsing %s" % pxd_pathname) + rel_path = module_name.replace('.', os.sep) + os.path.splitext(pxd_pathname)[1] + if not pxd_pathname.endswith(rel_path): + rel_path = pxd_pathname # safety measure to prevent printing incorrect paths + source_desc = FileSourceDescriptor(pxd_pathname, rel_path) + err, result = self.process_pxd(source_desc, scope, qualified_name) + if err: + raise err + (pxd_codenodes, pxd_scope) = result + self.pxds[module_name] = (pxd_codenodes, pxd_scope) + except CompileError: + pass + return scope + + def find_pxd_file(self, qualified_name, pos=None, sys_path=True, source_file_path=None): + # Search include path (and sys.path if sys_path is True) for + # the .pxd file corresponding to the given fully-qualified + # module name. + # Will find either a dotted filename or a file in a + # package directory. If a source file position is given, + # the directory containing the source file is searched first + # for a dotted filename, and its containing package root + # directory is searched first for a non-dotted filename. + pxd = self.search_include_directories( + qualified_name, suffix=".pxd", source_pos=pos, sys_path=sys_path, source_file_path=source_file_path) + if pxd is None and Options.cimport_from_pyx: + return self.find_pyx_file(qualified_name, pos, sys_path=sys_path) + return pxd + + def find_pyx_file(self, qualified_name, pos=None, sys_path=True, source_file_path=None): + # Search include path for the .pyx file corresponding to the + # given fully-qualified module name, as for find_pxd_file(). + return self.search_include_directories( + qualified_name, suffix=".pyx", source_pos=pos, sys_path=sys_path, source_file_path=source_file_path) + + def find_include_file(self, filename, pos=None, source_file_path=None): + # Search list of include directories for filename. + # Reports an error and returns None if not found. + path = self.search_include_directories( + filename, source_pos=pos, include=True, source_file_path=source_file_path) + if not path: + error(pos, "'%s' not found" % filename) + return path + + def search_include_directories(self, qualified_name, + suffix=None, source_pos=None, include=False, sys_path=False, source_file_path=None): + include_dirs = self.include_directories + if sys_path: + include_dirs = include_dirs + sys.path + # include_dirs must be hashable for caching in @cached_function + include_dirs = tuple(include_dirs + [standard_include_path]) + return search_include_directories( + include_dirs, qualified_name, suffix or "", source_pos, include, source_file_path) + + def find_root_package_dir(self, file_path): + return Utils.find_root_package_dir(file_path) + + def check_package_dir(self, dir, package_names): + return Utils.check_package_dir(dir, tuple(package_names)) + + def c_file_out_of_date(self, source_path, output_path): + if not os.path.exists(output_path): + return 1 + c_time = Utils.modification_time(output_path) + if Utils.file_newer_than(source_path, c_time): + return 1 + pxd_path = Utils.replace_suffix(source_path, ".pxd") + if os.path.exists(pxd_path) and Utils.file_newer_than(pxd_path, c_time): + return 1 + for kind, name in self.read_dependency_file(source_path): + if kind == "cimport": + dep_path = self.find_pxd_file(name, source_file_path=source_path) + elif kind == "include": + dep_path = self.search_include_directories(name, source_file_path=source_path) + else: + continue + if dep_path and Utils.file_newer_than(dep_path, c_time): + return 1 + return 0 + + def find_cimported_module_names(self, source_path): + return [ name for kind, name in self.read_dependency_file(source_path) + if kind == "cimport" ] + + def is_package_dir(self, dir_path): + return Utils.is_package_dir(dir_path) + + def read_dependency_file(self, source_path): + dep_path = Utils.replace_suffix(source_path, ".dep") + if os.path.exists(dep_path): + with open(dep_path) as f: + chunks = [ line.split(" ", 1) + for line in (l.strip() for l in f) + if " " in line ] + return chunks + else: + return () + + def lookup_submodule(self, name): + # Look up a top-level module. Returns None if not found. + return self.modules.get(name, None) + + def find_submodule(self, name, as_package=False): + # Find a top-level module, creating a new one if needed. + scope = self.lookup_submodule(name) + if not scope: + scope = ModuleScope(name, + parent_module = None, context = self, is_package=as_package) + self.modules[name] = scope + return scope + + def parse(self, source_desc, scope, pxd, full_module_name): + if not isinstance(source_desc, FileSourceDescriptor): + raise RuntimeError("Only file sources for code supported") + scope.cpp = self.cpp + # Parse the given source file and return a parse tree. + num_errors = Errors.get_errors_count() + try: + with source_desc.get_file_object() as f: + from . import Parsing + s = PyrexScanner(f, source_desc, source_encoding = f.encoding, + scope = scope, context = self) + tree = Parsing.p_module(s, pxd, full_module_name) + if self.options.formal_grammar: + try: + from ..Parser import ConcreteSyntaxTree + except ImportError: + raise RuntimeError( + "Formal grammar can only be used with compiled Cython with an available pgen.") + ConcreteSyntaxTree.p_module(source_desc.filename) + except UnicodeDecodeError as e: + #import traceback + #traceback.print_exc() + raise self._report_decode_error(source_desc, e) + + if Errors.get_errors_count() > num_errors: + raise CompileError() + return tree + + def _report_decode_error(self, source_desc, exc): + msg = exc.args[-1] + position = exc.args[2] + encoding = exc.args[0] + + line = 1 + column = idx = 0 + with open(source_desc.filename, encoding='iso8859-1', newline='') as f: + for line, data in enumerate(f, 1): + idx += len(data) + if idx >= position: + column = position - (idx - len(data)) + 1 + break + + return error((source_desc, line, column), + "Decoding error, missing or incorrect coding= " + "at top of source (cannot decode with encoding %r: %s)" % (encoding, msg)) + + def extract_module_name(self, path, options): + # Find fully_qualified module name from the full pathname + # of a source file. + dir, filename = os.path.split(path) + module_name, _ = os.path.splitext(filename) + if "." in module_name: + return module_name + names = [module_name] + while self.is_package_dir(dir): + parent, package_name = os.path.split(dir) + if parent == dir: + break + names.append(package_name) + dir = parent + names.reverse() + return ".".join(names) + + def setup_errors(self, options, result): + Errors.init_thread() + if options.use_listing_file: + path = result.listing_file = Utils.replace_suffix(result.main_source_file, ".lis") + else: + path = None + Errors.open_listing_file(path=path, echo_to_stderr=options.errors_to_stderr) + + def teardown_errors(self, err, options, result): + source_desc = result.compilation_source.source_desc + if not isinstance(source_desc, FileSourceDescriptor): + raise RuntimeError("Only file sources for code supported") + Errors.close_listing_file() + result.num_errors = Errors.get_errors_count() + if result.num_errors > 0: + err = True + if err and result.c_file: + try: + Utils.castrate_file(result.c_file, os.stat(source_desc.filename)) + except OSError: + pass + result.c_file = None + + +def get_output_filename(source_filename, cwd, options): + if options.cplus: + c_suffix = ".cpp" + else: + c_suffix = ".c" + suggested_file_name = Utils.replace_suffix(source_filename, c_suffix) + if options.output_file: + out_path = os.path.join(cwd, options.output_file) + if os.path.isdir(out_path): + return os.path.join(out_path, os.path.basename(suggested_file_name)) + else: + return out_path + else: + return suggested_file_name + + +def create_default_resultobj(compilation_source, options): + result = CompilationResult() + result.main_source_file = compilation_source.source_desc.filename + result.compilation_source = compilation_source + source_desc = compilation_source.source_desc + result.c_file = get_output_filename(source_desc.filename, + compilation_source.cwd, options) + result.embedded_metadata = options.embedded_metadata + return result + + +def setup_source_object(source, source_ext, full_module_name, options, context): + cwd = os.getcwd() + abs_path = os.path.abspath(source) + + full_module_name = full_module_name or context.extract_module_name(source, options) + full_module_name = EncodedString(full_module_name) + + Utils.raise_error_if_module_name_forbidden(full_module_name) + if options.relative_path_in_code_position_comments: + rel_path = full_module_name.replace('.', os.sep) + source_ext + if not abs_path.endswith(rel_path): + rel_path = source # safety measure to prevent printing incorrect paths + else: + rel_path = abs_path + source_desc = FileSourceDescriptor(abs_path, rel_path) + return CompilationSource(source_desc, full_module_name, cwd) + + +def run_cached_pipeline(source, options, full_module_name, context, cache, fingerprint): + cwd = os.getcwd() + output_filename = get_output_filename(source, cwd, options) + cached = cache.lookup_cache(output_filename, fingerprint) + if cached: + cache.load_from_cache(output_filename, cached) + + source_ext = os.path.splitext(source)[1] + options.configure_language_defaults(source_ext[1:]) # py/pyx + + source = setup_source_object(source, source_ext, full_module_name, options, context) + # Set up result object + return create_default_resultobj(source, options) + + result = run_pipeline(source, options, full_module_name, context) + if fingerprint: + cache.store_to_cache(output_filename, fingerprint, result) + return result + + +def run_pipeline(source, options, full_module_name, context): + from . import Pipeline + if options.verbose: + sys.stderr.write("Compiling %s\n" % source) + source_ext = os.path.splitext(source)[1] + abs_path = os.path.abspath(source) + options.configure_language_defaults(source_ext[1:]) # py/pyx + + source = setup_source_object(source, source_ext, full_module_name, options, context) + # Set up result object + result = create_default_resultobj(source, options) + + if options.annotate is None: + # By default, decide based on whether an html file already exists. + html_filename = os.path.splitext(result.c_file)[0] + ".html" + if os.path.exists(html_filename): + with open(html_filename, encoding="UTF-8") as html_file: + if ' State %d\n" % (key, state['number'])) + for key in ('bol', 'eol', 'eof', 'else'): + state = special_to_state.get(key) + if state: + file.write(" %s --> State %d\n" % (key, state['number'])) + + def chars_to_ranges(self, char_list: list) -> tuple: + char_list.sort() + + c1: cython.Py_ssize_t + c2: cython.Py_ssize_t + i: cython.Py_ssize_t = 0 + n: cython.Py_ssize_t = len(char_list) + result = [] + while i < n: + c1 = ord(char_list[i]) + c2 = c1 + i += 1 + while i < n and ord(char_list[i]) == c2 + 1: + i += 1 + c2 += 1 + result.append((chr(c1), chr(c2))) + return tuple(result) + + def ranges_to_string(self, range_list) -> str: + return ','.join(map(self.range_to_string, range_list)) + + def range_to_string(self, range_tuple: tuple): + (c1, c2) = range_tuple + if c1 == c2: + return repr(c1) + else: + return f"{c1!r}..{c2!r}" diff --git a/venv/lib/python3.10/site-packages/Cython/Plex/Regexps.py b/venv/lib/python3.10/site-packages/Cython/Plex/Regexps.py new file mode 100644 index 0000000000000000000000000000000000000000..cda201484bb0951c64950fa2e96c788ec64853b9 --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Plex/Regexps.py @@ -0,0 +1,539 @@ +""" +Python Lexical Analyser + +Regular Expressions +""" + +import types + +from . import Errors + +maxint = 2**31-1 # sentinel value + +# +# Constants +# + +BOL = 'bol' +EOL = 'eol' +EOF = 'eof' + +nl_code = ord('\n') + + +# +# Helper functions +# + +def chars_to_ranges(s): + """ + Return a list of character codes consisting of pairs + [code1a, code1b, code2a, code2b,...] which cover all + the characters in |s|. + """ + char_list = list(s) + char_list.sort() + i = 0 + n = len(char_list) + result = [] + while i < n: + code1 = ord(char_list[i]) + code2 = code1 + 1 + i += 1 + while i < n and code2 >= ord(char_list[i]): + code2 += 1 + i += 1 + result.append(code1) + result.append(code2) + return result + + +def uppercase_range(code1, code2): + """ + If the range of characters from code1 to code2-1 includes any + lower case letters, return the corresponding upper case range. + """ + code3 = max(code1, ord('a')) + code4 = min(code2, ord('z') + 1) + if code3 < code4: + d = ord('A') - ord('a') + return (code3 + d, code4 + d) + else: + return None + + +def lowercase_range(code1, code2): + """ + If the range of characters from code1 to code2-1 includes any + upper case letters, return the corresponding lower case range. + """ + code3 = max(code1, ord('A')) + code4 = min(code2, ord('Z') + 1) + if code3 < code4: + d = ord('a') - ord('A') + return (code3 + d, code4 + d) + else: + return None + + +def CodeRanges(code_list): + """ + Given a list of codes as returned by chars_to_ranges, return + an RE which will match a character in any of the ranges. + """ + re_list = [CodeRange(code_list[i], code_list[i + 1]) for i in range(0, len(code_list), 2)] + return Alt(*re_list) + + +def CodeRange(code1, code2): + """ + CodeRange(code1, code2) is an RE which matches any character + with a code |c| in the range |code1| <= |c| < |code2|. + """ + if code1 <= nl_code < code2: + return Alt(RawCodeRange(code1, nl_code), + RawNewline, + RawCodeRange(nl_code + 1, code2)) + else: + return RawCodeRange(code1, code2) + + +# +# Abstract classes +# + +class RE: + """RE is the base class for regular expression constructors. + The following operators are defined on REs: + + re1 + re2 is an RE which matches |re1| followed by |re2| + re1 | re2 is an RE which matches either |re1| or |re2| + """ + + nullable = 1 # True if this RE can match 0 input symbols + match_nl = 1 # True if this RE can match a string ending with '\n' + str = None # Set to a string to override the class's __str__ result + + def build_machine(self, machine, initial_state, final_state, + match_bol, nocase): + """ + This method should add states to |machine| to implement this + RE, starting at |initial_state| and ending at |final_state|. + If |match_bol| is true, the RE must be able to match at the + beginning of a line. If nocase is true, upper and lower case + letters should be treated as equivalent. + """ + raise NotImplementedError("%s.build_machine not implemented" % + self.__class__.__name__) + + def build_opt(self, m, initial_state, c): + """ + Given a state |s| of machine |m|, return a new state + reachable from |s| on character |c| or epsilon. + """ + s = m.new_state() + initial_state.link_to(s) + initial_state.add_transition(c, s) + return s + + def __add__(self, other): + return Seq(self, other) + + def __or__(self, other): + return Alt(self, other) + + def __str__(self): + if self.str: + return self.str + else: + return self.calc_str() + + def check_re(self, num, value): + if not isinstance(value, RE): + self.wrong_type(num, value, "Plex.RE instance") + + def check_string(self, num, value): + if type(value) is not str: + self.wrong_type(num, value, "string") + + def check_char(self, num, value): + self.check_string(num, value) + if len(value) != 1: + raise Errors.PlexValueError("Invalid value for argument %d of Plex.%s." + "Expected a string of length 1, got: %s" % ( + num, self.__class__.__name__, repr(value))) + + def wrong_type(self, num, value, expected): + if type(value) == types.InstanceType: + got = "%s.%s instance" % ( + value.__class__.__module__, value.__class__.__name__) + else: + got = type(value).__name__ + raise Errors.PlexTypeError("Invalid type for argument %d of Plex.%s " + "(expected %s, got %s" % ( + num, self.__class__.__name__, expected, got)) + +# +# Primitive RE constructors +# ------------------------- +# +# These are the basic REs from which all others are built. +# + + +def Char(c): + """ + Char(c) is an RE which matches the character |c|. + """ + if len(c) == 1: + result = CodeRange(ord(c), ord(c) + 1) + else: + result = SpecialSymbol(c) + result.str = "Char(%s)" % repr(c) + return result + + +class RawCodeRange(RE): + """ + RawCodeRange(code1, code2) is a low-level RE which matches any character + with a code |c| in the range |code1| <= |c| < |code2|, where the range + does not include newline. For internal use only. + """ + nullable = 0 + match_nl = 0 + range = None # (code, code) + uppercase_range = None # (code, code) or None + lowercase_range = None # (code, code) or None + + def __init__(self, code1, code2): + self.range = (code1, code2) + self.uppercase_range = uppercase_range(code1, code2) + self.lowercase_range = lowercase_range(code1, code2) + + def build_machine(self, m, initial_state, final_state, match_bol, nocase): + if match_bol: + initial_state = self.build_opt(m, initial_state, BOL) + initial_state.add_transition(self.range, final_state) + if nocase: + if self.uppercase_range: + initial_state.add_transition(self.uppercase_range, final_state) + if self.lowercase_range: + initial_state.add_transition(self.lowercase_range, final_state) + + def calc_str(self): + return "CodeRange(%d,%d)" % (self.code1, self.code2) + + +class _RawNewline(RE): + """ + RawNewline is a low-level RE which matches a newline character. + For internal use only. + """ + nullable = 0 + match_nl = 1 + + def build_machine(self, m, initial_state, final_state, match_bol, nocase): + if match_bol: + initial_state = self.build_opt(m, initial_state, BOL) + s = self.build_opt(m, initial_state, EOL) + s.add_transition((nl_code, nl_code + 1), final_state) + + +RawNewline = _RawNewline() + + +class SpecialSymbol(RE): + """ + SpecialSymbol(sym) is an RE which matches the special input + symbol |sym|, which is one of BOL, EOL or EOF. + """ + nullable = 0 + match_nl = 0 + sym = None + + def __init__(self, sym): + self.sym = sym + + def build_machine(self, m, initial_state, final_state, match_bol, nocase): + # Sequences 'bol bol' and 'bol eof' are impossible, so only need + # to allow for bol if sym is eol + if match_bol and self.sym == EOL: + initial_state = self.build_opt(m, initial_state, BOL) + initial_state.add_transition(self.sym, final_state) + + +class Seq(RE): + """Seq(re1, re2, re3...) is an RE which matches |re1| followed by + |re2| followed by |re3|...""" + + def __init__(self, *re_list): + nullable = 1 + for i, re in enumerate(re_list): + self.check_re(i, re) + nullable = nullable and re.nullable + self.re_list = re_list + self.nullable = nullable + i = len(re_list) + match_nl = 0 + while i: + i -= 1 + re = re_list[i] + if re.match_nl: + match_nl = 1 + break + if not re.nullable: + break + self.match_nl = match_nl + + def build_machine(self, m, initial_state, final_state, match_bol, nocase): + re_list = self.re_list + if len(re_list) == 0: + initial_state.link_to(final_state) + else: + s1 = initial_state + n = len(re_list) + for i, re in enumerate(re_list): + if i < n - 1: + s2 = m.new_state() + else: + s2 = final_state + re.build_machine(m, s1, s2, match_bol, nocase) + s1 = s2 + match_bol = re.match_nl or (match_bol and re.nullable) + + def calc_str(self): + return "Seq(%s)" % ','.join(map(str, self.re_list)) + + +class Alt(RE): + """Alt(re1, re2, re3...) is an RE which matches either |re1| or + |re2| or |re3|...""" + + def __init__(self, *re_list): + self.re_list = re_list + nullable = 0 + match_nl = 0 + nullable_res = [] + non_nullable_res = [] + i = 1 + for re in re_list: + self.check_re(i, re) + if re.nullable: + nullable_res.append(re) + nullable = 1 + else: + non_nullable_res.append(re) + if re.match_nl: + match_nl = 1 + i += 1 + self.nullable_res = nullable_res + self.non_nullable_res = non_nullable_res + self.nullable = nullable + self.match_nl = match_nl + + def build_machine(self, m, initial_state, final_state, match_bol, nocase): + for re in self.nullable_res: + re.build_machine(m, initial_state, final_state, match_bol, nocase) + if self.non_nullable_res: + if match_bol: + initial_state = self.build_opt(m, initial_state, BOL) + for re in self.non_nullable_res: + re.build_machine(m, initial_state, final_state, 0, nocase) + + def calc_str(self): + return "Alt(%s)" % ','.join(map(str, self.re_list)) + + +class Rep1(RE): + """Rep1(re) is an RE which matches one or more repetitions of |re|.""" + + def __init__(self, re): + self.check_re(1, re) + self.re = re + self.nullable = re.nullable + self.match_nl = re.match_nl + + def build_machine(self, m, initial_state, final_state, match_bol, nocase): + s1 = m.new_state() + s2 = m.new_state() + initial_state.link_to(s1) + self.re.build_machine(m, s1, s2, match_bol or self.re.match_nl, nocase) + s2.link_to(s1) + s2.link_to(final_state) + + def calc_str(self): + return "Rep1(%s)" % self.re + + +class SwitchCase(RE): + """ + SwitchCase(re, nocase) is an RE which matches the same strings as RE, + but treating upper and lower case letters according to |nocase|. If + |nocase| is true, case is ignored, otherwise it is not. + """ + re = None + nocase = None + + def __init__(self, re, nocase): + self.re = re + self.nocase = nocase + self.nullable = re.nullable + self.match_nl = re.match_nl + + def build_machine(self, m, initial_state, final_state, match_bol, nocase): + self.re.build_machine(m, initial_state, final_state, match_bol, + self.nocase) + + def calc_str(self): + if self.nocase: + name = "NoCase" + else: + name = "Case" + return "%s(%s)" % (name, self.re) + + +# +# Composite RE constructors +# ------------------------- +# +# These REs are defined in terms of the primitive REs. +# + +Empty = Seq() +Empty.__doc__ = \ + """ + Empty is an RE which matches the empty string. + """ +Empty.str = "Empty" + + +def Str1(s): + """ + Str1(s) is an RE which matches the literal string |s|. + """ + result = Seq(*tuple(map(Char, s))) + result.str = "Str(%s)" % repr(s) + return result + + +def Str(*strs): + """ + Str(s) is an RE which matches the literal string |s|. + Str(s1, s2, s3, ...) is an RE which matches any of |s1| or |s2| or |s3|... + """ + if len(strs) == 1: + return Str1(strs[0]) + else: + result = Alt(*tuple(map(Str1, strs))) + result.str = "Str(%s)" % ','.join(map(repr, strs)) + return result + + +def Any(s): + """ + Any(s) is an RE which matches any character in the string |s|. + """ + result = CodeRanges(chars_to_ranges(s)) + result.str = "Any(%s)" % repr(s) + return result + + +def AnyBut(s): + """ + AnyBut(s) is an RE which matches any character (including + newline) which is not in the string |s|. + """ + ranges = chars_to_ranges(s) + ranges.insert(0, -maxint) + ranges.append(maxint) + result = CodeRanges(ranges) + result.str = "AnyBut(%s)" % repr(s) + return result + + +AnyChar = AnyBut("") +AnyChar.__doc__ = \ + """ + AnyChar is an RE which matches any single character (including a newline). + """ +AnyChar.str = "AnyChar" + + +def Range(s1, s2=None): + """ + Range(c1, c2) is an RE which matches any single character in the range + |c1| to |c2| inclusive. + Range(s) where |s| is a string of even length is an RE which matches + any single character in the ranges |s[0]| to |s[1]|, |s[2]| to |s[3]|,... + """ + if s2: + result = CodeRange(ord(s1), ord(s2) + 1) + result.str = "Range(%s,%s)" % (s1, s2) + else: + ranges = [] + for i in range(0, len(s1), 2): + ranges.append(CodeRange(ord(s1[i]), ord(s1[i + 1]) + 1)) + result = Alt(*ranges) + result.str = "Range(%s)" % repr(s1) + return result + + +def Opt(re): + """ + Opt(re) is an RE which matches either |re| or the empty string. + """ + result = Alt(re, Empty) + result.str = "Opt(%s)" % re + return result + + +def Rep(re): + """ + Rep(re) is an RE which matches zero or more repetitions of |re|. + """ + result = Opt(Rep1(re)) + result.str = "Rep(%s)" % re + return result + + +def NoCase(re): + """ + NoCase(re) is an RE which matches the same strings as RE, but treating + upper and lower case letters as equivalent. + """ + return SwitchCase(re, nocase=1) + + +def Case(re): + """ + Case(re) is an RE which matches the same strings as RE, but treating + upper and lower case letters as distinct, i.e. it cancels the effect + of any enclosing NoCase(). + """ + return SwitchCase(re, nocase=0) + + +# +# RE Constants +# + +Bol = Char(BOL) +Bol.__doc__ = \ + """ + Bol is an RE which matches the beginning of a line. + """ +Bol.str = "Bol" + +Eol = Char(EOL) +Eol.__doc__ = \ + """ + Eol is an RE which matches the end of a line. + """ +Eol.str = "Eol" + +Eof = Char(EOF) +Eof.__doc__ = \ + """ + Eof is an RE which matches the end of the file. + """ +Eof.str = "Eof" diff --git a/venv/lib/python3.10/site-packages/Cython/Plex/Scanners.pxd b/venv/lib/python3.10/site-packages/Cython/Plex/Scanners.pxd new file mode 100644 index 0000000000000000000000000000000000000000..461a19d67c2c967575a6229dedc3ea4bd8774c3f --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Plex/Scanners.pxd @@ -0,0 +1,46 @@ +from __future__ import absolute_import + +import cython + +from Cython.Plex.Actions cimport Action + +cdef class Scanner: + + cdef public lexicon + cdef public stream + cdef public name + cdef public unicode buffer + cdef public Py_ssize_t buf_start_pos + cdef public Py_ssize_t next_pos + cdef public Py_ssize_t cur_pos + cdef public Py_ssize_t cur_line + cdef public Py_ssize_t cur_line_start + cdef public Py_ssize_t start_pos + cdef tuple current_scanner_position_tuple + cdef public tuple last_token_position_tuple + cdef public str text + cdef public initial_state # int? + cdef public state_name + cdef public list queue + cdef public bint trace + cdef public cur_char + cdef public long input_state + + cdef public level + + cdef inline next_char(self) + @cython.locals(action=Action) + cpdef tuple read(self) + cdef inline unread(self, token, value, position) + cdef inline get_current_scan_pos(self) + cdef inline tuple scan_a_token(self) + + # This could be @final and @cfunc, but that would hide it from Parsing.py + # unless that's compiled as well (which it isn't with "minimal" compilation). + #@cython.final + cpdef tuple position(self) # used frequently by Parsing.py + + cdef run_machine_inlined(self) + + cdef inline begin(self, state) + cdef inline produce(self, value, text = *) diff --git a/venv/lib/python3.10/site-packages/Cython/Plex/Scanners.py b/venv/lib/python3.10/site-packages/Cython/Plex/Scanners.py new file mode 100644 index 0000000000000000000000000000000000000000..965eb65e2ba1a1ee4a5bd14ef0048053b0fcf9e3 --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Plex/Scanners.py @@ -0,0 +1,361 @@ +""" +Python Lexical Analyser + +Scanning an input stream +""" + +import cython + +cython.declare(BOL=object, EOL=object, EOF=object, NOT_FOUND=object) # noqa:E402 + +from . import Errors +from .Regexps import BOL, EOL, EOF + +NOT_FOUND = object() + + +class Scanner: + """ + A Scanner is used to read tokens from a stream of characters + using the token set specified by a Plex.Lexicon. + + Constructor: + + Scanner(lexicon, stream, name = '') + + See the docstring of the __init__ method for details. + + Methods: + + See the docstrings of the individual methods for more + information. + + read() --> (value, text) + Reads the next lexical token from the stream. + + position() --> (name, line, col) + Returns the position of the last token read using the + read() method. + + begin(state_name) + Causes scanner to change state. + + produce(value [, text]) + Causes return of a token value to the caller of the + Scanner. + + """ + + # lexicon = None # Lexicon + # stream = None # file-like object + # name = '' + # buffer = '' + # + # These positions are used by the scanner to track its internal state: + # buf_start_pos = 0 # position in input of start of buffer + # next_pos = 0 # position in input of next char to read + # cur_pos = 0 # position in input of current char + # cur_line = 1 # line number of current char + # cur_line_start = 0 # position in input of start of current line + # start_pos = 0 # position in input of start of token + # current_scanner_position_tuple = ("", 0, 0) + # tuple of filename, line number and position in line, really mainly for error reporting + # + # These positions are used to track what was read from the queue + # (which may differ from the internal state when tokens are replaced onto the queue) + # last_token_position_tuple = ("", 0, 0) # tuple of filename, line number and position in line + + # text = None # text of last token read + # initial_state = None # Node + # state_name = '' # Name of initial state + # queue = None # list of tokens and positions to be returned + # trace = 0 + + def __init__(self, lexicon, stream, name='', initial_pos=None): + """ + Scanner(lexicon, stream, name = '') + + |lexicon| is a Plex.Lexicon instance specifying the lexical tokens + to be recognised. + + |stream| can be a file object or anything which implements a + compatible read() method. + + |name| is optional, and may be the name of the file being + scanned or any other identifying string. + """ + self.trace = 0 + + self.buffer = '' + self.buf_start_pos = 0 + self.next_pos = 0 + self.cur_pos = 0 + self.cur_line = 1 + self.start_pos = 0 + self.current_scanner_position_tuple = ("", 0, 0) + self.last_token_position_tuple = ("", 0, 0) + self.text = None + self.state_name = None + + self.lexicon = lexicon + self.stream = stream + self.name = name + self.queue = [] + self.initial_state = None + self.begin('') + self.next_pos = 0 + self.cur_pos = 0 + self.cur_line_start = 0 + self.cur_char = BOL + self.input_state = 1 + if initial_pos is not None: + self.cur_line, self.cur_line_start = initial_pos[1], -initial_pos[2] + + def read(self): + """ + Read the next lexical token from the stream and return a + tuple (value, text), where |value| is the value associated with + the token as specified by the Lexicon, and |text| is the actual + string read from the stream. Returns (None, '') on end of file. + """ + queue = self.queue + while not queue: + self.text, action = self.scan_a_token() + if action is None: + self.produce(None) + self.eof() + else: + value = action.perform(self, self.text) + if value is not None: + self.produce(value) + result, self.last_token_position_tuple = queue[0] + del queue[0] + return result + + def unread(self, token, value, position): + self.queue.insert(0, ((token, value), position)) + + def get_current_scan_pos(self): + # distinct from the position of the last token due to the queue + return self.current_scanner_position_tuple + + def scan_a_token(self): + """ + Read the next input sequence recognised by the machine + and return (text, action). Returns ('', None) on end of + file. + """ + self.start_pos = self.cur_pos + self.current_scanner_position_tuple = ( + self.name, self.cur_line, self.cur_pos - self.cur_line_start + ) + action = self.run_machine_inlined() + if action is not None: + if self.trace: + print("Scanner: read: Performing %s %d:%d" % ( + action, self.start_pos, self.cur_pos)) + text = self.buffer[ + self.start_pos - self.buf_start_pos: + self.cur_pos - self.buf_start_pos] + return (text, action) + else: + if self.cur_pos == self.start_pos: + if self.cur_char is EOL: + self.next_char() + if self.cur_char is None or self.cur_char is EOF: + return ('', None) + raise Errors.UnrecognizedInput(self, self.state_name) + + @cython.final + def run_machine_inlined(self): + """ + Inlined version of run_machine for speed. + """ + state: dict = self.initial_state + cur_pos: cython.Py_ssize_t = self.cur_pos + cur_line: cython.Py_ssize_t = self.cur_line + cur_line_start: cython.Py_ssize_t = self.cur_line_start + cur_char = self.cur_char + input_state: cython.long = self.input_state + next_pos: cython.Py_ssize_t = self.next_pos + data: str + buffer: str = self.buffer + buf_start_pos: cython.Py_ssize_t = self.buf_start_pos + buf_len: cython.Py_ssize_t = len(buffer) + buf_index: cython.Py_ssize_t + discard: cython.Py_ssize_t + + b_action, b_cur_pos, b_cur_line, b_cur_line_start, b_cur_char, b_input_state, b_next_pos = \ + None, 0, 0, 0, '', 0, 0 + + trace: cython.bint = self.trace + while 1: + if trace: + print("State %d, %d/%d:%s -->" % ( + state['number'], input_state, cur_pos, repr(cur_char))) + + # Begin inlined self.save_for_backup() + action = state['action'] + if action is not None: + b_action, b_cur_pos, b_cur_line, b_cur_line_start, b_cur_char, b_input_state, b_next_pos = \ + action, cur_pos, cur_line, cur_line_start, cur_char, input_state, next_pos + # End inlined self.save_for_backup() + + c = cur_char + new_state = state.get(c, NOT_FOUND) + if new_state is NOT_FOUND: + new_state = c and state.get('else') + + if new_state: + if trace: + print("State %d" % new_state['number']) + state = new_state + # Begin inlined: self.next_char() + if input_state == 1: + cur_pos = next_pos + # Begin inlined: c = self.read_char() + buf_index = next_pos - buf_start_pos + if buf_index < buf_len: + c = buffer[buf_index] + next_pos += 1 + else: + discard = self.start_pos - buf_start_pos + data = self.stream.read(0x1000) + buffer = self.buffer[discard:] + data + self.buffer = buffer + buf_start_pos += discard + self.buf_start_pos = buf_start_pos + buf_len = len(buffer) + buf_index -= discard + if data: + c = buffer[buf_index] + next_pos += 1 + else: + c = '' + # End inlined: c = self.read_char() + if c == '\n': + cur_char = EOL + input_state = 2 + elif not c: + cur_char = EOL + input_state = 4 + else: + cur_char = c + elif input_state == 2: # after EoL (1) -> BoL (3) + cur_char = '\n' + input_state = 3 + elif input_state == 3: # start new code line + cur_line += 1 + cur_line_start = cur_pos = next_pos + cur_char = BOL + input_state = 1 + elif input_state == 4: # after final line (1) -> EoF (5) + cur_char = EOF + input_state = 5 + else: # input_state == 5 (EoF) + cur_char = '' + # End inlined self.next_char() + else: # not new_state + if trace: + print("blocked") + # Begin inlined: action = self.back_up() + if b_action is not None: + (action, cur_pos, cur_line, cur_line_start, + cur_char, input_state, next_pos) = \ + (b_action, b_cur_pos, b_cur_line, b_cur_line_start, + b_cur_char, b_input_state, b_next_pos) + else: + action = None + break # while 1 + # End inlined: action = self.back_up() + + self.cur_pos = cur_pos + self.cur_line = cur_line + self.cur_line_start = cur_line_start + self.cur_char = cur_char + self.input_state = input_state + self.next_pos = next_pos + if trace: + if action is not None: + print("Doing %s" % action) + return action + + def next_char(self): + input_state: cython.int = self.input_state + if self.trace: + print("Scanner: next: %s [%d] %d" % (" " * 20, input_state, self.cur_pos)) + if input_state == 1: + self.cur_pos = self.next_pos + c = self.read_char() + if c == '\n': + self.cur_char = EOL + self.input_state = 2 + elif not c: + self.cur_char = EOL + self.input_state = 4 + else: + self.cur_char = c + elif input_state == 2: + self.cur_char = '\n' + self.input_state = 3 + elif input_state == 3: + self.cur_line += 1 + self.cur_line_start = self.cur_pos = self.next_pos + self.cur_char = BOL + self.input_state = 1 + elif input_state == 4: + self.cur_char = EOF + self.input_state = 5 + else: # input_state = 5 + self.cur_char = '' + if self.trace: + print("--> [%d] %d %r" % (input_state, self.cur_pos, self.cur_char)) + + def position(self) -> tuple: + """ + Return a tuple (name, line, col) representing the location of + the last token read using the read() method. |name| is the + name that was provided to the Scanner constructor; |line| + is the line number in the stream (1-based); |col| is the + position within the line of the first character of the token + (0-based). + """ + return self.last_token_position_tuple + + def get_position(self): + """ + Python accessible wrapper around position(), only for error reporting. + """ + return self.position() + + def begin(self, state_name): + """Set the current state of the scanner to the named state.""" + self.initial_state = ( + self.lexicon.get_initial_state(state_name)) + self.state_name = state_name + + def produce(self, value, text=None): + """ + Called from an action procedure, causes |value| to be returned + as the token value from read(). If |text| is supplied, it is + returned in place of the scanned text. + + produce() can be called more than once during a single call to an action + procedure, in which case the tokens are queued up and returned one + at a time by subsequent calls to read(), until the queue is empty, + whereupon scanning resumes. + """ + if text is None: + text = self.text + self.queue.append(((value, text), self.current_scanner_position_tuple)) + + def eof(self): + """ + Override this method if you want something to be done at + end of file. + """ + pass + + @property + def start_line(self): + return self.last_token_position_tuple[1] diff --git a/venv/lib/python3.10/site-packages/Cython/Plex/Transitions.pxd b/venv/lib/python3.10/site-packages/Cython/Plex/Transitions.pxd new file mode 100644 index 0000000000000000000000000000000000000000..773aa00836cc7a45d739f39c1aa3afed433d80dc --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Plex/Transitions.pxd @@ -0,0 +1,14 @@ +cimport cython + +cdef long maxint + +@cython.final +cdef class TransitionMap: + cdef list map + cdef dict special + + cpdef add(self, event, new_state) + cpdef add_set(self, event, new_set) + cpdef iteritems(self) + cdef Py_ssize_t split(self, long code) + cdef set get_special(self, event) diff --git a/venv/lib/python3.10/site-packages/Cython/Plex/Transitions.py b/venv/lib/python3.10/site-packages/Cython/Plex/Transitions.py new file mode 100644 index 0000000000000000000000000000000000000000..82c5c69bc73881fe2d2c049110bc2595e54e7b29 --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Plex/Transitions.py @@ -0,0 +1,239 @@ +""" +Plex - Transition Maps + +This version represents state sets directly as dicts for speed. +""" +import cython + +maxint = 2**31-1 # sentinel value + + +class TransitionMap: + """ + A TransitionMap maps an input event to a set of states. + An input event is one of: a range of character codes, + the empty string (representing an epsilon move), or one + of the special symbols BOL, EOL, EOF. + + For characters, this implementation compactly represents + the map by means of a list: + + [code_0, states_0, code_1, states_1, code_2, states_2, + ..., code_n-1, states_n-1, code_n] + + where |code_i| is a character code, and |states_i| is a + set of states corresponding to characters with codes |c| + in the range |code_i| <= |c| <= |code_i+1|. + + The following invariants hold: + n >= 1 + code_0 == -maxint + code_n == maxint + code_i < code_i+1 for i in 0..n-1 + states_0 == states_n-1 + + Mappings for the special events '', BOL, EOL, EOF are + kept separately in a dictionary. + """ + + def __init__(self, map=None, special=None): + if not map: + map = [-maxint, set(), maxint] + if not special: + special = {} + self.map = map # The list of codes and states + self.special = special # Mapping for special events + + def add(self, event, new_state): + """ + Add transition to |new_state| on |event|. + """ + i: cython.Py_ssize_t + j: cython.Py_ssize_t + if type(event) is tuple: + code0, code1 = event + i = self.split(code0) + j = self.split(code1) + map = self.map + while i < j: + map[i + 1].add(new_state) + i += 2 + else: + self.get_special(event).add(new_state) + + def add_set(self, event, new_set): + """ + Add transitions to the states in |new_set| on |event|. + """ + i: cython.Py_ssize_t + j: cython.Py_ssize_t + if type(event) is tuple: + code0, code1 = event + i = self.split(code0) + j = self.split(code1) + map = self.map + while i < j: + map[i + 1].update(new_set) + i += 2 + else: + self.get_special(event).update(new_set) + + def get_epsilon(self): + """ + Return the mapping for epsilon, or None. + """ + return self.special.get('') + + def iteritems(self): + """ + Return the mapping as an iterable of ((code1, code2), state_set) and + (special_event, state_set) pairs. + """ + result = [] + map = self.map + else_set: cython.bint = map[1] + i: cython.Py_ssize_t = 0 + n: cython.Py_ssize_t = len(map) - 1 + code0 = map[0] + while i < n: + state_set = map[i + 1] + code1 = map[i + 2] + if state_set or else_set: + result.append(((code0, code1), state_set)) + code0 = code1 + i += 2 + for event, state_set in self.special.items(): + if state_set: + result.append((event, state_set)) + return iter(result) + + items = iteritems + + # ------------------- Private methods -------------------- + + def split(self, code: cython.long): + """ + Search the list for the position of the split point for |code|, + inserting a new split point if necessary. Returns index |i| such + that |code| == |map[i]|. + """ + # We use a funky variation on binary search. + map = self.map + hi: cython.Py_ssize_t = len(map) - 1 + # Special case: code == map[-1] + if code == maxint: + return hi + + # General case + lo: cython.Py_ssize_t = 0 + mid: cython.Py_ssize_t + # loop invariant: map[lo] <= code < map[hi] and hi - lo >= 2 + while hi - lo >= 4: + # Find midpoint truncated to even index + mid = ((lo + hi) // 2) & ~1 + if code < map[mid]: + hi = mid + else: + lo = mid + # map[lo] <= code < map[hi] and hi - lo == 2 + if map[lo] == code: + return lo + else: + map[hi:hi] = [code, map[hi - 1].copy()] + return hi + + def get_special(self, event) -> set: + """ + Get state set for special event, adding a new entry if necessary. + """ + special = self.special + state_set = special.get(event) + if state_set is None: + state_set = set() + special[event] = state_set + return state_set + + # --------------------- Conversion methods ----------------------- + + def __str__(self): + map_strs = [] + map = self.map + n: cython.Py_ssize_t = len(map) + i: cython.Py_ssize_t = 0 + while i < n: + code = map[i] + if code == -maxint: + code_str = "-inf" + elif code == maxint: + code_str = "inf" + else: + code_str = str(code) + map_strs.append(code_str) + i += 1 + if i < n: + map_strs.append(state_set_str(map[i])) + i += 1 + special_strs = {} + for event, set in self.special.items(): + special_strs[event] = state_set_str(set) + return "[%s]+%s" % ( + ','.join(map_strs), + special_strs + ) + + # --------------------- Debugging methods ----------------------- + + def check(self): + """Check data structure integrity.""" + if not self.map[-3] < self.map[-1]: + print(self) + assert 0 + + def dump(self, file): + map = self.map + i: cython.Py_ssize_t = 0 + n: cython.Py_ssize_t = len(map) - 1 + while i < n: + self.dump_range(map[i], map[i + 2], map[i + 1], file) + i += 2 + for event, set in self.special.items(): + if set: + if not event: + event = 'empty' + self.dump_trans(event, set, file) + + def dump_range(self, code0, code1, set, file): + if set: + if code0 == -maxint: + if code1 == maxint: + k = "any" + else: + k = "< %s" % self.dump_char(code1) + elif code1 == maxint: + k = "> %s" % self.dump_char(code0 - 1) + elif code0 == code1 - 1: + k = self.dump_char(code0) + else: + k = "%s..%s" % (self.dump_char(code0), + self.dump_char(code1 - 1)) + self.dump_trans(k, set, file) + + def dump_char(self, code): + if 0 <= code <= 255: + return repr(chr(code)) + else: + return "chr(%d)" % code + + def dump_trans(self, key, set, file): + file.write(" %s --> %s\n" % (key, self.dump_set(set))) + + def dump_set(self, set): + return state_set_str(set) + + +# +# State set manipulation functions +# + +def state_set_str(set): + return "[%s]" % ','.join(["S%d" % state.number for state in set]) diff --git a/venv/lib/python3.10/site-packages/Cython/Plex/__init__.py b/venv/lib/python3.10/site-packages/Cython/Plex/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..9b22feadbe95da05456e146b0d5f2a1b63e68bea --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Plex/__init__.py @@ -0,0 +1,34 @@ +""" +Python Lexical Analyser + +The Plex module provides lexical analysers with similar capabilities +to GNU Flex. The following classes and functions are exported; +see the attached docstrings for more information. + + Scanner For scanning a character stream under the + direction of a Lexicon. + + Lexicon For constructing a lexical definition + to be used by a Scanner. + + Str, Any, AnyBut, AnyChar, Seq, Alt, Opt, Rep, Rep1, + Bol, Eol, Eof, Empty + + Regular expression constructors, for building pattern + definitions for a Lexicon. + + State For defining scanner states when creating a + Lexicon. + + TEXT, IGNORE, Begin + + Actions for associating with patterns when + creating a Lexicon. +""" +# flake8: noqa:F401 + +from .Actions import TEXT, IGNORE, Begin, Method +from .Lexicons import Lexicon, State +from .Regexps import RE, Seq, Alt, Rep1, Empty, Str, Any, AnyBut, AnyChar, Range +from .Regexps import Opt, Rep, Bol, Eol, Eof, Case, NoCase +from .Scanners import Scanner diff --git a/venv/lib/python3.10/site-packages/Cython/Plex/__pycache__/Actions.cpython-310.pyc b/venv/lib/python3.10/site-packages/Cython/Plex/__pycache__/Actions.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a82e7a7c24a995570028d23904c84d50b409cc1e Binary files /dev/null and b/venv/lib/python3.10/site-packages/Cython/Plex/__pycache__/Actions.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/Cython/Plex/__pycache__/DFA.cpython-310.pyc b/venv/lib/python3.10/site-packages/Cython/Plex/__pycache__/DFA.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e02e8ed45e5b0b5039252adeb783029b778b7f67 Binary files /dev/null and b/venv/lib/python3.10/site-packages/Cython/Plex/__pycache__/DFA.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/Cython/Plex/__pycache__/Errors.cpython-310.pyc b/venv/lib/python3.10/site-packages/Cython/Plex/__pycache__/Errors.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..059625f6ebc277dd871833b85e28530b88ca43d4 Binary files /dev/null and b/venv/lib/python3.10/site-packages/Cython/Plex/__pycache__/Errors.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/Cython/Plex/__pycache__/Lexicons.cpython-310.pyc b/venv/lib/python3.10/site-packages/Cython/Plex/__pycache__/Lexicons.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c45fafa2b1bd7650bf26153e17f3f94400c05c6c Binary files /dev/null and b/venv/lib/python3.10/site-packages/Cython/Plex/__pycache__/Lexicons.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/Cython/Plex/__pycache__/Machines.cpython-310.pyc b/venv/lib/python3.10/site-packages/Cython/Plex/__pycache__/Machines.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7247f7982c4c823253eae48bc1249b818cc017d5 Binary files /dev/null and b/venv/lib/python3.10/site-packages/Cython/Plex/__pycache__/Machines.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/Cython/Plex/__pycache__/Regexps.cpython-310.pyc b/venv/lib/python3.10/site-packages/Cython/Plex/__pycache__/Regexps.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9807c9d72618bdf3d4ea0cef819df42538b14b86 Binary files /dev/null and b/venv/lib/python3.10/site-packages/Cython/Plex/__pycache__/Regexps.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/Cython/Plex/__pycache__/Scanners.cpython-310.pyc b/venv/lib/python3.10/site-packages/Cython/Plex/__pycache__/Scanners.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f30dec90df1f1c8dccae816ae2aecc36efb430ab Binary files /dev/null and b/venv/lib/python3.10/site-packages/Cython/Plex/__pycache__/Scanners.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/Cython/Plex/__pycache__/Transitions.cpython-310.pyc b/venv/lib/python3.10/site-packages/Cython/Plex/__pycache__/Transitions.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7f520a0b311484da21f7a3a1e7fb78bce0f0ef25 Binary files /dev/null and b/venv/lib/python3.10/site-packages/Cython/Plex/__pycache__/Transitions.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/Cython/Plex/__pycache__/__init__.cpython-310.pyc b/venv/lib/python3.10/site-packages/Cython/Plex/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6cf52ea3f10e4ff2d5b6823957bc5a2487f451de Binary files /dev/null and b/venv/lib/python3.10/site-packages/Cython/Plex/__pycache__/__init__.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/Cython/Runtime/__init__.py b/venv/lib/python3.10/site-packages/Cython/Runtime/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..fa81adaff68e06d8e915a6afa375f62f7e5a8fad --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Runtime/__init__.py @@ -0,0 +1 @@ +# empty file diff --git a/venv/lib/python3.10/site-packages/Cython/Runtime/__pycache__/__init__.cpython-310.pyc b/venv/lib/python3.10/site-packages/Cython/Runtime/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..68b4ce5bbc0401f5ebbe46d56347151362b3ada2 Binary files /dev/null and b/venv/lib/python3.10/site-packages/Cython/Runtime/__pycache__/__init__.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/Cython/Runtime/refnanny.cpython-310-x86_64-linux-gnu.so b/venv/lib/python3.10/site-packages/Cython/Runtime/refnanny.cpython-310-x86_64-linux-gnu.so new file mode 100644 index 0000000000000000000000000000000000000000..75a184df83470b2c486c1c621e21952584b7a0ca Binary files /dev/null and b/venv/lib/python3.10/site-packages/Cython/Runtime/refnanny.cpython-310-x86_64-linux-gnu.so differ diff --git a/venv/lib/python3.10/site-packages/Cython/Runtime/refnanny.pyx b/venv/lib/python3.10/site-packages/Cython/Runtime/refnanny.pyx new file mode 100644 index 0000000000000000000000000000000000000000..599deda4681384f56866af5f09216eb1b5a5443d --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Runtime/refnanny.pyx @@ -0,0 +1,237 @@ +# cython: language_level=3, auto_pickle=False + +from cpython.ref cimport PyObject, Py_INCREF, Py_CLEAR, Py_XDECREF, Py_XINCREF +from cpython.exc cimport PyErr_Fetch, PyErr_Restore +from cpython.pystate cimport PyThreadState_Get + +cimport cython + +cdef extern from *: + """ + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + #define __Pyx_refnanny_mutex PyMutex + static CYTHON_INLINE void __Pyx_refnanny_lock_acquire(PyMutex *lock) { + PyMutex_Lock(lock); + } + + static CYTHON_INLINE void __Pyx_refnanny_lock_release(PyMutex *lock) { + PyMutex_Unlock(lock); + } + #else + #define __Pyx_refnanny_mutex void* + #define __Pyx_refnanny_lock_acquire(lock) + #define __Pyx_refnanny_lock_release(lock) + #endif + """ + ctypedef void *__Pyx_refnanny_mutex + void __Pyx_refnanny_lock_acquire(__Pyx_refnanny_mutex *lock) + void __Pyx_refnanny_lock_release(__Pyx_refnanny_mutex *lock) + +loglevel = 0 +reflog = [] + +cdef int log(int level, action, obj, lineno) except -1: + if ( loglevel) >= level: + if reflog is None: + # can happen during finalisation + return 0 + reflog.append((lineno, action, id(obj))) + return 0 + +LOG_NONE, LOG_ALL = range(2) +cdef int _LOG_NONE = LOG_NONE +cdef int _LOG_ALL = LOG_ALL + +cdef object NO_REFS = (0, None) + + +@cython.final +cdef class Context(object): + cdef readonly object name, filename + cdef readonly dict refs + cdef readonly list errors + cdef readonly Py_ssize_t start + cdef __Pyx_refnanny_mutex lock + + def __cinit__(self, name, line=0, filename=None): + self.name = name + self.start = line + self.filename = filename + self.refs = {} # id -> (count, [lineno]) + self.errors = [] + + cdef void acquire_lock(self) noexcept: + __Pyx_refnanny_lock_acquire(&self.lock) + + cdef void release_lock(self) noexcept: + __Pyx_refnanny_lock_release(&self.lock) + + cdef int regref(self, obj, Py_ssize_t lineno, bint is_null) except -1: + log(_LOG_ALL, u'regref', u"" if is_null else obj, lineno) + if is_null: + self.errors.append(f"NULL argument on line {lineno}") + return 0 + id_ = id(obj) + count, linenumbers = self.refs.get(id_, NO_REFS) + if linenumbers is None: + linenumbers = [] + self.refs[id_] = (count + 1, linenumbers) + linenumbers.append(lineno) + return 0 + + cdef bint delref(self, obj, Py_ssize_t lineno, bint is_null) except -1: + # returns whether it is ok to do the decref operation + log(_LOG_ALL, u'delref', u"" if is_null else obj, lineno) + if is_null: + self.errors.append(f"NULL argument on line {lineno}") + return False + id_ = id(obj) + count, linenumbers = self.refs.get(id_, NO_REFS) + if linenumbers is None: + linenumbers = [] + if count == 0: + self.errors.append(f"Too many decrefs on line {lineno}, reference acquired on lines {linenumbers!r}") + return False + if count == 1: + del self.refs[id_] + else: + self.refs[id_] = (count - 1, linenumbers) + return True + + cdef end(self): + if self.refs: + msg = u"References leaked:" + for count, linenos in self.refs.values(): + msg += f"\n ({count}) acquired on lines: {u', '.join([f'{x}' for x in linenos])}" + self.errors.append(msg) + return u"\n".join([f'REFNANNY: {error}' for error in self.errors]) if self.errors else None + + +cdef void report_unraisable(filename, Py_ssize_t lineno, object e=None) noexcept: + try: + if e is None: + import sys + e = sys.exc_info()[1] + print(f"refnanny raised an exception from {filename}:{lineno}: {e}") + finally: + return # We absolutely cannot exit with an exception + + +# All Python operations must happen after any existing +# exception has been fetched, in case we are called from +# exception-handling code. + +cdef PyObject* SetupContext(char* funcname, Py_ssize_t lineno, char* filename) except NULL: + if Context is None: + # Context may be None during finalize phase. + # In that case, we don't want to be doing anything fancy + # like caching and resetting exceptions. + return NULL + cdef (PyObject*) type = NULL, value = NULL, tb = NULL, result = NULL + PyThreadState_Get() # Check that we hold the GIL + PyErr_Fetch(&type, &value, &tb) + try: + ctx = Context.__new__(Context, funcname, lineno, filename) + Py_INCREF(ctx) + result = ctx + except Exception, e: + report_unraisable(filename, lineno, e) + PyErr_Restore(type, value, tb) + return result + +cdef void GOTREF(PyObject* _ctx, PyObject* p_obj, Py_ssize_t lineno): + if _ctx == NULL: return + cdef (PyObject*) type = NULL, value = NULL, tb = NULL + cdef Context ctx = _ctx + ctx.acquire_lock() + PyErr_Fetch(&type, &value, &tb) + try: + ctx.regref( + p_obj if p_obj is not NULL else None, + lineno, + is_null=p_obj is NULL, + ) + except: + report_unraisable(ctx.filename, lineno=ctx.start) + finally: + PyErr_Restore(type, value, tb) + ctx.release_lock() + return # swallow any exceptions + +cdef bint GIVEREF_and_report(PyObject* _ctx, PyObject* p_obj, Py_ssize_t lineno): + if _ctx == NULL: return 1 + cdef (PyObject*) type = NULL, value = NULL, tb = NULL + cdef bint decref_ok = False + cdef Context ctx = _ctx + ctx.acquire_lock() + PyErr_Fetch(&type, &value, &tb) + try: + decref_ok = ctx.delref( + p_obj if p_obj is not NULL else None, + lineno, + is_null=p_obj is NULL, + ) + except: + report_unraisable(ctx.filename, lineno=ctx.start) + finally: + PyErr_Restore(type, value, tb) + ctx.release_lock() + return decref_ok # swallow any exceptions + +cdef void GIVEREF(PyObject* ctx, PyObject* p_obj, Py_ssize_t lineno): + GIVEREF_and_report(ctx, p_obj, lineno) + +cdef void INCREF(PyObject* ctx, PyObject* obj, Py_ssize_t lineno): + Py_XINCREF(obj) + PyThreadState_Get() # Check that we hold the GIL + GOTREF(ctx, obj, lineno) + +cdef void DECREF(PyObject* ctx, PyObject* obj, Py_ssize_t lineno): + if GIVEREF_and_report(ctx, obj, lineno): + Py_XDECREF(obj) + PyThreadState_Get() # Check that we hold the GIL + +cdef void FinishContext(PyObject** ctx): + if ctx == NULL or ctx[0] == NULL: return + cdef (PyObject*) type = NULL, value = NULL, tb = NULL + cdef object errors = None + cdef Context context + PyThreadState_Get() # Check that we hold the GIL + PyErr_Fetch(&type, &value, &tb) + try: + context = ctx[0] + errors = context.end() + if errors: + print(f"{context.filename.decode('latin1')}: {context.name.decode('latin1')}()") + print(errors) + context = None + except: + report_unraisable( + context.filename if context is not None else None, + lineno=context.start if context is not None else 0, + ) + finally: + Py_CLEAR(ctx[0]) + PyErr_Restore(type, value, tb) + return # swallow any exceptions + +ctypedef struct RefNannyAPIStruct: + void (*INCREF)(PyObject*, PyObject*, Py_ssize_t) + void (*DECREF)(PyObject*, PyObject*, Py_ssize_t) + void (*GOTREF)(PyObject*, PyObject*, Py_ssize_t) + void (*GIVEREF)(PyObject*, PyObject*, Py_ssize_t) + PyObject* (*SetupContext)(char*, Py_ssize_t, char*) except NULL + void (*FinishContext)(PyObject**) + +cdef RefNannyAPIStruct api +api.INCREF = INCREF +api.DECREF = DECREF +api.GOTREF = GOTREF +api.GIVEREF = GIVEREF +api.SetupContext = SetupContext +api.FinishContext = FinishContext + +cdef extern from "Python.h": + object PyLong_FromVoidPtr(void*) + +RefNannyAPI = PyLong_FromVoidPtr(&api) diff --git a/venv/lib/python3.10/site-packages/Cython/Shadow.py b/venv/lib/python3.10/site-packages/Cython/Shadow.py new file mode 100644 index 0000000000000000000000000000000000000000..ba3fe8b70542fbcb86fadd9c9d4cb6592da43ce6 --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Shadow.py @@ -0,0 +1,690 @@ +# cython.* namespace for pure mode. + +# Possible version formats: "3.1.0", "3.1.0a1", "3.1.0a1.dev0" +__version__ = "3.1.6" + + +# BEGIN shameless copy from Cython/minivect/minitypes.py + +class _ArrayType: + + is_array = True + subtypes = ['dtype'] + + def __init__(self, dtype, ndim, is_c_contig=False, is_f_contig=False, + inner_contig=False, broadcasting=None): + self.dtype = dtype + self.ndim = ndim + self.is_c_contig = is_c_contig + self.is_f_contig = is_f_contig + self.inner_contig = inner_contig or is_c_contig or is_f_contig + self.broadcasting = broadcasting + + def __repr__(self): + axes = [":"] * self.ndim + if self.is_c_contig: + axes[-1] = "::1" + elif self.is_f_contig: + axes[0] = "::1" + + return "%s[%s]" % (self.dtype, ", ".join(axes)) + + +def index_type(base_type, item): + """ + Support array type creation by slicing, e.g. double[:, :] specifies + a 2D strided array of doubles. The syntax is the same as for + Cython memoryviews. + """ + class InvalidTypeSpecification(Exception): + pass + + def verify_slice(s): + if s.start or s.stop or s.step not in (None, 1): + raise InvalidTypeSpecification( + "Only a step of 1 may be provided to indicate C or " + "Fortran contiguity") + + if isinstance(item, tuple): + step_idx = None + for idx, s in enumerate(item): + verify_slice(s) + if s.step and (step_idx or idx not in (0, len(item) - 1)): + raise InvalidTypeSpecification( + "Step may only be provided once, and only in the " + "first or last dimension.") + + if s.step == 1: + step_idx = idx + + return _ArrayType(base_type, len(item), + is_c_contig=step_idx == len(item) - 1, + is_f_contig=step_idx == 0) + elif isinstance(item, slice): + verify_slice(item) + return _ArrayType(base_type, 1, is_c_contig=bool(item.step)) + else: + # int[8] etc. + assert int(item) == item # array size must be a plain integer + return array(base_type, item) + +# END shameless copy + + +compiled = False + +_Unspecified = object() + +# Function decorators + +def _empty_decorator(x): + return x + +def locals(**arg_types): + return _empty_decorator + +def test_assert_path_exists(*paths): + return _empty_decorator + +def test_fail_if_path_exists(*paths): + return _empty_decorator + +class _EmptyDecoratorAndManager: + def __call__(self, x): + return x + def __enter__(self): + pass + def __exit__(self, exc_type, exc_value, traceback): + pass + +class _Optimization: + pass + +cclass = ccall = cfunc = _EmptyDecoratorAndManager() + +annotation_typing = returns = wraparound = boundscheck = initializedcheck = \ + nonecheck = embedsignature = cdivision = cdivision_warnings = \ + always_allow_keywords = profile = linetrace = infer_types = \ + unraisable_tracebacks = freelist = auto_pickle = cpow = trashcan = \ + auto_cpdef = c_api_binop_methods = \ + allow_none_for_extension_args = callspec = show_performance_hints = \ + cpp_locals = py2_import = iterable_coroutine = remove_unreachable = \ + overflowcheck = \ + lambda _: _EmptyDecoratorAndManager() + +# Note that fast_getattr is untested and undocumented! +fast_getattr = lambda _: _EmptyDecoratorAndManager() +# c_compile_guard is largely for internal use +c_compile_guard = lambda _:_EmptyDecoratorAndManager() + +exceptval = lambda _=None, check=True: _EmptyDecoratorAndManager() + +optimize = _Optimization() + + +embedsignature.format = overflowcheck.fold = optimize.use_switch = \ + optimize.unpack_method_calls = lambda arg: _EmptyDecoratorAndManager() + +final = internal = type_version_tag = no_gc_clear = no_gc = total_ordering = \ + ufunc = _empty_decorator + +binding = lambda _: _empty_decorator + +class warn: + undeclared = unreachable = maybe_uninitialized = unused = \ + unused_arg = unused_result = \ + lambda _: _EmptyDecoratorAndManager() + + +_cython_inline = None +def inline(f, *args, **kwds): + if isinstance(f, str): + global _cython_inline + if _cython_inline is None: + from Cython.Build.Inline import cython_inline as _cython_inline + return _cython_inline(f, *args, **kwds) + else: + assert len(args) == len(kwds) == 0 + return f + + +def compile(f): + from Cython.Build.Inline import RuntimeCompiledFunction + return RuntimeCompiledFunction(f) + + +# Special functions + +def cdiv(a, b): + if a < 0: + a = -a + b = -b + if b < 0: + return (a + b + 1) // b + return a // b + +def cmod(a, b): + r = a % b + if (a * b) < 0 and r: + r -= b + return r + + +# Emulated language constructs + +def cast(t, *args, **kwargs): + kwargs.pop('typecheck', None) + assert not kwargs + + if isinstance(t, typedef): + return t(*args) + elif isinstance(t, type): # Doesn't work with old-style classes of Python 2.x + if len(args) != 1 or not (args[0] is None or isinstance(args[0], t)): + return t(*args) + + return args[0] + +def sizeof(arg): + return 1 + +def typeof(arg): + return arg.__class__.__name__ + # return type(arg) + +def address(arg): + return pointer(type(arg))([arg]) + +def _is_value_type(t): + if isinstance(t, typedef): + return _is_value_type(t._basetype) + + return isinstance(t, type) and issubclass(t, (StructType, UnionType, ArrayType)) + +def declare(t=None, value=_Unspecified, **kwds): + if value is not _Unspecified: + return cast(t, value) + elif _is_value_type(t): + return t() + else: + return None + +class _nogil: + """Support for 'with nogil' statement and @nogil decorator. + """ + def __call__(self, x): + if callable(x): + # Used as function decorator => return the function unchanged. + return x + # Used as conditional context manager or to create an "@nogil(True/False)" decorator => keep going. + return self + + def __enter__(self): + pass + def __exit__(self, exc_class, exc, tb): + return exc_class is None + +nogil = _nogil() +gil = _nogil() +with_gil = _nogil() # Actually not a context manager, but compilation will give the right error. +del _nogil + + +class critical_section: + def __init__(self, arg0, arg1=None): + # It's ambiguous if this is being used as a decorator or context manager + # even with a callable arg. + self.arg0 = arg0 + def __call__(self, *args, **kwds): + return self.arg0(*args, **kwds) + def __enter__(self): + pass + def __exit__(self, exc_class, exc, tb): + return False + + +# Emulated types + +class CythonMetaType(type): + + def __getitem__(type, ix): + return array(type, ix) + +CythonTypeObject = CythonMetaType('CythonTypeObject', (object,), {}) + +class CythonType(CythonTypeObject): + + def _pointer(self, n=1): + for i in range(n): + self = pointer(self) + return self + +class PointerType(CythonType): + + def __init__(self, value=None): + if isinstance(value, (ArrayType, PointerType)): + self._items = [cast(self._basetype, a) for a in value._items] + elif isinstance(value, list): + self._items = [cast(self._basetype, a) for a in value] + elif value is None or value == 0: + self._items = [] + else: + raise ValueError + + def __getitem__(self, ix): + if ix < 0: + raise IndexError("negative indexing not allowed in C") + return self._items[ix] + + def __setitem__(self, ix, value): + if ix < 0: + raise IndexError("negative indexing not allowed in C") + self._items[ix] = cast(self._basetype, value) + + def __eq__(self, value): + if value is None and not self._items: + return True + elif type(self) != type(value): + return False + else: + return not self._items and not value._items + + def __repr__(self): + return f"{self._basetype} *" + + +class ArrayType(PointerType): + + def __init__(self, value=None): + if value is None: + self._items = [None] * self._n + else: + super().__init__(value) + + +class StructType(CythonType): + + def __init__(self, *posargs, **data): + if not (posargs or data): + return + if posargs and data: + raise ValueError('Cannot accept both positional and keyword arguments.') + + # Allow 'cast_from' as single positional or keyword argument. + if data and len(data) == 1 and 'cast_from' in data: + cast_from = data.pop('cast_from') + elif len(posargs) == 1 and type(posargs[0]) is type(self): + cast_from, posargs = posargs[0], () + elif posargs: + for key, arg in zip(self._members, posargs): + setattr(self, key, arg) + return + else: + for key, value in data.items(): + if key not in self._members: + raise ValueError("Invalid struct attribute for %s: %s" % ( + self.__class__.__name__, key)) + setattr(self, key, value) + return + + # do cast + if data: + raise ValueError('Cannot accept keyword arguments when casting.') + if type(cast_from) is not type(self): + raise ValueError('Cannot cast from %s' % cast_from) + for key, value in cast_from.__dict__.items(): + setattr(self, key, value) + + def __setattr__(self, key, value): + if key in self._members: + self.__dict__[key] = cast(self._members[key], value) + else: + raise AttributeError("Struct has no member '%s'" % key) + + +class UnionType(CythonType): + + def __init__(self, cast_from=_Unspecified, **data): + if cast_from is not _Unspecified: + # do type cast + if len(data) > 0: + raise ValueError('Cannot accept keyword arguments when casting.') + if isinstance(cast_from, dict): + datadict = cast_from + elif type(cast_from) is type(self): + datadict = cast_from.__dict__ + else: + raise ValueError('Cannot cast from %s' % cast_from) + else: + datadict = data + if len(datadict) > 1: + raise AttributeError("Union can only store one field at a time.") + for key, value in datadict.items(): + setattr(self, key, value) + + def __setattr__(self, key, value): + if key == '__dict__': + CythonType.__setattr__(self, key, value) + elif key in self._members: + self.__dict__ = {key: cast(self._members[key], value)} + else: + raise AttributeError("Union has no member '%s'" % key) + + +class pointer(PointerType): + # Implemented as class to support both 'pointer(int)' and 'pointer[int]'. + def __new__(cls, basetype): + class PointerInstance(PointerType): + _basetype = basetype + return PointerInstance + + def __class_getitem__(cls, basetype): + return cls(basetype) + + +class array(ArrayType): + # Implemented as class to support both 'array(int, 5)' and 'array[int, 5]'. + def __new__(cls, basetype, n): + class ArrayInstance(ArrayType): + _basetype = basetype + _n = n + return ArrayInstance + + def __class_getitem__(cls, item): + basetype, n = item + return cls(basetype, item) + + +def struct(**members): + class StructInstance(StructType): + _members = members + for key in members: + setattr(StructInstance, key, None) + return StructInstance + +def union(**members): + class UnionInstance(UnionType): + _members = members + for key in members: + setattr(UnionInstance, key, None) + return UnionInstance + + +class typedef(CythonType): + + def __init__(self, type, name=None): + self._basetype = type + self.name = name + + def __call__(self, *arg): + value = cast(self._basetype, *arg) + return value + + def __repr__(self): + return self.name or str(self._basetype) + + __getitem__ = index_type + + +class const(typedef): + def __init__(self, type, name=None): + name = f"const {name or repr(type)}" + super().__init__(type, name) + + def __class_getitem__(cls, base_type): + return const(base_type) + + +class volatile(typedef): + def __init__(self, type, name=None): + name = f"volatile {name or repr(type)}" + super().__init__(type, name) + + def __class_getitem__(cls, base_type): + return volatile(base_type) + + +class _FusedType(CythonType): + __getitem__ = index_type + + +def fused_type(*args): + if not args: + raise TypeError("Expected at least one type as argument") + + # Find the numeric type with biggest rank if all types are numeric + rank = -1 + for type in args: + if type not in (py_int, py_long, py_float, py_complex): + break + + if type_ordering.index(type) > rank: + result_type = type + else: + return result_type + + # Not a simple numeric type, return a fused type instance. The result + # isn't really meant to be used, as we can't keep track of the context in + # pure-mode. Casting won't do anything in this case. + return _FusedType() + + +def _specialized_from_args(signatures, args, kwargs): + "Perhaps this should be implemented in a TreeFragment in Cython code" + raise Exception("yet to be implemented") + + +py_int = typedef(int, "int") +py_long = typedef(int, "long") # for legacy Py2 code only +py_float = typedef(float, "float") +py_complex = typedef(complex, "double complex") + + +# Predefined types + +int_types = [ + 'char', + 'short', + 'Py_UNICODE', + 'int', + 'Py_UCS4', + 'long', + 'longlong', + 'Py_hash_t', + 'Py_ssize_t', + 'size_t', + 'ssize_t', + 'ptrdiff_t', +] +float_types = [ + 'longdouble', + 'double', + 'float', +] +complex_types = [ + 'longdoublecomplex', + 'doublecomplex', + 'floatcomplex', + 'complex', +] +other_types = [ + 'bint', + 'void', + 'Py_tss_t', +] + +to_repr = { + 'longlong': 'long long', + 'longdouble': 'long double', + 'longdoublecomplex': 'long double complex', + 'doublecomplex': 'double complex', + 'floatcomplex': 'float complex', +}.get + +gs = globals() + +gs['unicode'] = typedef(str, 'unicode') + +for name in int_types: + reprname = to_repr(name, name) + gs[name] = typedef(py_int, reprname) + if name not in ('Py_UNICODE', 'Py_UCS4', 'Py_hash_t', 'ptrdiff_t') and not name.endswith('size_t'): + gs['u'+name] = typedef(py_int, "unsigned " + reprname) + gs['s'+name] = typedef(py_int, "signed " + reprname) + +for name in float_types: + gs[name] = typedef(py_float, to_repr(name, name)) + +for name in complex_types: + gs[name] = typedef(py_complex, to_repr(name, name)) + +del name, reprname + +bint = typedef(bool, "bint") +void = typedef(None, "void") +Py_tss_t = typedef(None, "Py_tss_t") + +# Generate const types. +for t in int_types + float_types + complex_types + other_types: + for t in (t, f'u{t}', f's{t}'): + if t in gs: + gs[f"const_{t}"] = const(gs[t], t) + +# Generate pointer types: p_int, p_const_char, etc. +for i in range(1, 4): + for const_ in ('', 'const_'): + for t in int_types: + for t in (t, f'u{t}', f's{t}'): + if t in gs: + gs[f"{'p'*i}_{const_}{t}"] = pointer(gs[f"{'p'*(i-1)}{'_' if i > 1 else ''}{const_}{t}"]) + + for t in float_types + complex_types: + gs[f"{'p'*i}_{const_}{t}"] = pointer(gs[f"{'p'*(i-1)}{'_' if i > 1 else ''}{const_}{t}"]) + + gs[f"{'p'*i}_const_bint"] = pointer(gs[f"{'p'*(i-1)}{'_' if i > 1 else ''}const_bint"]) + for t in other_types: + gs[f"{'p'*i}_{t}"] = pointer(gs[f"{'p'*(i-1)}{'_' if i > 1 else ''}{t}"]) + +del t, const_, i + +NULL = gs['p_void'](0) + +del gs + + +def __getattr__(name): + # looks like 'gs' has some users out there by now... + if name == 'gs': + import warnings + warnings.warn( + "'gs' is not a publicly exposed name in cython.*. Use vars() or globals() instead.", + DeprecationWarning) + return globals() + raise AttributeError(f"'cython' has no attribute {name!r}") + + +integral = floating = numeric = _FusedType() + +type_ordering = [py_int, py_long, py_float, py_complex] + +class CythonDotParallel: + """ + The cython.parallel module. + """ + + __all__ = ['parallel', 'prange', 'threadid'] + + def parallel(self, num_threads=None): + return nogil + + def prange(self, start=0, stop=None, step=1, nogil=False, schedule=None, chunksize=None, num_threads=None): + if stop is None: + stop = start + start = 0 + return range(start, stop, step) + + def threadid(self): + return 0 + + # def threadsavailable(self): + # return 1 + +class CythonDotImportedFromElsewhere: + """ + cython.dataclasses just shadows the standard library modules of the same name + """ + def __init__(self, module): + self.__path__ = [] + self.__file__ = None + self.__name__ = module + self.__package__ = module + + def __getattr__(self, attr): + # we typically only expect this to be called once + from importlib import import_module + import sys + try: + mod = import_module(self.__name__) + except ImportError: + # but if they don't exist (Python is not sufficiently up-to-date) then + # you can't use them + raise AttributeError("%s: the standard library module %s is not available" % + (attr, self.__name__)) + sys.modules['cython.%s' % self.__name__] = mod + return getattr(mod, attr) + +class CythonCImports: + """ + Simplistic module mock to make cimports sort-of work in Python code. + """ + def __init__(self, module, **attributes): + self.__path__ = [] + self.__file__ = None + self.__name__ = module + self.__package__ = module + if attributes: + self.__dict__.update(attributes) + + def __getattr__(self, item): + if item.startswith('__') and item.endswith('__'): + raise AttributeError(item) + + package = self.__package__[len('cython.cimports.'):] + + from importlib import import_module + try: + return import_module(item, package or None) + except ImportError: + ex = AttributeError(item) + ex.__cause__ = None + raise ex + + +import math, sys +sys.modules['cython.parallel'] = CythonDotParallel() +sys.modules['cython.cimports.libc.math'] = math +sys.modules['cython.cimports.libc'] = CythonCImports('cython.cimports.libc', math=math) +sys.modules['cython.cimports'] = CythonCImports('cython.cimports', libc=sys.modules['cython.cimports.libc']) + +# In pure Python mode @cython.dataclasses.dataclass and dataclass field should just +# shadow the standard library ones (if they are available) +dataclasses = sys.modules['cython.dataclasses'] = CythonDotImportedFromElsewhere('dataclasses') +del math, sys + +class pymutex: + def __init__(self): + import threading + self._l = threading.Lock() + + def acquire(self): + return self._l.acquire() + + def release(self): + return self._l.release() + + def __enter__(self): + return self._l.__enter__() + + def __exit__(self, exc_type, exc_value, traceback): + return self._l.__exit__(exc_type, exc_value, traceback) + +pythread_type_lock = pymutex diff --git a/venv/lib/python3.10/site-packages/Cython/Shadow.pyi b/venv/lib/python3.10/site-packages/Cython/Shadow.pyi new file mode 100644 index 0000000000000000000000000000000000000000..4d3202cb54f12f3f0a8ded8412c646668b9beede --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Shadow.pyi @@ -0,0 +1,521 @@ +import dataclasses as dataclasses +from builtins import (int as py_int, float as py_float, + bool as py_bool, str as py_str, complex as py_complex) +from types import TracebackType +from typing import ( + Any, Iterable, Sequence, Optional, Type, TypeVar, Generic, Callable, overload, + TypeAlias, Annotated, +) + +# Type checkers assume typing_extensions is always present +from typing_extensions import Literal, ParamSpec, overload, final as final + +# Normally all imports aren't exported in stub files but we can explicitly expose +# imports by using import ... as ... (with the same name) which was done for +# dataclasses and the final decorator. + +__version__: str + +# Predefined types + +Py_UCS4 = py_int | str +Py_UNICODE = py_int | str + +bint = py_bool +void = Type[None] +basestring = py_str +unicode = py_str + +compiled: bool + + +_T = TypeVar('_T') +_P = ParamSpec('_P') +_C = TypeVar('_C', bound='Callable') +_TypeT = TypeVar('_TypeT', bound='Type') +_Decorator = Callable[[_C], _C] + + +_func_deco: _Decorator + +cfunc = ccall = compile = ufunc = _func_deco + +def locals(**kwargs: Any) -> _Decorator: ... + +def _class_deco(__cls: _TypeT) -> _TypeT: ... + +cclass = internal = c_api_binop_methods = type_version_tag = no_gc_clear = no_gc = total_ordering = _class_deco + +# May be a bit hard to read but essentially means: +# > Returns a callable that takes another callable with these parameters and *some* +# > return value, then returns another callable with the same parameters but +# > the return type is the previous 'type' parameter. +# On Python 3.5, the latest version of Mypy available is 0.910 which doesn't understand ParamSpec +def returns(__type: Type[_T]) -> Callable[[Callable[_P, object]], Callable[_P, _T]]: ... # type: ignore + +def exceptval(__val: Any, *, check: bool = False) -> _Decorator: ... + +class _EmptyDecoratorAndManager(object): + @overload + def __call__(self, __val: bool) -> _Decorator: ... + + @overload + def __call__(self, __func: _C) -> _C: ... + + def __enter__(self) -> None: ... + + def __exit__( + self, + exc_type: Optional[Type[BaseException]], + exc: Optional[BaseException], + tb: Optional[TracebackType] + ) -> None: ... +_empty_decorator_and_manager: _EmptyDecoratorAndManager + +@overload +def _compiler_directive(__func: _C) -> _C: ... + +@overload +def _compiler_directive(__val: bool = ...) -> _Decorator: ... + +# These all come from 'Compiler directives' on Source Files and Compilation. +# The following directives are missing as they need to be global: +# - c_string_type +# - c_string_encoding +# Note that c_api_binop_methods and type_version_tag is defined above. + +annotation_typing = returns = wraparound = boundscheck = initializedcheck = \ + nonecheck = cdivision = cdivision_warnings = \ + profile = linetrace = infer_types = \ + freelist = auto_pickle = cpow = trashcan = \ + auto_cpdef = c_api_binop_methods = \ + allow_none_for_extension_args = callspec = show_performance_hints = \ + cpp_locals = py2_import = iterable_coroutine = remove_unreachable = \ + _empty_decorator_and_manager + +binding = embedsignature = always_allow_keywords = unraisable_tracebacks = \ + cpp_locals = \ + _compiler_directive + +# overflowcheck() has to be specialized because there is also overflowcheck.fold +class _OverflowcheckClass: + def __call__(self, __val: bool = ...) -> _Decorator: ... + + def fold(self, __val: bool = ...) -> _Decorator: ... + +overflowcheck = _OverflowcheckClass() + +class optimize: + @staticmethod + def use_switch(__val: bool = ...) -> _Decorator: ... + + @staticmethod + def unpack_method_calls(__val: bool = ...) -> _Decorator: ... + +class warn: + @staticmethod + def undeclared(__val: bool = ...) -> _Decorator: ... + + @staticmethod + def unreachable(__val: bool = ...) -> _Decorator: ... + + @staticmethod + def maybe_uninitialized(__val: bool = ...) -> _Decorator: ... + + @staticmethod + def unused(__val: bool = ...) -> _Decorator: ... + + @staticmethod + def unused_argument(__val: bool = ...) -> _Decorator: ... + + @staticmethod + def multiple_declarators(__val: bool = ...) -> _Decorator: ... + +@overload +def inline(__func: _C) -> _C: ... + +@overload +def inline(__code: str, *, get_type: Callable[[object, object], str] = ..., lib_dir: str = ..., + cython_include_dirs: Iterable[str] = ..., cython_compiler_directives: Iterable[str] = ..., + force: bool = ..., quiet: bool = ..., locals: dict[str, str] = ..., globals: dict[str, str] = ..., + language_level: str = ...) -> Any: ... + +def cdiv(__a: int, __b: int) -> int: ... + +def cmod(__a: int, __b: int) -> int: ... + +@overload +def cast(__t: Type[_T], __value: Any) -> _T: ... + +# On Python 3.5, the latest version of Mypy available is 0.910 which doesn't understand ParamSpec +@overload +def cast(__t: Callable[_P, _T], *args: _P.args, **kwargs: _P.kwargs) -> _T: ... # type: ignore + +def sizeof(__obj: object) -> int: ... + +def typeof(__obj: object) -> str: ... + +def address(__obj: object) -> PointerType: ... + +const: TypeAlias = Annotated[_T, "cython.const"] +volatile: TypeAlias = Annotated[_T, "cython.volatile"] + + +@overload +def declare( + t: Optional[Callable[..., _T]] = ..., + value: Any = ..., +) -> _T: + ... + +# This one is for attributes, they cannot have initializers through cython.declare() currently. +@overload +def declare( + t: Callable[..., _T], + *, + visibility: Literal['public', 'readonly', 'private'] = ..., +) -> _T: + ... + +@overload +def declare(**kwargs: type) -> None: ... + + +class _nogil: + @overload + def __call__(self, __val: bool) -> _Decorator: ... + + @overload + def __call__(self, __func: _C) -> _C: ... + + @overload + def __call__(self) -> '_nogil': ... + + def __enter__(self) -> None: ... + + def __exit__( + self, + exc_type: Optional[Type[BaseException]], + exc: Optional[BaseException], + tb: Optional[TracebackType] + ) -> None: ... + +nogil = gil = _nogil + + +class _ArrayType(Generic[_T]): + is_array: bool + subtypes: Sequence[str] + dtype: _T + ndim: int + is_c_contig: bool + is_f_contig: bool + inner_contig: bool + broadcasting: Any + + # broadcasting is not used, so it's not clear about its type + def __init__(self, dtype: _T, ndim: int, is_c_contig: bool = ..., + is_f_contig: bool = ..., inner_contig: bool = ..., + broadcasting: Any = ...) -> None: ... + def __repr__(self) -> str: ... + + +class CythonTypeObject(object): + ... + +class CythonType(CythonTypeObject): + ... + +class PointerType(CythonType, Generic[_T]): + def __init__( + self, + value: Optional[ArrayType[_T] | PointerType[_T] | list[_T] | int] = ... + ) -> None: ... + def __getitem__(self, ix: int) -> _T: ... + def __setitem__(self, ix: int, value: _T) -> None: ... + def __eq__(self, value: object) -> bool: ... + def __repr__(self) -> str: ... + +class ArrayType(PointerType[_T]): + def __init__(self) -> None: ... + +def index_type( + base_type: _T, item: tuple | slice | int) -> _ArrayType[_T]: ... + +class pointer(PointerType[_T]): + def __new__(cls, basetype: _T) -> Type[PointerType[_T]]: ... + def __class_getitem__(cls, basetype: _T) -> Type[PointerType[_T]]: ... + +class array(ArrayType[_T]): + def __new__(basetype: _T, n: int) -> Type[ArrayType[_T, int]]: ... + def __class_getitem__(cls, item: tuple[_T, int]) -> Type[ArrayType[_T, int]]: ... + +def struct(**members: type) -> Type[Any]: ... + +def union(**members: type) -> Type[Any]: ... + +def fused_type(*args: Any) -> Type[Any]: ... + + +class typedef(CythonType, Generic[_T]): + name: str + + def __init__(self, type: _T, name: Optional[str] = ...) -> None: ... + def __call__(self, *arg: Any) -> _T: ... + def __repr__(self) -> str: ... + __getitem__ = index_type + +NULL: pointer[Any] + +##### START: GENERATED LIST OF GENERATED TYPES ##### +# Generated by "Tools/cython-generate-shadow-pyi.py" on 2024-09-24 11:45:22.474391 + +const_bint : TypeAlias = const[bint] +p_const_bint = pointer[const[bint]] +pp_const_bint = pointer[pointer[const[bint]]] +ppp_const_bint = pointer[pointer[pointer[const[bint]]]] +p_bint = pointer[bint] +pp_bint = pointer[pointer[bint]] +ppp_bint = pointer[pointer[pointer[bint]]] +char : TypeAlias = py_int +const_char : TypeAlias = const[py_int] +p_const_char : TypeAlias = pointer[const[py_int]] +pp_const_char = pointer[pointer[const[py_int]]] +ppp_const_char = pointer[pointer[pointer[const[py_int]]]] +p_char = pointer[py_int] +pp_char = pointer[pointer[py_int]] +ppp_char = pointer[pointer[pointer[py_int]]] +complex : TypeAlias = py_complex +const_complex : TypeAlias = const[py_complex] +p_const_complex = pointer[const[py_complex]] +pp_const_complex = pointer[pointer[const[py_complex]]] +ppp_const_complex = pointer[pointer[pointer[const[py_complex]]]] +p_complex = pointer[py_complex] +pp_complex = pointer[pointer[py_complex]] +ppp_complex = pointer[pointer[pointer[py_complex]]] +double : TypeAlias = py_float +const_double : TypeAlias = const[py_float] +p_const_double = pointer[const[py_float]] +pp_const_double = pointer[pointer[const[py_float]]] +ppp_const_double = pointer[pointer[pointer[const[py_float]]]] +p_double = pointer[py_float] +pp_double = pointer[pointer[py_float]] +ppp_double = pointer[pointer[pointer[py_float]]] +doublecomplex : TypeAlias = py_complex +const_doublecomplex : TypeAlias = const[py_complex] +p_const_doublecomplex = pointer[const[py_complex]] +pp_const_doublecomplex = pointer[pointer[const[py_complex]]] +ppp_const_doublecomplex = pointer[pointer[pointer[const[py_complex]]]] +p_doublecomplex = pointer[py_complex] +pp_doublecomplex = pointer[pointer[py_complex]] +ppp_doublecomplex = pointer[pointer[pointer[py_complex]]] +float : TypeAlias = py_float +const_float : TypeAlias = const[py_float] +p_const_float = pointer[const[py_float]] +pp_const_float = pointer[pointer[const[py_float]]] +ppp_const_float = pointer[pointer[pointer[const[py_float]]]] +p_float = pointer[py_float] +pp_float = pointer[pointer[py_float]] +ppp_float = pointer[pointer[pointer[py_float]]] +floatcomplex : TypeAlias = py_complex +const_floatcomplex : TypeAlias = const[py_complex] +p_const_floatcomplex = pointer[const[py_complex]] +pp_const_floatcomplex = pointer[pointer[const[py_complex]]] +ppp_const_floatcomplex = pointer[pointer[pointer[const[py_complex]]]] +p_floatcomplex = pointer[py_complex] +pp_floatcomplex = pointer[pointer[py_complex]] +ppp_floatcomplex = pointer[pointer[pointer[py_complex]]] +int : TypeAlias = py_int +const_int : TypeAlias = const[py_int] +p_const_int = pointer[const[py_int]] +pp_const_int = pointer[pointer[const[py_int]]] +ppp_const_int = pointer[pointer[pointer[const[py_int]]]] +p_int = pointer[py_int] +pp_int = pointer[pointer[py_int]] +ppp_int = pointer[pointer[pointer[py_int]]] +long : TypeAlias = py_int +const_long : TypeAlias = const[py_int] +p_const_long = pointer[const[py_int]] +pp_const_long = pointer[pointer[const[py_int]]] +ppp_const_long = pointer[pointer[pointer[const[py_int]]]] +p_long = pointer[py_int] +pp_long = pointer[pointer[py_int]] +ppp_long = pointer[pointer[pointer[py_int]]] +py_long : TypeAlias = py_int +longdouble : TypeAlias = py_float +const_longdouble : TypeAlias = const[py_float] +p_const_longdouble = pointer[const[py_float]] +pp_const_longdouble = pointer[pointer[const[py_float]]] +ppp_const_longdouble = pointer[pointer[pointer[const[py_float]]]] +p_longdouble = pointer[py_float] +pp_longdouble = pointer[pointer[py_float]] +ppp_longdouble = pointer[pointer[pointer[py_float]]] +longdoublecomplex : TypeAlias = py_complex +const_longdoublecomplex : TypeAlias = const[py_complex] +p_const_longdoublecomplex = pointer[const[py_complex]] +pp_const_longdoublecomplex = pointer[pointer[const[py_complex]]] +ppp_const_longdoublecomplex = pointer[pointer[pointer[const[py_complex]]]] +p_longdoublecomplex = pointer[py_complex] +pp_longdoublecomplex = pointer[pointer[py_complex]] +ppp_longdoublecomplex = pointer[pointer[pointer[py_complex]]] +longlong : TypeAlias = py_int +const_longlong : TypeAlias = const[py_int] +p_const_longlong = pointer[const[py_int]] +pp_const_longlong = pointer[pointer[const[py_int]]] +ppp_const_longlong = pointer[pointer[pointer[const[py_int]]]] +p_longlong = pointer[py_int] +pp_longlong = pointer[pointer[py_int]] +ppp_longlong = pointer[pointer[pointer[py_int]]] +schar : TypeAlias = py_int +const_schar : TypeAlias = const[py_int] +p_const_schar = pointer[const[py_int]] +pp_const_schar = pointer[pointer[const[py_int]]] +ppp_const_schar = pointer[pointer[pointer[const[py_int]]]] +p_schar = pointer[py_int] +pp_schar = pointer[pointer[py_int]] +ppp_schar = pointer[pointer[pointer[py_int]]] +short : TypeAlias = py_int +const_short : TypeAlias = const[py_int] +p_const_short = pointer[const[py_int]] +pp_const_short = pointer[pointer[const[py_int]]] +ppp_const_short = pointer[pointer[pointer[const[py_int]]]] +p_short = pointer[py_int] +pp_short = pointer[pointer[py_int]] +ppp_short = pointer[pointer[pointer[py_int]]] +sint : TypeAlias = py_int +const_sint : TypeAlias = const[py_int] +p_const_sint = pointer[const[py_int]] +pp_const_sint = pointer[pointer[const[py_int]]] +ppp_const_sint = pointer[pointer[pointer[const[py_int]]]] +p_sint = pointer[py_int] +pp_sint = pointer[pointer[py_int]] +ppp_sint = pointer[pointer[pointer[py_int]]] +slong : TypeAlias = py_int +const_slong : TypeAlias = const[py_int] +p_const_slong = pointer[const[py_int]] +pp_const_slong = pointer[pointer[const[py_int]]] +ppp_const_slong = pointer[pointer[pointer[const[py_int]]]] +p_slong = pointer[py_int] +pp_slong = pointer[pointer[py_int]] +ppp_slong = pointer[pointer[pointer[py_int]]] +slonglong : TypeAlias = py_int +const_slonglong : TypeAlias = const[py_int] +p_const_slonglong = pointer[const[py_int]] +pp_const_slonglong = pointer[pointer[const[py_int]]] +ppp_const_slonglong = pointer[pointer[pointer[const[py_int]]]] +p_slonglong = pointer[py_int] +pp_slonglong = pointer[pointer[py_int]] +ppp_slonglong = pointer[pointer[pointer[py_int]]] +sshort : TypeAlias = py_int +const_sshort : TypeAlias = const[py_int] +p_const_sshort = pointer[const[py_int]] +pp_const_sshort = pointer[pointer[const[py_int]]] +ppp_const_sshort = pointer[pointer[pointer[const[py_int]]]] +p_sshort = pointer[py_int] +pp_sshort = pointer[pointer[py_int]] +ppp_sshort = pointer[pointer[pointer[py_int]]] +Py_hash_t : TypeAlias = py_int +const_Py_hash_t : TypeAlias = const[py_int] +p_const_Py_hash_t = pointer[const[py_int]] +pp_const_Py_hash_t = pointer[pointer[const[py_int]]] +ppp_const_Py_hash_t = pointer[pointer[pointer[const[py_int]]]] +p_Py_hash_t = pointer[py_int] +pp_Py_hash_t = pointer[pointer[py_int]] +ppp_Py_hash_t = pointer[pointer[pointer[py_int]]] +ptrdiff_t : TypeAlias = py_int +const_ptrdiff_t : TypeAlias = const[py_int] +p_const_ptrdiff_t = pointer[const[py_int]] +pp_const_ptrdiff_t = pointer[pointer[const[py_int]]] +ppp_const_ptrdiff_t = pointer[pointer[pointer[const[py_int]]]] +p_ptrdiff_t = pointer[py_int] +pp_ptrdiff_t = pointer[pointer[py_int]] +ppp_ptrdiff_t = pointer[pointer[pointer[py_int]]] +size_t : TypeAlias = py_int +const_size_t : TypeAlias = const[py_int] +p_const_size_t = pointer[const[py_int]] +pp_const_size_t = pointer[pointer[const[py_int]]] +ppp_const_size_t = pointer[pointer[pointer[const[py_int]]]] +p_size_t = pointer[py_int] +pp_size_t = pointer[pointer[py_int]] +ppp_size_t = pointer[pointer[pointer[py_int]]] +ssize_t : TypeAlias = py_int +const_ssize_t : TypeAlias = const[py_int] +p_const_ssize_t = pointer[const[py_int]] +pp_const_ssize_t = pointer[pointer[const[py_int]]] +ppp_const_ssize_t = pointer[pointer[pointer[const[py_int]]]] +p_ssize_t = pointer[py_int] +pp_ssize_t = pointer[pointer[py_int]] +ppp_ssize_t = pointer[pointer[pointer[py_int]]] +Py_ssize_t : TypeAlias = py_int +const_Py_ssize_t : TypeAlias = const[py_int] +p_const_Py_ssize_t = pointer[const[py_int]] +pp_const_Py_ssize_t = pointer[pointer[const[py_int]]] +ppp_const_Py_ssize_t = pointer[pointer[pointer[const[py_int]]]] +p_Py_ssize_t = pointer[py_int] +pp_Py_ssize_t = pointer[pointer[py_int]] +ppp_Py_ssize_t = pointer[pointer[pointer[py_int]]] +Py_tss_t : TypeAlias = Any +const_Py_tss_t : TypeAlias = const[Any] +p_Py_tss_t = pointer[Any] +pp_Py_tss_t = pointer[pointer[Any]] +ppp_Py_tss_t = pointer[pointer[pointer[Any]]] +uchar : TypeAlias = py_int +const_uchar : TypeAlias = const[py_int] +p_const_uchar = pointer[const[py_int]] +pp_const_uchar = pointer[pointer[const[py_int]]] +ppp_const_uchar = pointer[pointer[pointer[const[py_int]]]] +p_uchar = pointer[py_int] +pp_uchar = pointer[pointer[py_int]] +ppp_uchar = pointer[pointer[pointer[py_int]]] +const_Py_UCS4 : TypeAlias = const[py_int] +p_const_Py_UCS4 = pointer[const[py_int]] +pp_const_Py_UCS4 = pointer[pointer[const[py_int]]] +ppp_const_Py_UCS4 = pointer[pointer[pointer[const[py_int]]]] +p_Py_UCS4 = pointer[py_int] +pp_Py_UCS4 = pointer[pointer[py_int]] +ppp_Py_UCS4 = pointer[pointer[pointer[py_int]]] +uint : TypeAlias = py_int +const_uint : TypeAlias = const[py_int] +p_const_uint = pointer[const[py_int]] +pp_const_uint = pointer[pointer[const[py_int]]] +ppp_const_uint = pointer[pointer[pointer[const[py_int]]]] +p_uint = pointer[py_int] +pp_uint = pointer[pointer[py_int]] +ppp_uint = pointer[pointer[pointer[py_int]]] +ulong : TypeAlias = py_int +const_ulong : TypeAlias = const[py_int] +p_const_ulong = pointer[const[py_int]] +pp_const_ulong = pointer[pointer[const[py_int]]] +ppp_const_ulong = pointer[pointer[pointer[const[py_int]]]] +p_ulong = pointer[py_int] +pp_ulong = pointer[pointer[py_int]] +ppp_ulong = pointer[pointer[pointer[py_int]]] +ulonglong : TypeAlias = py_int +const_ulonglong : TypeAlias = const[py_int] +p_const_ulonglong = pointer[const[py_int]] +pp_const_ulonglong = pointer[pointer[const[py_int]]] +ppp_const_ulonglong = pointer[pointer[pointer[const[py_int]]]] +p_ulonglong = pointer[py_int] +pp_ulonglong = pointer[pointer[py_int]] +ppp_ulonglong = pointer[pointer[pointer[py_int]]] +const_Py_UNICODE : TypeAlias = const[py_int] +p_const_Py_UNICODE = pointer[const[py_int]] +pp_const_Py_UNICODE = pointer[pointer[const[py_int]]] +ppp_const_Py_UNICODE = pointer[pointer[pointer[const[py_int]]]] +p_Py_UNICODE = pointer[py_int] +pp_Py_UNICODE = pointer[pointer[py_int]] +ppp_Py_UNICODE = pointer[pointer[pointer[py_int]]] +ushort : TypeAlias = py_int +const_ushort : TypeAlias = const[py_int] +p_const_ushort = pointer[const[py_int]] +pp_const_ushort = pointer[pointer[const[py_int]]] +ppp_const_ushort = pointer[pointer[pointer[const[py_int]]]] +p_ushort = pointer[py_int] +pp_ushort = pointer[pointer[py_int]] +ppp_ushort = pointer[pointer[pointer[py_int]]] +const_void : TypeAlias = const[Any] +p_void = pointer[Any] +pp_void = pointer[pointer[Any]] +ppp_void = pointer[pointer[pointer[Any]]] + +##### END: GENERATED LIST OF GENERATED TYPES ##### diff --git a/venv/lib/python3.10/site-packages/Cython/StringIOTree.cpython-310-x86_64-linux-gnu.so b/venv/lib/python3.10/site-packages/Cython/StringIOTree.cpython-310-x86_64-linux-gnu.so new file mode 100644 index 0000000000000000000000000000000000000000..8ee2ee8aa74d77dd7c1e2be028b71f45d06a8e20 Binary files /dev/null and b/venv/lib/python3.10/site-packages/Cython/StringIOTree.cpython-310-x86_64-linux-gnu.so differ diff --git a/venv/lib/python3.10/site-packages/Cython/StringIOTree.py b/venv/lib/python3.10/site-packages/Cython/StringIOTree.py new file mode 100644 index 0000000000000000000000000000000000000000..2e73400aab6f83b51187522a5d09cdc30c402bde --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/StringIOTree.py @@ -0,0 +1,170 @@ +r""" +Implements a buffer with insertion points. When you know you need to +"get back" to a place and write more later, simply call insertion_point() +at that spot and get a new StringIOTree object that is "left behind". + +EXAMPLE: + +>>> a = StringIOTree() +>>> _= a.write('first\n') +>>> b = a.insertion_point() +>>> _= a.write('third\n') +>>> _= b.write('second\n') +>>> a.getvalue().split() +['first', 'second', 'third'] + +>>> c = b.insertion_point() +>>> d = c.insertion_point() +>>> _= d.write('alpha\n') +>>> _= b.write('gamma\n') +>>> _= c.write('beta\n') +>>> b.getvalue().split() +['second', 'alpha', 'beta', 'gamma'] + +>>> try: from cStringIO import StringIO +... except ImportError: from io import StringIO + +>>> i = StringIOTree() +>>> d.insert(i) +>>> _= i.write('inserted\n') +>>> out = StringIO() +>>> a.copyto(out) +>>> out.getvalue().split() +['first', 'second', 'alpha', 'inserted', 'beta', 'gamma', 'third'] +""" + + +from io import StringIO + + +class StringIOTree: + """ + See module docs. + """ + + def __init__(self, stream=None): + self.prepended_children = [] + if stream is None: + stream = StringIO() + self.stream = stream + self.write = stream.write + self.markers = [] + + def empty(self): + if self.stream.tell(): + return False + return all([child.empty() for child in self.prepended_children]) if self.prepended_children else True + + def getvalue(self): + content = [] + self._collect_in(content) + return "".join(content) + + def _collect_in(self, target_list): + x: StringIOTree + for x in self.prepended_children: + x._collect_in(target_list) + stream_content = self.stream.getvalue() + if stream_content: + target_list.append(stream_content) + + def copyto(self, target): + """Potentially cheaper than getvalue as no string concatenation + needs to happen.""" + child: StringIOTree + for child in self.prepended_children: + child.copyto(target) + stream_content = self.stream.getvalue() + if stream_content: + target.write(stream_content) + + def commit(self): + # Save what we have written until now so that the buffer + # itself is empty -- this makes it ready for insertion + if self.stream.tell(): + self.prepended_children.append(StringIOTree(self.stream)) + self.prepended_children[-1].markers = self.markers + self.markers = [] + self.stream = StringIO() + self.write = self.stream.write + + def reset(self): + self.prepended_children = [] + self.markers = [] + self.stream = StringIO() + self.write = self.stream.write + + def insert(self, iotree): + """ + Insert a StringIOTree (and all of its contents) at this location. + Further writing to self appears after what is inserted. + """ + self.commit() + self.prepended_children.append(iotree) + + def insertion_point(self): + """ + Returns a new StringIOTree, which is left behind at the current position + (it what is written to the result will appear right before whatever is + next written to self). + + Calling getvalue() or copyto() on the result will only return the + contents written to it. + """ + # Save what we have written until now + # This is so that getvalue on the result doesn't include it. + self.commit() + # Construct the new forked object to return + other = StringIOTree() + self.prepended_children.append(other) + return other + + def allmarkers(self): + c: StringIOTree + children = self.prepended_children + return [m for c in children for m in c.allmarkers()] + self.markers + + """ + # Print the result of allmarkers in a nice human-readable form. Use it only for debugging. + # Prints e.g. + # /path/to/source.pyx: + # cython line 2 maps to 3299-3343 + # cython line 4 maps to 2236-2245 2306 3188-3201 + # /path/to/othersource.pyx: + # cython line 3 maps to 1234-1270 + # ... + # Note: In the example above, 3343 maps to line 2, 3344 does not. + def print_hr_allmarkers(self): + from collections import defaultdict + markers = self.allmarkers() + totmap = defaultdict(lambda: defaultdict(list)) + for c_lineno, (cython_desc, cython_lineno) in enumerate(markers): + if cython_lineno > 0 and cython_desc.filename is not None: + totmap[cython_desc.filename][cython_lineno].append(c_lineno + 1) + reprstr = "" + if totmap == 0: + reprstr += "allmarkers is empty\n" + try: + sorted(totmap.items()) + except: + print(totmap) + print(totmap.items()) + for cython_path, filemap in sorted(totmap.items()): + reprstr += cython_path + ":\n" + for cython_lineno, c_linenos in sorted(filemap.items()): + reprstr += "\tcython line " + str(cython_lineno) + " maps to " + i = 0 + while i < len(c_linenos): + reprstr += str(c_linenos[i]) + flag = False + while i+1 < len(c_linenos) and c_linenos[i+1] == c_linenos[i]+1: + i += 1 + flag = True + if flag: + reprstr += "-" + str(c_linenos[i]) + " " + i += 1 + reprstr += "\n" + + import sys + sys.stdout.write(reprstr) + """ diff --git a/venv/lib/python3.10/site-packages/Cython/Tempita/__init__.py b/venv/lib/python3.10/site-packages/Cython/Tempita/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..41a0ce3d0efa247760db266bace8e34a4b5dd9fa --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Tempita/__init__.py @@ -0,0 +1,4 @@ +# The original Tempita implements all of its templating code here. +# Moved it to _tempita.py to make the compilation portable. + +from ._tempita import * diff --git a/venv/lib/python3.10/site-packages/Cython/Tempita/__pycache__/__init__.cpython-310.pyc b/venv/lib/python3.10/site-packages/Cython/Tempita/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5f284404492166eb48946c564be2f62536a37459 Binary files /dev/null and b/venv/lib/python3.10/site-packages/Cython/Tempita/__pycache__/__init__.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/Cython/Tempita/__pycache__/_looper.cpython-310.pyc b/venv/lib/python3.10/site-packages/Cython/Tempita/__pycache__/_looper.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7a44e075c87c6a992449558d81ecf43fe69bcd48 Binary files /dev/null and b/venv/lib/python3.10/site-packages/Cython/Tempita/__pycache__/_looper.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/Cython/Tempita/__pycache__/_tempita.cpython-310.pyc b/venv/lib/python3.10/site-packages/Cython/Tempita/__pycache__/_tempita.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9391d61639819d90bb18b00f539008c0ff239a00 Binary files /dev/null and b/venv/lib/python3.10/site-packages/Cython/Tempita/__pycache__/_tempita.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/Cython/Tempita/_looper.py b/venv/lib/python3.10/site-packages/Cython/Tempita/_looper.py new file mode 100644 index 0000000000000000000000000000000000000000..53fb6d11b35a02b79cc297bba15508bda0ace392 --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Tempita/_looper.py @@ -0,0 +1,154 @@ +""" +Helper for looping over sequences, particular in templates. + +Often in a loop in a template it's handy to know what's next up, +previously up, if this is the first or last item in the sequence, etc. +These can be awkward to manage in a normal Python loop, but using the +looper you can get a better sense of the context. Use like:: + + >>> for loop, item in looper(['a', 'b', 'c']): + ... print loop.number, item + ... if not loop.last: + ... print '---' + 1 a + --- + 2 b + --- + 3 c + +""" + +__all__ = ['looper'] + + +class looper: + """ + Helper for looping (particularly in templates) + + Use this like:: + + for loop, item in looper(seq): + if loop.first: + ... + """ + + def __init__(self, seq): + self.seq = seq + + def __iter__(self): + return looper_iter(self.seq) + + def __repr__(self): + return '<%s for %r>' % ( + self.__class__.__name__, self.seq) + + +class looper_iter: + + def __init__(self, seq): + self.seq = list(seq) + self.pos = 0 + + def __iter__(self): + return self + + def __next__(self): + if self.pos >= len(self.seq): + raise StopIteration + result = loop_pos(self.seq, self.pos), self.seq[self.pos] + self.pos += 1 + return result + + +class loop_pos: + + def __init__(self, seq, pos): + self.seq = seq + self.pos = pos + + def __repr__(self): + return '' % ( + self.seq[self.pos], self.pos) + + def index(self): + return self.pos + index = property(index) + + def number(self): + return self.pos + 1 + number = property(number) + + def item(self): + return self.seq[self.pos] + item = property(item) + + def __next__(self): + try: + return self.seq[self.pos + 1] + except IndexError: + return None + __next__ = property(__next__) + + def previous(self): + if self.pos == 0: + return None + return self.seq[self.pos - 1] + previous = property(previous) + + def odd(self): + return not self.pos % 2 + odd = property(odd) + + def even(self): + return self.pos % 2 + even = property(even) + + def first(self): + return self.pos == 0 + first = property(first) + + def last(self): + return self.pos == len(self.seq) - 1 + last = property(last) + + def length(self): + return len(self.seq) + length = property(length) + + def first_group(self, getter=None): + """ + Returns true if this item is the start of a new group, + where groups mean that some attribute has changed. The getter + can be None (the item itself changes), an attribute name like + ``'.attr'``, a function, or a dict key or list index. + """ + if self.first: + return True + return self._compare_group(self.item, self.previous, getter) + + def last_group(self, getter=None): + """ + Returns true if this item is the end of a new group, + where groups mean that some attribute has changed. The getter + can be None (the item itself changes), an attribute name like + ``'.attr'``, a function, or a dict key or list index. + """ + if self.last: + return True + return self._compare_group(self.item, self.__next__, getter) + + def _compare_group(self, item, other, getter): + if getter is None: + return item != other + elif (isinstance(getter, str) + and getter.startswith('.')): + getter = getter[1:] + if getter.endswith('()'): + getter = getter[:-2] + return getattr(item, getter)() != getattr(other, getter)() + else: + return getattr(item, getter) != getattr(other, getter) + elif hasattr(getter, '__call__'): + return getter(item) != getter(other) + else: + return item[getter] != other[getter] diff --git a/venv/lib/python3.10/site-packages/Cython/Tempita/_tempita.py b/venv/lib/python3.10/site-packages/Cython/Tempita/_tempita.py new file mode 100644 index 0000000000000000000000000000000000000000..114ed47fca746175d23137396b292270d802a98d --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Tempita/_tempita.py @@ -0,0 +1,1091 @@ +""" +A small templating language + +This implements a small templating language. This language implements +if/elif/else, for/continue/break, expressions, and blocks of Python +code. The syntax is:: + + {{any expression (function calls etc)}} + {{any expression | filter}} + {{for x in y}}...{{endfor}} + {{if x}}x{{elif y}}y{{else}}z{{endif}} + {{py:x=1}} + {{py: + def foo(bar): + return 'baz' + }} + {{default var = default_value}} + {{# comment}} + +You use this with the ``Template`` class or the ``sub`` shortcut. +The ``Template`` class takes the template string and the name of +the template (for errors) and a default namespace. Then (like +``string.Template``) you can call the ``tmpl.substitute(**kw)`` +method to make a substitution (or ``tmpl.substitute(a_dict)``). + +``sub(content, **kw)`` substitutes the template immediately. You +can use ``__name='tmpl.html'`` to set the name of the template. + +If there are syntax errors ``TemplateError`` will be raised. +""" + + +import re +import sys +import os +import tokenize +from io import StringIO + +from ._looper import looper + +__all__ = ['TemplateError', 'Template', 'sub', 'bunch'] + +in_re = re.compile(r'\s+in\s+') +var_re = re.compile(r'^[a-z_][a-z0-9_]*$', re.I) + +def coerce_text(v): + if not isinstance(v, str): + if hasattr(v, '__str__'): + return str(v) + else: + return bytes(v) + return v + +class TemplateError(Exception): + """Exception raised while parsing a template + """ + + def __init__(self, message, position, name=None): + Exception.__init__(self, message) + self.position = position + self.name = name + + def __str__(self): + msg = ' '.join(self.args) + if self.position: + msg = '%s at line %s column %s' % ( + msg, self.position[0], self.position[1]) + if self.name: + msg += ' in %s' % self.name + return msg + + +class _TemplateContinue(Exception): + pass + + +class _TemplateBreak(Exception): + pass + + +def get_file_template(name, from_template): + path = os.path.join(os.path.dirname(from_template.name), name) + return from_template.__class__.from_filename( + path, namespace=from_template.namespace, + get_template=from_template.get_template) + + +class Template: + + default_namespace = { + 'start_braces': '{{', + 'end_braces': '}}', + 'looper': looper, + } + + default_encoding = 'utf8' + default_inherit = None + + def __init__(self, content, name=None, namespace=None, stacklevel=None, + get_template=None, default_inherit=None, line_offset=0, + delimiters=None, delimeters=None): + self.content = content + + # set delimiters + if delimeters: + import warnings + warnings.warn( + "'delimeters' kwarg is being deprecated in favor of correctly" + " spelled 'delimiters'. Please adjust your code.", + DeprecationWarning + ) + if delimiters is None: + delimiters = delimeters + if delimiters is None: + delimiters = (self.default_namespace['start_braces'], + self.default_namespace['end_braces']) + else: + #assert len(delimiters) == 2 and all([isinstance(delimiter, str) + # for delimiter in delimiters]) + self.default_namespace = self.__class__.default_namespace.copy() + self.default_namespace['start_braces'] = delimiters[0] + self.default_namespace['end_braces'] = delimiters[1] + self.delimiters = self.delimeters = delimiters # Keep a legacy read-only copy, but don't use it. + + self._unicode = isinstance(content, str) + if name is None and stacklevel is not None: + try: + caller = sys._getframe(stacklevel) + except ValueError: + pass + else: + globals = caller.f_globals + lineno = caller.f_lineno + if '__file__' in globals: + name = globals['__file__'] + if name.endswith('.pyc') or name.endswith('.pyo'): + name = name[:-1] + elif '__name__' in globals: + name = globals['__name__'] + else: + name = '' + if lineno: + name += ':%s' % lineno + self.name = name + self._parsed = parse(content, name=name, line_offset=line_offset, delimiters=self.delimiters) + if namespace is None: + namespace = {} + self.namespace = namespace + self.get_template = get_template + if default_inherit is not None: + self.default_inherit = default_inherit + + def from_filename(cls, filename, namespace=None, encoding=None, + default_inherit=None, get_template=get_file_template): + with open(filename, 'rb') as f: + c = f.read() + if encoding: + c = c.decode(encoding) + return cls(content=c, name=filename, namespace=namespace, + default_inherit=default_inherit, get_template=get_template) + + from_filename = classmethod(from_filename) + + def __repr__(self): + return '<%s %s name=%r>' % ( + self.__class__.__name__, + hex(id(self))[2:], self.name) + + def substitute(self, *args, **kw): + if args: + if kw: + raise TypeError( + "You can only give positional *or* keyword arguments") + if len(args) > 1: + raise TypeError( + "You can only give one positional argument") + if not hasattr(args[0], 'items'): + raise TypeError( + "If you pass in a single argument, you must pass in a dictionary-like object (with a .items() method); you gave %r" + % (args[0],)) + kw = args[0] + ns = kw + ns['__template_name__'] = self.name + if self.namespace: + ns.update(self.namespace) + result, defs, inherit = self._interpret(ns) + if not inherit: + inherit = self.default_inherit + if inherit: + result = self._interpret_inherit(result, defs, inherit, ns) + return result + + def _interpret(self, ns): + __traceback_hide__ = True + parts = [] + defs = {} + self._interpret_codes(self._parsed, ns, out=parts, defs=defs) + if '__inherit__' in defs: + inherit = defs.pop('__inherit__') + else: + inherit = None + return ''.join(parts), defs, inherit + + def _interpret_inherit(self, body, defs, inherit_template, ns): + __traceback_hide__ = True + if not self.get_template: + raise TemplateError( + 'You cannot use inheritance without passing in get_template', + position=None, name=self.name) + templ = self.get_template(inherit_template, self) + self_ = TemplateObject(self.name) + for name, value in defs.items(): + setattr(self_, name, value) + self_.body = body + ns = ns.copy() + ns['self'] = self_ + return templ.substitute(ns) + + def _interpret_codes(self, codes, ns, out, defs): + __traceback_hide__ = True + for item in codes: + if isinstance(item, str): + out.append(item) + else: + self._interpret_code(item, ns, out, defs) + + def _interpret_code(self, code, ns, out, defs): + __traceback_hide__ = True + name, pos = code[0], code[1] + if name == 'py': + self._exec(code[2], ns, pos) + elif name == 'continue': + raise _TemplateContinue() + elif name == 'break': + raise _TemplateBreak() + elif name == 'for': + vars, expr, content = code[2], code[3], code[4] + expr = self._eval(expr, ns, pos) + self._interpret_for(vars, expr, content, ns, out, defs) + elif name == 'cond': + parts = code[2:] + self._interpret_if(parts, ns, out, defs) + elif name == 'expr': + parts = code[2].split('|') + base = self._eval(parts[0], ns, pos) + for part in parts[1:]: + func = self._eval(part, ns, pos) + base = func(base) + out.append(self._repr(base, pos)) + elif name == 'default': + var, expr = code[2], code[3] + if var not in ns: + result = self._eval(expr, ns, pos) + ns[var] = result + elif name == 'inherit': + expr = code[2] + value = self._eval(expr, ns, pos) + defs['__inherit__'] = value + elif name == 'def': + name = code[2] + signature = code[3] + parts = code[4] + ns[name] = defs[name] = TemplateDef(self, name, signature, body=parts, ns=ns, + pos=pos) + elif name == 'comment': + return + else: + assert 0, "Unknown code: %r" % name + + def _interpret_for(self, vars, expr, content, ns, out, defs): + __traceback_hide__ = True + for item in expr: + if len(vars) == 1: + ns[vars[0]] = item + else: + if len(vars) != len(item): + raise ValueError( + 'Need %i items to unpack (got %i items)' + % (len(vars), len(item))) + for name, value in zip(vars, item): + ns[name] = value + try: + self._interpret_codes(content, ns, out, defs) + except _TemplateContinue: + continue + except _TemplateBreak: + break + + def _interpret_if(self, parts, ns, out, defs): + __traceback_hide__ = True + # @@: if/else/else gets through + for part in parts: + assert not isinstance(part, str) + name, pos = part[0], part[1] + if name == 'else': + result = True + else: + result = self._eval(part[2], ns, pos) + if result: + self._interpret_codes(part[3], ns, out, defs) + break + + def _eval(self, code, ns, pos): + __traceback_hide__ = True + try: + try: + value = eval(code, self.default_namespace, ns) + except SyntaxError as e: + raise SyntaxError( + 'invalid syntax in expression: %s' % code) + return value + except Exception as e: + if getattr(e, 'args', None): + arg0 = e.args[0] + else: + arg0 = coerce_text(e) + e.args = (self._add_line_info(arg0, pos),) + raise + + def _exec(self, code, ns, pos): + __traceback_hide__ = True + try: + exec(code, self.default_namespace, ns) + except Exception as e: + if e.args: + e.args = (self._add_line_info(e.args[0], pos),) + else: + e.args = (self._add_line_info(None, pos),) + raise + + def _repr(self, value, pos): + __traceback_hide__ = True + try: + if value is None: + return '' + if self._unicode: + try: + value = str(value) + except UnicodeDecodeError: + value = bytes(value) + else: + if not isinstance(value, str): + value = coerce_text(value) + if (isinstance(value, str) + and self.default_encoding): + value = value.encode(self.default_encoding) + except Exception as e: + e.args = (self._add_line_info(e.args[0], pos),) + raise + else: + if self._unicode and isinstance(value, bytes): + if not self.default_encoding: + raise UnicodeDecodeError( + 'Cannot decode bytes value %r into unicode ' + '(no default_encoding provided)' % value) + try: + value = value.decode(self.default_encoding) + except UnicodeDecodeError as e: + raise UnicodeDecodeError( + e.encoding, + e.object, + e.start, + e.end, + e.reason + ' in string %r' % value) + elif not self._unicode and isinstance(value, str): + if not self.default_encoding: + raise UnicodeEncodeError( + 'Cannot encode unicode value %r into bytes ' + '(no default_encoding provided)' % value) + value = value.encode(self.default_encoding) + return value + + def _add_line_info(self, msg, pos): + msg = "%s at line %s column %s" % ( + msg, pos[0], pos[1]) + if self.name: + msg += " in file %s" % self.name + return msg + + +def sub(content, delimiters=None, **kw): + name = kw.get('__name') + delimeters = kw.pop('delimeters') if 'delimeters' in kw else None # for legacy code + tmpl = Template(content, name=name, delimiters=delimiters, delimeters=delimeters) + return tmpl.substitute(kw) + + +def paste_script_template_renderer(content, vars, filename=None): + tmpl = Template(content, name=filename) + return tmpl.substitute(vars) + + +class bunch(dict): + + def __init__(self, **kw): + for name, value in kw.items(): + setattr(self, name, value) + + def __setattr__(self, name, value): + self[name] = value + + def __getattr__(self, name): + try: + return self[name] + except KeyError: + raise AttributeError(name) + + def __getitem__(self, key): + if 'default' in self: + try: + return dict.__getitem__(self, key) + except KeyError: + return dict.__getitem__(self, 'default') + else: + return dict.__getitem__(self, key) + + def __repr__(self): + return '<%s %s>' % ( + self.__class__.__name__, + ' '.join(['%s=%r' % (k, v) for k, v in sorted(self.items())])) + + +class TemplateDef: + def __init__(self, template, func_name, func_signature, + body, ns, pos, bound_self=None): + self._template = template + self._func_name = func_name + self._func_signature = func_signature + self._body = body + self._ns = ns + self._pos = pos + self._bound_self = bound_self + + def __repr__(self): + return '' % ( + self._func_name, self._func_signature, + self._template.name, self._pos) + + def __str__(self): + return self() + + def __call__(self, *args, **kw): + values = self._parse_signature(args, kw) + ns = self._ns.copy() + ns.update(values) + if self._bound_self is not None: + ns['self'] = self._bound_self + out = [] + subdefs = {} + self._template._interpret_codes(self._body, ns, out, subdefs) + return ''.join(out) + + def __get__(self, obj, type=None): + if obj is None: + return self + return self.__class__( + self._template, self._func_name, self._func_signature, + self._body, self._ns, self._pos, bound_self=obj) + + def _parse_signature(self, args, kw): + values = {} + sig_args, var_args, var_kw, defaults = self._func_signature + extra_kw = {} + for name, value in kw.items(): + if not var_kw and name not in sig_args: + raise TypeError( + 'Unexpected argument %s' % name) + if name in sig_args: + values[sig_args] = value + else: + extra_kw[name] = value + args = list(args) + sig_args = list(sig_args) + while args: + while sig_args and sig_args[0] in values: + sig_args.pop(0) + if sig_args: + name = sig_args.pop(0) + values[name] = args.pop(0) + elif var_args: + values[var_args] = tuple(args) + break + else: + raise TypeError( + 'Extra position arguments: %s' + % ', '.join([repr(v) for v in args])) + for name, value_expr in defaults.items(): + if name not in values: + values[name] = self._template._eval( + value_expr, self._ns, self._pos) + for name in sig_args: + if name not in values: + raise TypeError( + 'Missing argument: %s' % name) + if var_kw: + values[var_kw] = extra_kw + return values + + +class TemplateObject: + + def __init__(self, name): + self.__name = name + self.get = TemplateObjectGetter(self) + + def __repr__(self): + return '<%s %s>' % (self.__class__.__name__, self.__name) + + +class TemplateObjectGetter: + + def __init__(self, template_obj): + self.__template_obj = template_obj + + def __getattr__(self, attr): + return getattr(self.__template_obj, attr, Empty) + + def __repr__(self): + return '<%s around %r>' % (self.__class__.__name__, self.__template_obj) + + +class _Empty: + def __call__(self, *args, **kw): + return self + + def __str__(self): + return '' + + def __repr__(self): + return 'Empty' + + def __unicode__(self): + return '' + + def __iter__(self): + return iter(()) + + def __bool__(self): + return False + +Empty = _Empty() +del _Empty + +############################################################ +## Lexing and Parsing +############################################################ + + +def lex(s, name=None, trim_whitespace=True, line_offset=0, delimiters=None): + """ + Lex a string into chunks: + + >>> lex('hey') + ['hey'] + >>> lex('hey {{you}}') + ['hey ', ('you', (1, 7))] + >>> lex('hey {{') + Traceback (most recent call last): + ... + TemplateError: No }} to finish last expression at line 1 column 7 + >>> lex('hey }}') + Traceback (most recent call last): + ... + TemplateError: }} outside expression at line 1 column 7 + >>> lex('hey {{ {{') + Traceback (most recent call last): + ... + TemplateError: {{ inside expression at line 1 column 10 + + """ + if delimiters is None: + delimiters = ( Template.default_namespace['start_braces'], + Template.default_namespace['end_braces'] ) + in_expr = False + chunks = [] + last = 0 + last_pos = (line_offset + 1, 1) + + token_re = re.compile(r'%s|%s' % (re.escape(delimiters[0]), + re.escape(delimiters[1]))) + for match in token_re.finditer(s): + expr = match.group(0) + pos = find_position(s, match.end(), last, last_pos) + if expr == delimiters[0] and in_expr: + raise TemplateError('%s inside expression' % delimiters[0], + position=pos, + name=name) + elif expr == delimiters[1] and not in_expr: + raise TemplateError('%s outside expression' % delimiters[1], + position=pos, + name=name) + if expr == delimiters[0]: + part = s[last:match.start()] + if part: + chunks.append(part) + in_expr = True + else: + chunks.append((s[last:match.start()], last_pos)) + in_expr = False + last = match.end() + last_pos = pos + if in_expr: + raise TemplateError('No %s to finish last expression' % delimiters[1], + name=name, position=last_pos) + part = s[last:] + if part: + chunks.append(part) + if trim_whitespace: + chunks = trim_lex(chunks) + return chunks + +statement_re = re.compile(r'^(?:if |elif |for |def |inherit |default |py:)') +single_statements = ['else', 'endif', 'endfor', 'enddef', 'continue', 'break'] +trail_whitespace_re = re.compile(r'\n\r?[\t ]*$') +lead_whitespace_re = re.compile(r'^[\t ]*\n') + + +def trim_lex(tokens): + r""" + Takes a lexed set of tokens, and removes whitespace when there is + a directive on a line by itself: + + >>> tokens = lex('{{if x}}\nx\n{{endif}}\ny', trim_whitespace=False) + >>> tokens + [('if x', (1, 3)), '\nx\n', ('endif', (3, 3)), '\ny'] + >>> trim_lex(tokens) + [('if x', (1, 3)), 'x\n', ('endif', (3, 3)), 'y'] + """ + last_trim = None + for i, current in enumerate(tokens): + if isinstance(current, str): + # we don't trim this + continue + item = current[0] + if not statement_re.search(item) and item not in single_statements: + continue + if not i: + prev = '' + else: + prev = tokens[i - 1] + if i + 1 >= len(tokens): + next_chunk = '' + else: + next_chunk = tokens[i + 1] + if (not isinstance(next_chunk, str) + or not isinstance(prev, str)): + continue + prev_ok = not prev or trail_whitespace_re.search(prev) + if i == 1 and not prev.strip(): + prev_ok = True + if last_trim is not None and last_trim + 2 == i and not prev.strip(): + prev_ok = 'last' + if (prev_ok + and (not next_chunk or lead_whitespace_re.search(next_chunk) + or (i == len(tokens) - 2 and not next_chunk.strip()))): + if prev: + if ((i == 1 and not prev.strip()) + or prev_ok == 'last'): + tokens[i - 1] = '' + else: + m = trail_whitespace_re.search(prev) + # +1 to leave the leading \n on: + prev = prev[:m.start() + 1] + tokens[i - 1] = prev + if next_chunk: + last_trim = i + if i == len(tokens) - 2 and not next_chunk.strip(): + tokens[i + 1] = '' + else: + m = lead_whitespace_re.search(next_chunk) + next_chunk = next_chunk[m.end():] + tokens[i + 1] = next_chunk + return tokens + + +def find_position(string, index, last_index, last_pos): + """Given a string and index, return (line, column)""" + lines = string.count('\n', last_index, index) + if lines > 0: + column = index - string.rfind('\n', last_index, index) + else: + column = last_pos[1] + (index - last_index) + return (last_pos[0] + lines, column) + + +def parse(s, name=None, line_offset=0, delimiters=None): + r""" + Parses a string into a kind of AST + + >>> parse('{{x}}') + [('expr', (1, 3), 'x')] + >>> parse('foo') + ['foo'] + >>> parse('{{if x}}test{{endif}}') + [('cond', (1, 3), ('if', (1, 3), 'x', ['test']))] + >>> parse('series->{{for x in y}}x={{x}}{{endfor}}') + ['series->', ('for', (1, 11), ('x',), 'y', ['x=', ('expr', (1, 27), 'x')])] + >>> parse('{{for x, y in z:}}{{continue}}{{endfor}}') + [('for', (1, 3), ('x', 'y'), 'z', [('continue', (1, 21))])] + >>> parse('{{py:x=1}}') + [('py', (1, 3), 'x=1')] + >>> parse('{{if x}}a{{elif y}}b{{else}}c{{endif}}') + [('cond', (1, 3), ('if', (1, 3), 'x', ['a']), ('elif', (1, 12), 'y', ['b']), ('else', (1, 23), None, ['c']))] + + Some exceptions:: + + >>> parse('{{continue}}') + Traceback (most recent call last): + ... + TemplateError: continue outside of for loop at line 1 column 3 + >>> parse('{{if x}}foo') + Traceback (most recent call last): + ... + TemplateError: No {{endif}} at line 1 column 3 + >>> parse('{{else}}') + Traceback (most recent call last): + ... + TemplateError: else outside of an if block at line 1 column 3 + >>> parse('{{if x}}{{for x in y}}{{endif}}{{endfor}}') + Traceback (most recent call last): + ... + TemplateError: Unexpected endif at line 1 column 25 + >>> parse('{{if}}{{endif}}') + Traceback (most recent call last): + ... + TemplateError: if with no expression at line 1 column 3 + >>> parse('{{for x y}}{{endfor}}') + Traceback (most recent call last): + ... + TemplateError: Bad for (no "in") in 'x y' at line 1 column 3 + >>> parse('{{py:x=1\ny=2}}') + Traceback (most recent call last): + ... + TemplateError: Multi-line py blocks must start with a newline at line 1 column 3 + """ + if delimiters is None: + delimiters = ( Template.default_namespace['start_braces'], + Template.default_namespace['end_braces'] ) + tokens = lex(s, name=name, line_offset=line_offset, delimiters=delimiters) + result = [] + while tokens: + next_chunk, tokens = parse_expr(tokens, name) + result.append(next_chunk) + return result + + +def parse_expr(tokens, name, context=()): + if isinstance(tokens[0], str): + return tokens[0], tokens[1:] + expr, pos = tokens[0] + expr = expr.strip() + if expr.startswith('py:'): + expr = expr[3:].lstrip(' \t') + if expr.startswith('\n') or expr.startswith('\r'): + expr = expr.lstrip('\r\n') + if '\r' in expr: + expr = expr.replace('\r\n', '\n') + expr = expr.replace('\r', '') + expr += '\n' + else: + if '\n' in expr: + raise TemplateError( + 'Multi-line py blocks must start with a newline', + position=pos, name=name) + return ('py', pos, expr), tokens[1:] + elif expr in ('continue', 'break'): + if 'for' not in context: + raise TemplateError( + 'continue outside of for loop', + position=pos, name=name) + return (expr, pos), tokens[1:] + elif expr.startswith('if '): + return parse_cond(tokens, name, context) + elif (expr.startswith('elif ') + or expr == 'else'): + raise TemplateError( + '%s outside of an if block' % expr.split()[0], + position=pos, name=name) + elif expr in ('if', 'elif', 'for'): + raise TemplateError( + '%s with no expression' % expr, + position=pos, name=name) + elif expr in ('endif', 'endfor', 'enddef'): + raise TemplateError( + 'Unexpected %s' % expr, + position=pos, name=name) + elif expr.startswith('for '): + return parse_for(tokens, name, context) + elif expr.startswith('default '): + return parse_default(tokens, name, context) + elif expr.startswith('inherit '): + return parse_inherit(tokens, name, context) + elif expr.startswith('def '): + return parse_def(tokens, name, context) + elif expr.startswith('#'): + return ('comment', pos, tokens[0][0]), tokens[1:] + return ('expr', pos, tokens[0][0]), tokens[1:] + + +def parse_cond(tokens, name, context): + start = tokens[0][1] + pieces = [] + context = context + ('if',) + while 1: + if not tokens: + raise TemplateError( + 'Missing {{endif}}', + position=start, name=name) + if (isinstance(tokens[0], tuple) + and tokens[0][0] == 'endif'): + return ('cond', start) + tuple(pieces), tokens[1:] + next_chunk, tokens = parse_one_cond(tokens, name, context) + pieces.append(next_chunk) + + +def parse_one_cond(tokens, name, context): + (first, pos), tokens = tokens[0], tokens[1:] + content = [] + if first.endswith(':'): + first = first[:-1] + if first.startswith('if '): + part = ('if', pos, first[3:].lstrip(), content) + elif first.startswith('elif '): + part = ('elif', pos, first[5:].lstrip(), content) + elif first == 'else': + part = ('else', pos, None, content) + else: + assert 0, "Unexpected token %r at %s" % (first, pos) + while 1: + if not tokens: + raise TemplateError( + 'No {{endif}}', + position=pos, name=name) + if (isinstance(tokens[0], tuple) + and (tokens[0][0] == 'endif' + or tokens[0][0].startswith('elif ') + or tokens[0][0] == 'else')): + return part, tokens + next_chunk, tokens = parse_expr(tokens, name, context) + content.append(next_chunk) + + +def parse_for(tokens, name, context): + first, pos = tokens[0] + tokens = tokens[1:] + context = ('for',) + context + content = [] + assert first.startswith('for '), first + if first.endswith(':'): + first = first[:-1] + first = first[3:].strip() + match = in_re.search(first) + if not match: + raise TemplateError( + 'Bad for (no "in") in %r' % first, + position=pos, name=name) + vars = first[:match.start()] + if '(' in vars: + raise TemplateError( + 'You cannot have () in the variable section of a for loop (%r)' + % vars, position=pos, name=name) + vars = tuple([ + v.strip() for v in first[:match.start()].split(',') + if v.strip()]) + expr = first[match.end():] + while 1: + if not tokens: + raise TemplateError( + 'No {{endfor}}', + position=pos, name=name) + if (isinstance(tokens[0], tuple) + and tokens[0][0] == 'endfor'): + return ('for', pos, vars, expr, content), tokens[1:] + next_chunk, tokens = parse_expr(tokens, name, context) + content.append(next_chunk) + + +def parse_default(tokens, name, context): + first, pos = tokens[0] + assert first.startswith('default ') + first = first.split(None, 1)[1] + parts = first.split('=', 1) + if len(parts) == 1: + raise TemplateError( + "Expression must be {{default var=value}}; no = found in %r" % first, + position=pos, name=name) + var = parts[0].strip() + if ',' in var: + raise TemplateError( + "{{default x, y = ...}} is not supported", + position=pos, name=name) + if not var_re.search(var): + raise TemplateError( + "Not a valid variable name for {{default}}: %r" + % var, position=pos, name=name) + expr = parts[1].strip() + return ('default', pos, var, expr), tokens[1:] + + +def parse_inherit(tokens, name, context): + first, pos = tokens[0] + assert first.startswith('inherit ') + expr = first.split(None, 1)[1] + return ('inherit', pos, expr), tokens[1:] + + +def parse_def(tokens, name, context): + first, start = tokens[0] + tokens = tokens[1:] + assert first.startswith('def ') + first = first.split(None, 1)[1] + if first.endswith(':'): + first = first[:-1] + if '(' not in first: + func_name = first + sig = ((), None, None, {}) + elif not first.endswith(')'): + raise TemplateError("Function definition doesn't end with ): %s" % first, + position=start, name=name) + else: + first = first[:-1] + func_name, sig_text = first.split('(', 1) + sig = parse_signature(sig_text, name, start) + context = context + ('def',) + content = [] + while 1: + if not tokens: + raise TemplateError( + 'Missing {{enddef}}', + position=start, name=name) + if (isinstance(tokens[0], tuple) + and tokens[0][0] == 'enddef'): + return ('def', start, func_name, sig, content), tokens[1:] + next_chunk, tokens = parse_expr(tokens, name, context) + content.append(next_chunk) + + +def parse_signature(sig_text, name, pos): + tokens = tokenize.generate_tokens(StringIO(sig_text).readline) + sig_args = [] + var_arg = None + var_kw = None + defaults = {} + + def get_token(pos=False): + try: + tok_type, tok_string, (srow, scol), (erow, ecol), line = next(tokens) + except StopIteration: + return tokenize.ENDMARKER, '' + if pos: + return tok_type, tok_string, (srow, scol), (erow, ecol) + else: + return tok_type, tok_string + while 1: + var_arg_type = None + tok_type, tok_string = get_token() + if tok_type == tokenize.ENDMARKER: + break + if tok_type == tokenize.OP and (tok_string == '*' or tok_string == '**'): + var_arg_type = tok_string + tok_type, tok_string = get_token() + if tok_type != tokenize.NAME: + raise TemplateError('Invalid signature: (%s)' % sig_text, + position=pos, name=name) + var_name = tok_string + tok_type, tok_string = get_token() + if tok_type == tokenize.ENDMARKER or (tok_type == tokenize.OP and tok_string == ','): + if var_arg_type == '*': + var_arg = var_name + elif var_arg_type == '**': + var_kw = var_name + else: + sig_args.append(var_name) + if tok_type == tokenize.ENDMARKER: + break + continue + if var_arg_type is not None: + raise TemplateError('Invalid signature: (%s)' % sig_text, + position=pos, name=name) + if tok_type == tokenize.OP and tok_string == '=': + nest_type = None + unnest_type = None + nest_count = 0 + start_pos = end_pos = None + parts = [] + while 1: + tok_type, tok_string, s, e = get_token(True) + if start_pos is None: + start_pos = s + end_pos = e + if tok_type == tokenize.ENDMARKER and nest_count: + raise TemplateError('Invalid signature: (%s)' % sig_text, + position=pos, name=name) + if (not nest_count and + (tok_type == tokenize.ENDMARKER or (tok_type == tokenize.OP and tok_string == ','))): + default_expr = isolate_expression(sig_text, start_pos, end_pos) + defaults[var_name] = default_expr + sig_args.append(var_name) + break + parts.append((tok_type, tok_string)) + if nest_count and tok_type == tokenize.OP and tok_string == nest_type: + nest_count += 1 + elif nest_count and tok_type == tokenize.OP and tok_string == unnest_type: + nest_count -= 1 + if not nest_count: + nest_type = unnest_type = None + elif not nest_count and tok_type == tokenize.OP and tok_string in ('(', '[', '{'): + nest_type = tok_string + nest_count = 1 + unnest_type = {'(': ')', '[': ']', '{': '}'}[nest_type] + return sig_args, var_arg, var_kw, defaults + + +def isolate_expression(string, start_pos, end_pos): + srow, scol = start_pos + srow -= 1 + erow, ecol = end_pos + erow -= 1 + lines = string.splitlines(True) + if srow == erow: + return lines[srow][scol:ecol] + parts = [lines[srow][scol:]] + parts.extend(lines[srow+1:erow]) + if erow < len(lines): + # It'll sometimes give (end_row_past_finish, 0) + parts.append(lines[erow][:ecol]) + return ''.join(parts) + +_fill_command_usage = """\ +%prog [OPTIONS] TEMPLATE arg=value + +Use py:arg=value to set a Python value; otherwise all values are +strings. +""" + + +def fill_command(args=None): + import sys + import optparse + import pkg_resources + import os + if args is None: + args = sys.argv[1:] + dist = pkg_resources.get_distribution('Paste') + parser = optparse.OptionParser( + version=coerce_text(dist), + usage=_fill_command_usage) + parser.add_option( + '-o', '--output', + dest='output', + metavar="FILENAME", + help="File to write output to (default stdout)") + parser.add_option( + '--env', + dest='use_env', + action='store_true', + help="Put the environment in as top-level variables") + options, args = parser.parse_args(args) + if len(args) < 1: + print('You must give a template filename') + sys.exit(2) + template_name = args[0] + args = args[1:] + vars = {} + if options.use_env: + vars.update(os.environ) + for value in args: + if '=' not in value: + print('Bad argument: %r' % value) + sys.exit(2) + name, value = value.split('=', 1) + if name.startswith('py:'): + name = name[:3] + value = eval(value) + vars[name] = value + if template_name == '-': + template_content = sys.stdin.read() + template_name = '' + else: + with open(template_name, 'rb') as f: + template_content = f.read() + template = Template(template_content, name=template_name) + result = template.substitute(vars) + if options.output: + with open(options.output, 'wb') as f: + f.write(result) + else: + sys.stdout.write(result) + +if __name__ == '__main__': + fill_command() diff --git a/venv/lib/python3.10/site-packages/Cython/TestUtils.py b/venv/lib/python3.10/site-packages/Cython/TestUtils.py new file mode 100644 index 0000000000000000000000000000000000000000..82ce1cd23b30a6b7c0c5f4605c80bc3c3b2c2f34 --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/TestUtils.py @@ -0,0 +1,410 @@ +import os +import re +import unittest +import shlex +import sys +import tempfile +import textwrap +from functools import partial + +from .Compiler import Errors +from .CodeWriter import CodeWriter +from .Compiler.TreeFragment import TreeFragment, strip_common_indent, StringParseContext +from .Compiler.Visitor import TreeVisitor, VisitorTransform +from .Compiler import TreePath +from .Compiler.ParseTreeTransforms import PostParse + + +class NodeTypeWriter(TreeVisitor): + def __init__(self): + super().__init__() + self._indents = 0 + self.result = [] + + def visit_Node(self, node): + if not self.access_path: + name = "(root)" + else: + tip = self.access_path[-1] + if tip[2] is not None: + name = "%s[%d]" % tip[1:3] + else: + name = tip[1] + + self.result.append(" " * self._indents + + "%s: %s" % (name, node.__class__.__name__)) + self._indents += 1 + self.visitchildren(node) + self._indents -= 1 + + +def treetypes(root): + """Returns a string representing the tree by class names. + There's a leading and trailing whitespace so that it can be + compared by simple string comparison while still making test + cases look ok.""" + w = NodeTypeWriter() + w.visit(root) + return "\n".join([""] + w.result + [""]) + + +class CythonTest(unittest.TestCase): + + def setUp(self): + Errors.init_thread() + + def tearDown(self): + Errors.init_thread() + + def assertLines(self, expected, result): + "Checks that the given strings or lists of strings are equal line by line" + if not isinstance(expected, list): + expected = expected.split("\n") + if not isinstance(result, list): + result = result.split("\n") + for idx, (expected_line, result_line) in enumerate(zip(expected, result)): + self.assertEqual(expected_line, result_line, + "Line %d:\nExp: %s\nGot: %s" % (idx, expected_line, result_line)) + self.assertEqual(len(expected), len(result), + "Unmatched lines. Got:\n%s\nExpected:\n%s" % ("\n".join(expected), "\n".join(result))) + + def codeToLines(self, tree): + writer = CodeWriter() + writer.write(tree) + return writer.result.lines + + def codeToString(self, tree): + return "\n".join(self.codeToLines(tree)) + + def assertCode(self, expected, result_tree): + result_lines = self.codeToLines(result_tree) + + expected_lines = strip_common_indent(expected.split("\n")) + + for idx, (line, expected_line) in enumerate(zip(result_lines, expected_lines)): + self.assertEqual(expected_line, line, + "Line %d:\nGot: %s\nExp: %s" % (idx, line, expected_line)) + self.assertEqual(len(result_lines), len(expected_lines), + "Unmatched lines. Got:\n%s\nExpected:\n%s" % ("\n".join(result_lines), expected)) + + def assertNodeExists(self, path, result_tree): + self.assertNotEqual(TreePath.find_first(result_tree, path), None, + "Path '%s' not found in result tree" % path) + + def fragment(self, code, pxds=None, pipeline=None): + "Simply create a tree fragment using the name of the test-case in parse errors." + if pxds is None: + pxds = {} + if pipeline is None: + pipeline = [] + name = self.id() + if name.startswith("__main__."): + name = name[len("__main__."):] + name = name.replace(".", "_") + return TreeFragment(code, name, pxds, pipeline=pipeline) + + def treetypes(self, root): + return treetypes(root) + + def should_fail(self, func, exc_type=Exception): + """Calls "func" and fails if it doesn't raise the right exception + (any exception by default). Also returns the exception in question. + """ + try: + func() + self.fail("Expected an exception of type %r" % exc_type) + except exc_type as e: + self.assertTrue(isinstance(e, exc_type)) + return e + + def should_not_fail(self, func): + """Calls func and succeeds if and only if no exception is raised + (i.e. converts exception raising into a failed testcase). Returns + the return value of func.""" + try: + return func() + except Exception as exc: + self.fail(str(exc)) + + +class TransformTest(CythonTest): + """ + Utility base class for transform unit tests. It is based around constructing + test trees (either explicitly or by parsing a Cython code string); running + the transform, serialize it using a customized Cython serializer (with + special markup for nodes that cannot be represented in Cython), + and do a string-comparison line-by-line of the result. + + To create a test case: + - Call run_pipeline. The pipeline should at least contain the transform you + are testing; pyx should be either a string (passed to the parser to + create a post-parse tree) or a node representing input to pipeline. + The result will be a transformed result. + + - Check that the tree is correct. If wanted, assertCode can be used, which + takes a code string as expected, and a ModuleNode in result_tree + (it serializes the ModuleNode to a string and compares line-by-line). + + All code strings are first stripped for whitespace lines and then common + indentation. + + Plans: One could have a pxd dictionary parameter to run_pipeline. + """ + + def run_pipeline(self, pipeline, pyx, pxds=None): + if pxds is None: + pxds = {} + tree = self.fragment(pyx, pxds).root + # Run pipeline + for T in pipeline: + tree = T(tree) + return tree + + +# For the test C code validation, we have to take care that the test directives (and thus +# the match strings) do not just appear in (multiline) C code comments containing the original +# Cython source code. Thus, we discard the comments before matching. +# This seems a prime case for re.VERBOSE, but it seems to match some of the whitespace. +_strip_c_comments = partial(re.compile( + re.sub(r'\s+', '', r''' + /[*] ( + (?: [^*\n] | [*][^/] )* + [\n] + (?: [^*] | [*][^/] )* + ) [*]/ + ''') +).sub, '') + +_strip_cython_code_from_html = partial(re.compile( + re.sub(r'\s\s+', '', r''' + (?: + 
+        (?:[^<]|<(?!/pre))+
+
+ )|(?: + ]*> + (?:[^<]|<(?!/style))+ + + ) + ''') +).sub, '') + + +def _parse_pattern(pattern): + start = end = None + if pattern.startswith('/'): + start, pattern = re.split(r"(?= os.path.getmtime(file_path): + write_file(file_path, content, dedent=dedent, encoding=encoding) + + +def py_parse_code(code): + """ + Compiles code far enough to get errors from the parser and post-parse stage. + + Is useful for checking for syntax errors, however it doesn't generate runable + code. + """ + context = StringParseContext("test") + # all the errors we care about are in the parsing or postparse stage + try: + with Errors.local_errors() as errors: + result = TreeFragment(code, pipeline=[PostParse(context)]) + result = result.substitute() + if errors: + raise errors[0] # compile error, which should get caught below + else: + return result + except Errors.CompileError as e: + raise SyntaxError(e.message_only) diff --git a/venv/lib/python3.10/site-packages/Cython/Tests/TestCodeWriter.py b/venv/lib/python3.10/site-packages/Cython/Tests/TestCodeWriter.py new file mode 100644 index 0000000000000000000000000000000000000000..47175834ca726de6f8072cb5e41082e98563262c --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Tests/TestCodeWriter.py @@ -0,0 +1,128 @@ +from Cython.TestUtils import CythonTest + +class TestCodeWriter(CythonTest): + # CythonTest uses the CodeWriter heavily, so do some checking by + # roundtripping Cython code through the test framework. + + # Note that this test is dependent upon the normal Cython parser + # to generate the input trees to the CodeWriter. This save *a lot* + # of time; better to spend that time writing other tests than perfecting + # this one... + + # Whitespace is very significant in this process: + # - always newline on new block (!) + # - indent 4 spaces + # - 1 space around every operator + + def t(self, codestr): + self.assertCode(codestr, self.fragment(codestr).root) + + def test_print(self): + self.t(""" + print(x + y ** 2) + print(x, y, z) + print(x + y, x + y * z, x * (y + z)) + """) + + def test_if(self): + self.t("if x:\n pass") + + def test_ifelifelse(self): + self.t(""" + if x: + pass + elif y: + pass + elif z + 34 ** 34 - 2: + pass + else: + pass + """) + + def test_def(self): + self.t(""" + def f(x, y, z): + pass + def f(x = 34, y = 54, z): + pass + """) + + def test_cdef(self): + self.t(""" + cdef f(x, y, z): + pass + cdef public void (x = 34, y = 54, z): + pass + cdef f(int *x, void *y, Value *z): + pass + cdef f(int **x, void **y, Value **z): + pass + cdef inline f(int &x, Value &z): + pass + """) + + def test_longness_and_signedness(self): + self.t("def f(unsigned long long long long long int y):\n pass") + + def test_signed_short(self): + self.t("def f(signed short int y):\n pass") + + def test_typed_args(self): + self.t("def f(int x, unsigned long int y):\n pass") + + def test_cdef_var(self): + self.t(""" + cdef int hello + cdef int hello = 4, x = 3, y, z + """) + + def test_for_loop(self): + self.t(""" + for x, y, z in f(g(h(34) * 2) + 23): + print(x, y, z) + else: + print(43) + """) + self.t(""" + for abc in (1, 2, 3): + print(x, y, z) + else: + print(43) + """) + + def test_while_loop(self): + self.t(""" + while True: + while True: + while True: + continue + """) + + def test_inplace_assignment(self): + self.t("x += 43") + + def test_cascaded_assignment(self): + self.t("x = y = z = abc = 43") + + def test_attribute(self): + self.t("a.x") + + def test_return_none(self): + self.t(""" + def f(x, y, z): + return + cdef f(x, y, z): + return + def f(x, y, z): + return None + cdef f(x, y, z): + return None + def f(x, y, z): + return 1234 + cdef f(x, y, z): + return 1234 + """) + +if __name__ == "__main__": + import unittest + unittest.main() diff --git a/venv/lib/python3.10/site-packages/Cython/Tests/TestCythonUtils.py b/venv/lib/python3.10/site-packages/Cython/Tests/TestCythonUtils.py new file mode 100644 index 0000000000000000000000000000000000000000..5cae90c134095eedc91a320bb8e0eb75323eff73 --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Tests/TestCythonUtils.py @@ -0,0 +1,202 @@ +import sys +import unittest +from io import StringIO + +from Cython.Utils import ( + _CACHE_NAME_PATTERN, _build_cache_name, _find_cache_attributes, + build_hex_version, cached_method, clear_method_caches, try_finally_contextmanager, + print_version, normalise_float_repr, +) + +METHOD_NAME = "cached_next" +CACHE_NAME = _build_cache_name(METHOD_NAME) +NAMES = CACHE_NAME, METHOD_NAME + +class Cached: + @cached_method + def cached_next(self, x): + return next(x) + + +class TestCythonUtils(unittest.TestCase): + def test_build_hex_version(self): + self.assertEqual('0x001D00A1', build_hex_version('0.29a1')) + self.assertEqual('0x001D03C4', build_hex_version('0.29.3rc4')) + self.assertEqual('0x001D00F0', build_hex_version('0.29')) + self.assertEqual('0x040000F0', build_hex_version('4.0')) + + ############################## Cached Methods ############################## + + def test_cache_method_name(self): + method_name = "foo" + cache_name = _build_cache_name(method_name) + match = _CACHE_NAME_PATTERN.match(cache_name) + + self.assertIsNot(match, None) + self.assertEqual(match.group(1), method_name) + + def test_requirements_for_Cached(self): + obj = Cached() + + self.assertFalse(hasattr(obj, CACHE_NAME)) + self.assertTrue(hasattr(obj, METHOD_NAME)) + self.set_of_names_equal(obj, set()) + + def set_of_names_equal(self, obj, value): + self.assertEqual(set(_find_cache_attributes(obj)), value) + + def test_find_cache_attributes(self): + obj = Cached() + method_name = "bar" + cache_name = _build_cache_name(method_name) + + setattr(obj, CACHE_NAME, {}) + setattr(obj, cache_name, {}) + + self.assertFalse(hasattr(obj, method_name)) + self.set_of_names_equal(obj, {NAMES, (cache_name, method_name)}) + + def test_cached_method(self): + obj = Cached() + value = iter(range(3)) + cache = {(value,): 0} + + # cache args + self.assertEqual(obj.cached_next(value), 0) + self.set_of_names_equal(obj, {NAMES}) + self.assertEqual(getattr(obj, CACHE_NAME), cache) + + # use cache + self.assertEqual(obj.cached_next(value), 0) + self.set_of_names_equal(obj, {NAMES}) + self.assertEqual(getattr(obj, CACHE_NAME), cache) + + def test_clear_method_caches(self): + obj = Cached() + value = iter(range(3)) + cache = {(value,): 1} + + obj.cached_next(value) # cache args + + clear_method_caches(obj) + self.set_of_names_equal(obj, set()) + + self.assertEqual(obj.cached_next(value), 1) + self.set_of_names_equal(obj, {NAMES}) + self.assertEqual(getattr(obj, CACHE_NAME), cache) + + def test_clear_method_caches_with_missing_method(self): + obj = Cached() + method_name = "bar" + cache_name = _build_cache_name(method_name) + names = cache_name, method_name + + setattr(obj, cache_name, object()) + + self.assertFalse(hasattr(obj, method_name)) + self.set_of_names_equal(obj, {names}) + + clear_method_caches(obj) + self.set_of_names_equal(obj, {names}) + + def test_try_finally_contextmanager(self): + states = [] + @try_finally_contextmanager + def gen(*args, **kwargs): + states.append("enter") + yield (args, kwargs) + states.append("exit") + + with gen(1, 2, 3, x=4) as call_args: + assert states == ["enter"] + self.assertEqual(call_args, ((1, 2, 3), {'x': 4})) + assert states == ["enter", "exit"] + + class MyException(RuntimeError): + pass + + del states[:] + with self.assertRaises(MyException): + with gen(1, 2, y=4) as call_args: + assert states == ["enter"] + self.assertEqual(call_args, ((1, 2), {'y': 4})) + raise MyException("FAIL INSIDE") + assert states == ["enter", "exit"] + + del states[:] + with self.assertRaises(StopIteration): + with gen(1, 2, y=4) as call_args: + assert states == ["enter"] + self.assertEqual(call_args, ((1, 2), {'y': 4})) + raise StopIteration("STOP") + assert states == ["enter", "exit"] + + def test_print_version(self): + orig_stderr = sys.stderr + orig_stdout = sys.stdout + stderr = sys.stderr = StringIO() + stdout = sys.stdout = StringIO() + try: + print_version() + finally: + sys.stdout = orig_stdout + sys.stderr = orig_stderr + + stdout = stdout.getvalue() + stderr = stderr.getvalue() + + from .. import __version__ as version + self.assertIn(version, stdout) + if stderr: # Depends on os.fstat(1/2). + self.assertIn(version, stderr) + + def test_print_version_stdouterr(self): + orig_stderr = sys.stderr + orig_stdout = sys.stdout + stdout = sys.stdout = sys.stderr = StringIO() # same! + try: + print_version() + finally: + sys.stdout = orig_stdout + sys.stderr = orig_stderr + + stdout = stdout.getvalue() + + from .. import __version__ as version + self.assertIn(version, stdout) + self.assertEqual(stdout.count(version), 1) + + def test_normalise_float_repr(self): + examples = [ + ('.0', '.0'), + ('.000000', '.0'), + ('.1', '.1'), + ('1.', '1.'), + ('1.0', '1.'), + ('1.000000000000000000000', '1.'), + ('00000000000000000000001.000000000000000000000', '1.'), + ('12345.0025', '12345.0025'), + ('1E5', '100000.'), + ('.1E-5', '.000001'), + ('1.1E-5', '.000011'), + ('12.3E-5', '.000123'), + ('.1E10', '1000000000.'), + ('1.1E10', '11000000000.'), + ('123.4E10', '1234000000000.'), + ('123.456E0', '123.456'), + ('123.456E-1', '12.3456'), + ('123.456E-2', '1.23456'), + ('123.456E1', '1234.56'), + ('123.456E2', '12345.6'), + ('2.1E80', '210000000000000000000000000000000000000000000000000000000000000000000000000000000.'), + ] + + for float_str, norm_str in examples: + self.assertEqual(float(float_str), float(norm_str)) # safety check for test data + + result = normalise_float_repr(float_str) + self.assertEqual(float(float_str), float(result)) + self.assertEqual( + result, norm_str, + "normalise_float_repr(%r) == %r != %r (%.330f)" % (float_str, result, norm_str, float(float_str)) + ) diff --git a/venv/lib/python3.10/site-packages/Cython/Tests/TestJediTyper.py b/venv/lib/python3.10/site-packages/Cython/Tests/TestJediTyper.py new file mode 100644 index 0000000000000000000000000000000000000000..cce3db3480dc841a34b008a044234901f5412c5c --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Tests/TestJediTyper.py @@ -0,0 +1,223 @@ +# tag: jedi + + +import sys +import os.path + +from textwrap import dedent +from contextlib import contextmanager +from tempfile import NamedTemporaryFile + +from Cython.Compiler.ParseTreeTransforms import NormalizeTree, InterpretCompilerDirectives +from Cython.Compiler import Main, Symtab, Visitor, Options +from Cython.TestUtils import TransformTest + +TOOLS_DIR = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', 'Tools')) + + +@contextmanager +def _tempfile(code): + code = dedent(code) + if not isinstance(code, bytes): + code = code.encode('utf8') + + with NamedTemporaryFile(suffix='.py') as f: + f.write(code) + f.seek(0) + yield f + + +def _test_typing(code, inject=False): + sys.path.insert(0, TOOLS_DIR) + try: + import jedityper + finally: + sys.path.remove(TOOLS_DIR) + lines = [] + with _tempfile(code) as f: + types = jedityper.analyse(f.name) + if inject: + lines = jedityper.inject_types(f.name, types) + return types, lines + + +class DeclarationsFinder(Visitor.VisitorTransform): + directives = None + + visit_Node = Visitor.VisitorTransform.recurse_to_children + + def visit_CompilerDirectivesNode(self, node): + if not self.directives: + self.directives = [] + self.directives.append(node) + self.visitchildren(node) + return node + + +class TestJediTyper(TransformTest): + def _test(self, code): + return _test_typing(code)[0] + + def test_typing_global_int_loop(self): + code = '''\ + for i in range(10): + a = i + 1 + ''' + types = self._test(code) + self.assertIn((None, (1, 0)), types) + variables = types.pop((None, (1, 0))) + self.assertFalse(types) + self.assertEqual({'a': {'int'}, 'i': {'int'}}, variables) + + def test_typing_function_int_loop(self): + code = '''\ + def func(x): + for i in range(x): + a = i + 1 + return a + ''' + types = self._test(code) + self.assertIn(('func', (1, 0)), types) + variables = types.pop(('func', (1, 0))) + self.assertFalse(types) + self.assertEqual({'a': {'int'}, 'i': {'int'}}, variables) + + def test_conflicting_types_in_function(self): + code = '''\ + def func(a, b): + print(a) + a = 1 + b += a + a = 'abc' + return a, str(b) + + print(func(1.5, 2)) + ''' + types = self._test(code) + self.assertIn(('func', (1, 0)), types) + variables = types.pop(('func', (1, 0))) + self.assertFalse(types) + self.assertEqual({'a': {'float', 'int', 'str'}, 'b': {'int'}}, variables) + + def _test_typing_function_char_loop(self): + code = '''\ + def func(x): + l = [] + for c in x: + l.append(c) + return l + + print(func('abcdefg')) + ''' + types = self._test(code) + self.assertIn(('func', (1, 0)), types) + variables = types.pop(('func', (1, 0))) + self.assertFalse(types) + self.assertEqual({'a': {'int'}, 'i': {'int'}}, variables) + + def test_typing_global_list(self): + code = '''\ + a = [x for x in range(10)] + b = list(range(10)) + c = a + b + d = [0]*10 + ''' + types = self._test(code) + self.assertIn((None, (1, 0)), types) + variables = types.pop((None, (1, 0))) + self.assertFalse(types) + self.assertEqual({'a': {'list'}, 'b': {'list'}, 'c': {'list'}, 'd': {'list'}}, variables) + + def test_typing_function_list(self): + code = '''\ + def func(x): + a = [[], []] + b = [0]* 10 + a + c = a[0] + + print(func([0]*100)) + ''' + types = self._test(code) + self.assertIn(('func', (1, 0)), types) + variables = types.pop(('func', (1, 0))) + self.assertFalse(types) + self.assertEqual({'a': {'list'}, 'b': {'list'}, 'c': {'list'}, 'x': {'list'}}, variables) + + def test_typing_global_dict(self): + code = '''\ + a = dict() + b = {i: i**2 for i in range(10)} + c = a + ''' + types = self._test(code) + self.assertIn((None, (1, 0)), types) + variables = types.pop((None, (1, 0))) + self.assertFalse(types) + self.assertEqual({'a': {'dict'}, 'b': {'dict'}, 'c': {'dict'}}, variables) + + def test_typing_function_dict(self): + code = '''\ + def func(x): + a = dict() + b = {i: i**2 for i in range(10)} + c = x + + print(func({1:2, 'x':7})) + ''' + types = self._test(code) + self.assertIn(('func', (1, 0)), types) + variables = types.pop(('func', (1, 0))) + self.assertFalse(types) + self.assertEqual({'a': {'dict'}, 'b': {'dict'}, 'c': {'dict'}, 'x': {'dict'}}, variables) + + + def test_typing_global_set(self): + code = '''\ + a = set() + # b = {i for i in range(10)} # jedi does not support set comprehension yet + c = a + d = {1,2,3} + e = a | b + ''' + types = self._test(code) + self.assertIn((None, (1, 0)), types) + variables = types.pop((None, (1, 0))) + self.assertFalse(types) + self.assertEqual({'a': {'set'}, 'c': {'set'}, 'd': {'set'}, 'e': {'set'}}, variables) + + def test_typing_function_set(self): + code = '''\ + def func(x): + a = set() + # b = {i for i in range(10)} # jedi does not support set comprehension yet + c = a + d = a | b + + print(func({1,2,3})) + ''' + types = self._test(code) + self.assertIn(('func', (1, 0)), types) + variables = types.pop(('func', (1, 0))) + self.assertFalse(types) + self.assertEqual({'a': {'set'}, 'c': {'set'}, 'd': {'set'}, 'x': {'set'}}, variables) + + +class TestTypeInjection(TestJediTyper): + """ + Subtype of TestJediTyper that additionally tests type injection and compilation. + """ + def setUp(self): + super().setUp() + compilation_options = Options.CompilationOptions(Options.default_options) + ctx = Main.Context.from_options(compilation_options) + transform = InterpretCompilerDirectives(ctx, ctx.compiler_directives) + transform.module_scope = Symtab.ModuleScope('__main__', None, ctx) + self.declarations_finder = DeclarationsFinder() + self.pipeline = [NormalizeTree(None), transform, self.declarations_finder] + + def _test(self, code): + types, lines = _test_typing(code, inject=True) + tree = self.run_pipeline(self.pipeline, ''.join(lines)) + directives = self.declarations_finder.directives + # TODO: validate directives + return types diff --git a/venv/lib/python3.10/site-packages/Cython/Tests/TestShadow.py b/venv/lib/python3.10/site-packages/Cython/Tests/TestShadow.py new file mode 100644 index 0000000000000000000000000000000000000000..ffbabd8248820fb0880b9e8a0fe18c7fca0d0f36 --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Tests/TestShadow.py @@ -0,0 +1,114 @@ +import unittest + +from Cython import Shadow +from Cython.Compiler import Options, CythonScope, PyrexTypes, Errors + +class TestShadow(unittest.TestCase): + def test_all_directives_in_shadow(self): + missing_directives = [] + extra_directives = [] + for full_directive in Options.directive_types.keys(): + # Python 2 doesn't support "directive, *rest = full_directive.split('.')" + split_directive = full_directive.split('.') + directive, rest = split_directive[0], split_directive[1:] + + scope = Options.directive_scopes.get(full_directive) + if scope and len(scope) == 1 and scope[0] == "module": + # module-scoped things can't be used from Cython + if hasattr(Shadow, directive): + extra_directives.append(full_directive) + continue + if full_directive == "collection_type": + # collection_type is current restricted to utility code only + # so doesn't need to be in Shadow + continue + if full_directive == "staticmethod": + # staticmethod is a weird special-case and not really intended to be + # used from the cython module + continue + + if not hasattr(Shadow, directive): + missing_directives.append(full_directive) + elif rest: + directive_value = getattr(Shadow, directive) + for subdirective in rest: + if (hasattr(type(directive_value), '__getattr__') or + hasattr(type(directive_value), '__getattribute__')): + # skip things like "dataclasses" which override attribute lookup + break + self.assertEqual(missing_directives, []) + self.assertEqual(extra_directives, []) + + def test_all_types_in_shadow(self): + cython_scope = CythonScope.create_cython_scope(None) + # Not doing load_cythonscope at this stage because it requires a proper context and + # Errors.py to be set up + + missing_types = [] + for key in cython_scope.entries.keys(): + if key.startswith('__') and key.endswith('__'): + continue + if key in ('PyTypeObject', 'PyObject_TypeCheck'): + # These are declared in Shadow.py for reasons that look to + # be an implementation detail, but it isn't our intention for + # users to access them from Pure Python mode. + continue + if not hasattr(Shadow, key): + missing_types.append(key) + self.assertEqual(missing_types, []) + + def test_int_types_in_shadow(self): + missing_types = [] + for int_name in Shadow.int_types: + for sign in ['', 'u', 's']: + name = sign + int_name + + if sign and ( + int_name in ['Py_UNICODE', 'Py_UCS4', 'Py_ssize_t', + 'ssize_t', 'ptrdiff_t', 'Py_hash_t'] or + name == "usize_t"): + # size_t is special-cased here a little since ssize_t legitimate + # but usize_t isn't + self.assertNotIn(name, dir(Shadow)) + self.assertNotIn('p_' + name, dir(Shadow)) + continue + + if not hasattr(Shadow, name): + missing_types.append(name) + + for ptr in range(1, 4): + ptr_name = 'p' * ptr + '_' + name + if not hasattr(Shadow, ptr_name): + missing_types.append(ptr_name) + self.assertEqual(missing_types, []) + + def test_most_types(self): + # TODO it's unfortunately hard to get a definite list of types to confirm that they're + # present (because they're obtained by on-the-fly string parsing in `cython_scope.lookup_type`) + + cython_scope = CythonScope.create_cython_scope(None) + # Set up just enough of "Context" and "Errors" that CythonScope.lookup_type can fail + class Context: + cpp = False + language_level = 3 + future_directives = [] + cython_scope._context = Context + Errors.init_thread() + + missing_types = [] + missing_lookups = [] + for (signed, longness, name), type_ in PyrexTypes.modifiers_and_name_to_type.items(): + if name == 'object': + continue # This probably shouldn't be in Shadow + if not hasattr(Shadow, name): + missing_types.append(name) + if not cython_scope.lookup_type(name): + missing_lookups.append(name) + for ptr in range(1, 4): + ptr_name = 'p' * ptr + '_' + name + if not hasattr(Shadow, ptr_name): + missing_types.append(ptr_name) + if not cython_scope.lookup_type(ptr_name): + missing_lookups.append(ptr_name) + self.assertEqual(missing_types, []) + self.assertEqual(missing_lookups, []) diff --git a/venv/lib/python3.10/site-packages/Cython/Tests/TestStringIOTree.py b/venv/lib/python3.10/site-packages/Cython/Tests/TestStringIOTree.py new file mode 100644 index 0000000000000000000000000000000000000000..a15f2cd88d706fb11d8438e3fe7a63af23b08dcf --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Tests/TestStringIOTree.py @@ -0,0 +1,67 @@ +import unittest + +from Cython import StringIOTree as stringtree + +code = """ +cdef int spam # line 1 + +cdef ham(): + a = 1 + b = 2 + c = 3 + d = 4 + +def eggs(): + pass + +cpdef bacon(): + print spam + print 'scotch' + print 'tea?' + print 'or coffee?' # line 16 +""" + +linemap = dict(enumerate(code.splitlines())) + +class TestStringIOTree(unittest.TestCase): + + def setUp(self): + self.tree = stringtree.StringIOTree() + + def test_markers(self): + assert not self.tree.allmarkers() + + def test_insertion(self): + self.write_lines((1, 2, 3)) + line_4_to_6_insertion_point = self.tree.insertion_point() + self.write_lines((7, 8)) + line_9_to_13_insertion_point = self.tree.insertion_point() + self.write_lines((14, 15, 16)) + + line_4_insertion_point = line_4_to_6_insertion_point.insertion_point() + self.write_lines((5, 6), tree=line_4_to_6_insertion_point) + + line_9_to_12_insertion_point = ( + line_9_to_13_insertion_point.insertion_point()) + self.write_line(13, tree=line_9_to_13_insertion_point) + + self.write_line(4, tree=line_4_insertion_point) + self.write_line(9, tree=line_9_to_12_insertion_point) + line_10_insertion_point = line_9_to_12_insertion_point.insertion_point() + self.write_line(11, tree=line_9_to_12_insertion_point) + self.write_line(10, tree=line_10_insertion_point) + self.write_line(12, tree=line_9_to_12_insertion_point) + + self.assertEqual(self.tree.allmarkers(), list(range(1, 17))) + self.assertEqual(code.strip(), self.tree.getvalue().strip()) + + + def write_lines(self, linenos, tree=None): + for lineno in linenos: + self.write_line(lineno, tree=tree) + + def write_line(self, lineno, tree=None): + if tree is None: + tree = self.tree + tree.markers.append(lineno) + tree.write(linemap[lineno] + '\n') diff --git a/venv/lib/python3.10/site-packages/Cython/Tests/TestTestUtils.py b/venv/lib/python3.10/site-packages/Cython/Tests/TestTestUtils.py new file mode 100644 index 0000000000000000000000000000000000000000..6afe90672fb7205a351789e10dcb37ad34b249f7 --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Tests/TestTestUtils.py @@ -0,0 +1,90 @@ +import os.path +import unittest +import tempfile +import textwrap +import shutil + +from ..TestUtils import write_file, write_newer_file, _parse_pattern + + +class TestTestUtils(unittest.TestCase): + def setUp(self): + super().setUp() + self.temp_dir = tempfile.mkdtemp() + + def tearDown(self): + if self.temp_dir and os.path.isdir(self.temp_dir): + shutil.rmtree(self.temp_dir) + super().tearDown() + + def _test_path(self, filename): + return os.path.join(self.temp_dir, filename) + + def _test_write_file(self, content, expected, **kwargs): + file_path = self._test_path("abcfile") + write_file(file_path, content, **kwargs) + assert os.path.isfile(file_path) + + with open(file_path, 'rb') as f: + found = f.read() + assert found == expected, (repr(expected), repr(found)) + + def test_write_file_text(self): + text = "abcüöä" + self._test_write_file(text, text.encode('utf8')) + + def test_write_file_dedent(self): + text = """ + A horse is a horse, + of course, of course, + And no one can talk to a horse + of course + """ + self._test_write_file(text, textwrap.dedent(text).encode('utf8'), dedent=True) + + def test_write_file_bytes(self): + self._test_write_file(b"ab\0c", b"ab\0c") + + def test_write_newer_file(self): + file_path_1 = self._test_path("abcfile1.txt") + file_path_2 = self._test_path("abcfile2.txt") + write_file(file_path_1, "abc") + assert os.path.isfile(file_path_1) + write_newer_file(file_path_2, file_path_1, "xyz") + assert os.path.isfile(file_path_2) + assert os.path.getmtime(file_path_2) > os.path.getmtime(file_path_1) + + def test_write_newer_file_same(self): + file_path = self._test_path("abcfile.txt") + write_file(file_path, "abc") + mtime = os.path.getmtime(file_path) + write_newer_file(file_path, file_path, "xyz") + assert os.path.getmtime(file_path) > mtime + + def test_write_newer_file_fresh(self): + file_path = self._test_path("abcfile.txt") + assert not os.path.exists(file_path) + write_newer_file(file_path, file_path, "xyz") + assert os.path.isfile(file_path) + + def test_parse_pattern(self): + self.assertEqual( + _parse_pattern("pattern"), + (None, None, 'pattern') + ) + self.assertEqual( + _parse_pattern("/start/:pattern"), + ('start', None, 'pattern') + ) + self.assertEqual( + _parse_pattern(":/end/ pattern"), + (None, 'end', 'pattern') + ) + self.assertEqual( + _parse_pattern("/start/:/end/ pattern"), + ('start', 'end', 'pattern') + ) + self.assertEqual( + _parse_pattern("/start/:/end/pattern"), + ('start', 'end', 'pattern') + ) diff --git a/venv/lib/python3.10/site-packages/Cython/Tests/__init__.py b/venv/lib/python3.10/site-packages/Cython/Tests/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..fa81adaff68e06d8e915a6afa375f62f7e5a8fad --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Tests/__init__.py @@ -0,0 +1 @@ +# empty file diff --git a/venv/lib/python3.10/site-packages/Cython/Tests/__pycache__/TestCodeWriter.cpython-310.pyc b/venv/lib/python3.10/site-packages/Cython/Tests/__pycache__/TestCodeWriter.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b7ff8536b73df63703497fedcc3a12bd5ddcea0a Binary files /dev/null and b/venv/lib/python3.10/site-packages/Cython/Tests/__pycache__/TestCodeWriter.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/Cython/Tests/__pycache__/TestCythonUtils.cpython-310.pyc b/venv/lib/python3.10/site-packages/Cython/Tests/__pycache__/TestCythonUtils.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2bcd03a0a97ad581c8f88f3cd65c4fd2fd75a3b2 Binary files /dev/null and b/venv/lib/python3.10/site-packages/Cython/Tests/__pycache__/TestCythonUtils.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/Cython/Tests/__pycache__/TestJediTyper.cpython-310.pyc b/venv/lib/python3.10/site-packages/Cython/Tests/__pycache__/TestJediTyper.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..79b935b69d5d3aea4c49ab4f8f3ef41eed699262 Binary files /dev/null and b/venv/lib/python3.10/site-packages/Cython/Tests/__pycache__/TestJediTyper.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/Cython/Tests/__pycache__/TestShadow.cpython-310.pyc b/venv/lib/python3.10/site-packages/Cython/Tests/__pycache__/TestShadow.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d2066b52c1ae3bf4f6e2934fad2d793df9176d01 Binary files /dev/null and b/venv/lib/python3.10/site-packages/Cython/Tests/__pycache__/TestShadow.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/Cython/Tests/__pycache__/TestStringIOTree.cpython-310.pyc b/venv/lib/python3.10/site-packages/Cython/Tests/__pycache__/TestStringIOTree.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..134fd6bfb7109019501bd5d53fce320ef3436f9f Binary files /dev/null and b/venv/lib/python3.10/site-packages/Cython/Tests/__pycache__/TestStringIOTree.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/Cython/Tests/__pycache__/TestTestUtils.cpython-310.pyc b/venv/lib/python3.10/site-packages/Cython/Tests/__pycache__/TestTestUtils.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b644d5b4f117556696d3f1770d85a428111e3580 Binary files /dev/null and b/venv/lib/python3.10/site-packages/Cython/Tests/__pycache__/TestTestUtils.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/Cython/Tests/__pycache__/__init__.cpython-310.pyc b/venv/lib/python3.10/site-packages/Cython/Tests/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fd2351c2bde38c38be90c002f7e028f6019c7a47 Binary files /dev/null and b/venv/lib/python3.10/site-packages/Cython/Tests/__pycache__/__init__.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/Cython/Tests/__pycache__/xmlrunner.cpython-310.pyc b/venv/lib/python3.10/site-packages/Cython/Tests/__pycache__/xmlrunner.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1af573ee430b8cd4e8a9ad03e1d6a7a4eaf740a8 Binary files /dev/null and b/venv/lib/python3.10/site-packages/Cython/Tests/__pycache__/xmlrunner.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/Cython/Tests/xmlrunner.py b/venv/lib/python3.10/site-packages/Cython/Tests/xmlrunner.py new file mode 100644 index 0000000000000000000000000000000000000000..cd1913575423eef55eec1b3f3c2a8d0c4642633a --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Tests/xmlrunner.py @@ -0,0 +1,390 @@ +"""unittest-xml-reporting is a PyUnit-based TestRunner that can export test +results to XML files that can be consumed by a wide range of tools, such as +build systems, IDEs and Continuous Integration servers. + +This module provides the XMLTestRunner class, which is heavily based on the +default TextTestRunner. This makes the XMLTestRunner very simple to use. + +The script below, adapted from the unittest documentation, shows how to use +XMLTestRunner in a very simple way. In fact, the only difference between this +script and the original one is the last line: + +import random +import unittest +import xmlrunner + +class TestSequenceFunctions(unittest.TestCase): + def setUp(self): + self.seq = range(10) + + def test_shuffle(self): + # make sure the shuffled sequence does not lose any elements + random.shuffle(self.seq) + self.seq.sort() + self.assertEqual(self.seq, range(10)) + + def test_choice(self): + element = random.choice(self.seq) + self.assertTrue(element in self.seq) + + def test_sample(self): + self.assertRaises(ValueError, random.sample, self.seq, 20) + for element in random.sample(self.seq, 5): + self.assertTrue(element in self.seq) + +if __name__ == '__main__': + unittest.main(testRunner=xmlrunner.XMLTestRunner(output='test-reports')) +""" + + +import os +import sys +import time +from unittest import TestResult, TextTestResult, TextTestRunner +import xml.dom.minidom + +from io import StringIO + + +class XMLDocument(xml.dom.minidom.Document): + def createCDATAOrText(self, data): + if ']]>' in data: + return self.createTextNode(data) + return self.createCDATASection(data) + + +class _TestInfo: + """This class is used to keep useful information about the execution of a + test method. + """ + + # Possible test outcomes + (SUCCESS, FAILURE, ERROR) = range(3) + + def __init__(self, test_result, test_method, outcome=SUCCESS, err=None): + "Create a new instance of _TestInfo." + self.test_result = test_result + self.test_method = test_method + self.outcome = outcome + self.err = err + self.stdout = test_result.stdout and test_result.stdout.getvalue().strip() or '' + self.stderr = test_result.stdout and test_result.stderr.getvalue().strip() or '' + + def get_elapsed_time(self): + """Return the time that shows how long the test method took to + execute. + """ + return self.test_result.stop_time - self.test_result.start_time + + def get_description(self): + "Return a text representation of the test method." + return self.test_result.getDescription(self.test_method) + + def get_error_info(self): + """Return a text representation of an exception thrown by a test + method. + """ + if not self.err: + return '' + return self.test_result._exc_info_to_string( + self.err, self.test_method) + + +class _XMLTestResult(TextTestResult): + """A test result class that can express test results in a XML report. + + Used by XMLTestRunner. + """ + def __init__(self, stream=sys.stderr, descriptions=1, verbosity=1, + elapsed_times=True): + "Create a new instance of _XMLTestResult." + TextTestResult.__init__(self, stream, descriptions, verbosity) + self.successes = [] + self.callback = None + self.elapsed_times = elapsed_times + self.output_patched = False + + def _prepare_callback(self, test_info, target_list, verbose_str, short_str): + """Append a _TestInfo to the given target list and sets a callback + method to be called by stopTest method. + """ + target_list.append(test_info) + def callback(): + """This callback prints the test method outcome to the stream, + as well as the elapsed time. + """ + + # Ignore the elapsed times for a more reliable unit testing + if not self.elapsed_times: + self.start_time = self.stop_time = 0 + + if self.showAll: + self.stream.writeln('(%.3fs) %s' % + (test_info.get_elapsed_time(), verbose_str)) + elif self.dots: + self.stream.write(short_str) + self.callback = callback + + def _patch_standard_output(self): + """Replace the stdout and stderr streams with string-based streams + in order to capture the tests' output. + """ + if not self.output_patched: + (self.old_stdout, self.old_stderr) = (sys.stdout, sys.stderr) + self.output_patched = True + (sys.stdout, sys.stderr) = (self.stdout, self.stderr) = \ + (StringIO(), StringIO()) + + def _restore_standard_output(self): + "Restore the stdout and stderr streams." + (sys.stdout, sys.stderr) = (self.old_stdout, self.old_stderr) + self.output_patched = False + + def startTest(self, test): + "Called before execute each test method." + self._patch_standard_output() + self.start_time = time.time() + TestResult.startTest(self, test) + + if self.showAll: + self.stream.write(' ' + self.getDescription(test)) + self.stream.write(" ... ") + + def stopTest(self, test): + "Called after execute each test method." + self._restore_standard_output() + TextTestResult.stopTest(self, test) + self.stop_time = time.time() + + if self.callback and callable(self.callback): + self.callback() + self.callback = None + + def addSuccess(self, test): + "Called when a test executes successfully." + self._prepare_callback(_TestInfo(self, test), + self.successes, 'OK', '.') + + def addFailure(self, test, err): + "Called when a test method fails." + self._prepare_callback(_TestInfo(self, test, _TestInfo.FAILURE, err), + self.failures, 'FAIL', 'F') + + def addError(self, test, err): + "Called when a test method raises an error." + self._prepare_callback(_TestInfo(self, test, _TestInfo.ERROR, err), + self.errors, 'ERROR', 'E') + + def printErrorList(self, flavour, errors): + "Write some information about the FAIL or ERROR to the stream." + for test_info in errors: + if isinstance(test_info, tuple): + test_info, exc_info = test_info + + try: + t = test_info.get_elapsed_time() + except AttributeError: + t = 0 + try: + descr = test_info.get_description() + except AttributeError: + try: + descr = test_info.getDescription() + except AttributeError: + descr = str(test_info) + try: + err_info = test_info.get_error_info() + except AttributeError: + err_info = str(test_info) + + self.stream.writeln(self.separator1) + self.stream.writeln('%s [%.3fs]: %s' % (flavour, t, descr)) + self.stream.writeln(self.separator2) + self.stream.writeln('%s' % err_info) + + def _get_info_by_testcase(self): + """This method organizes test results by TestCase module. This + information is used during the report generation, where a XML report + will be generated for each TestCase. + """ + tests_by_testcase = {} + + for tests in (self.successes, self.failures, self.errors): + for test_info in tests: + if not isinstance(test_info, _TestInfo): + print("Unexpected test result type: %r" % (test_info,)) + continue + testcase = type(test_info.test_method) + + # Ignore module name if it is '__main__' + module = testcase.__module__ + '.' + if module == '__main__.': + module = '' + testcase_name = module + testcase.__name__ + + if testcase_name not in tests_by_testcase: + tests_by_testcase[testcase_name] = [] + tests_by_testcase[testcase_name].append(test_info) + + return tests_by_testcase + + def _report_testsuite(suite_name, tests, xml_document): + "Appends the testsuite section to the XML document." + testsuite = xml_document.createElement('testsuite') + xml_document.appendChild(testsuite) + + testsuite.setAttribute('name', str(suite_name)) + testsuite.setAttribute('tests', str(len(tests))) + + testsuite.setAttribute('time', '%.3f' % + sum([e.get_elapsed_time() for e in tests])) + + failures = len([1 for e in tests if e.outcome == _TestInfo.FAILURE]) + testsuite.setAttribute('failures', str(failures)) + + errors = len([1 for e in tests if e.outcome == _TestInfo.ERROR]) + testsuite.setAttribute('errors', str(errors)) + + return testsuite + + _report_testsuite = staticmethod(_report_testsuite) + + def _report_testcase(suite_name, test_result, xml_testsuite, xml_document): + "Appends a testcase section to the XML document." + testcase = xml_document.createElement('testcase') + xml_testsuite.appendChild(testcase) + + testcase.setAttribute('classname', str(suite_name)) + testcase.setAttribute('name', test_result.test_method.shortDescription() + or getattr(test_result.test_method, '_testMethodName', + str(test_result.test_method))) + testcase.setAttribute('time', '%.3f' % test_result.get_elapsed_time()) + + if (test_result.outcome != _TestInfo.SUCCESS): + elem_name = ('failure', 'error')[test_result.outcome-1] + failure = xml_document.createElement(elem_name) + testcase.appendChild(failure) + + failure.setAttribute('type', str(test_result.err[0].__name__)) + failure.setAttribute('message', str(test_result.err[1])) + + error_info = test_result.get_error_info() + failureText = xml_document.createCDATAOrText(error_info) + failure.appendChild(failureText) + + _report_testcase = staticmethod(_report_testcase) + + def _report_output(test_runner, xml_testsuite, xml_document, stdout, stderr): + "Appends the system-out and system-err sections to the XML document." + systemout = xml_document.createElement('system-out') + xml_testsuite.appendChild(systemout) + + systemout_text = xml_document.createCDATAOrText(stdout) + systemout.appendChild(systemout_text) + + systemerr = xml_document.createElement('system-err') + xml_testsuite.appendChild(systemerr) + + systemerr_text = xml_document.createCDATAOrText(stderr) + systemerr.appendChild(systemerr_text) + + _report_output = staticmethod(_report_output) + + def generate_reports(self, test_runner): + "Generates the XML reports to a given XMLTestRunner object." + all_results = self._get_info_by_testcase() + + if isinstance(test_runner.output, str) and not os.path.exists(test_runner.output): + os.makedirs(test_runner.output) + + for suite, tests in all_results.items(): + doc = XMLDocument() + + # Build the XML file + testsuite = _XMLTestResult._report_testsuite(suite, tests, doc) + stdout, stderr = [], [] + for test in tests: + _XMLTestResult._report_testcase(suite, test, testsuite, doc) + if test.stdout: + stdout.extend(['*****************', test.get_description(), test.stdout]) + if test.stderr: + stderr.extend(['*****************', test.get_description(), test.stderr]) + _XMLTestResult._report_output(test_runner, testsuite, doc, + '\n'.join(stdout), '\n'.join(stderr)) + xml_content = doc.toprettyxml(indent='\t') + + if type(test_runner.output) is str: + report_file = open('%s%sTEST-%s.xml' % + (test_runner.output, os.sep, suite), 'w') + try: + report_file.write(xml_content) + finally: + report_file.close() + else: + # Assume that test_runner.output is a stream + test_runner.output.write(xml_content) + + +class XMLTestRunner(TextTestRunner): + """A test runner class that outputs the results in JUnit like XML files. + """ + def __init__(self, output='.', stream=None, descriptions=True, verbose=False, elapsed_times=True): + "Create a new instance of XMLTestRunner." + if stream is None: + stream = sys.stderr + verbosity = (1, 2)[verbose] + TextTestRunner.__init__(self, stream, descriptions, verbosity) + self.output = output + self.elapsed_times = elapsed_times + + def _make_result(self): + """Create the TestResult object which will be used to store + information about the executed tests. + """ + return _XMLTestResult(self.stream, self.descriptions, + self.verbosity, self.elapsed_times) + + def run(self, test): + "Run the given test case or test suite." + # Prepare the test execution + result = self._make_result() + + # Print a nice header + self.stream.writeln() + self.stream.writeln('Running tests...') + self.stream.writeln(result.separator2) + + # Execute tests + start_time = time.time() + test(result) + stop_time = time.time() + time_taken = stop_time - start_time + + # Generate reports + self.stream.writeln() + self.stream.writeln('Generating XML reports...') + result.generate_reports(self) + + # Print results + result.printErrors() + self.stream.writeln(result.separator2) + run = result.testsRun + self.stream.writeln("Ran %d test%s in %.3fs" % + (run, run != 1 and "s" or "", time_taken)) + self.stream.writeln() + + # Error traces + if not result.wasSuccessful(): + self.stream.write("FAILED (") + failed, errored = (len(result.failures), len(result.errors)) + if failed: + self.stream.write("failures=%d" % failed) + if errored: + if failed: + self.stream.write(", ") + self.stream.write("errors=%d" % errored) + self.stream.writeln(")") + else: + self.stream.writeln("OK") + + return result diff --git a/venv/lib/python3.10/site-packages/Cython/Utility/AsyncGen.c b/venv/lib/python3.10/site-packages/Cython/Utility/AsyncGen.c new file mode 100644 index 0000000000000000000000000000000000000000..589118e33f27a940be58cf16dcd12b0e9c4817f0 --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Utility/AsyncGen.c @@ -0,0 +1,1005 @@ +// This is copied from genobject.c in CPython 3.6. +// Try to keep it in sync by doing this from time to time: +// sed -e 's|__pyx_||ig' Cython/Utility/AsyncGen.c | diff -udw - cpython/Objects/genobject.c | less + +//////////////////// AsyncGenerator.module_state_decls //////////////////// + +PyTypeObject *__pyx__PyAsyncGenWrappedValueType; +PyTypeObject *__pyx__PyAsyncGenASendType; +PyTypeObject *__pyx__PyAsyncGenAThrowType; +PyTypeObject *__pyx_AsyncGenType; + +// Freelists boost performance 6-10%; they also reduce memory +// fragmentation, as _PyAsyncGenWrappedValue and PyAsyncGenASend +// are short-living objects that are instantiated for every +// __anext__ call. + +#if CYTHON_USE_FREELISTS +struct __pyx__PyAsyncGenWrappedValue *__Pyx_ag_value_freelist[_PyAsyncGen_MAXFREELIST]; +int __Pyx_ag_value_freelist_free; + +struct __pyx_PyAsyncGenASend *__Pyx_ag_asend_freelist[_PyAsyncGen_MAXFREELIST]; +int __Pyx_ag_asend_freelist_free; +#endif + +//////////////////// AsyncGenerator.proto //////////////////// +//@requires: Coroutine.c::Coroutine + +#define __Pyx_AsyncGen_USED +typedef struct { + __pyx_CoroutineObject coro; + PyObject *ag_finalizer; + int ag_hooks_inited; + int ag_closed; + int ag_running_async; +} __pyx_PyAsyncGenObject; + +#define __Pyx_AsyncGen_CheckExact(obj) __Pyx_IS_TYPE(obj, CGLOBAL(__pyx_AsyncGenType)) +#define __pyx_PyAsyncGenASend_CheckExact(o) \ + __Pyx_IS_TYPE(o, CGLOBAL(__pyx__PyAsyncGenASendType)) +#define __pyx_PyAsyncGenAThrow_CheckExact(o) \ + __Pyx_IS_TYPE(o, CGLOBAL(__pyx__PyAsyncGenAThrowType)) + +static PyObject *__Pyx_async_gen_anext(PyObject *o); +static CYTHON_INLINE PyObject *__Pyx_async_gen_asend_iternext(PyObject *o); +static PyObject *__Pyx_async_gen_asend_send(PyObject *g, PyObject *arg); +static PyObject *__Pyx_async_gen_asend_close(PyObject *o, PyObject *args); +static PyObject *__Pyx_async_gen_athrow_close(PyObject *o, PyObject *args); + +static PyObject *__Pyx__PyAsyncGenValueWrapperNew(PyObject *val); + + +static __pyx_CoroutineObject *__Pyx_AsyncGen_New( + __pyx_coroutine_body_t body, PyObject *code, PyObject *closure, + PyObject *name, PyObject *qualname, PyObject *module_name); + +static int __pyx_AsyncGen_init(PyObject *module); +static void __Pyx_PyAsyncGen_Fini(void); + +#if CYTHON_USE_FREELISTS && !defined(_PyAsyncGen_MAXFREELIST) +#define _PyAsyncGen_MAXFREELIST 80 +#endif + +struct __pyx__PyAsyncGenWrappedValue; +struct __pyx_PyAsyncGenASend; + +//////////////////// AsyncGenerator.cleanup //////////////////// + +__Pyx_PyAsyncGen_Fini(); + +//////////////////// AsyncGenerator //////////////////// +//@substitute: naming +//@requires: Coroutine.c::Coroutine +//@requires: Coroutine.c::ReturnWithStopIteration +//@requires: ObjectHandling.c::PyObjectCall2Args +//@requires: ExtensionTypes.c::CallTypeTraverse + +PyDoc_STRVAR(__Pyx_async_gen_send_doc, +"send(arg) -> send 'arg' into generator,\n\ +return next yielded value or raise StopIteration."); + +PyDoc_STRVAR(__Pyx_async_gen_close_doc, +"close() -> raise GeneratorExit inside generator."); + +PyDoc_STRVAR(__Pyx_async_gen_throw_doc, +"throw(typ[,val[,tb]]) -> raise exception in generator,\n\ +return next yielded value or raise StopIteration."); + +PyDoc_STRVAR(__Pyx_async_gen_await_doc, +"__await__() -> return a representation that can be passed into the 'await' expression."); + +static __pyx_CoroutineObject *__Pyx_AsyncGen_New( + __pyx_coroutine_body_t body, PyObject *code, PyObject *closure, + PyObject *name, PyObject *qualname, PyObject *module_name) { + __pyx_PyAsyncGenObject *gen = PyObject_GC_New(__pyx_PyAsyncGenObject, CGLOBAL(__pyx_AsyncGenType)); + if (unlikely(!gen)) + return NULL; + gen->ag_finalizer = NULL; + gen->ag_closed = 0; + gen->ag_hooks_inited = 0; + gen->ag_running_async = 0; + return __Pyx__Coroutine_NewInit((__pyx_CoroutineObject*)gen, body, code, closure, name, qualname, module_name); +} + +// COPY STARTS HERE: + +static PyObject *__Pyx_async_gen_asend_new(__pyx_PyAsyncGenObject *, PyObject *); +static PyObject *__Pyx_async_gen_athrow_new(__pyx_PyAsyncGenObject *, PyObject *); + +static const char *__Pyx_NON_INIT_CORO_MSG = "can't send non-None value to a just-started coroutine"; +static const char *__Pyx_ASYNC_GEN_IGNORED_EXIT_MSG = "async generator ignored GeneratorExit"; +static const char *__Pyx_ASYNC_GEN_CANNOT_REUSE_SEND_MSG = "cannot reuse already awaited __anext__()/asend()"; +static const char *__Pyx_ASYNC_GEN_CANNOT_REUSE_CLOSE_MSG = "cannot reuse already awaited aclose()/athrow()"; + +typedef enum { + __PYX_AWAITABLE_STATE_INIT, /* new awaitable, has not yet been iterated */ + __PYX_AWAITABLE_STATE_ITER, /* being iterated */ + __PYX_AWAITABLE_STATE_CLOSED, /* closed */ +} __pyx_AwaitableState; + +typedef struct __pyx_PyAsyncGenASend { + PyObject_HEAD + __pyx_PyAsyncGenObject *ags_gen; + + /* Can be NULL, when in the __anext__() mode (equivalent of "asend(None)") */ + PyObject *ags_sendval; + + __pyx_AwaitableState ags_state; +} __pyx_PyAsyncGenASend; + + +typedef struct { + PyObject_HEAD + __pyx_PyAsyncGenObject *agt_gen; + + /* Can be NULL, when in the "aclose()" mode (equivalent of "athrow(GeneratorExit)") */ + PyObject *agt_args; + + __pyx_AwaitableState agt_state; +} __pyx_PyAsyncGenAThrow; + + +typedef struct __pyx__PyAsyncGenWrappedValue { + PyObject_HEAD + PyObject *agw_val; +} __pyx__PyAsyncGenWrappedValue; + +#define __pyx__PyAsyncGenWrappedValue_CheckExact(o) \ + __Pyx_IS_TYPE(o, CGLOBAL(__pyx__PyAsyncGenWrappedValueType)) + + +static int +__Pyx_async_gen_traverse(__pyx_PyAsyncGenObject *gen, visitproc visit, void *arg) +{ + // visiting the type is handled in the base if needed + Py_VISIT(gen->ag_finalizer); + return __Pyx_Coroutine_traverse((__pyx_CoroutineObject*)gen, visit, arg); +} + + +static PyObject * +__Pyx_async_gen_repr(__pyx_CoroutineObject *o) +{ + // avoid NULL pointer dereference for qualname during garbage collection + return PyUnicode_FromFormat("", + o->gi_qualname ? o->gi_qualname : Py_None, o); +} + + +static int +__Pyx_async_gen_init_hooks_firstiter(__pyx_PyAsyncGenObject *o, PyObject *firstiter) +{ + PyObject *res; + // at least asyncio stores methods here => optimise the call +#if CYTHON_UNPACK_METHODS + PyObject *self; + if (likely(PyMethod_Check(firstiter)) && likely((self = PyMethod_GET_SELF(firstiter)) != NULL)) { + PyObject *function = PyMethod_GET_FUNCTION(firstiter); + res = __Pyx_PyObject_Call2Args(function, self, (PyObject*)o); + } else +#endif + res = __Pyx_PyObject_CallOneArg(firstiter, (PyObject*)o); + + Py_DECREF(firstiter); + + if (unlikely(res == NULL)) + return 1; + + Py_DECREF(res); + return 0; +} + + +static CYTHON_INLINE int +__Pyx_async_gen_init_hooks_done(__pyx_PyAsyncGenObject *o) { + return o->ag_hooks_inited != 0; +} + +static int +__Pyx_async_gen_init_hooks(__pyx_PyAsyncGenObject *o) +{ +#if !CYTHON_COMPILING_IN_PYPY && !CYTHON_COMPILING_IN_LIMITED_API + PyThreadState *tstate; +#endif + PyObject *finalizer; + PyObject *firstiter; + + assert (!__Pyx_async_gen_init_hooks_done(o)); + o->ag_hooks_inited = 1; + +#if CYTHON_COMPILING_IN_LIMITED_API + { + PyObject *hooks_func = PySys_GetObject("get_asyncgen_hooks"); + if (unlikely(!hooks_func)) { + PyErr_SetString( + PyExc_AttributeError, + "Failed to get 'get_asyncgen_hooks' from sys" + ); + return 1; + } + PyObject *async_gen_hooks = PyObject_CallFunctionObjArgs(hooks_func, NULL); + if (unlikely(!async_gen_hooks)) return 1; + firstiter = PySequence_GetItem(async_gen_hooks, 0); + if (unlikely(!firstiter)) { + Py_DECREF(async_gen_hooks); + return 1; + } + if (firstiter == Py_None) { + Py_CLEAR(firstiter); + } + + finalizer = PySequence_GetItem(async_gen_hooks, 1); + Py_DECREF(async_gen_hooks); + + if (unlikely(!finalizer)) { + Py_XDECREF(firstiter); + return 1; + } + if (finalizer == Py_None) { + Py_CLEAR(finalizer); + } + } +#endif + +#if CYTHON_COMPILING_IN_PYPY + finalizer = _PyEval_GetAsyncGenFinalizer(); +#elif !CYTHON_COMPILING_IN_LIMITED_API + tstate = __Pyx_PyThreadState_Current; + finalizer = tstate->async_gen_finalizer; +#endif + if (finalizer) { +#if !CYTHON_COMPILING_IN_LIMITED_API + Py_INCREF(finalizer); +#endif + o->ag_finalizer = finalizer; + } + +#if CYTHON_COMPILING_IN_PYPY + firstiter = _PyEval_GetAsyncGenFirstiter(); +#elif !CYTHON_COMPILING_IN_LIMITED_API + firstiter = tstate->async_gen_firstiter; +#endif + if (firstiter) { +#if !CYTHON_COMPILING_IN_LIMITED_API + Py_INCREF(firstiter); +#endif + // Transfers the reference. + if (unlikely(__Pyx_async_gen_init_hooks_firstiter(o, firstiter))) + return 1; + } + + return 0; +} + + +static PyObject * +__Pyx_async_gen_anext(PyObject *g) +{ + __pyx_PyAsyncGenObject *o = (__pyx_PyAsyncGenObject*) g; + if (!__Pyx_async_gen_init_hooks_done(o) && unlikely(__Pyx_async_gen_init_hooks(o))) { + return NULL; + } + return __Pyx_async_gen_asend_new(o, NULL); +} + +static PyObject * +__Pyx_async_gen_anext_method(PyObject *g, PyObject *arg) { + CYTHON_UNUSED_VAR(arg); + return __Pyx_async_gen_anext(g); +} + + +static PyObject * +__Pyx_async_gen_asend(__pyx_PyAsyncGenObject *o, PyObject *arg) +{ + if (!__Pyx_async_gen_init_hooks_done(o) && unlikely(__Pyx_async_gen_init_hooks(o))) { + return NULL; + } + return __Pyx_async_gen_asend_new(o, arg); +} + + +static PyObject * +__Pyx_async_gen_aclose(__pyx_PyAsyncGenObject *o, PyObject *arg) +{ + CYTHON_UNUSED_VAR(arg); + if (!__Pyx_async_gen_init_hooks_done(o) && unlikely(__Pyx_async_gen_init_hooks(o))) { + return NULL; + } + return __Pyx_async_gen_athrow_new(o, NULL); +} + + +static PyObject * +__Pyx_async_gen_athrow(__pyx_PyAsyncGenObject *o, PyObject *args) +{ + if (!__Pyx_async_gen_init_hooks_done(o) && unlikely(__Pyx_async_gen_init_hooks(o))) { + return NULL; + } + return __Pyx_async_gen_athrow_new(o, args); +} + + +static PyObject * +__Pyx_async_gen_self_method(PyObject *g, PyObject *arg) { + CYTHON_UNUSED_VAR(arg); + return __Pyx_NewRef(g); +} + + +static PyGetSetDef __Pyx_async_gen_getsetlist[] = { + {"__name__", (getter)__Pyx_Coroutine_get_name, (setter)__Pyx_Coroutine_set_name, + PyDoc_STR("name of the async generator"), 0}, + {"__qualname__", (getter)__Pyx_Coroutine_get_qualname, (setter)__Pyx_Coroutine_set_qualname, + PyDoc_STR("qualified name of the async generator"), 0}, + //REMOVED: {(char*) "ag_await", (getter)coro_get_cr_await, NULL, + //REMOVED: (char*) PyDoc_STR("object being awaited on, or None")}, + {0, 0, 0, 0, 0} /* Sentinel */ +}; + +static PyMemberDef __Pyx_async_gen_memberlist[] = { + //REMOVED: {(char*) "ag_frame", T_OBJECT, offsetof(__pyx_PyAsyncGenObject, ag_frame), READONLY}, + {"ag_running", T_BOOL, offsetof(__pyx_PyAsyncGenObject, ag_running_async), READONLY, NULL}, + //REMOVED: {(char*) "ag_code", T_OBJECT, offsetof(__pyx_PyAsyncGenObject, ag_code), READONLY}, + //ADDED: "ag_await" + {"ag_await", T_OBJECT, offsetof(__pyx_CoroutineObject, yieldfrom), READONLY, + PyDoc_STR("object being awaited on, or None")}, + {"__module__", T_OBJECT, offsetof(__pyx_CoroutineObject, gi_modulename), 0, 0}, + {"__weaklistoffset__", T_PYSSIZET, offsetof(__pyx_CoroutineObject, gi_weakreflist), READONLY, 0}, + {0, 0, 0, 0, 0} /* Sentinel */ +}; + +PyDoc_STRVAR(__Pyx_async_aclose_doc, +"aclose() -> raise GeneratorExit inside generator."); + +PyDoc_STRVAR(__Pyx_async_asend_doc, +"asend(v) -> send 'v' in generator."); + +PyDoc_STRVAR(__Pyx_async_athrow_doc, +"athrow(typ[,val[,tb]]) -> raise exception in generator."); + +PyDoc_STRVAR(__Pyx_async_aiter_doc, +"__aiter__(v) -> return an asynchronous iterator."); + +PyDoc_STRVAR(__Pyx_async_anext_doc, +"__anext__(v) -> continue asynchronous iteration and return the next element."); + +static PyMethodDef __Pyx_async_gen_methods[] = { + {"asend", (PyCFunction)__Pyx_async_gen_asend, METH_O, __Pyx_async_asend_doc}, + {"athrow",(PyCFunction)__Pyx_async_gen_athrow, METH_VARARGS, __Pyx_async_athrow_doc}, + {"aclose", (PyCFunction)__Pyx_async_gen_aclose, METH_NOARGS, __Pyx_async_aclose_doc}, + {"__aiter__", (PyCFunction)__Pyx_async_gen_self_method, METH_NOARGS, __Pyx_async_aiter_doc}, + {"__anext__", (PyCFunction)__Pyx_async_gen_anext_method, METH_NOARGS, __Pyx_async_anext_doc}, + {"__reduce_ex__", (PyCFunction) __Pyx_Coroutine_fail_reduce_ex, METH_O, 0}, + {"__reduce__", (PyCFunction) __Pyx_Coroutine_fail_reduce_ex, METH_NOARGS, 0}, + {0, 0, 0, 0} /* Sentinel */ +}; + + +static PyType_Slot __pyx_AsyncGenType_slots[] = { + {Py_tp_dealloc, (void *)__Pyx_Coroutine_dealloc}, + {Py_am_aiter, (void *)PyObject_SelfIter}, + {Py_am_anext, (void *)__Pyx_async_gen_anext}, + {Py_tp_repr, (void *)__Pyx_async_gen_repr}, + {Py_tp_traverse, (void *)__Pyx_async_gen_traverse}, + {Py_tp_methods, (void *)__Pyx_async_gen_methods}, + {Py_tp_members, (void *)__Pyx_async_gen_memberlist}, + {Py_tp_getset, (void *)__Pyx_async_gen_getsetlist}, +#if CYTHON_USE_TP_FINALIZE + {Py_tp_finalize, (void *)__Pyx_Coroutine_del}, +#endif + {0, 0}, +}; + +static PyType_Spec __pyx_AsyncGenType_spec = { + __PYX_TYPE_MODULE_PREFIX "async_generator", + sizeof(__pyx_PyAsyncGenObject), + 0, +#if PY_VERSION_HEX >= 0x030A0000 + Py_TPFLAGS_IMMUTABLETYPE | +#endif + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_HAVE_FINALIZE, /*tp_flags*/ + __pyx_AsyncGenType_slots +}; + + +static int +__Pyx_PyAsyncGen_ClearFreeLists(void) +{ + #if CYTHON_USE_FREELISTS + int ret = CGLOBAL(__Pyx_ag_value_freelist_free) + CGLOBAL(__Pyx_ag_asend_freelist_free); + + while (CGLOBAL(__Pyx_ag_value_freelist_free)) { + __pyx__PyAsyncGenWrappedValue *o; + o = CGLOBAL(__Pyx_ag_value_freelist)[--CGLOBAL(__Pyx_ag_value_freelist_free]); + assert(__pyx__PyAsyncGenWrappedValue_CheckExact(o)); + __Pyx_PyHeapTypeObject_GC_Del(o); + } + + while (CGLOBAL(__Pyx_ag_asend_freelist_free)) { + __pyx_PyAsyncGenASend *o; + o = CGLOBAL(__Pyx_ag_asend_freelist)[--CGLOBAL(__Pyx_ag_asend_freelist_free)]; + assert(__Pyx_IS_TYPE(o, CGLOBAL(__pyx__PyAsyncGenASendType))); + __Pyx_PyHeapTypeObject_GC_Del(o); + } + + return ret; + #else + return 0; + #endif +} + +static void +__Pyx_PyAsyncGen_Fini(void) +{ + __Pyx_PyAsyncGen_ClearFreeLists(); +} + + +static PyObject * +__Pyx_async_gen_unwrap_value(__pyx_PyAsyncGenObject *gen, PyObject *result, int iternext) +{ + if (result == NULL) { + PyObject *exc_type = PyErr_Occurred(); + if (!exc_type) { + PyErr_SetNone(PyExc_StopAsyncIteration); + gen->ag_closed = 1; + } else if (__Pyx_PyErr_GivenExceptionMatches2(exc_type, PyExc_StopAsyncIteration, PyExc_GeneratorExit)) { + gen->ag_closed = 1; + } + + gen->ag_running_async = 0; + return NULL; + } + + if (__pyx__PyAsyncGenWrappedValue_CheckExact(result)) { + /* async yield */ + __Pyx_ReturnWithStopIteration(((__pyx__PyAsyncGenWrappedValue*)result)->agw_val, 0, iternext); + Py_DECREF(result); + gen->ag_running_async = 0; + return NULL; + } + + return result; +} + + +/* ---------- Async Generator ASend Awaitable ------------ */ + + +static void +__Pyx_async_gen_asend_dealloc(__pyx_PyAsyncGenASend *o) +{ + PyObject_GC_UnTrack((PyObject *)o); + Py_CLEAR(o->ags_gen); + Py_CLEAR(o->ags_sendval); + #if CYTHON_USE_FREELISTS + if (likely(CGLOBAL(__Pyx_ag_asend_freelist_free) < _PyAsyncGen_MAXFREELIST)) { + assert(__pyx_PyAsyncGenASend_CheckExact(o)); + CGLOBAL(__Pyx_ag_asend_freelist)[CGLOBAL(__Pyx_ag_asend_freelist_free)++] = o; + } else + #endif + { + __Pyx_PyHeapTypeObject_GC_Del(o); + } +} + +static int +__Pyx_async_gen_asend_traverse(__pyx_PyAsyncGenASend *o, visitproc visit, void *arg) +{ + { + int e = __Pyx_call_type_traverse((PyObject*)o, 1, visit, arg); + if (e) return e; + } + Py_VISIT(o->ags_gen); + Py_VISIT(o->ags_sendval); + return 0; +} + +static PyObject * +__Pyx_async_gen_asend_send_impl(PyObject *g, PyObject *arg, int iternext) +{ + __pyx_PyAsyncGenASend *o = (__pyx_PyAsyncGenASend*) g; + PyObject *retval; + + if (unlikely(o->ags_state == __PYX_AWAITABLE_STATE_CLOSED)) { + PyErr_SetString(PyExc_RuntimeError, __Pyx_ASYNC_GEN_CANNOT_REUSE_SEND_MSG); + return NULL; + } + + if (o->ags_state == __PYX_AWAITABLE_STATE_INIT) { + if (unlikely(o->ags_gen->ag_running_async)) { + PyErr_SetString( + PyExc_RuntimeError, + "anext(): asynchronous generator is already running"); + return NULL; + } + + if (arg == NULL || arg == Py_None) { + arg = o->ags_sendval ? o->ags_sendval : Py_None; + } + o->ags_state = __PYX_AWAITABLE_STATE_ITER; + } + + o->ags_gen->ag_running_async = 1; + retval = __Pyx_Coroutine_Send((PyObject*)o->ags_gen, arg); + retval = __Pyx_async_gen_unwrap_value(o->ags_gen, retval, iternext); + + if (!retval) { + o->ags_state = __PYX_AWAITABLE_STATE_CLOSED; + } + + return retval; +} + +static PyObject * +__Pyx_async_gen_asend_send(PyObject *g, PyObject *arg) +{ + return __Pyx_async_gen_asend_send_impl(g, arg, 0); +} + + +static CYTHON_INLINE PyObject * +__Pyx_async_gen_asend_iternext(PyObject *o) +{ + return __Pyx_async_gen_asend_send_impl(o, Py_None, 1); +} + + +static PyObject * +__Pyx_async_gen_asend_throw(__pyx_PyAsyncGenASend *o, PyObject *args) +{ + PyObject *result; + + if (unlikely(o->ags_state == __PYX_AWAITABLE_STATE_CLOSED)) { + PyErr_SetString(PyExc_RuntimeError, __Pyx_ASYNC_GEN_CANNOT_REUSE_SEND_MSG); + return NULL; + } + + result = __Pyx_Coroutine_Throw((PyObject*)o->ags_gen, args); + result = __Pyx_async_gen_unwrap_value(o->ags_gen, result, 0); + + if (result == NULL) { + o->ags_state = __PYX_AWAITABLE_STATE_CLOSED; + } + + return result; +} + + +static PyObject * +__Pyx_async_gen_asend_close(PyObject *g, PyObject *args) +{ + __pyx_PyAsyncGenASend *o = (__pyx_PyAsyncGenASend*) g; + CYTHON_UNUSED_VAR(args); + o->ags_state = __PYX_AWAITABLE_STATE_CLOSED; + Py_RETURN_NONE; +} + + +static PyMethodDef __Pyx_async_gen_asend_methods[] = { + {"send", (PyCFunction)__Pyx_async_gen_asend_send, METH_O, __Pyx_async_gen_send_doc}, + {"throw", (PyCFunction)__Pyx_async_gen_asend_throw, METH_VARARGS, __Pyx_async_gen_throw_doc}, + {"close", (PyCFunction)__Pyx_async_gen_asend_close, METH_NOARGS, __Pyx_async_gen_close_doc}, + {"__await__", (PyCFunction)__Pyx_async_gen_self_method, METH_NOARGS, __Pyx_async_gen_await_doc}, + {0, 0, 0, 0} /* Sentinel */ +}; + + +static PyType_Slot __pyx__PyAsyncGenASendType_slots[] = { + {Py_tp_dealloc, (void *)__Pyx_async_gen_asend_dealloc}, + {Py_am_await, (void *)PyObject_SelfIter}, + {Py_tp_traverse, (void *)__Pyx_async_gen_asend_traverse}, + {Py_tp_methods, (void *)__Pyx_async_gen_asend_methods}, + {Py_tp_iter, (void *)PyObject_SelfIter}, + {Py_tp_iternext, (void *)__Pyx_async_gen_asend_iternext}, + {0, 0}, +}; + +static PyType_Spec __pyx__PyAsyncGenASendType_spec = { + __PYX_TYPE_MODULE_PREFIX "async_generator_asend", + sizeof(__pyx_PyAsyncGenASend), + 0, +#if PY_VERSION_HEX >= 0x030A0000 + Py_TPFLAGS_IMMUTABLETYPE | +#endif + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + __pyx__PyAsyncGenASendType_slots +}; + + +static PyObject * +__Pyx_async_gen_asend_new(__pyx_PyAsyncGenObject *gen, PyObject *sendval) +{ + __pyx_PyAsyncGenASend *o; + #if CYTHON_USE_FREELISTS + if (likely(CGLOBAL(__Pyx_ag_asend_freelist_free))) { + CGLOBAL(__Pyx_ag_asend_freelist_free)--; + o = CGLOBAL(__Pyx_ag_asend_freelist)[CGLOBAL(__Pyx_ag_asend_freelist_free)]; + _Py_NewReference((PyObject *)o); + } else + #endif + { + o = PyObject_GC_New(__pyx_PyAsyncGenASend, CGLOBAL(__pyx__PyAsyncGenASendType)); + if (unlikely(o == NULL)) { + return NULL; + } + } + + Py_INCREF((PyObject*)gen); + o->ags_gen = gen; + + Py_XINCREF(sendval); + o->ags_sendval = sendval; + + o->ags_state = __PYX_AWAITABLE_STATE_INIT; + + PyObject_GC_Track((PyObject*)o); + return (PyObject*)o; +} + + +/* ---------- Async Generator Value Wrapper ------------ */ + + +static void +__Pyx_async_gen_wrapped_val_dealloc(__pyx__PyAsyncGenWrappedValue *o) +{ + PyObject_GC_UnTrack((PyObject *)o); + Py_CLEAR(o->agw_val); + #if CYTHON_USE_FREELISTS + if (likely(CGLOBAL(__Pyx_ag_value_freelist_free) < _PyAsyncGen_MAXFREELIST)) { + assert(__pyx__PyAsyncGenWrappedValue_CheckExact(o)); + CGLOBAL(__Pyx_ag_value_freelist)[CGLOBAL(__Pyx_ag_value_freelist_free)++] = o; + } else + #endif + { + __Pyx_PyHeapTypeObject_GC_Del(o); + } +} + + +static int +__Pyx_async_gen_wrapped_val_traverse(__pyx__PyAsyncGenWrappedValue *o, + visitproc visit, void *arg) +{ + { + int e = __Pyx_call_type_traverse((PyObject*)o, 1, visit, arg); + if (e) return e; + } + Py_VISIT(o->agw_val); + return 0; +} + + +static PyType_Slot __pyx__PyAsyncGenWrappedValueType_slots[] = { + {Py_tp_dealloc, (void *)__Pyx_async_gen_wrapped_val_dealloc}, + {Py_tp_traverse, (void *)__Pyx_async_gen_wrapped_val_traverse}, + {0, 0}, +}; + +static PyType_Spec __pyx__PyAsyncGenWrappedValueType_spec = { + __PYX_TYPE_MODULE_PREFIX "async_generator_wrapped_value", + sizeof(__pyx__PyAsyncGenWrappedValue), + 0, +#if PY_VERSION_HEX >= 0x030A0000 + Py_TPFLAGS_IMMUTABLETYPE | +#endif + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + __pyx__PyAsyncGenWrappedValueType_slots +}; + + +static PyObject * +__Pyx__PyAsyncGenValueWrapperNew(PyObject *val) +{ + // NOTE: steals a reference to val ! + __pyx__PyAsyncGenWrappedValue *o; + assert(val); + + #if CYTHON_USE_FREELISTS + if (likely(CGLOBAL(__Pyx_ag_value_freelist_free))) { + CGLOBAL(__Pyx_ag_value_freelist_free)--; + o = CGLOBAL(__Pyx_ag_value_freelist)[CGLOBAL(__Pyx_ag_value_freelist_free)]; + assert(__pyx__PyAsyncGenWrappedValue_CheckExact(o)); + _Py_NewReference((PyObject*)o); + } else + #endif + { + o = PyObject_GC_New(__pyx__PyAsyncGenWrappedValue, CGLOBAL(__pyx__PyAsyncGenWrappedValueType)); + if (unlikely(!o)) { + Py_DECREF(val); + return NULL; + } + } + o->agw_val = val; + // no Py_INCREF(val) - steals reference! + PyObject_GC_Track((PyObject*)o); + return (PyObject*)o; +} + + +/* ---------- Async Generator AThrow awaitable ------------ */ + + +static void +__Pyx_async_gen_athrow_dealloc(__pyx_PyAsyncGenAThrow *o) +{ + PyObject_GC_UnTrack((PyObject *)o); + Py_CLEAR(o->agt_gen); + Py_CLEAR(o->agt_args); + __Pyx_PyHeapTypeObject_GC_Del(o); +} + + +static int +__Pyx_async_gen_athrow_traverse(__pyx_PyAsyncGenAThrow *o, visitproc visit, void *arg) +{ + { + int e = __Pyx_call_type_traverse((PyObject*)o, 1, visit, arg); + if (e) return e; + } + Py_VISIT(o->agt_gen); + Py_VISIT(o->agt_args); + return 0; +} + + +static PyObject * +__Pyx_async_gen_athrow_send_impl(__pyx_PyAsyncGenAThrow *o, PyObject *arg, int iternext) +{ + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject*)o->agt_gen; + PyObject *retval, *exc_type; + + if (unlikely(o->agt_state == __PYX_AWAITABLE_STATE_CLOSED)) { + PyErr_SetString(PyExc_RuntimeError, __Pyx_ASYNC_GEN_CANNOT_REUSE_CLOSE_MSG); + return NULL; + } + + if (unlikely(gen->resume_label == -1)) { + // already run past the end + o->agt_state = __PYX_AWAITABLE_STATE_CLOSED; + PyErr_SetNone(PyExc_StopIteration); + return NULL; + } + + if (o->agt_state == __PYX_AWAITABLE_STATE_INIT) { + if (unlikely(o->agt_gen->ag_running_async)) { + o->agt_state = __PYX_AWAITABLE_STATE_CLOSED; + if (o->agt_args == NULL) { + PyErr_SetString( + PyExc_RuntimeError, + "aclose(): asynchronous generator is already running"); + } else { + PyErr_SetString( + PyExc_RuntimeError, + "athrow(): asynchronous generator is already running"); + } + return NULL; + } + + if (unlikely(o->agt_gen->ag_closed)) { + o->agt_state = __PYX_AWAITABLE_STATE_CLOSED; + PyErr_SetNone(PyExc_StopAsyncIteration); + return NULL; + } + + if (unlikely(arg != Py_None)) { + PyErr_SetString(PyExc_RuntimeError, __Pyx_NON_INIT_CORO_MSG); + return NULL; + } + + o->agt_state = __PYX_AWAITABLE_STATE_ITER; + o->agt_gen->ag_running_async = 1; + + if (o->agt_args == NULL) { + /* aclose() mode */ + o->agt_gen->ag_closed = 1; + + retval = __Pyx__Coroutine_Throw((PyObject*)gen, + /* Do not close generator when PyExc_GeneratorExit is passed */ + PyExc_GeneratorExit, NULL, NULL, NULL, 0); + + if (retval && __pyx__PyAsyncGenWrappedValue_CheckExact(retval)) { + Py_DECREF(retval); + goto yield_close; + } + } else { + PyObject *typ; + PyObject *tb = NULL; + PyObject *val = NULL; + + if (unlikely(!PyArg_UnpackTuple(o->agt_args, "athrow", 1, 3, &typ, &val, &tb))) { + return NULL; + } + + retval = __Pyx__Coroutine_Throw((PyObject*)gen, + /* Do not close generator when PyExc_GeneratorExit is passed */ + typ, val, tb, o->agt_args, 0); + retval = __Pyx_async_gen_unwrap_value(o->agt_gen, retval, iternext); + } + if (retval == NULL) { + goto check_error; + } + return retval; + } + + assert (o->agt_state == __PYX_AWAITABLE_STATE_ITER); + + retval = __Pyx_Coroutine_Send((PyObject *)gen, arg); + if (o->agt_args) { + return __Pyx_async_gen_unwrap_value(o->agt_gen, retval, iternext); + } else { + /* aclose() mode */ + if (retval) { + if (unlikely(__pyx__PyAsyncGenWrappedValue_CheckExact(retval))) { + Py_DECREF(retval); + goto yield_close; + } + else { + return retval; + } + } + else { + goto check_error; + } + } + +yield_close: + o->agt_gen->ag_running_async = 0; + o->agt_state = __PYX_AWAITABLE_STATE_CLOSED; + PyErr_SetString( + PyExc_RuntimeError, __Pyx_ASYNC_GEN_IGNORED_EXIT_MSG); + return NULL; + +check_error: + o->agt_gen->ag_running_async = 0; + o->agt_state = __PYX_AWAITABLE_STATE_CLOSED; + exc_type = PyErr_Occurred(); + if (__Pyx_PyErr_GivenExceptionMatches2(exc_type, PyExc_StopAsyncIteration, PyExc_GeneratorExit)) { + if (o->agt_args == NULL) { + // when aclose() is called we don't want to propagate + // StopAsyncIteration or GeneratorExit; just raise + // StopIteration, signalling that this 'aclose()' await + // is done. + PyErr_Clear(); + PyErr_SetNone(PyExc_StopIteration); + } + } + return NULL; +} + +static PyObject * +__Pyx_async_gen_athrow_send(__pyx_PyAsyncGenAThrow *o, PyObject *arg) +{ + return __Pyx_async_gen_athrow_send_impl(o, arg, 0); +} + + +static PyObject * +__Pyx_async_gen_athrow_throw(__pyx_PyAsyncGenAThrow *o, PyObject *args) +{ + PyObject *retval; + + if (unlikely(o->agt_state == __PYX_AWAITABLE_STATE_CLOSED)) { + PyErr_SetString(PyExc_RuntimeError, __Pyx_ASYNC_GEN_CANNOT_REUSE_CLOSE_MSG); + return NULL; + } + + retval = __Pyx_Coroutine_Throw((PyObject*)o->agt_gen, args); + if (o->agt_args) { + return __Pyx_async_gen_unwrap_value(o->agt_gen, retval, 0); + } else { + // aclose() mode + PyObject *exc_type; + if (unlikely(retval && __pyx__PyAsyncGenWrappedValue_CheckExact(retval))) { + o->agt_gen->ag_running_async = 0; + o->agt_state = __PYX_AWAITABLE_STATE_CLOSED; + Py_DECREF(retval); + PyErr_SetString(PyExc_RuntimeError, __Pyx_ASYNC_GEN_IGNORED_EXIT_MSG); + return NULL; + } + exc_type = PyErr_Occurred(); + if (__Pyx_PyErr_GivenExceptionMatches2(exc_type, PyExc_StopAsyncIteration, PyExc_GeneratorExit)) { + // when aclose() is called we don't want to propagate + // StopAsyncIteration or GeneratorExit; just raise + // StopIteration, signalling that this 'aclose()' await + // is done. + PyErr_Clear(); + PyErr_SetNone(PyExc_StopIteration); + } + return retval; + } +} + + +static PyObject * +__Pyx_async_gen_athrow_iternext(__pyx_PyAsyncGenAThrow *o) +{ + return __Pyx_async_gen_athrow_send_impl(o, Py_None, 1); +} + + +static PyObject * +__Pyx_async_gen_athrow_close(PyObject *g, PyObject *args) +{ + __pyx_PyAsyncGenAThrow *o = (__pyx_PyAsyncGenAThrow*) g; + CYTHON_UNUSED_VAR(args); + o->agt_state = __PYX_AWAITABLE_STATE_CLOSED; + Py_RETURN_NONE; +} + + +static PyMethodDef __Pyx_async_gen_athrow_methods[] = { + {"send", (PyCFunction)__Pyx_async_gen_athrow_send, METH_O, __Pyx_async_gen_send_doc}, + {"throw", (PyCFunction)__Pyx_async_gen_athrow_throw, METH_VARARGS, __Pyx_async_gen_throw_doc}, + {"close", (PyCFunction)__Pyx_async_gen_athrow_close, METH_NOARGS, __Pyx_async_gen_close_doc}, + {"__await__", (PyCFunction)__Pyx_async_gen_self_method, METH_NOARGS, __Pyx_async_gen_await_doc}, + {0, 0, 0, 0} /* Sentinel */ +}; + + +static PyType_Slot __pyx__PyAsyncGenAThrowType_slots[] = { + {Py_tp_dealloc, (void *)__Pyx_async_gen_athrow_dealloc}, + {Py_am_await, (void *)PyObject_SelfIter}, + {Py_tp_traverse, (void *)__Pyx_async_gen_athrow_traverse}, + {Py_tp_iter, (void *)PyObject_SelfIter}, + {Py_tp_iternext, (void *)__Pyx_async_gen_athrow_iternext}, + {Py_tp_methods, (void *)__Pyx_async_gen_athrow_methods}, + {Py_tp_getattro, (void *)PyObject_GenericGetAttr}, + {0, 0}, +}; + +static PyType_Spec __pyx__PyAsyncGenAThrowType_spec = { + __PYX_TYPE_MODULE_PREFIX "async_generator_athrow", + sizeof(__pyx_PyAsyncGenAThrow), + 0, +#if PY_VERSION_HEX >= 0x030A0000 + Py_TPFLAGS_IMMUTABLETYPE | +#endif + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + __pyx__PyAsyncGenAThrowType_slots +}; + + +static PyObject * +__Pyx_async_gen_athrow_new(__pyx_PyAsyncGenObject *gen, PyObject *args) +{ + __pyx_PyAsyncGenAThrow *o; + o = PyObject_GC_New(__pyx_PyAsyncGenAThrow, CGLOBAL(__pyx__PyAsyncGenAThrowType)); + if (unlikely(o == NULL)) { + return NULL; + } + o->agt_gen = gen; + o->agt_args = args; + o->agt_state = __PYX_AWAITABLE_STATE_INIT; + Py_INCREF((PyObject*)gen); + Py_XINCREF(args); + PyObject_GC_Track((PyObject*)o); + return (PyObject*)o; +} + + +/* ---------- global type sharing ------------ */ + +static int __pyx_AsyncGen_init(PyObject *module) { + $modulestatetype_cname *mstate = __Pyx_PyModule_GetState(module); + mstate->__pyx_AsyncGenType = __Pyx_FetchCommonTypeFromSpec( + mstate->__pyx_CommonTypesMetaclassType, module, &__pyx_AsyncGenType_spec, NULL); + if (unlikely(!mstate->__pyx_AsyncGenType)) + return -1; + + mstate->__pyx__PyAsyncGenAThrowType = __Pyx_FetchCommonTypeFromSpec(NULL, module, &__pyx__PyAsyncGenAThrowType_spec, NULL); + if (unlikely(!mstate->__pyx__PyAsyncGenAThrowType)) + return -1; + + mstate->__pyx__PyAsyncGenWrappedValueType = __Pyx_FetchCommonTypeFromSpec(NULL, module, &__pyx__PyAsyncGenWrappedValueType_spec, NULL); + if (unlikely(!mstate->__pyx__PyAsyncGenWrappedValueType)) + return -1; + + mstate->__pyx__PyAsyncGenASendType = __Pyx_FetchCommonTypeFromSpec(NULL, module, &__pyx__PyAsyncGenASendType_spec, NULL); + if (unlikely(!mstate->__pyx__PyAsyncGenASendType)) + return -1; + + return 0; +} diff --git a/venv/lib/python3.10/site-packages/Cython/Utility/Buffer.c b/venv/lib/python3.10/site-packages/Cython/Utility/Buffer.c new file mode 100644 index 0000000000000000000000000000000000000000..fa82504ba0c5bfc839c5a9b3ad05882226e02f14 --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Utility/Buffer.c @@ -0,0 +1,875 @@ +/////////////// BufferStructDeclare.proto /////////////// + +/* structs for buffer access */ + +typedef struct { + Py_ssize_t shape, strides, suboffsets; +} __Pyx_Buf_DimInfo; + +typedef struct { + size_t refcount; + Py_buffer pybuffer; +} __Pyx_Buffer; + +typedef struct { + __Pyx_Buffer *rcbuffer; + char *data; + __Pyx_Buf_DimInfo diminfo[{{max_dims}}]; +} __Pyx_LocalBuf_ND; + +/////////////// BufferIndexError.proto /////////////// +static void __Pyx_RaiseBufferIndexError(int axis); /*proto*/ + +/////////////// BufferIndexError /////////////// +static void __Pyx_RaiseBufferIndexError(int axis) { + PyErr_Format(PyExc_IndexError, + "Out of bounds on buffer access (axis %d)", axis); +} + +/////////////// BufferIndexErrorNogil.proto /////////////// +//@requires: BufferIndexError + +static void __Pyx_RaiseBufferIndexErrorNogil(int axis); /*proto*/ + +/////////////// BufferIndexErrorNogil /////////////// +static void __Pyx_RaiseBufferIndexErrorNogil(int axis) { + PyGILState_STATE gilstate = PyGILState_Ensure(); + __Pyx_RaiseBufferIndexError(axis); + PyGILState_Release(gilstate); +} + +/////////////// BufferFallbackError.proto /////////////// +static void __Pyx_RaiseBufferFallbackError(void); /*proto*/ + +/////////////// BufferFallbackError /////////////// +static void __Pyx_RaiseBufferFallbackError(void) { + PyErr_SetString(PyExc_ValueError, + "Buffer acquisition failed on assignment; and then reacquiring the old buffer failed too!"); +} + +/////////////// BufferFormatStructs.proto /////////////// +//@proto_block: utility_code_proto_before_types + +/* Run-time type information about structs used with buffers */ +struct __Pyx_StructField_; + +#define __PYX_BUF_FLAGS_PACKED_STRUCT (1 << 0) + +typedef struct { + const char* name; /* for error messages only */ + const struct __Pyx_StructField_* fields; + size_t size; /* sizeof(type) */ + size_t arraysize[8]; /* length of array in each dimension */ + int ndim; + char typegroup; /* _R_eal, _C_omplex, Signed _I_nt, _U_nsigned int, _S_truct, _P_ointer, _O_bject, c_H_ar */ + char is_unsigned; + int flags; +} __Pyx_TypeInfo; + +typedef struct __Pyx_StructField_ { + const __Pyx_TypeInfo* type; + const char* name; + size_t offset; +} __Pyx_StructField; + +typedef struct { + const __Pyx_StructField* field; + size_t parent_offset; +} __Pyx_BufFmt_StackElem; + +typedef struct { + __Pyx_StructField root; + __Pyx_BufFmt_StackElem* head; + size_t fmt_offset; + size_t new_count, enc_count; + size_t struct_alignment; + int is_complex; + char enc_type; + char new_packmode; + char enc_packmode; + char is_valid_array; +} __Pyx_BufFmt_Context; + + +/////////////// BufferGetAndValidate.proto /////////////// + +#define __Pyx_GetBufferAndValidate(buf, obj, dtype, flags, nd, cast, stack) \ + ((obj == Py_None || obj == NULL) ? \ + (__Pyx_ZeroBuffer(buf), 0) : \ + __Pyx__GetBufferAndValidate(buf, obj, dtype, flags, nd, cast, stack)) + +static int __Pyx__GetBufferAndValidate(Py_buffer* buf, PyObject* obj, + const __Pyx_TypeInfo* dtype, int flags, int nd, int cast, __Pyx_BufFmt_StackElem* stack); +static void __Pyx_ZeroBuffer(Py_buffer* buf); +static CYTHON_INLINE void __Pyx_SafeReleaseBuffer(Py_buffer* info);/*proto*/ + +static Py_ssize_t __Pyx_minusones[] = { {{ ", ".join(["-1"] * max_dims) }} }; +static Py_ssize_t __Pyx_zeros[] = { {{ ", ".join(["0"] * max_dims) }} }; + + +/////////////// BufferGetAndValidate /////////////// +//@requires: BufferFormatCheck + +static CYTHON_INLINE void __Pyx_SafeReleaseBuffer(Py_buffer* info) { + if (unlikely(info->buf == NULL)) return; + if (info->suboffsets == __Pyx_minusones) info->suboffsets = NULL; + PyBuffer_Release(info); +} + +static void __Pyx_ZeroBuffer(Py_buffer* buf) { + buf->buf = NULL; + buf->obj = NULL; + buf->strides = __Pyx_zeros; + buf->shape = __Pyx_zeros; + buf->suboffsets = __Pyx_minusones; +} + +static int __Pyx__GetBufferAndValidate( + Py_buffer* buf, PyObject* obj, const __Pyx_TypeInfo* dtype, int flags, + int nd, int cast, __Pyx_BufFmt_StackElem* stack) +{ + buf->buf = NULL; + if (unlikely(PyObject_GetBuffer(obj, buf, flags) == -1)) { + __Pyx_ZeroBuffer(buf); + return -1; + } + // From this point on, we have acquired the buffer and must release it on errors. + if (unlikely(buf->ndim != nd)) { + PyErr_Format(PyExc_ValueError, + "Buffer has wrong number of dimensions (expected %d, got %d)", + nd, buf->ndim); + goto fail; + } + if (!cast) { + __Pyx_BufFmt_Context ctx; + __Pyx_BufFmt_Init(&ctx, stack, dtype); + if (!__Pyx_BufFmt_CheckString(&ctx, buf->format)) goto fail; + } + if (unlikely((size_t)buf->itemsize != dtype->size)) { + PyErr_Format(PyExc_ValueError, + "Item size of buffer (%" CYTHON_FORMAT_SSIZE_T "d byte%s) does not match size of '%s' (%" CYTHON_FORMAT_SSIZE_T "d byte%s)", + buf->itemsize, (buf->itemsize > 1) ? "s" : "", + dtype->name, (Py_ssize_t)dtype->size, (dtype->size > 1) ? "s" : ""); + goto fail; + } + if (buf->suboffsets == NULL) buf->suboffsets = __Pyx_minusones; + return 0; +fail:; + __Pyx_SafeReleaseBuffer(buf); + return -1; +} + + +/////////////// BufferFormatCheck.proto /////////////// + +// Buffer format string checking +// +// Buffer type checking. Utility code for checking that acquired +// buffers match our assumptions. We only need to check ndim and +// the format string; the access mode/flags is checked by the +// exporter. See: +// +// https://docs.python.org/3/library/struct.html +// https://www.python.org/dev/peps/pep-3118/#additions-to-the-struct-string-syntax +// +// The alignment code is copied from _struct.c in Python. + +static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts); +static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx, + __Pyx_BufFmt_StackElem* stack, + const __Pyx_TypeInfo* type); /*proto*/ + +/////////////// BufferFormatCheck /////////////// +//@requires: ModuleSetupCode.c::IsLittleEndian +//@requires: BufferFormatStructs + +static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx, + __Pyx_BufFmt_StackElem* stack, + const __Pyx_TypeInfo* type) { + stack[0].field = &ctx->root; + stack[0].parent_offset = 0; + ctx->root.type = type; + ctx->root.name = "buffer dtype"; + ctx->root.offset = 0; + ctx->head = stack; + ctx->head->field = &ctx->root; + ctx->fmt_offset = 0; + ctx->head->parent_offset = 0; + ctx->new_packmode = '@'; + ctx->enc_packmode = '@'; + ctx->new_count = 1; + ctx->enc_count = 0; + ctx->enc_type = 0; + ctx->is_complex = 0; + ctx->is_valid_array = 0; + ctx->struct_alignment = 0; + while (type->typegroup == 'S') { + ++ctx->head; + ctx->head->field = type->fields; + ctx->head->parent_offset = 0; + type = type->fields->type; + } +} + +static int __Pyx_BufFmt_ParseNumber(const char** ts) { + int count; + const char* t = *ts; + if (*t < '0' || *t > '9') { + return -1; + } else { + count = *t++ - '0'; + while (*t >= '0' && *t <= '9') { + count *= 10; + count += *t++ - '0'; + } + } + *ts = t; + return count; +} + +static int __Pyx_BufFmt_ExpectNumber(const char **ts) { + int number = __Pyx_BufFmt_ParseNumber(ts); + if (number == -1) /* First char was not a digit */ + PyErr_Format(PyExc_ValueError,\ + "Does not understand character buffer dtype format string ('%c')", **ts); + return number; +} + + +static void __Pyx_BufFmt_RaiseUnexpectedChar(char ch) { + PyErr_Format(PyExc_ValueError, + "Unexpected format string character: '%c'", ch); +} + +static const char* __Pyx_BufFmt_DescribeTypeChar(char ch, int is_complex) { + switch (ch) { + case '?': return "'bool'"; + case 'c': return "'char'"; + case 'b': return "'signed char'"; + case 'B': return "'unsigned char'"; + case 'h': return "'short'"; + case 'H': return "'unsigned short'"; + case 'i': return "'int'"; + case 'I': return "'unsigned int'"; + case 'l': return "'long'"; + case 'L': return "'unsigned long'"; + case 'q': return "'long long'"; + case 'Q': return "'unsigned long long'"; + case 'f': return (is_complex ? "'complex float'" : "'float'"); + case 'd': return (is_complex ? "'complex double'" : "'double'"); + case 'g': return (is_complex ? "'complex long double'" : "'long double'"); + case 'T': return "a struct"; + case 'O': return "Python object"; + case 'P': return "a pointer"; + case 's': case 'p': return "a string"; + case 0: return "end"; + default: return "unparsable format string"; + } +} + +static size_t __Pyx_BufFmt_TypeCharToStandardSize(char ch, int is_complex) { + switch (ch) { + case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; + case 'h': case 'H': return 2; + case 'i': case 'I': case 'l': case 'L': return 4; + case 'q': case 'Q': return 8; + case 'f': return (is_complex ? 8 : 4); + case 'd': return (is_complex ? 16 : 8); + case 'g': { + PyErr_SetString(PyExc_ValueError, "Python does not define a standard format string size for long double ('g').."); + return 0; + } + case 'O': case 'P': return sizeof(void*); + default: + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } +} + +static size_t __Pyx_BufFmt_TypeCharToNativeSize(char ch, int is_complex) { + switch (ch) { + case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; + case 'h': case 'H': return sizeof(short); + case 'i': case 'I': return sizeof(int); + case 'l': case 'L': return sizeof(long); + #ifdef HAVE_LONG_LONG + case 'q': case 'Q': return sizeof(PY_LONG_LONG); + #endif + case 'f': return sizeof(float) * (is_complex ? 2 : 1); + case 'd': return sizeof(double) * (is_complex ? 2 : 1); + case 'g': return sizeof(long double) * (is_complex ? 2 : 1); + case 'O': case 'P': return sizeof(void*); + default: { + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } + } +} + +typedef struct { char c; short x; } __Pyx_st_short; +typedef struct { char c; int x; } __Pyx_st_int; +typedef struct { char c; long x; } __Pyx_st_long; +typedef struct { char c; float x; } __Pyx_st_float; +typedef struct { char c; double x; } __Pyx_st_double; +typedef struct { char c; long double x; } __Pyx_st_longdouble; +typedef struct { char c; void *x; } __Pyx_st_void_p; +#ifdef HAVE_LONG_LONG +typedef struct { char c; PY_LONG_LONG x; } __Pyx_st_longlong; +#endif + +static size_t __Pyx_BufFmt_TypeCharToAlignment(char ch, int is_complex) { + CYTHON_UNUSED_VAR(is_complex); + switch (ch) { + case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; + case 'h': case 'H': return sizeof(__Pyx_st_short) - sizeof(short); + case 'i': case 'I': return sizeof(__Pyx_st_int) - sizeof(int); + case 'l': case 'L': return sizeof(__Pyx_st_long) - sizeof(long); +#ifdef HAVE_LONG_LONG + case 'q': case 'Q': return sizeof(__Pyx_st_longlong) - sizeof(PY_LONG_LONG); +#endif + case 'f': return sizeof(__Pyx_st_float) - sizeof(float); + case 'd': return sizeof(__Pyx_st_double) - sizeof(double); + case 'g': return sizeof(__Pyx_st_longdouble) - sizeof(long double); + case 'P': case 'O': return sizeof(__Pyx_st_void_p) - sizeof(void*); + default: + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } +} + +/* These are for computing the padding at the end of the struct to align + on the first member of the struct. This will probably the same as above, + but we don't have any guarantees. + */ +typedef struct { short x; char c; } __Pyx_pad_short; +typedef struct { int x; char c; } __Pyx_pad_int; +typedef struct { long x; char c; } __Pyx_pad_long; +typedef struct { float x; char c; } __Pyx_pad_float; +typedef struct { double x; char c; } __Pyx_pad_double; +typedef struct { long double x; char c; } __Pyx_pad_longdouble; +typedef struct { void *x; char c; } __Pyx_pad_void_p; +#ifdef HAVE_LONG_LONG +typedef struct { PY_LONG_LONG x; char c; } __Pyx_pad_longlong; +#endif + +static size_t __Pyx_BufFmt_TypeCharToPadding(char ch, int is_complex) { + CYTHON_UNUSED_VAR(is_complex); + switch (ch) { + case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; + case 'h': case 'H': return sizeof(__Pyx_pad_short) - sizeof(short); + case 'i': case 'I': return sizeof(__Pyx_pad_int) - sizeof(int); + case 'l': case 'L': return sizeof(__Pyx_pad_long) - sizeof(long); +#ifdef HAVE_LONG_LONG + case 'q': case 'Q': return sizeof(__Pyx_pad_longlong) - sizeof(PY_LONG_LONG); +#endif + case 'f': return sizeof(__Pyx_pad_float) - sizeof(float); + case 'd': return sizeof(__Pyx_pad_double) - sizeof(double); + case 'g': return sizeof(__Pyx_pad_longdouble) - sizeof(long double); + case 'P': case 'O': return sizeof(__Pyx_pad_void_p) - sizeof(void*); + default: + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } +} + +static char __Pyx_BufFmt_TypeCharToGroup(char ch, int is_complex) { + switch (ch) { + case 'c': + return 'H'; + case 'b': case 'h': case 'i': + case 'l': case 'q': case 's': case 'p': + return 'I'; + case '?': case 'B': case 'H': case 'I': case 'L': case 'Q': + return 'U'; + case 'f': case 'd': case 'g': + return (is_complex ? 'C' : 'R'); + case 'O': + return 'O'; + case 'P': + return 'P'; + default: { + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } + } +} + + +static void __Pyx_BufFmt_RaiseExpected(__Pyx_BufFmt_Context* ctx) { + if (ctx->head == NULL || ctx->head->field == &ctx->root) { + const char* expected; + const char* quote; + if (ctx->head == NULL) { + expected = "end"; + quote = ""; + } else { + expected = ctx->head->field->type->name; + quote = "'"; + } + PyErr_Format(PyExc_ValueError, + "Buffer dtype mismatch, expected %s%s%s but got %s", + quote, expected, quote, + __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex)); + } else { + const __Pyx_StructField* field = ctx->head->field; + const __Pyx_StructField* parent = (ctx->head - 1)->field; + PyErr_Format(PyExc_ValueError, + "Buffer dtype mismatch, expected '%s' but got %s in '%s.%s'", + field->type->name, __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex), + parent->type->name, field->name); + } +} + +static int __Pyx_BufFmt_ProcessTypeChunk(__Pyx_BufFmt_Context* ctx) { + char group; + size_t size, offset, arraysize = 1; + + /* printf("processing... %s\n", ctx->head->field->type->name); */ + + if (ctx->enc_type == 0) return 0; + + /* Validate array size */ + if (ctx->head->field->type->arraysize[0]) { + int i, ndim = 0; + + /* handle strings ('s' and 'p') */ + if (ctx->enc_type == 's' || ctx->enc_type == 'p') { + ctx->is_valid_array = ctx->head->field->type->ndim == 1; + ndim = 1; + if (ctx->enc_count != ctx->head->field->type->arraysize[0]) { + PyErr_Format(PyExc_ValueError, + "Expected a dimension of size %zu, got %zu", + ctx->head->field->type->arraysize[0], ctx->enc_count); + return -1; + } + } + + if (!ctx->is_valid_array) { + PyErr_Format(PyExc_ValueError, "Expected %d dimensions, got %d", + ctx->head->field->type->ndim, ndim); + return -1; + } + for (i = 0; i < ctx->head->field->type->ndim; i++) { + arraysize *= ctx->head->field->type->arraysize[i]; + } + ctx->is_valid_array = 0; + ctx->enc_count = 1; + } + + group = __Pyx_BufFmt_TypeCharToGroup(ctx->enc_type, ctx->is_complex); + do { + const __Pyx_StructField* field = ctx->head->field; + const __Pyx_TypeInfo* type = field->type; + + if (ctx->enc_packmode == '@' || ctx->enc_packmode == '^') { + size = __Pyx_BufFmt_TypeCharToNativeSize(ctx->enc_type, ctx->is_complex); + } else { + size = __Pyx_BufFmt_TypeCharToStandardSize(ctx->enc_type, ctx->is_complex); + } + + if (ctx->enc_packmode == '@') { + size_t align_at = __Pyx_BufFmt_TypeCharToAlignment(ctx->enc_type, ctx->is_complex); + size_t align_mod_offset; + if (align_at == 0) return -1; + align_mod_offset = ctx->fmt_offset % align_at; + if (align_mod_offset > 0) ctx->fmt_offset += align_at - align_mod_offset; + + if (ctx->struct_alignment == 0) + ctx->struct_alignment = __Pyx_BufFmt_TypeCharToPadding(ctx->enc_type, + ctx->is_complex); + } + + if (type->size != size || type->typegroup != group) { + if (type->typegroup == 'C' && type->fields != NULL) { + /* special case -- treat as struct rather than complex number */ + size_t parent_offset = ctx->head->parent_offset + field->offset; + ++ctx->head; + ctx->head->field = type->fields; + ctx->head->parent_offset = parent_offset; + continue; + } + + if ((type->typegroup == 'H' || group == 'H') && type->size == size) { + /* special case -- chars don't care about sign */ + } else { + __Pyx_BufFmt_RaiseExpected(ctx); + return -1; + } + } + + offset = ctx->head->parent_offset + field->offset; + if (ctx->fmt_offset != offset) { + PyErr_Format(PyExc_ValueError, + "Buffer dtype mismatch; next field is at offset %" CYTHON_FORMAT_SSIZE_T "d but %" CYTHON_FORMAT_SSIZE_T "d expected", + (Py_ssize_t)ctx->fmt_offset, (Py_ssize_t)offset); + return -1; + } + + ctx->fmt_offset += size; + if (arraysize) + ctx->fmt_offset += (arraysize - 1) * size; + + --ctx->enc_count; /* Consume from buffer string */ + + /* Done checking, move to next field, pushing or popping struct stack if needed */ + while (1) { + if (field == &ctx->root) { + ctx->head = NULL; + if (ctx->enc_count != 0) { + __Pyx_BufFmt_RaiseExpected(ctx); + return -1; + } + break; /* breaks both loops as ctx->enc_count == 0 */ + } + ctx->head->field = ++field; + if (field->type == NULL) { + --ctx->head; + field = ctx->head->field; + continue; + } else if (field->type->typegroup == 'S') { + size_t parent_offset = ctx->head->parent_offset + field->offset; + if (field->type->fields->type == NULL) continue; /* empty struct */ + field = field->type->fields; + ++ctx->head; + ctx->head->field = field; + ctx->head->parent_offset = parent_offset; + break; + } else { + break; + } + } + } while (ctx->enc_count); + ctx->enc_type = 0; + ctx->is_complex = 0; + return 0; +} + +// Parse an array in the format string (e.g. (1,2,3)) +// Return 0 on success, -1 on error +static int +__pyx_buffmt_parse_array(__Pyx_BufFmt_Context* ctx, const char** tsp) +{ + const char *ts = *tsp; + int i = 0, number, ndim; + + ++ts; + if (ctx->new_count != 1) { + PyErr_SetString(PyExc_ValueError, + "Cannot handle repeated arrays in format string"); + return -1; + } + + /* Process the previous element */ + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return -1; + + // store ndim now, as field advanced by __Pyx_BufFmt_ProcessTypeChunk call + ndim = ctx->head->field->type->ndim; + + /* Parse all numbers in the format string */ + while (*ts && *ts != ')') { + // ignore space characters (not using isspace() due to C/C++ problem on MacOS-X) + switch (*ts) { + case ' ': case '\f': case '\r': case '\n': case '\t': case '\v': continue; + default: break; /* not a 'break' in the loop */ + } + + number = __Pyx_BufFmt_ExpectNumber(&ts); + if (number == -1) return -1; + + if (i < ndim && (size_t) number != ctx->head->field->type->arraysize[i]) { + PyErr_Format(PyExc_ValueError, + "Expected a dimension of size %zu, got %d", + ctx->head->field->type->arraysize[i], number); + return -1; + } + + if (*ts != ',' && *ts != ')') { + PyErr_Format(PyExc_ValueError, + "Expected a comma in format string, got '%c'", *ts); + return -1; + } + + if (*ts == ',') ts++; + i++; + } + + if (i != ndim) { + PyErr_Format(PyExc_ValueError, "Expected %d dimension(s), got %d", + ctx->head->field->type->ndim, i); + return -1; + } + + if (!*ts) { + PyErr_SetString(PyExc_ValueError, + "Unexpected end of format string, expected ')'"); + return -1; + } + + ctx->is_valid_array = 1; + ctx->new_count = 1; + *tsp = ++ts; + return 0; +} + +static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts) { + int got_Z = 0; + + while (1) { + /* puts(ts); */ + switch(*ts) { + case 0: + if (ctx->enc_type != 0 && ctx->head == NULL) { + __Pyx_BufFmt_RaiseExpected(ctx); + return NULL; + } + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + if (ctx->head != NULL) { + __Pyx_BufFmt_RaiseExpected(ctx); + return NULL; + } + return ts; + case ' ': + case '\r': + case '\n': + ++ts; + break; + case '<': + if (!__Pyx_Is_Little_Endian()) { + PyErr_SetString(PyExc_ValueError, "Little-endian buffer not supported on big-endian compiler"); + return NULL; + } + ctx->new_packmode = '='; + ++ts; + break; + case '>': + case '!': + if (__Pyx_Is_Little_Endian()) { + PyErr_SetString(PyExc_ValueError, "Big-endian buffer not supported on little-endian compiler"); + return NULL; + } + ctx->new_packmode = '='; + ++ts; + break; + case '=': + case '@': + case '^': + ctx->new_packmode = *ts++; + break; + case 'T': /* substruct */ + { + const char* ts_after_sub; + size_t i, struct_count = ctx->new_count; + size_t struct_alignment = ctx->struct_alignment; + ctx->new_count = 1; + ++ts; + if (*ts != '{') { + PyErr_SetString(PyExc_ValueError, "Buffer acquisition: Expected '{' after 'T'"); + return NULL; + } + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ctx->enc_type = 0; /* Erase processed last struct element */ + ctx->enc_count = 0; + ctx->struct_alignment = 0; + ++ts; + ts_after_sub = ts; + for (i = 0; i != struct_count; ++i) { + ts_after_sub = __Pyx_BufFmt_CheckString(ctx, ts); + if (!ts_after_sub) return NULL; + } + ts = ts_after_sub; + if (struct_alignment) ctx->struct_alignment = struct_alignment; + } + break; + case '}': /* end of substruct; either repeat or move on */ + { + size_t alignment = ctx->struct_alignment; + ++ts; + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ctx->enc_type = 0; /* Erase processed last struct element */ + if (alignment && ctx->fmt_offset % alignment) { + /* Pad struct on size of the first member */ + ctx->fmt_offset += alignment - (ctx->fmt_offset % alignment); + } + } + return ts; + case 'x': + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ctx->fmt_offset += ctx->new_count; + ctx->new_count = 1; + ctx->enc_count = 0; + ctx->enc_type = 0; + ctx->enc_packmode = ctx->new_packmode; + ++ts; + break; + case 'Z': + got_Z = 1; + ++ts; + if (*ts != 'f' && *ts != 'd' && *ts != 'g') { + __Pyx_BufFmt_RaiseUnexpectedChar('Z'); + return NULL; + } + CYTHON_FALLTHROUGH; + case '?': case 'c': case 'b': case 'B': case 'h': case 'H': case 'i': case 'I': + case 'l': case 'L': case 'q': case 'Q': + case 'f': case 'd': case 'g': + case 'O': case 'p': + if ((ctx->enc_type == *ts) && (got_Z == ctx->is_complex) && + (ctx->enc_packmode == ctx->new_packmode) && (!ctx->is_valid_array)) { + /* Continue pooling same type */ + ctx->enc_count += ctx->new_count; + ctx->new_count = 1; + got_Z = 0; + ++ts; + break; + } + CYTHON_FALLTHROUGH; + case 's': + /* 's' or new type (cannot be added to current pool) */ + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ctx->enc_count = ctx->new_count; + ctx->enc_packmode = ctx->new_packmode; + ctx->enc_type = *ts; + ctx->is_complex = got_Z; + ++ts; + ctx->new_count = 1; + got_Z = 0; + break; + case ':': + ++ts; + while(*ts != ':') ++ts; + ++ts; + break; + case '(': + if (__pyx_buffmt_parse_array(ctx, &ts) < 0) return NULL; + break; + default: + { + int number = __Pyx_BufFmt_ExpectNumber(&ts); + if (number == -1) return NULL; + ctx->new_count = (size_t)number; + } + } + } +} + +/////////////// TypeInfoCompare.proto /////////////// +static int __pyx_typeinfo_cmp(const __Pyx_TypeInfo *a, const __Pyx_TypeInfo *b); + +/////////////// TypeInfoCompare /////////////// +//@requires: BufferFormatStructs + +// See if two dtypes are equal +static int +__pyx_typeinfo_cmp(const __Pyx_TypeInfo *a, const __Pyx_TypeInfo *b) +{ + int i; + + if (!a || !b) + return 0; + + if (a == b) + return 1; + + if (a->size != b->size || a->typegroup != b->typegroup || + a->is_unsigned != b->is_unsigned || a->ndim != b->ndim) { + if (a->typegroup == 'H' || b->typegroup == 'H') { + /* Special case for chars */ + return a->size == b->size; + } else { + return 0; + } + } + + if (a->ndim) { + /* Verify multidimensional C arrays */ + for (i = 0; i < a->ndim; i++) + if (a->arraysize[i] != b->arraysize[i]) + return 0; + } + + if (a->typegroup == 'S') { + /* Check for packed struct */ + if (a->flags != b->flags) + return 0; + + /* compare all struct fields */ + if (a->fields || b->fields) { + /* Check if both have fields */ + if (!(a->fields && b->fields)) + return 0; + + /* compare */ + for (i = 0; a->fields[i].type && b->fields[i].type; i++) { + const __Pyx_StructField *field_a = a->fields + i; + const __Pyx_StructField *field_b = b->fields + i; + + if (field_a->offset != field_b->offset || + !__pyx_typeinfo_cmp(field_a->type, field_b->type)) + return 0; + } + + /* If all fields are processed, we have a match */ + return !a->fields[i].type && !b->fields[i].type; + } + } + + return 1; +} + + +/////////////// TypeInfoToFormat.proto /////////////// +struct __pyx_typeinfo_string { + char string[3]; +}; +static struct __pyx_typeinfo_string __Pyx_TypeInfoToFormat(const __Pyx_TypeInfo *type); + +/////////////// TypeInfoToFormat /////////////// +//@requires: BufferFormatStructs + +// See also MemoryView.pyx:BufferFormatFromTypeInfo + +static struct __pyx_typeinfo_string __Pyx_TypeInfoToFormat(const __Pyx_TypeInfo *type) { + struct __pyx_typeinfo_string result = { {0} }; + char *buf = (char *) result.string; + size_t size = type->size; + + switch (type->typegroup) { + case 'H': + *buf = 'c'; + break; + case 'I': + case 'U': + if (size == 1) + *buf = (type->is_unsigned) ? 'B' : 'b'; + else if (size == 2) + *buf = (type->is_unsigned) ? 'H' : 'h'; + else if (size == 4) + *buf = (type->is_unsigned) ? 'I' : 'i'; + else if (size == 8) + *buf = (type->is_unsigned) ? 'Q' : 'q'; + break; + case 'P': + *buf = 'P'; + break; + case 'C': + { + __Pyx_TypeInfo complex_type = *type; + complex_type.typegroup = 'R'; + complex_type.size /= 2; + + *buf++ = 'Z'; + *buf = __Pyx_TypeInfoToFormat(&complex_type).string[0]; + break; + } + case 'R': + if (size == 4) + *buf = 'f'; + else if (size == 8) + *buf = 'd'; + else + *buf = 'g'; + break; + } + + return result; +} diff --git a/venv/lib/python3.10/site-packages/Cython/Utility/BufferFormatFromTypeInfo.pxd b/venv/lib/python3.10/site-packages/Cython/Utility/BufferFormatFromTypeInfo.pxd new file mode 100644 index 0000000000000000000000000000000000000000..6df83aa07814d77ef85d92cde8c0d8222f6ac629 --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Utility/BufferFormatFromTypeInfo.pxd @@ -0,0 +1,2 @@ +@cname('__pyx_format_from_typeinfo') +cdef bytes format_from_typeinfo(const __Pyx_TypeInfo *type) diff --git a/venv/lib/python3.10/site-packages/Cython/Utility/Builtins.c b/venv/lib/python3.10/site-packages/Cython/Utility/Builtins.c new file mode 100644 index 0000000000000000000000000000000000000000..8bf30819047a398ef177802a3b3c5fe0321e292f --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Utility/Builtins.c @@ -0,0 +1,776 @@ +/* + * Special implementations of built-in functions and methods. + * + * Optional optimisations for builtins are in Optimize.c. + * + * General object operations and protocols are in ObjectHandling.c. + */ + +//////////////////// Globals.proto //////////////////// + +static PyObject* __Pyx_Globals(void); /*proto*/ + +//////////////////// Globals //////////////////// +//@requires: ObjectHandling.c::GetAttr + +// This is a stub implementation until we have something more complete. +// Currently, we only handle the most common case of a read-only dict +// of Python names. Supporting cdef names in the module and write +// access requires a rewrite as a dedicated class. + +static PyObject* __Pyx_Globals(void) { + return __Pyx_NewRef(NAMED_CGLOBAL(moddict_cname)); +} + +//////////////////// PyExecGlobals.proto //////////////////// + +static PyObject* __Pyx_PyExecGlobals(PyObject*); + +//////////////////// PyExecGlobals //////////////////// +//@requires: PyExec + +static PyObject* __Pyx_PyExecGlobals(PyObject* code) { + return __Pyx_PyExec2(code, NAMED_CGLOBAL(moddict_cname)); +} + +//////////////////// PyExec.proto //////////////////// + +static PyObject* __Pyx_PyExec3(PyObject*, PyObject*, PyObject*); +static CYTHON_INLINE PyObject* __Pyx_PyExec2(PyObject*, PyObject*); + +//////////////////// PyExec //////////////////// + +static CYTHON_INLINE PyObject* __Pyx_PyExec2(PyObject* o, PyObject* globals) { + return __Pyx_PyExec3(o, globals, NULL); +} + +static PyObject* __Pyx_PyExec3(PyObject* o, PyObject* globals, PyObject* locals) { + PyObject* result; +#if !CYTHON_COMPILING_IN_LIMITED_API + PyObject* s = 0; + char *code = 0; +#endif + + if (!globals || globals == Py_None) { + globals = NAMED_CGLOBAL(moddict_cname); + } +#if !CYTHON_COMPILING_IN_LIMITED_API + // In Limited API we just use exec builtin which already has this + else if (unlikely(!PyDict_Check(globals))) { + __Pyx_TypeName globals_type_name = + __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(globals)); + PyErr_Format(PyExc_TypeError, + "exec() arg 2 must be a dict, not " __Pyx_FMT_TYPENAME, + globals_type_name); + __Pyx_DECREF_TypeName(globals_type_name); + goto bad; + } +#endif + if (!locals || locals == Py_None) { + locals = globals; + } + +#if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_PyDict_GetItemStr(globals, PYIDENT("__builtins__")) == NULL) { + if (unlikely(PyDict_SetItem(globals, PYIDENT("__builtins__"), PyEval_GetBuiltins()) < 0)) + goto bad; + } + + if (PyCode_Check(o)) { + if (unlikely(__Pyx_PyCode_HasFreeVars((PyCodeObject *)o))) { + PyErr_SetString(PyExc_TypeError, + "code object passed to exec() may not contain free variables"); + goto bad; + } + #if CYTHON_COMPILING_IN_PYPY && PYPY_VERSION_NUM < 0x07030400 + result = PyEval_EvalCode((PyCodeObject *)o, globals, locals); + #else + result = PyEval_EvalCode(o, globals, locals); + #endif + } else { + PyCompilerFlags cf; + cf.cf_flags = 0; +#if PY_VERSION_HEX >= 0x030800A3 + cf.cf_feature_version = PY_MINOR_VERSION; +#endif + if (PyUnicode_Check(o)) { + cf.cf_flags = PyCF_SOURCE_IS_UTF8; + s = PyUnicode_AsUTF8String(o); + if (unlikely(!s)) goto bad; + o = s; + } else if (unlikely(!PyBytes_Check(o))) { + __Pyx_TypeName o_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(o)); + PyErr_Format(PyExc_TypeError, + "exec: arg 1 must be string, bytes or code object, got " __Pyx_FMT_TYPENAME, + o_type_name); + __Pyx_DECREF_TypeName(o_type_name); + goto bad; + } + code = PyBytes_AS_STRING(o); + if (PyEval_MergeCompilerFlags(&cf)) { + result = PyRun_StringFlags(code, Py_file_input, globals, locals, &cf); + } else { + result = PyRun_String(code, Py_file_input, globals, locals); + } + Py_XDECREF(s); + } + + return result; +bad: + Py_XDECREF(s); + return 0; +#else // CYTHON_COMPILING_IN_LIMITED_API + { + // For the limited API we just defer to the actual builtin + // (after setting up globals and locals) - there's too much we can't do otherwise + PyObject *builtins, *exec, *exec_str; + builtins = PyEval_GetBuiltins(); + if (!builtins) return NULL; + exec_str = PyUnicode_FromStringAndSize("exec", 4); + if (!exec_str) return NULL; + exec = PyObject_GetItem(builtins, exec_str); + Py_DECREF(exec_str); + if (!exec) return NULL; + result = PyObject_CallFunctionObjArgs(exec, o, globals, locals, NULL); + Py_DECREF(exec); + return result; + } +#endif +} + +//////////////////// GetAttr3.proto //////////////////// + +static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *, PyObject *, PyObject *); /*proto*/ + +//////////////////// GetAttr3 //////////////////// +//@requires: ObjectHandling.c::PyObjectGetAttrStr +//@requires: Exceptions.c::PyThreadStateGet +//@requires: Exceptions.c::PyErrFetchRestore +//@requires: Exceptions.c::PyErrExceptionMatches + +#if __PYX_LIMITED_VERSION_HEX < 0x030d0000 +static PyObject *__Pyx_GetAttr3Default(PyObject *d) { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + if (unlikely(!__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError))) + return NULL; + __Pyx_PyErr_Clear(); + Py_INCREF(d); + return d; +} +#endif + +static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *o, PyObject *n, PyObject *d) { + PyObject *r; +#if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 + int res = PyObject_GetOptionalAttr(o, n, &r); + // On failure (res == -1), r is set to NULL. + return (res != 0) ? r : __Pyx_NewRef(d); +#else + #if CYTHON_USE_TYPE_SLOTS + if (likely(PyUnicode_Check(n))) { + r = __Pyx_PyObject_GetAttrStrNoError(o, n); + if (unlikely(!r) && likely(!PyErr_Occurred())) { + r = __Pyx_NewRef(d); + } + return r; + } + #endif + r = PyObject_GetAttr(o, n); + return (likely(r)) ? r : __Pyx_GetAttr3Default(d); +#endif +} + +//////////////////// HasAttr.proto //////////////////// + +#if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 +#define __Pyx_HasAttr(o, n) PyObject_HasAttrWithError(o, n) +#else +static CYTHON_INLINE int __Pyx_HasAttr(PyObject *, PyObject *); /*proto*/ +#endif + +//////////////////// HasAttr //////////////////// +//@requires: ObjectHandling.c::PyObjectGetAttrStrNoError + +#if __PYX_LIMITED_VERSION_HEX < 0x030d0000 +static CYTHON_INLINE int __Pyx_HasAttr(PyObject *o, PyObject *n) { + PyObject *r; + if (unlikely(!PyUnicode_Check(n))) { + PyErr_SetString(PyExc_TypeError, + "hasattr(): attribute name must be string"); + return -1; + } + r = __Pyx_PyObject_GetAttrStrNoError(o, n); + if (!r) { + return (unlikely(PyErr_Occurred())) ? -1 : 0; + } else { + Py_DECREF(r); + return 1; + } +} +#endif + +//////////////////// Intern.proto //////////////////// + +static PyObject* __Pyx_Intern(PyObject* s); /* proto */ + +//////////////////// Intern //////////////////// +//@requires: ObjectHandling.c::RaiseUnexpectedTypeError + +static PyObject* __Pyx_Intern(PyObject* s) { + if (unlikely(!PyUnicode_CheckExact(s))) { + __Pyx_RaiseUnexpectedTypeError("str", s); + return NULL; + } + Py_INCREF(s); + PyUnicode_InternInPlace(&s); + return s; +} + +//////////////////// abs_longlong.proto //////////////////// + +static CYTHON_INLINE PY_LONG_LONG __Pyx_abs_longlong(PY_LONG_LONG x) { +#if defined (__cplusplus) && __cplusplus >= 201103L + return std::abs(x); +#elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + return llabs(x); +#elif defined (_MSC_VER) + // abs() is defined for long, but 64-bits type on MSVC is long long. + // Use MS-specific _abs64() instead, which returns the original (negative) value for abs(-MAX-1) + return _abs64(x); +#elif defined (__GNUC__) + // gcc or clang on 64 bit windows. + return __builtin_llabs(x); +#else + if (sizeof(PY_LONG_LONG) <= sizeof(Py_ssize_t)) + return __Pyx_sst_abs(x); + return (x<0) ? -x : x; +#endif +} + + +//////////////////// py_abs.proto //////////////////// + +#if CYTHON_USE_PYLONG_INTERNALS +static PyObject *__Pyx_PyLong_AbsNeg(PyObject *num);/*proto*/ + +#define __Pyx_PyNumber_Absolute(x) \ + ((likely(PyLong_CheckExact(x))) ? \ + (likely(__Pyx_PyLong_IsNonNeg(x)) ? __Pyx_NewRef(x) : __Pyx_PyLong_AbsNeg(x)) : \ + PyNumber_Absolute(x)) + +#else +#define __Pyx_PyNumber_Absolute(x) PyNumber_Absolute(x) +#endif + +//////////////////// py_abs //////////////////// + +#if CYTHON_USE_PYLONG_INTERNALS +static PyObject *__Pyx_PyLong_AbsNeg(PyObject *n) { +#if PY_VERSION_HEX >= 0x030C00A7 + if (likely(__Pyx_PyLong_IsCompact(n))) { + return PyLong_FromSize_t(__Pyx_PyLong_CompactValueUnsigned(n)); + } +#else + if (likely(Py_SIZE(n) == -1)) { + // digits are unsigned + return PyLong_FromUnsignedLong(__Pyx_PyLong_Digits(n)[0]); + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + { + PyObject *copy = _PyLong_Copy((PyLongObject*)n); + if (likely(copy)) { + #if PY_VERSION_HEX >= 0x030C00A7 + // clear the sign bits to set the sign from SIGN_NEGATIVE (2) to positive (0) + ((PyLongObject*)copy)->long_value.lv_tag ^= ((PyLongObject*)copy)->long_value.lv_tag & _PyLong_SIGN_MASK; + #else + // negate the size to swap the sign + __Pyx_SET_SIZE(copy, -Py_SIZE(copy)); + #endif + } + return copy; + } +#else + return PyNumber_Negative(n); +#endif +} +#endif + + +//////////////////// pow2.proto //////////////////// + +#define __Pyx_PyNumber_Power2(a, b) PyNumber_Power(a, b, Py_None) + + +//////////////////// divmod_int.proto ////////////////// + +const {{RETURN_TYPE}} __Pyx_divmod_ERROR_VALUE_{{CFUNC_SUFFIX}} = {-1, -1}; + +static CYTHON_INLINE {{RETURN_TYPE}} __Pyx_divmod_{{CFUNC_SUFFIX}}({{TYPE}} a, {{TYPE}} b); /*proto*/ + + +//////////////////// divmod_int ////////////////// + +static CYTHON_INLINE {{RETURN_TYPE}} __Pyx_divmod_{{CFUNC_SUFFIX}}({{TYPE}} a, {{TYPE}} b) { + // Python and C/C++ use different algorithms in calculating quotients and remainders. + // This results in different answers between Python and C/C++ + // when the dividend is negative and the divisor is positive and vice versa. + {{TYPE}} q, r; + if (unlikely(b == 0)) { + {{if NOGIL}}PyGILState_STATE gilstate = PyGILState_Ensure();{{endif}} + PyErr_SetString(PyExc_ZeroDivisionError, "division by zero"); + {{if NOGIL}}PyGILState_Release(gilstate);{{endif}} + return __Pyx_divmod_ERROR_VALUE_{{CFUNC_SUFFIX}}; + } else if (a == 0) { + q = 0; + r = 0; + } else if ((a < 0) != (b < 0)) { + // see CMath.c :: DivInt and ModInt utility code + q = a / b; + r = a - q * b; + {{TYPE}} adapt_python = ((r != 0) & ((r < 0) ^ (b < 0))); + q -= adapt_python; + r += adapt_python * b; + } + else { + q = a / b; + r = a % b; + } + + {{RETURN_TYPE}} c_result = {q, r}; + return c_result; +} + + +//////////////////// divmod_float.proto ////////////////// + +const {{RETURN_TYPE}} __Pyx_divmod_ERROR_VALUE_{{CFUNC_SUFFIX}} = {-1.0, -1.0}; + +static CYTHON_INLINE {{RETURN_TYPE}} __Pyx_divmod_{{CFUNC_SUFFIX}}({{TYPE}} a, {{TYPE}} b); /*proto*/ + + +//////////////////// divmod_float ////////////////// + +static CYTHON_INLINE {{RETURN_TYPE}} __Pyx_divmod_{{CFUNC_SUFFIX}}({{TYPE}} a, {{TYPE}} b) { + // Python and C/C++ use different algorithms in calculating quotients and remainders. + // This results in different answers between Python and C/C++ + // when the dividend is negative and the divisor is positive and vice versa. + + // Adapted from CPython 3.14: floatobject.c / _float_div_mod() + + {{TYPE}} q, r, div; + + if (unlikely(b == 0.0)) { + {{if NOGIL}}PyGILState_STATE gilstate = PyGILState_Ensure();{{endif}} + PyErr_SetString(PyExc_ZeroDivisionError, "division by zero"); + {{if NOGIL}}PyGILState_Release(gilstate);{{endif}} + return __Pyx_divmod_ERROR_VALUE_{{CFUNC_SUFFIX}}; + } + + r = fmod{{MATH_SUFFIX}}(a, b); + // fmod is typically exact, so a-mod is *mathematically* an + // exact multiple of b. But this is fp arithmetic, and fp + // a - mod is an approximation; the result is that div may + // not be an exact integral value after the division, although + // it will always be very close to one. + div = (a - r) / b; + if (r) { + // ensure the remainder has the same sign as the denominator + if ((b < 0) != (r < 0)) { + r += b; + div -= 1.0; + } + } + else { + // the remainder is zero, and in the presence of signed zeroes + // fmod returns different results across platforms; ensure + // it has the same sign as the denominator. + r = copysign{{MATH_SUFFIX}}(0.0, b); + } + // snap quotient to nearest integral value + if (div) { + q = floor{{MATH_SUFFIX}}(div); + if (div - q > 0.5) { + q += 1.0; + } + } + else { + // div is zero - get the same sign as the true quotient + q = copysign{{MATH_SUFFIX}}(0.0, a / b); /* zero w/ sign of a/b */ + } + + {{RETURN_TYPE}} c_result = {q, r}; + return c_result; +} + + +//////////////////// int_pyucs4.proto //////////////////// + +static CYTHON_INLINE int __Pyx_int_from_UCS4(Py_UCS4 uchar); + +//////////////////// int_pyucs4 //////////////////// + +static int __Pyx_int_from_UCS4(Py_UCS4 uchar) { + // Fast path for ascii digits + if (likely(uchar >= (Py_UCS4)'0' && uchar <= (Py_UCS4)'9')) { + return uchar - (Py_UCS4)'0'; + } +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *u = PyUnicode_FromOrdinal(uchar); + if (unlikely(!u)) return -1; + PyObject *l = PyObject_CallFunctionObjArgs((PyObject*)(&PyLong_Type), u, NULL); + Py_DECREF(u); + if (unlikely(!l)) return -1; +#if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 + int result = PyLong_AsInt(l); +#else + // just don't handle overflow - it's very difficult to see how we'll get it from + // a single digit. + int result = (int)PyLong_AsLong(l); +#endif + Py_DECREF(l); + return result; +#else + int digit = Py_UNICODE_TODECIMAL(uchar); + if (unlikely(digit < 0)) { + PyErr_Format(PyExc_ValueError, + "invalid literal for int() with base 10: '%c'", + (int) uchar); + return -1; + } + return digit; +#endif +} + + +//////////////////// float_pyucs4.proto //////////////////// + +static CYTHON_INLINE double __Pyx_double_from_UCS4(Py_UCS4 uchar); + +//////////////////// float_pyucs4 //////////////////// + +static double __Pyx_double_from_UCS4(Py_UCS4 uchar) { + // fast path for "just an ascii digit" + if (likely(uchar >= (Py_UCS4)'0' && uchar <= (Py_UCS4)'9')) { + return uchar - (Py_UCS4)'0'; + } +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *u = PyUnicode_FromOrdinal(uchar); + if (unlikely(!u)) return -1.0; + PyObject *f = PyFloat_FromString(u); + Py_DECREF(u); + if (unlikely(!f)) return -1.0; + double result = PyFloat_AsDouble(f); + Py_DECREF(f); + return result; +#else + // ...TONUMERIC would initially seem to be a better fit. + // However, that accepts things like the "half" symbol, while + // float(string) rejects those. + double digit = Py_UNICODE_TODECIMAL(uchar); + if (unlikely(digit < 0.0)) { + PyErr_Format(PyExc_ValueError, + "could not convert string to float: '%c'", + (int) uchar); + return -1.0; + } + return digit; +#endif +} + + +//////////////////// object_ord.proto //////////////////// +//@requires: TypeConversion.c::UnicodeAsUCS4 + +#define __Pyx_PyObject_Ord(c) \ + (likely(PyUnicode_Check(c)) ? (long)__Pyx_PyUnicode_AsPy_UCS4(c) : __Pyx__PyObject_Ord(c)) +static long __Pyx__PyObject_Ord(PyObject* c); /*proto*/ + +//////////////////// object_ord //////////////////// + +static long __Pyx__PyObject_Ord(PyObject* c) { + Py_ssize_t size; + if (PyBytes_Check(c)) { + size = __Pyx_PyBytes_GET_SIZE(c); + if (likely(size == 1)) { +#if CYTHON_ASSUME_SAFE_MACROS + return (unsigned char) PyBytes_AS_STRING(c)[0]; +#else + char *data = PyBytes_AsString(c); + if (unlikely(!data)) return -1; + return (unsigned char) data[0]; +#endif + } +#if !CYTHON_ASSUME_SAFE_SIZE + else if (unlikely(size < 0)) return -1; +#endif + } else if (PyByteArray_Check(c)) { + size = __Pyx_PyByteArray_GET_SIZE(c); + if (likely(size == 1)) { +#if CYTHON_ASSUME_SAFE_MACROS + return (unsigned char) PyByteArray_AS_STRING(c)[0]; +#else + char *data = PyByteArray_AsString(c); + if (unlikely(!data)) return -1; + return (unsigned char) data[0]; +#endif + } +#if !CYTHON_ASSUME_SAFE_SIZE + else if (unlikely(size < 0)) return -1; +#endif + } else { + // FIXME: support character buffers - but CPython doesn't support them either + __Pyx_TypeName c_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(c)); + PyErr_Format(PyExc_TypeError, + "ord() expected string of length 1, but " __Pyx_FMT_TYPENAME " found", + c_type_name); + __Pyx_DECREF_TypeName(c_type_name); + return (long)(Py_UCS4)-1; + } + PyErr_Format(PyExc_TypeError, + "ord() expected a character, but string of length %zd found", size); + return (long)(Py_UCS4)-1; +} + + +//////////////////// py_dict_keys.proto //////////////////// + +static CYTHON_INLINE PyObject* __Pyx_PyDict_Keys(PyObject* d); /*proto*/ + +//////////////////// py_dict_keys //////////////////// + +static CYTHON_INLINE PyObject* __Pyx_PyDict_Keys(PyObject* d) { + return CALL_UNBOUND_METHOD(PyDict_Type, "keys", d); +} + +//////////////////// py_dict_values.proto //////////////////// + +static CYTHON_INLINE PyObject* __Pyx_PyDict_Values(PyObject* d); /*proto*/ + +//////////////////// py_dict_values //////////////////// + +static CYTHON_INLINE PyObject* __Pyx_PyDict_Values(PyObject* d) { + return CALL_UNBOUND_METHOD(PyDict_Type, "values", d); +} + +//////////////////// py_dict_items.proto //////////////////// + +static CYTHON_INLINE PyObject* __Pyx_PyDict_Items(PyObject* d); /*proto*/ + +//////////////////// py_dict_items //////////////////// + +static CYTHON_INLINE PyObject* __Pyx_PyDict_Items(PyObject* d) { + return CALL_UNBOUND_METHOD(PyDict_Type, "items", d); +} + +//////////////////// py_dict_iterkeys.proto //////////////////// + +static CYTHON_INLINE PyObject* __Pyx_PyDict_IterKeys(PyObject* d); /*proto*/ + +//////////////////// py_dict_iterkeys //////////////////// + +static CYTHON_INLINE PyObject* __Pyx_PyDict_IterKeys(PyObject* d) { + return CALL_UNBOUND_METHOD(PyDict_Type, "keys", d); +} + +//////////////////// py_dict_itervalues.proto //////////////////// + +static CYTHON_INLINE PyObject* __Pyx_PyDict_IterValues(PyObject* d); /*proto*/ + +//////////////////// py_dict_itervalues //////////////////// + +static CYTHON_INLINE PyObject* __Pyx_PyDict_IterValues(PyObject* d) { + return CALL_UNBOUND_METHOD(PyDict_Type, "values", d); +} + +//////////////////// py_dict_iteritems.proto //////////////////// + +static CYTHON_INLINE PyObject* __Pyx_PyDict_IterItems(PyObject* d); /*proto*/ + +//////////////////// py_dict_iteritems //////////////////// + +static CYTHON_INLINE PyObject* __Pyx_PyDict_IterItems(PyObject* d) { + return CALL_UNBOUND_METHOD(PyDict_Type, "items", d); +} + +//////////////////// py_dict_viewkeys.proto //////////////////// + +static CYTHON_INLINE PyObject* __Pyx_PyDict_ViewKeys(PyObject* d); /*proto*/ + +//////////////////// py_dict_viewkeys //////////////////// + +static CYTHON_INLINE PyObject* __Pyx_PyDict_ViewKeys(PyObject* d) { + return CALL_UNBOUND_METHOD(PyDict_Type, "keys", d); +} + +//////////////////// py_dict_viewvalues.proto //////////////////// + +static CYTHON_INLINE PyObject* __Pyx_PyDict_ViewValues(PyObject* d); /*proto*/ + +//////////////////// py_dict_viewvalues //////////////////// + +static CYTHON_INLINE PyObject* __Pyx_PyDict_ViewValues(PyObject* d) { + return CALL_UNBOUND_METHOD(PyDict_Type, "values", d); +} + +//////////////////// py_dict_viewitems.proto //////////////////// + +static CYTHON_INLINE PyObject* __Pyx_PyDict_ViewItems(PyObject* d); /*proto*/ + +//////////////////// py_dict_viewitems //////////////////// + +static CYTHON_INLINE PyObject* __Pyx_PyDict_ViewItems(PyObject* d) { + return CALL_UNBOUND_METHOD(PyDict_Type, "items", d); +} + + +//////////////////// pyfrozenset_new.proto //////////////////// + +static CYTHON_INLINE PyObject* __Pyx_PyFrozenSet_New(PyObject* it); + +//////////////////// pyfrozenset_new //////////////////// +//@requires: ObjectHandling.c::PyObjectCallNoArg + +static CYTHON_INLINE PyObject* __Pyx_PyFrozenSet_New(PyObject* it) { + if (it) { + PyObject* result; +#if CYTHON_COMPILING_IN_PYPY + // PyPy currently lacks PyFrozenSet_CheckExact() and PyFrozenSet_New() + PyObject* args; + args = PyTuple_Pack(1, it); + if (unlikely(!args)) + return NULL; + result = PyObject_Call((PyObject*)&PyFrozenSet_Type, args, NULL); + Py_DECREF(args); + return result; +#else + if (PyFrozenSet_CheckExact(it)) { + Py_INCREF(it); + return it; + } + result = PyFrozenSet_New(it); + if (unlikely(!result)) + return NULL; + if ((__PYX_LIMITED_VERSION_HEX >= 0x030A0000) +#if CYTHON_COMPILING_IN_LIMITED_API + || __Pyx_get_runtime_version() >= 0x030A0000 +#endif + ) + return result; + { + Py_ssize_t size = __Pyx_PySet_GET_SIZE(result); + if (likely(size > 0)) + return result; +#if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(size < 0)) { + Py_DECREF(result); + return NULL; + } +#endif + } + // empty frozenset is a singleton (on Python <3.10) + // seems wasteful, but CPython does the same + Py_DECREF(result); +#endif + } + return __Pyx_PyObject_CallNoArg((PyObject*) &PyFrozenSet_Type); +} + + +//////////////////// PySet_Update.proto //////////////////// + +static CYTHON_INLINE int __Pyx_PySet_Update(PyObject* set, PyObject* it); /*proto*/ + +//////////////////// PySet_Update //////////////////// + +static CYTHON_INLINE int __Pyx_PySet_Update(PyObject* set, PyObject* it) { + PyObject *retval; + #if CYTHON_USE_TYPE_SLOTS && !CYTHON_COMPILING_IN_PYPY + if (PyAnySet_Check(it)) { + Py_ssize_t size = __Pyx_PySet_GET_SIZE(it); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(size < 0)) return -1; + #endif + if (size == 0) + return 0; + // fast and safe case: CPython will update our result set and return it + retval = PySet_Type.tp_as_number->nb_inplace_or(set, it); + if (likely(retval == set)) { + Py_DECREF(retval); + return 0; + } + if (unlikely(!retval)) + return -1; + // unusual result, fall through to set.update() call below + Py_DECREF(retval); + } + #endif + retval = CALL_UNBOUND_METHOD(PySet_Type, "update", set, it); + if (unlikely(!retval)) return -1; + Py_DECREF(retval); + return 0; +} + +///////////////// memoryview_get_from_buffer.proto //////////////////// + +#if !CYTHON_COMPILING_IN_LIMITED_API +#define __Pyx_PyMemoryView_Get_{{name}}(o) PyMemoryView_GET_BUFFER(o)->{{name}} +#else +{{py: +out_types = dict( + ndim='int', readonly='int', + len='Py_ssize_t', itemsize='Py_ssize_t') +}} // can't get format like this unfortunately. It's unicode via getattr +{{py: out_type = out_types[name]}} +static {{out_type}} __Pyx_PyMemoryView_Get_{{name}}(PyObject *obj); /* proto */ +#endif + +////////////// memoryview_get_from_buffer ///////////////////////// + +#if !CYTHON_COMPILING_IN_LIMITED_API +#else +{{py: +out_types = dict( + ndim='int', readonly='int', + len='Py_ssize_t', itemsize='Py_ssize_t') +}} +{{py: out_type = out_types[name]}} +static {{out_type}} __Pyx_PyMemoryView_Get_{{name}}(PyObject *obj) { + {{out_type}} result; + PyObject *attr = PyObject_GetAttr(obj, PYIDENT("{{name}}")); + if (!attr) { + goto bad; + } +{{if out_type == 'int'}} + // I'm not worrying about overflow here because + // ultimately it comes from a C struct that's an int + result = PyLong_AsLong(attr); +{{elif out_type == 'Py_ssize_t'}} + result = PyLong_AsSsize_t(attr); +{{endif}} + Py_DECREF(attr); + return result; + + bad: + Py_XDECREF(attr); + return -1; +} +#endif + +////////////// PySliceAccessors.proto ///////////////////////// + +#if CYTHON_COMPILING_IN_LIMITED_API +#define __Pyx_PySlice_Start(o) PyObject_GetAttr(o, PYIDENT("start")) +#define __Pyx_PySlice_Stop(o) PyObject_GetAttr(o, PYIDENT("stop")) +#define __Pyx_PySlice_Step(o) PyObject_GetAttr(o, PYIDENT("step")) +#elif CYTHON_COMPILING_IN_GRAAL +// Graal defines it's own accessor functions +#define __Pyx_PySlice_Start(o) __Pyx_NewRef(PySlice_Start((PySliceObject*)o)) +#define __Pyx_PySlice_Stop(o) __Pyx_NewRef(PySlice_Stop((PySliceObject*)o)) +#define __Pyx_PySlice_Step(o) __Pyx_NewRef(PySlice_Step((PySliceObject*)o)) +#else +#define __Pyx_PySlice_Start(o) __Pyx_NewRef(((PySliceObject*)o)->start) +#define __Pyx_PySlice_Stop(o) __Pyx_NewRef(((PySliceObject*)o)->stop) +#define __Pyx_PySlice_Step(o) __Pyx_NewRef(((PySliceObject*)o)->step) +#endif diff --git a/venv/lib/python3.10/site-packages/Cython/Utility/CConvert.pyx b/venv/lib/python3.10/site-packages/Cython/Utility/CConvert.pyx new file mode 100644 index 0000000000000000000000000000000000000000..3afcb1aadfeeb99bef33428ed7f06d58342dfc86 --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Utility/CConvert.pyx @@ -0,0 +1,134 @@ +#################### FromPyStructUtility #################### + +cdef extern from *: + ctypedef struct PyTypeObject: + char* tp_name + PyTypeObject *Py_TYPE(obj) + bint PyMapping_Check(obj) + object PyErr_Format(exc, const char *format, ...) + int __Pyx_RaiseUnexpectedTypeError(const char *expected, object obj) except 0 + +@cname("{{funcname}}") +cdef {{struct_type}} {{funcname}}(obj) except *: + cdef {{struct_type}} result + if not PyMapping_Check(obj): + __Pyx_RaiseUnexpectedTypeError(b"a mapping", obj) + + {{for member in var_entries:}} + try: + value = obj['{{member.name}}'] + except KeyError: + raise ValueError("No value specified for struct attribute '{{member.name}}'") + result.{{member.name}} = value + {{endfor}} + return result + + +#################### FromPyUnionUtility #################### + +cdef extern from *: + ctypedef struct PyTypeObject: + char* tp_name + PyTypeObject *Py_TYPE(obj) + bint PyMapping_Check(obj) + object PyErr_Format(exc, const char *format, ...) + int __Pyx_RaiseUnexpectedTypeError(const char *expected, object obj) except 0 + +@cname("{{funcname}}") +cdef {{struct_type}} {{funcname}}(obj) except *: + cdef {{struct_type}} result + cdef Py_ssize_t length + if not PyMapping_Check(obj): + __Pyx_RaiseUnexpectedTypeError(b"a mapping", obj) + + last_found = None + length = len(obj) + if length: + {{for member in var_entries:}} + if '{{member.name}}' in obj: + if last_found is not None: + raise ValueError("More than one union attribute passed: '%s' and '%s'" % (last_found, '{{member.name}}')) + last_found = '{{member.name}}' + result.{{member.cname}} = obj['{{member.name}}'] + length -= 1 + if not length: + return result + {{endfor}} + if last_found is None: + raise ValueError("No value specified for any of the union attributes (%s)" % + '{{", ".join(member.name for member in var_entries)}}') + return result + + +#################### cfunc.to_py #################### + +@cname("{{cname}}") +cdef object {{cname}}({{return_type.ctype}} (*f)({{ ', '.join(arg.type_cname for arg in args) }}) {{except_clause}}): + def wrap({{ ', '.join('{arg.ctype} {arg.name}'.format(arg=arg) for arg in args) }}): + """wrap({{', '.join(('{arg.name}: {arg.type_displayname}'.format(arg=arg) if arg.type_displayname else arg.name) for arg in args)}}){{if return_type.type_displayname}} -> {{return_type.type_displayname}}{{endif}}""" + {{'' if return_type.type.is_void else 'return '}}f({{ ', '.join(arg.name for arg in args) }}) + return wrap + + +#################### carray.from_py #################### + +cdef extern from *: + object PyErr_Format(exc, const char *format, ...) + +@cname("{{cname}}") +cdef int {{cname}}(object o, {{base_type}} *v, Py_ssize_t length) except -1: + cdef Py_ssize_t i = length + try: + i = len(o) + except (TypeError, OverflowError): + pass + if i == length: + for i, item in enumerate(o): + if i >= length: + break + v[i] = item + else: + i += 1 # convert index to length + if i == length: + return 0 + + PyErr_Format( + IndexError, + ("too many values found during array assignment, expected %zd" + if i >= length else + "not enough values found during array assignment, expected %zd, got %zd"), + length, i) + + +#################### carray.to_py #################### + +cdef extern from *: + void Py_INCREF(object o) + tuple PyTuple_New(Py_ssize_t size) + list PyList_New(Py_ssize_t size) + int __Pyx_PyTuple_SET_ITEM(object p, Py_ssize_t pos, object o) except -1 + int __Pyx_PyList_SET_ITEM(object p, Py_ssize_t pos, object o) except -1 + + +@cname("{{cname}}") +cdef inline list {{cname}}({{base_type}} *v, Py_ssize_t length): + cdef Py_ssize_t i + cdef object value + l = PyList_New(length) + for i in range(length): + value = v[ i] + Py_INCREF(value) + __Pyx_PyList_SET_ITEM(l, i, value) + return l + + +@cname("{{to_tuple_cname}}") +cdef inline tuple {{to_tuple_cname}}({{base_type}} *v, Py_ssize_t length): + cdef Py_ssize_t i + cdef object value + t = PyTuple_New(length) + for i in range(length): + value = v[ i] + Py_INCREF(value) + __Pyx_PyTuple_SET_ITEM(t, i, value) + return t diff --git a/venv/lib/python3.10/site-packages/Cython/Utility/CMath.c b/venv/lib/python3.10/site-packages/Cython/Utility/CMath.c new file mode 100644 index 0000000000000000000000000000000000000000..785c40644dd03dd57a59a3dcd99a55ea187b114f --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Utility/CMath.c @@ -0,0 +1,104 @@ + +/////////////// CDivisionWarning.proto /////////////// + +static int __Pyx_cdivision_warning(const char *, int); /* proto */ + +/////////////// CDivisionWarning /////////////// + +static int __Pyx_cdivision_warning(const char *filename, int lineno) { +#if CYTHON_COMPILING_IN_PYPY + // avoid compiler warnings + filename++; lineno++; + return PyErr_Warn(PyExc_RuntimeWarning, + "division with oppositely signed operands, C and Python semantics differ"); +#else + return PyErr_WarnExplicit(PyExc_RuntimeWarning, + "division with oppositely signed operands, C and Python semantics differ", + filename, + lineno, + __Pyx_MODULE_NAME, + NULL); +#endif +} + + +/////////////// DivInt.proto /////////////// + +static CYTHON_INLINE %(type)s __Pyx_div_%(type_name)s(%(type)s, %(type)s, int b_is_constant); /* proto */ + +/////////////// DivInt /////////////// + +static CYTHON_INLINE %(type)s __Pyx_div_%(type_name)s(%(type)s a, %(type)s b, int b_is_constant) { + %(type)s q = a / b; + %(type)s r = a - q*b; + %(type)s adapt_python = (b_is_constant ? + // Take advantage of constant folding for 'b'. + ((r != 0) & ((r < 0) ^ (b < 0))) : + ((r != 0) & ((r ^ b) < 0)) + ); + return q - adapt_python; +} + + +/////////////// ModInt.proto /////////////// + +static CYTHON_INLINE %(type)s __Pyx_mod_%(type_name)s(%(type)s, %(type)s, int b_is_constant); /* proto */ + +/////////////// ModInt /////////////// + +static CYTHON_INLINE %(type)s __Pyx_mod_%(type_name)s(%(type)s a, %(type)s b, int b_is_constant) { + %(type)s r = a %% b; + %(type)s adapt_python = (b_is_constant ? + // Take advantage of constant folding for 'b'. + ((r != 0) & ((r < 0) ^ (b < 0))) : + ((r != 0) & ((r ^ b) < 0)) + ); + return r + adapt_python * b; +} + + +/////////////// ModFloat.proto /////////////// + +static CYTHON_INLINE %(type)s __Pyx_mod_%(type_name)s(%(type)s, %(type)s, int b_is_constant); /* proto */ + +/////////////// ModFloat /////////////// + +static CYTHON_INLINE %(type)s __Pyx_mod_%(type_name)s(%(type)s a, %(type)s b, int b_is_constant) { + CYTHON_UNUSED_VAR(b_is_constant); + %(type)s r = fmod%(math_h_modifier)s(a, b); + r += ((r != 0) & ((r < 0) ^ (b < 0))) * b; + return r; +} + + +/////////////// IntPow.proto /////////////// + +static CYTHON_INLINE %(type)s %(func_name)s(%(type)s, %(type)s); /* proto */ + +/////////////// IntPow /////////////// + +static CYTHON_INLINE %(type)s %(func_name)s(%(type)s b, %(type)s e) { + %(type)s t = b; + switch (e) { + case 3: + t *= b; + CYTHON_FALLTHROUGH; + case 2: + t *= b; + CYTHON_FALLTHROUGH; + case 1: + return t; + case 0: + return 1; + } + #if %(signed)s + if (unlikely(e<0)) return 0; + #endif + t = 1; + while (likely(e)) { + t *= (b * (e&1)) | ((~e)&1); /* 1 or b */ + b *= b; + e >>= 1; + } + return t; +} diff --git a/venv/lib/python3.10/site-packages/Cython/Utility/CommonStructures.c b/venv/lib/python3.10/site-packages/Cython/Utility/CommonStructures.c new file mode 100644 index 0000000000000000000000000000000000000000..794b66a635c819fa2360445c3ad8ca88db9c5d09 --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Utility/CommonStructures.c @@ -0,0 +1,202 @@ +/////////////// FetchSharedCythonModule.proto /////// + +static PyObject *__Pyx_FetchSharedCythonABIModule(void); + +/////////////// FetchSharedCythonModule //////////// + +static PyObject *__Pyx_FetchSharedCythonABIModule(void) { + return __Pyx_PyImport_AddModuleRef(__PYX_ABI_MODULE_NAME); +} + +/////////////// FetchCommonType.proto /////////////// + +static PyTypeObject* __Pyx_FetchCommonTypeFromSpec(PyTypeObject *metaclass, PyObject *module, PyType_Spec *spec, PyObject *bases); + +/////////////// FetchCommonType /////////////// +//@requires:ExtensionTypes.c::FixUpExtensionType +//@requires: FetchSharedCythonModule +//@requires:StringTools.c::IncludeStringH +//@requires:Optimize.c::dict_setdefault + +#if __PYX_LIMITED_VERSION_HEX < 0x030C0000 +static PyObject* __Pyx_PyType_FromMetaclass(PyTypeObject *metaclass, PyObject *module, PyType_Spec *spec, PyObject *bases) { + PyObject *result = __Pyx_PyType_FromModuleAndSpec(module, spec, bases); + if (result && metaclass) { + PyObject *old_tp = (PyObject*)Py_TYPE(result); + Py_INCREF((PyObject*)metaclass); +#if __PYX_LIMITED_VERSION_HEX >= 0x03090000 + Py_SET_TYPE(result, metaclass); +#else + result->ob_type = metaclass; +#endif + Py_DECREF(old_tp); + } + return result; +} +#else +#define __Pyx_PyType_FromMetaclass(me, mo, s, b) PyType_FromMetaclass(me, mo, s, b) +#endif + +static int __Pyx_VerifyCachedType(PyObject *cached_type, + const char *name, + Py_ssize_t expected_basicsize) { + Py_ssize_t basicsize; + + if (!PyType_Check(cached_type)) { + PyErr_Format(PyExc_TypeError, + "Shared Cython type %.200s is not a type object", name); + return -1; + } + + if (expected_basicsize == 0) { + return 0; // size is inherited, nothing useful to check + } + +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *py_basicsize; + py_basicsize = PyObject_GetAttrString(cached_type, "__basicsize__"); + if (unlikely(!py_basicsize)) return -1; + basicsize = PyLong_AsSsize_t(py_basicsize); + Py_DECREF(py_basicsize); + py_basicsize = NULL; + if (unlikely(basicsize == (Py_ssize_t)-1) && PyErr_Occurred()) return -1; +#else + basicsize = ((PyTypeObject*) cached_type)->tp_basicsize; +#endif + + if (basicsize != expected_basicsize) { + PyErr_Format(PyExc_TypeError, + "Shared Cython type %.200s has the wrong size, try recompiling", + name); + return -1; + } + return 0; +} + +static PyTypeObject *__Pyx_FetchCommonTypeFromSpec(PyTypeObject *metaclass, PyObject *module, PyType_Spec *spec, PyObject *bases) { + PyObject *abi_module = NULL, *cached_type = NULL, *abi_module_dict, *new_cached_type, *py_object_name; + int get_item_ref_result; + // get the final part of the object name (after the last dot) + const char* object_name = strrchr(spec->name, '.'); + object_name = object_name ? object_name+1 : spec->name; + + py_object_name = PyUnicode_FromString(object_name); + if (!py_object_name) return NULL; + + abi_module = __Pyx_FetchSharedCythonABIModule(); + if (!abi_module) goto done; + abi_module_dict = PyModule_GetDict(abi_module); + if (!abi_module_dict) goto done; + + + get_item_ref_result = __Pyx_PyDict_GetItemRef(abi_module_dict, py_object_name, &cached_type); + if (get_item_ref_result == 1) { + if (__Pyx_VerifyCachedType( + cached_type, + object_name, + spec->basicsize) < 0) { + goto bad; + } + goto done; + } else if (unlikely(get_item_ref_result == -1)) { + goto bad; + } + + // We pass the ABI module reference to avoid keeping the user module alive by foreign type usages. + CYTHON_UNUSED_VAR(module); + cached_type = __Pyx_PyType_FromMetaclass(metaclass, abi_module, spec, bases); + if (unlikely(!cached_type)) goto bad; + if (unlikely(__Pyx_fix_up_extension_type_from_spec(spec, (PyTypeObject *) cached_type) < 0)) goto bad; + + new_cached_type = __Pyx_PyDict_SetDefault(abi_module_dict, py_object_name, cached_type, 1); + if (unlikely(new_cached_type != cached_type)) { + if (unlikely(!new_cached_type)) goto bad; + // race to initialize it - use the value that's already been set. + Py_DECREF(cached_type); + cached_type = new_cached_type; + + if (__Pyx_VerifyCachedType( + cached_type, + object_name, + spec->basicsize) < 0) { + goto bad; + } + goto done; + } else { + Py_DECREF(new_cached_type); + } + +done: + Py_XDECREF(abi_module); + Py_DECREF(py_object_name); + // NOTE: always returns owned reference, or NULL on error + assert(cached_type == NULL || PyType_Check(cached_type)); + return (PyTypeObject *) cached_type; + +bad: + Py_XDECREF(cached_type); + cached_type = NULL; + goto done; +} + +//////////////////// CommonTypesMetaclass.module_state_decls //////////////////// + +PyTypeObject *__pyx_CommonTypesMetaclassType; + +//////////////////// CommonTypesMetaclass.module_state_traverse /////////////////// + +Py_VISIT(traverse_module_state->__pyx_CommonTypesMetaclassType); + +//////////////////// CommonTypesMetaclass.module_state_clear /////////////////// + +Py_CLEAR(clear_module_state->__pyx_CommonTypesMetaclassType); + +/////////////////////////// CommonTypesMetaclass.proto //////////////////////// + +static int __pyx_CommonTypesMetaclass_init(PyObject *module); /* proto */ + +#define __Pyx_CommonTypesMetaclass_USED + +//////////////////// CommonTypesMetaclass //////////////////// +//@requires: FetchCommonType +//@substitute: naming + +static PyObject* __pyx_CommonTypesMetaclass_get_module(CYTHON_UNUSED PyObject *self, CYTHON_UNUSED void* context) { + return PyUnicode_FromString(__PYX_ABI_MODULE_NAME); +} + +static PyGetSetDef __pyx_CommonTypesMetaclass_getset[] = { + {"__module__", __pyx_CommonTypesMetaclass_get_module, NULL, NULL, NULL}, + {0, 0, 0, 0, 0} +}; + +static PyType_Slot __pyx_CommonTypesMetaclass_slots[] = { + {Py_tp_getset, (void *)__pyx_CommonTypesMetaclass_getset}, + {0, 0} +}; + +static PyType_Spec __pyx_CommonTypesMetaclass_spec = { + __PYX_TYPE_MODULE_PREFIX "_common_types_metatype", + 0, + 0, +#if PY_VERSION_HEX >= 0x030A0000 + Py_TPFLAGS_IMMUTABLETYPE | + Py_TPFLAGS_DISALLOW_INSTANTIATION | +#endif + Py_TPFLAGS_DEFAULT, /*tp_flags*/ + __pyx_CommonTypesMetaclass_slots +}; + +static int __pyx_CommonTypesMetaclass_init(PyObject *module) { + $modulestatetype_cname *mstate = __Pyx_PyModule_GetState(module); + PyObject *bases = PyTuple_Pack(1, &PyType_Type); + if (unlikely(!bases)) { + return -1; + } + mstate->__pyx_CommonTypesMetaclassType = __Pyx_FetchCommonTypeFromSpec(NULL, module, &__pyx_CommonTypesMetaclass_spec, bases); + Py_DECREF(bases); + if (unlikely(mstate->__pyx_CommonTypesMetaclassType == NULL)) { + return -1; + } + return 0; +} diff --git a/venv/lib/python3.10/site-packages/Cython/Utility/Complex.c b/venv/lib/python3.10/site-packages/Cython/Utility/Complex.c new file mode 100644 index 0000000000000000000000000000000000000000..be1acf1d37a34b4e577e556489c4d8a7d7fc109e --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Utility/Complex.c @@ -0,0 +1,378 @@ +/////////////// Header.proto /////////////// +//@proto_block: h_code + +#if !defined(CYTHON_CCOMPLEX) + #if defined(__cplusplus) + #define CYTHON_CCOMPLEX 1 + #elif (defined(_Complex_I) && !defined(_MSC_VER)) || ((defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L) && !defined(__STDC_NO_COMPLEX__) && !defined(_MSC_VER)) + // should exist since C99, but only C11 defines a test to detect it. + // MSVC defines "_Complex_I" but not "_Complex". See https://github.com/cython/cython/issues/5512 + #define CYTHON_CCOMPLEX 1 + #else + #define CYTHON_CCOMPLEX 0 + #endif +#endif + +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + #include + #else + #include + #endif +#endif + +#if CYTHON_CCOMPLEX && !defined(__cplusplus) && defined(__sun__) && defined(__GNUC__) + #undef _Complex_I + #define _Complex_I 1.0fj +#endif + +/////////////// RealImag.proto /////////////// + +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + #define __Pyx_CREAL(z) ((z).real()) + #define __Pyx_CIMAG(z) ((z).imag()) + #else + #define __Pyx_CREAL(z) (__real__(z)) + #define __Pyx_CIMAG(z) (__imag__(z)) + #endif +#else + #define __Pyx_CREAL(z) ((z).real) + #define __Pyx_CIMAG(z) ((z).imag) +#endif + +#if defined(__cplusplus) && CYTHON_CCOMPLEX \ + && (defined(_WIN32) || defined(__clang__) || (defined(__GNUC__) && (__GNUC__ >= 5 || __GNUC__ == 4 && __GNUC_MINOR__ >= 4 )) || __cplusplus >= 201103) + #define __Pyx_SET_CREAL(z,x) ((z).real(x)) + #define __Pyx_SET_CIMAG(z,y) ((z).imag(y)) +#else + #define __Pyx_SET_CREAL(z,x) __Pyx_CREAL(z) = (x) + #define __Pyx_SET_CIMAG(z,y) __Pyx_CIMAG(z) = (y) +#endif + +/////////////// RealImag_Cy.proto /////////////// + +// alternative version of RealImag.proto for the case where +// we definitely want to force it to use the Cython utility +// code version of complex. +// Because integer complex types simply aren't covered by +// the C or C++ standards +// (although practically will probably work in C++). + +#define __Pyx_CREAL_Cy(z) ((z).real) +#define __Pyx_CIMAG_Cy(z) ((z).imag) +#define __Pyx_SET_CREAL_Cy(z,x) __Pyx_CREAL_Cy(z) = (x) +#define __Pyx_SET_CIMAG_Cy(z,y) __Pyx_CIMAG_cy(z) = (y) + +/////////////// RealImag_CyTypedef.proto ////////// +//@requires: RealImag +//@requires: RealImag_Cy + +#if __cplusplus +// C++ is fine with complexes based on typedefs because the template sees through them +#define __Pyx_CREAL_CyTypedef(z) __Pyx_CREAL(z) +#define __Pyx_CIMAG_CyTypedef(z) __Pyx_CIMAG(z) +#define __Pyx_SET_CREAL_CyTypedef(z,x) __Pyx_SET_CREAL(z) +#define __Pyx_SET_CIMAG_CyTypedef(z,x) __Pyx_SET_CIMAG(z) +#else +// C isn't +#define __Pyx_CREAL_CyTypedef(z) __Pyx_CREAL_Cy(z) +#define __Pyx_CIMAG_CyTypedef(z) __Pyx_CIMAG_Cy(z) +#define __Pyx_SET_CREAL_CyTypedef(z,x) __Pyx_SET_CREAL_Cy(z) +#define __Pyx_SET_CIMAG_CyTypedef(z,x) __Pyx_SET_CIMAG_Cy(z) +#endif + +/////////////// Declarations.proto /////////////// +//@proto_block: complex_type_declarations + +#if CYTHON_CCOMPLEX && ({{is_float}}) && (!{{is_extern_float_typedef}} || __cplusplus) + #ifdef __cplusplus + typedef ::std::complex< {{real_type}} > {{type_name}}; + #else + typedef {{real_type}} _Complex {{type_name}}; + #endif +#else + typedef struct { {{real_type}} real, imag; } {{type_name}}; +#endif + +static CYTHON_INLINE {{type}} {{type_name}}_from_parts({{real_type}}, {{real_type}}); + +/////////////// Declarations /////////////// + +#if CYTHON_CCOMPLEX && ({{is_float}}) && (!{{is_extern_float_typedef}} || __cplusplus) + #ifdef __cplusplus + static CYTHON_INLINE {{type}} {{type_name}}_from_parts({{real_type}} x, {{real_type}} y) { + return ::std::complex< {{real_type}} >(x, y); + } + #else + static CYTHON_INLINE {{type}} {{type_name}}_from_parts({{real_type}} x, {{real_type}} y) { + return x + y*({{type}})_Complex_I; + } + #endif +#else + static CYTHON_INLINE {{type}} {{type_name}}_from_parts({{real_type}} x, {{real_type}} y) { + {{type}} z; + z.real = x; + z.imag = y; + return z; + } +#endif + + +/////////////// ToPy.proto /////////////// + +{{py: func_suffix = "_CyTypedef" if is_extern_float_typedef else ("" if is_float else "_Cy")}} +#define __pyx_PyComplex_FromComplex{{func_suffix}}(z) \ + PyComplex_FromDoubles((double)__Pyx_CREAL{{func_suffix}}(z), \ + (double)__Pyx_CIMAG{{func_suffix}}(z)) + +/////////////// FromPy.proto /////////////// + +static {{type}} __Pyx_PyComplex_As_{{type_name}}(PyObject*); + +/////////////// FromPy /////////////// + +static {{type}} __Pyx_PyComplex_As_{{type_name}}(PyObject* o) { +#if CYTHON_COMPILING_IN_LIMITED_API + double real=-1.0, imag=-1.0; + real = PyComplex_RealAsDouble(o); + if (unlikely(real == -1.0 && PyErr_Occurred())) goto end; + imag = PyComplex_ImagAsDouble(o); + // No error check on imag since we do the same thing either way + end: + return {{type_name}}_from_parts( + ({{real_type}})real, ({{real_type}})imag + ); +#else + Py_complex cval; +#if !CYTHON_COMPILING_IN_PYPY && !CYTHON_COMPILING_IN_GRAAL + if (PyComplex_CheckExact(o)) + cval = ((PyComplexObject *)o)->cval; + else +#endif + cval = PyComplex_AsCComplex(o); + return {{type_name}}_from_parts( + ({{real_type}})cval.real, + ({{real_type}})cval.imag); +#endif +} + + +/////////////// Arithmetic.proto /////////////// + +#if CYTHON_CCOMPLEX && ({{is_float}}) && (!{{is_extern_float_typedef}} || __cplusplus) + #define __Pyx_c_eq{{func_suffix}}(a, b) ((a)==(b)) + #define __Pyx_c_sum{{func_suffix}}(a, b) ((a)+(b)) + #define __Pyx_c_diff{{func_suffix}}(a, b) ((a)-(b)) + #define __Pyx_c_prod{{func_suffix}}(a, b) ((a)*(b)) + #define __Pyx_c_quot{{func_suffix}}(a, b) ((a)/(b)) + #define __Pyx_c_neg{{func_suffix}}(a) (-(a)) + #ifdef __cplusplus + #define __Pyx_c_is_zero{{func_suffix}}(z) ((z)==({{real_type}})0) + #define __Pyx_c_conj{{func_suffix}}(z) (::std::conj(z)) + #if {{is_float}} + #define __Pyx_c_abs{{func_suffix}}(z) (::std::abs(z)) + #define __Pyx_c_pow{{func_suffix}}(a, b) (::std::pow(a, b)) + #endif + #else + #define __Pyx_c_is_zero{{func_suffix}}(z) ((z)==0) + #define __Pyx_c_conj{{func_suffix}}(z) (conj{{m}}(z)) + #if {{is_float}} + #define __Pyx_c_abs{{func_suffix}}(z) (cabs{{m}}(z)) + #define __Pyx_c_pow{{func_suffix}}(a, b) (cpow{{m}}(a, b)) + #endif + #endif +#else + static CYTHON_INLINE int __Pyx_c_eq{{func_suffix}}({{type}}, {{type}}); + static CYTHON_INLINE {{type}} __Pyx_c_sum{{func_suffix}}({{type}}, {{type}}); + static CYTHON_INLINE {{type}} __Pyx_c_diff{{func_suffix}}({{type}}, {{type}}); + static CYTHON_INLINE {{type}} __Pyx_c_prod{{func_suffix}}({{type}}, {{type}}); + static CYTHON_INLINE {{type}} __Pyx_c_quot{{func_suffix}}({{type}}, {{type}}); + static CYTHON_INLINE {{type}} __Pyx_c_neg{{func_suffix}}({{type}}); + static CYTHON_INLINE int __Pyx_c_is_zero{{func_suffix}}({{type}}); + static CYTHON_INLINE {{type}} __Pyx_c_conj{{func_suffix}}({{type}}); + #if {{is_float}} + static CYTHON_INLINE {{real_type}} __Pyx_c_abs{{func_suffix}}({{type}}); + static CYTHON_INLINE {{type}} __Pyx_c_pow{{func_suffix}}({{type}}, {{type}}); + #endif +#endif + +/////////////// Arithmetic /////////////// + +#if CYTHON_CCOMPLEX && ({{is_float}}) && (!{{is_extern_float_typedef}} || __cplusplus) +#else + static CYTHON_INLINE int __Pyx_c_eq{{func_suffix}}({{type}} a, {{type}} b) { + return (a.real == b.real) && (a.imag == b.imag); + } + static CYTHON_INLINE {{type}} __Pyx_c_sum{{func_suffix}}({{type}} a, {{type}} b) { + {{type}} z; + z.real = a.real + b.real; + z.imag = a.imag + b.imag; + return z; + } + static CYTHON_INLINE {{type}} __Pyx_c_diff{{func_suffix}}({{type}} a, {{type}} b) { + {{type}} z; + z.real = a.real - b.real; + z.imag = a.imag - b.imag; + return z; + } + static CYTHON_INLINE {{type}} __Pyx_c_prod{{func_suffix}}({{type}} a, {{type}} b) { + {{type}} z; + z.real = a.real * b.real - a.imag * b.imag; + z.imag = a.real * b.imag + a.imag * b.real; + return z; + } + + #if {{is_float}} + static CYTHON_INLINE {{type}} __Pyx_c_quot{{func_suffix}}({{type}} a, {{type}} b) { + if (b.imag == 0) { + return {{type_name}}_from_parts(a.real / b.real, a.imag / b.real); + } else if (fabs{{m}}(b.real) >= fabs{{m}}(b.imag)) { + if (b.real == 0 && b.imag == 0) { + return {{type_name}}_from_parts(a.real / b.real, a.imag / b.imag); + } else { + {{real_type}} r = b.imag / b.real; + {{real_type}} s = ({{real_type}})(1.0) / (b.real + b.imag * r); + return {{type_name}}_from_parts( + (a.real + a.imag * r) * s, (a.imag - a.real * r) * s); + } + } else { + {{real_type}} r = b.real / b.imag; + {{real_type}} s = ({{real_type}})(1.0) / (b.imag + b.real * r); + return {{type_name}}_from_parts( + (a.real * r + a.imag) * s, (a.imag * r - a.real) * s); + } + } + #else + static CYTHON_INLINE {{type}} __Pyx_c_quot{{func_suffix}}({{type}} a, {{type}} b) { + if (b.imag == 0) { + return {{type_name}}_from_parts(a.real / b.real, a.imag / b.real); + } else { + {{real_type}} denom = b.real * b.real + b.imag * b.imag; + return {{type_name}}_from_parts( + (a.real * b.real + a.imag * b.imag) / denom, + (a.imag * b.real - a.real * b.imag) / denom); + } + } + #endif + + static CYTHON_INLINE {{type}} __Pyx_c_neg{{func_suffix}}({{type}} a) { + {{type}} z; + z.real = -a.real; + z.imag = -a.imag; + return z; + } + static CYTHON_INLINE int __Pyx_c_is_zero{{func_suffix}}({{type}} a) { + return (a.real == 0) && (a.imag == 0); + } + static CYTHON_INLINE {{type}} __Pyx_c_conj{{func_suffix}}({{type}} a) { + {{type}} z; + z.real = a.real; + z.imag = -a.imag; + return z; + } + #if {{is_float}} + static CYTHON_INLINE {{real_type}} __Pyx_c_abs{{func_suffix}}({{type}} z) { + #if !defined(HAVE_HYPOT) || defined(_MSC_VER) + return sqrt{{m}}(z.real*z.real + z.imag*z.imag); + #else + return hypot{{m}}(z.real, z.imag); + #endif + } + static CYTHON_INLINE {{type}} __Pyx_c_pow{{func_suffix}}({{type}} a, {{type}} b) { + {{type}} z; + {{real_type}} r, lnr, theta, z_r, z_theta; + if (b.imag == 0 && b.real == (int)b.real) { + if (b.real < 0) { + {{real_type}} denom = a.real * a.real + a.imag * a.imag; + a.real = a.real / denom; + a.imag = -a.imag / denom; + b.real = -b.real; + } + switch ((int)b.real) { + case 0: + z.real = 1; + z.imag = 0; + return z; + case 1: + return a; + case 2: + return __Pyx_c_prod{{func_suffix}}(a, a); + case 3: + z = __Pyx_c_prod{{func_suffix}}(a, a); + return __Pyx_c_prod{{func_suffix}}(z, a); + case 4: + z = __Pyx_c_prod{{func_suffix}}(a, a); + return __Pyx_c_prod{{func_suffix}}(z, z); + } + } + if (a.imag == 0) { + if (a.real == 0) { + return a; + } else if ((b.imag == 0) && (a.real >= 0)) { + z.real = pow{{m}}(a.real, b.real); + z.imag = 0; + return z; + } else if (a.real > 0) { + r = a.real; + theta = 0; + } else { + r = -a.real; + theta = atan2{{m}}(0.0, -1.0); + } + } else { + r = __Pyx_c_abs{{func_suffix}}(a); + theta = atan2{{m}}(a.imag, a.real); + } + lnr = log{{m}}(r); + z_r = exp{{m}}(lnr * b.real - theta * b.imag); + z_theta = theta * b.real + lnr * b.imag; + z.real = z_r * cos{{m}}(z_theta); + z.imag = z_r * sin{{m}}(z_theta); + return z; + } + #endif +#endif + +/////////////// SoftComplexToDouble.proto ////////////////// + +static double __Pyx_SoftComplexToDouble(__pyx_t_double_complex value, int have_nogil); /* proto */ + +/////////////// SoftComplexToDouble ////////////////// +//@requires: RealImag + +static double __Pyx_SoftComplexToDouble(__pyx_t_double_complex value, int have_nogil) { + // This isn't an absolutely perfect match for the Python behaviour: + // In Python the type would be determined right after the number is + // created (usually '**'), while here it's determined when coerced + // to a PyObject, which may be a few operations later. + if (unlikely(__Pyx_CIMAG(value))) { + PyGILState_STATE gilstate; + if (have_nogil) + gilstate = PyGILState_Ensure(); + PyErr_SetString(PyExc_TypeError, + "Cannot convert 'complex' with non-zero imaginary component to 'double' " + "(this most likely comes from the '**' operator; " + "use 'cython.cpow(True)' to return 'nan' instead of a " + "complex number)."); + if (have_nogil) + PyGILState_Release(gilstate); + return -1.; + } + return __Pyx_CREAL(value); +} + +///////// SoftComplexToPy.proto /////////////////////// + +static PyObject *__pyx_Py_FromSoftComplex(__pyx_t_double_complex value); /* proto */ + +//////// SoftComplexToPy //////////////// +//@requires: RealImag + +static PyObject *__pyx_Py_FromSoftComplex(__pyx_t_double_complex value) { + if (__Pyx_CIMAG(value)) { + return PyComplex_FromDoubles(__Pyx_CREAL(value), __Pyx_CIMAG(value)); + } else { + return PyFloat_FromDouble(__Pyx_CREAL(value)); + } +} diff --git a/venv/lib/python3.10/site-packages/Cython/Utility/Coroutine.c b/venv/lib/python3.10/site-packages/Cython/Utility/Coroutine.c new file mode 100644 index 0000000000000000000000000000000000000000..c69d2bbc8bf7bd65cccc43d570300045ddf606b9 --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Utility/Coroutine.c @@ -0,0 +1,2220 @@ +// ### CPython revisions to investigate for potential changes: + +// 2f180ce2cb6 (bpo-44530: Add co_qualname field to PyCodeObject (GH-26941)) +// a4760cc32d9 (bpo-42747: Remove Py_TPFLAGS_HAVE_AM_SEND and make Py_TPFLAGS_HAVE_VERSION_TAG no-op (GH-27260)) +// ae0a2b75625 (bpo-44590: Lazily allocate frame objects (GH-27077)) +// 69806b9516d (bpo-46009: Do not exhaust generator when send() method raises (GH-29986)) +// b04dfbbe4bd (bpo-46409: Make generators in bytecode (GH-30633) -- ".gi_suspended") +// 304197b3820 (bpo-46944: use FASTCALL calling convention in generator.throw (GH-31723)) +// 8be7c2bc5ad (bpo-14911: Corrected generator.throw() documentation (GH-32207)) +// 5bfb3c372bd (GH-90997: Wrap yield from/await in a virtual try/except StopIteration (GH-96010)) +// 83a3de4e063 (gh-96348: Deprecate the 3-arg signature of coroutine.throw and generator.throw (GH-96428)) +// f4adb975061 (GH-96793: Implement PEP 479 in bytecode. (GH-99006)) +// f02fa64bf2d (GH-100762: Don't call `gen.throw()` in `gen.close()`, unless necessary. (GH-101013)) +// 11a2c6ce516 (gh-102192: Replace PyErr_Fetch/Restore etc by more efficient alternatives (in Objects/) (#102218)) +// ced13c96a4e (gh-79940: add introspection API for asynchronous generators to `inspect` module (#11590) -- ".ag_suspended") +// d56c933992c (gh-104770: Let generator.close() return value (#104771)) +// 7fc542c88dc (GH-89091: raise `RuntimeWarning` for unawaited async generator methods (#104611)) +// 0d30a5a4096 (GH-100964: Break cycles involving exception state when returning from generator (GH-107563)) +// 7d369d471cf (GH-117536: GH-117894: fix athrow().throw(...) unawaited warning (GH-117851)) +// fc7e1aa3c00 (GH-117881: fix athrow().throw()/asend().throw() concurrent access (GH-117882)) +// e5c699280de (GH-117714: implement athrow().close() and asend().close() using throw (GH-117906)) +// 2c7209a3bdf (gh-114091: Reword error message for unawaitable types (#114090)) + + +//////////////////// CoroutineSetYieldFrom //////////////////// + +static void +__Pyx_Coroutine_Set_Owned_Yield_From(__pyx_CoroutineObject *gen, PyObject *yf) { + // NOTE: steals a reference to yf by transferring it to 'gen->yieldfrom' ! + assert (!gen->yieldfrom); +#if CYTHON_USE_AM_SEND + assert (!gen->yieldfrom_am_send); + #if PY_VERSION_HEX < 0x030A00F0 + if (__Pyx_PyType_HasFeature(Py_TYPE(yf), __Pyx_TPFLAGS_HAVE_AM_SEND)) + #endif + { + __Pyx_pyiter_sendfunc am_send; + #if __PYX_LIMITED_VERSION_HEX >= 0x030A0000 + am_send = __Pyx_PyObject_TryGetSubSlot(yf, tp_as_async, am_send, __Pyx_pyiter_sendfunc); + #else + __Pyx_PyAsyncMethodsStruct* tp_as_async = (__Pyx_PyAsyncMethodsStruct*) Py_TYPE(yf)->tp_as_async; + am_send = tp_as_async ? tp_as_async->am_send : NULL; + #endif + if (likely(am_send)) { + // Keep a direct reference to am->am_send, if provided. + gen->yieldfrom_am_send = am_send; + } + } +#endif + gen->yieldfrom = yf; +} + + +//////////////////// GeneratorYieldFrom.proto //////////////////// + +static CYTHON_INLINE __Pyx_PySendResult __Pyx_Generator_Yield_From(__pyx_CoroutineObject *gen, PyObject *source, PyObject **retval); + +//////////////////// GeneratorYieldFrom //////////////////// +//@requires: Generator +//@requires: CoroutineSetYieldFrom +//@requires: ObjectHandling.c::IterNextPlain + +#if CYTHON_USE_TYPE_SLOTS +static void __Pyx_PyIter_CheckErrorAndDecref(PyObject *source) { + __Pyx_TypeName source_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(source)); + PyErr_Format(PyExc_TypeError, + "iter() returned non-iterator of type '" __Pyx_FMT_TYPENAME "'", source_type_name); + __Pyx_DECREF_TypeName(source_type_name); + Py_DECREF(source); +} +#endif + +static CYTHON_INLINE __Pyx_PySendResult __Pyx_Generator_Yield_From(__pyx_CoroutineObject *gen, PyObject *source, PyObject **retval) { + PyObject *source_gen; + __Pyx_PySendResult result; +#ifdef __Pyx_Coroutine_USED + if (__Pyx_Coroutine_Check(source)) { + // TODO: this should only happen for types.coroutine()ed generators, but we can't determine that here + Py_INCREF(source); + source_gen = source; + result = __Pyx_Coroutine_AmSend(source, Py_None, retval); + } else +#endif + { +#if CYTHON_USE_TYPE_SLOTS + if (likely(Py_TYPE(source)->tp_iter)) { + source_gen = Py_TYPE(source)->tp_iter(source); + if (unlikely(!source_gen)) { + *retval = NULL; + return PYGEN_ERROR; + } + if (unlikely(!PyIter_Check(source_gen))) { + __Pyx_PyIter_CheckErrorAndDecref(source_gen); + *retval = NULL; + return PYGEN_ERROR; + } + } else + // CPython also allows non-iterable sequences to be iterated over +#endif + { + source_gen = PyObject_GetIter(source); + if (unlikely(!source_gen)) { + *retval = NULL; + return PYGEN_ERROR; + } + } + // source_gen is now the iterator, make the first next() call + *retval = __Pyx_PyIter_Next_Plain(source_gen); + result = __Pyx_Coroutine_status_from_result(retval); + } + if (likely(result == PYGEN_NEXT)) { + __Pyx_Coroutine_Set_Owned_Yield_From(gen, source_gen); + return PYGEN_NEXT; + } + Py_DECREF(source_gen); + return result; +} + + +//////////////////// CoroutineYieldFrom.proto //////////////////// + +static CYTHON_INLINE __Pyx_PySendResult __Pyx_Coroutine_Yield_From(__pyx_CoroutineObject *gen, PyObject *source, PyObject **retval); /*proto*/ + +//////////////////// CoroutineYieldFrom //////////////////// +//@requires: Coroutine +//@requires: GetAwaitIter +//@requires: CoroutineSetYieldFrom +//@requires: ObjectHandling.c::IterNextPlain + +static __Pyx_PySendResult __Pyx_Coroutine_Yield_From_Coroutine(__pyx_CoroutineObject *gen, PyObject *source, PyObject **retval) { + __Pyx_PySendResult result; + if (unlikely(((__pyx_CoroutineObject*)source)->yieldfrom)) { + PyErr_SetString( + PyExc_RuntimeError, + "coroutine is being awaited already"); + return PYGEN_ERROR; + } + result = __Pyx_Coroutine_AmSend(source, Py_None, retval); + if (result == PYGEN_NEXT) { + Py_INCREF(source); + __Pyx_Coroutine_Set_Owned_Yield_From(gen, source); + } + return result; +} + +static __Pyx_PySendResult __Pyx_Coroutine_Yield_From_Generic(__pyx_CoroutineObject *gen, PyObject *source, PyObject **retval) { + __Pyx_PySendResult result; + PyObject *source_gen = NULL; + + source_gen = __Pyx_Coroutine_GetAwaitableIter(source); + if (unlikely(!source_gen)) return PYGEN_ERROR; + + // source_gen is now the iterator, make the first next() call + if (__Pyx_Coroutine_Check(source_gen)) { + result = __Pyx_Coroutine_Yield_From_Coroutine(gen, source_gen, retval); + Py_DECREF(source_gen); + return result; + } + + *retval = __Pyx_PyIter_Next_Plain(source_gen); + if (*retval) { + __Pyx_Coroutine_Set_Owned_Yield_From(gen, source_gen); + return PYGEN_NEXT; + } + + result = __Pyx_Coroutine_status_from_result(retval); + Py_XDECREF(source_gen); + return result; +} + +static CYTHON_INLINE __Pyx_PySendResult __Pyx_Coroutine_Yield_From(__pyx_CoroutineObject *gen, PyObject *source, PyObject **retval) { + if (__Pyx_Coroutine_Check(source)) { + return __Pyx_Coroutine_Yield_From_Coroutine(gen, source, retval); + } + +#ifdef __Pyx_AsyncGen_USED + // Inlined "__pyx_PyAsyncGenASend" handling to avoid the series of generic calls. + if (__pyx_PyAsyncGenASend_CheckExact(source)) { + *retval = __Pyx_async_gen_asend_iternext(source); + if (*retval) { + Py_INCREF(source); + __Pyx_Coroutine_Set_Owned_Yield_From(gen, source); + return PYGEN_NEXT; + } + return __Pyx_Coroutine_status_from_result(retval); + } +#endif + + return __Pyx_Coroutine_Yield_From_Generic(gen, source, retval); +} + + +//////////////////// GetAwaitIter.proto //////////////////// + +static CYTHON_INLINE PyObject *__Pyx_Coroutine_GetAwaitableIter(PyObject *o); /*proto*/ +static PyObject *__Pyx__Coroutine_GetAwaitableIter(PyObject *o); /*proto*/ + +//////////////////// GetAwaitIter //////////////////// +//@requires: ObjectHandling.c::PyObjectGetMethod +//@requires: ObjectHandling.c::PyObjectCallNoArg +//@requires: ObjectHandling.c::PyObjectCallOneArg +//@requires: Coro_CheckExact + +static CYTHON_INLINE PyObject *__Pyx_Coroutine_GetAwaitableIter(PyObject *o) { +#ifdef __Pyx_Coroutine_USED + if (__Pyx_Coroutine_Check(o)) { + return __Pyx_NewRef(o); + } +#endif + return __Pyx__Coroutine_GetAwaitableIter(o); +} + + +static void __Pyx_Coroutine_AwaitableIterError(PyObject *source) { +#if (PY_VERSION_HEX < 0x030d0000 || defined(_PyErr_FormatFromCause)) && !CYTHON_COMPILING_IN_LIMITED_API + __Pyx_TypeName source_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(source)); + _PyErr_FormatFromCause(PyExc_TypeError, + "'async for' received an invalid object from __anext__: " __Pyx_FMT_TYPENAME, source_type_name); + __Pyx_DECREF_TypeName(source_type_name); +#else + PyObject *exc, *val, *val2, *tb; + __Pyx_TypeName source_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(source)); + assert(PyErr_Occurred()); + PyErr_Fetch(&exc, &val, &tb); + PyErr_NormalizeException(&exc, &val, &tb); + if (tb != NULL) { + PyException_SetTraceback(val, tb); + Py_DECREF(tb); + } + Py_DECREF(exc); + assert(!PyErr_Occurred()); + PyErr_Format(PyExc_TypeError, + "'async for' received an invalid object from __anext__: " __Pyx_FMT_TYPENAME, source_type_name); + __Pyx_DECREF_TypeName(source_type_name); + + PyErr_Fetch(&exc, &val2, &tb); + PyErr_NormalizeException(&exc, &val2, &tb); + Py_INCREF(val); + PyException_SetCause(val2, val); + PyException_SetContext(val2, val); + PyErr_Restore(exc, val2, tb); +#endif +} + +// adapted from genobject.c in Py3.5 +static PyObject *__Pyx__Coroutine_GetAwaitableIter(PyObject *obj) { + PyObject *res; + unaryfunc am_await; + am_await = __Pyx_PyObject_TryGetSubSlot(obj, tp_as_async, am_await, unaryfunc); + if (likely(am_await)) { + res = (*am_await)(obj); + } else +#if CYTHON_COMPILING_IN_CPYTHON && defined(CO_ITERABLE_COROUTINE) +#if PY_VERSION_HEX >= 0x030C00A6 + if (PyGen_CheckExact(obj) && (PyGen_GetCode((PyGenObject*)obj)->co_flags & CO_ITERABLE_COROUTINE)) { +#else + if (PyGen_CheckExact(obj) && ((PyGenObject*)obj)->gi_code && ((PyCodeObject *)((PyGenObject*)obj)->gi_code)->co_flags & CO_ITERABLE_COROUTINE) { +#endif + // Python generator marked with "@types.coroutine" decorator + return __Pyx_NewRef(obj); + } else +#endif + { + PyObject *method = NULL; + int is_method = __Pyx_PyObject_GetMethod(obj, PYIDENT("__await__"), &method); + if (likely(is_method)) { + res = __Pyx_PyObject_CallOneArg(method, obj); + } else if (likely(method)) { + res = __Pyx_PyObject_CallNoArg(method); + } else + goto slot_error; + Py_DECREF(method); + } + if (unlikely(!res)) { + // surprisingly, CPython replaces the exception here... + __Pyx_Coroutine_AwaitableIterError(obj); + goto bad; + } + if (unlikely(!PyIter_Check(res))) { + __Pyx_TypeName res_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(res)); + PyErr_Format(PyExc_TypeError, + "__await__() returned non-iterator of type '" __Pyx_FMT_TYPENAME "'", res_type_name); + __Pyx_DECREF_TypeName(res_type_name); + Py_CLEAR(res); + } else { + int is_coroutine = 0; + #ifdef __Pyx_Coroutine_USED + is_coroutine |= __Pyx_Coroutine_Check(res); + #endif + is_coroutine |= __Pyx_PyCoro_CheckExact(res); + if (unlikely(is_coroutine)) { + /* __await__ must return an *iterator*, not + a coroutine or another awaitable (see PEP 492) */ + PyErr_SetString(PyExc_TypeError, + "__await__() returned a coroutine"); + Py_CLEAR(res); + } + } + return res; +slot_error: + { + __Pyx_TypeName obj_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(obj)); + PyErr_Format(PyExc_TypeError, + "object " __Pyx_FMT_TYPENAME " can't be used in 'await' expression", obj_type_name); + __Pyx_DECREF_TypeName(obj_type_name); + } +bad: + return NULL; +} + + +//////////////////// AsyncIter.proto //////////////////// + +static CYTHON_INLINE PyObject *__Pyx_Coroutine_GetAsyncIter(PyObject *o); /*proto*/ +static CYTHON_INLINE PyObject *__Pyx_Coroutine_AsyncIterNext(PyObject *o); /*proto*/ + +//////////////////// AsyncIter //////////////////// +//@requires: GetAwaitIter + +static PyObject *__Pyx_Coroutine_GetAsyncIter_Fail(PyObject *obj) { + __Pyx_TypeName obj_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(obj)); + PyErr_Format(PyExc_TypeError, + "'async for' requires an object with __aiter__ method, got " __Pyx_FMT_TYPENAME, obj_type_name); + __Pyx_DECREF_TypeName(obj_type_name); + return NULL; +} + + +static CYTHON_INLINE PyObject *__Pyx_Coroutine_GetAsyncIter(PyObject *obj) { +#ifdef __Pyx_AsyncGen_USED + if (__Pyx_AsyncGen_CheckExact(obj)) { + return __Pyx_NewRef(obj); + } +#endif + { + unaryfunc am_aiter = __Pyx_PyObject_TryGetSubSlot(obj, tp_as_async, am_aiter, unaryfunc); + if (likely(am_aiter)) { + return (*am_aiter)(obj); + } + } + return __Pyx_Coroutine_GetAsyncIter_Fail(obj); +} + + +static PyObject *__Pyx_Coroutine_AsyncIterNext_Fail(PyObject *obj) { + __Pyx_TypeName obj_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(obj)); + PyErr_Format(PyExc_TypeError, + "'async for' requires an object with __anext__ method, got " __Pyx_FMT_TYPENAME, obj_type_name); + __Pyx_DECREF_TypeName(obj_type_name); + return NULL; +} + + +static CYTHON_INLINE PyObject *__Pyx_Coroutine_AsyncIterNext(PyObject *obj) { +#ifdef __Pyx_AsyncGen_USED + if (__Pyx_AsyncGen_CheckExact(obj)) { + return __Pyx_async_gen_anext(obj); + } +#endif + { + unaryfunc am_anext = __Pyx_PyObject_TryGetSubSlot(obj, tp_as_async, am_anext, unaryfunc); + if (likely(am_anext)) { + return (*am_anext)(obj); + } + } + return __Pyx_Coroutine_AsyncIterNext_Fail(obj); +} + + +//////////////////// pep479.proto //////////////////// + +static void __Pyx_Generator_Replace_StopIteration(int in_async_gen); /*proto*/ + +//////////////////// pep479 //////////////////// +//@requires: Exceptions.c::GetException + +static void __Pyx_Generator_Replace_StopIteration(int in_async_gen) { + PyObject *exc, *val, *tb, *cur_exc, *new_exc; + __Pyx_PyThreadState_declare + int is_async_stopiteration = 0; + CYTHON_MAYBE_UNUSED_VAR(in_async_gen); + + __Pyx_PyThreadState_assign + cur_exc = __Pyx_PyErr_CurrentExceptionType(); + if (likely(!__Pyx_PyErr_GivenExceptionMatches(cur_exc, PyExc_StopIteration))) { + if (in_async_gen && unlikely(__Pyx_PyErr_GivenExceptionMatches(cur_exc, PyExc_StopAsyncIteration))) { + is_async_stopiteration = 1; + } else { + return; + } + } + + // Explicitly chain the Stop(Async)Iteration by moving it to exc_info before creating the RuntimeError. + __Pyx_GetException(&exc, &val, &tb); + Py_XDECREF(exc); + Py_XDECREF(tb); + new_exc = PyObject_CallFunction(PyExc_RuntimeError, "s", + is_async_stopiteration ? "async generator raised StopAsyncIteration" : + in_async_gen ? "async generator raised StopIteration" : + "generator raised StopIteration"); + if (!new_exc) { + Py_XDECREF(val); + return; + } + PyException_SetCause(new_exc, val); // steals ref to val + PyErr_SetObject(PyExc_RuntimeError, new_exc); +} + + +//////////////////// CoroutineBase.proto //////////////////// +//@substitute: naming + +struct __pyx_CoroutineObject; +typedef PyObject *(*__pyx_coroutine_body_t)(struct __pyx_CoroutineObject *, PyThreadState *, PyObject *); + +#if CYTHON_USE_EXC_INFO_STACK +// See https://bugs.python.org/issue25612 +#define __Pyx_ExcInfoStruct _PyErr_StackItem +#else +// Minimal replacement struct for Py<3.7, without the Py3.7 exception state stack. +typedef struct { + PyObject *exc_type; + PyObject *exc_value; + PyObject *exc_traceback; +} __Pyx_ExcInfoStruct; +#endif + +typedef struct __pyx_CoroutineObject { + PyObject_HEAD + __pyx_coroutine_body_t body; + PyObject *closure; + __Pyx_ExcInfoStruct gi_exc_state; + PyObject *gi_weakreflist; + PyObject *classobj; + PyObject *yieldfrom; + // "yieldfrom_am_send" is always included to avoid changing the struct layout. + __Pyx_pyiter_sendfunc yieldfrom_am_send; + PyObject *gi_name; + PyObject *gi_qualname; + PyObject *gi_modulename; + PyObject *gi_code; + PyObject *gi_frame; +#if CYTHON_USE_SYS_MONITORING && (CYTHON_PROFILE || CYTHON_TRACE) + PyMonitoringState $monitoring_states_cname[__Pyx_MonitoringEventTypes_CyGen_count]; + uint64_t $monitoring_version_cname; +#endif + int resume_label; + // is_running is the main thread-safety mechanism for coroutines, so treat it carefully + char is_running; +} __pyx_CoroutineObject; + +static __pyx_CoroutineObject *__Pyx__Coroutine_New( + PyTypeObject *type, __pyx_coroutine_body_t body, PyObject *code, PyObject *closure, + PyObject *name, PyObject *qualname, PyObject *module_name); /*proto*/ + +static __pyx_CoroutineObject *__Pyx__Coroutine_NewInit( + __pyx_CoroutineObject *gen, __pyx_coroutine_body_t body, PyObject *code, PyObject *closure, + PyObject *name, PyObject *qualname, PyObject *module_name); /*proto*/ + +static CYTHON_INLINE void __Pyx_Coroutine_ExceptionClear(__Pyx_ExcInfoStruct *self); +static int __Pyx_Coroutine_clear(PyObject *self); /*proto*/ +static __Pyx_PySendResult __Pyx_Coroutine_AmSend(PyObject *self, PyObject *value, PyObject **retval); /*proto*/ +static PyObject *__Pyx_Coroutine_Send(PyObject *self, PyObject *value); /*proto*/ +static __Pyx_PySendResult __Pyx_Coroutine_Close(PyObject *self, PyObject **retval); /*proto*/ +static PyObject *__Pyx_Coroutine_Throw(PyObject *gen, PyObject *args); /*proto*/ + +// macros for exception state swapping instead of inline functions to make use of the local thread state context +#if CYTHON_USE_EXC_INFO_STACK +#define __Pyx_Coroutine_SwapException(self) +#define __Pyx_Coroutine_ResetAndClearException(self) __Pyx_Coroutine_ExceptionClear(&(self)->gi_exc_state) +#else +#define __Pyx_Coroutine_SwapException(self) { \ + __Pyx_ExceptionSwap(&(self)->gi_exc_state.exc_type, &(self)->gi_exc_state.exc_value, &(self)->gi_exc_state.exc_traceback); \ + __Pyx_Coroutine_ResetFrameBackpointer(&(self)->gi_exc_state); \ + } +#define __Pyx_Coroutine_ResetAndClearException(self) { \ + __Pyx_ExceptionReset((self)->gi_exc_state.exc_type, (self)->gi_exc_state.exc_value, (self)->gi_exc_state.exc_traceback); \ + (self)->gi_exc_state.exc_type = (self)->gi_exc_state.exc_value = (self)->gi_exc_state.exc_traceback = NULL; \ + } +#endif + +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyGen_FetchStopIterationValue(pvalue) \ + __Pyx_PyGen__FetchStopIterationValue($local_tstate_cname, pvalue) +#else +#define __Pyx_PyGen_FetchStopIterationValue(pvalue) \ + __Pyx_PyGen__FetchStopIterationValue(__Pyx_PyThreadState_Current, pvalue) +#endif +static int __Pyx_PyGen__FetchStopIterationValue(PyThreadState *tstate, PyObject **pvalue); /*proto*/ +static CYTHON_INLINE void __Pyx_Coroutine_ResetFrameBackpointer(__Pyx_ExcInfoStruct *exc_state); /*proto*/ + +static char __Pyx_Coroutine_test_and_set_is_running(__pyx_CoroutineObject *gen); +static void __Pyx_Coroutine_unset_is_running(__pyx_CoroutineObject *gen); +static char __Pyx_Coroutine_get_is_running(__pyx_CoroutineObject *gen); +static PyObject *__Pyx_Coroutine_get_is_running_getter(PyObject *gen, void *closure); + +#if __PYX_HAS_PY_AM_SEND == 2 +static void __Pyx_SetBackportTypeAmSend(PyTypeObject *type, __Pyx_PyAsyncMethodsStruct *static_amsend_methods, __Pyx_pyiter_sendfunc am_send); /* proto */ +#endif + +static PyObject *__Pyx_Coroutine_fail_reduce_ex(PyObject *self, PyObject *arg); /*proto*/ + +//////////////////// Coroutine.proto //////////////////// + +#define __Pyx_Coroutine_USED +#define __Pyx_Coroutine_CheckExact(obj) __Pyx_IS_TYPE(obj, CGLOBAL(__pyx_CoroutineType)) +// __Pyx_Coroutine_Check(obj): see override for IterableCoroutine below +#define __Pyx_Coroutine_Check(obj) __Pyx_Coroutine_CheckExact(obj) +#define __Pyx_CoroutineAwait_CheckExact(obj) __Pyx_IS_TYPE(obj, CGLOBAL(__pyx_CoroutineAwaitType)) + +#define __Pyx_Coroutine_New(body, code, closure, name, qualname, module_name) \ + __Pyx__Coroutine_New(CGLOBAL(__pyx_CoroutineType), body, code, closure, name, qualname, module_name) + +static int __pyx_Coroutine_init(PyObject *module); /*proto*/ +static PyObject *__Pyx__Coroutine_await(PyObject *coroutine); /*proto*/ + +typedef struct { + PyObject_HEAD + PyObject *coroutine; +} __pyx_CoroutineAwaitObject; + +static __Pyx_PySendResult __Pyx_CoroutineAwait_Close(__pyx_CoroutineAwaitObject *self); /*proto*/ + + +//////////////////// Generator.proto //////////////////// + +#define __Pyx_Generator_USED +#define __Pyx_Generator_CheckExact(obj) __Pyx_IS_TYPE(obj, CGLOBAL(__pyx_GeneratorType)) + +#define __Pyx_Generator_New(body, code, closure, name, qualname, module_name) \ + __Pyx__Coroutine_New(CGLOBAL(__pyx_GeneratorType), body, code, closure, name, qualname, module_name) + +static PyObject *__Pyx_Generator_Next(PyObject *self); +static int __pyx_Generator_init(PyObject *module); /*proto*/ +static CYTHON_INLINE PyObject *__Pyx_Generator_GetInlinedResult(PyObject *self); /*proto*/ + + +//////////////////// AsyncGen //////////////////// +//@requires: AsyncGen.c::AsyncGenerator +// -> empty, only delegates to separate file + + +//////////////////// CoroutineBase //////////////////// +//@substitute: naming +//@requires: ReturnWithStopIteration +//@requires: Exceptions.c::PyErrFetchRestore +//@requires: Exceptions.c::PyThreadStateGet +//@requires: Exceptions.c::SwapException +//@requires: Exceptions.c::RaiseException +//@requires: Exceptions.c::SaveResetException +//@requires: ObjectHandling.c::PyObjectCallMethod1 +//@requires: ObjectHandling.c::PyObjectCallNoArg +//@requires: ObjectHandling.c::PyObjectCallOneArg +//@requires: ObjectHandling.c::PyObjectFastCall +//@requires: ObjectHandling.c::PyObjectGetAttrStr +//@requires: ObjectHandling.c::PyObjectGetAttrStrNoError +//@requires: ObjectHandling.c::IterNextPlain +//@requires: CommonStructures.c::FetchCommonType +//@requires: CommonStructures.c::CommonTypesMetaclass +//@requires: ModuleSetupCode.c::IncludeStructmemberH +//@requires: ExtensionTypes.c::CallTypeTraverse + +#if !CYTHON_COMPILING_IN_LIMITED_API +#include +#if PY_VERSION_HEX >= 0x030b00a6 && !defined(PYPY_VERSION) + #ifndef Py_BUILD_CORE + #define Py_BUILD_CORE 1 + #endif + #include "internal/pycore_frame.h" +#endif +#endif // CYTHON_COMPILING_IN_LIMITED_API + +static CYTHON_INLINE void +__Pyx_Coroutine_Undelegate(__pyx_CoroutineObject *gen) { +#if CYTHON_USE_AM_SEND + gen->yieldfrom_am_send = NULL; +#endif + Py_CLEAR(gen->yieldfrom); +} + +// If StopIteration exception is set, fetches its 'value' +// attribute if any, otherwise sets pvalue to None. +// +// Returns 0 if no exception or StopIteration is set. +// If any other exception is set, returns -1 and leaves +// pvalue unchanged. +static int __Pyx_PyGen__FetchStopIterationValue(PyThreadState *$local_tstate_cname, PyObject **pvalue) { + PyObject *et, *ev, *tb; + PyObject *value = NULL; + CYTHON_UNUSED_VAR($local_tstate_cname); + + __Pyx_ErrFetch(&et, &ev, &tb); + + if (!et) { + Py_XDECREF(tb); + Py_XDECREF(ev); + Py_INCREF(Py_None); + *pvalue = Py_None; + return 0; + } + + // most common case: plain StopIteration without or with separate argument + if (likely(et == PyExc_StopIteration)) { + if (!ev) { + Py_INCREF(Py_None); + value = Py_None; + } + else if (likely(__Pyx_IS_TYPE(ev, (PyTypeObject*)PyExc_StopIteration))) { + #if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_GRAAL + value = PyObject_GetAttr(ev, PYIDENT("value")); + if (unlikely(!value)) goto limited_api_failure; + #else + value = ((PyStopIterationObject *)ev)->value; + Py_INCREF(value); + #endif + Py_DECREF(ev); + } + // PyErr_SetObject() and friends put the value directly into ev + else if (unlikely(PyTuple_Check(ev))) { + // if it's a tuple, it is interpreted as separate constructor arguments (surprise!) + Py_ssize_t tuple_size = __Pyx_PyTuple_GET_SIZE(ev); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(tuple_size < 0)) { + Py_XDECREF(tb); + Py_DECREF(ev); + Py_DECREF(et); + return -1; + } + #endif + if (tuple_size >= 1) { +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + value = PyTuple_GET_ITEM(ev, 0); + Py_INCREF(value); +#elif CYTHON_ASSUME_SAFE_MACROS + value = PySequence_ITEM(ev, 0); +#else + value = PySequence_GetItem(ev, 0); + if (!value) goto limited_api_failure; +#endif + } else { + Py_INCREF(Py_None); + value = Py_None; + } + Py_DECREF(ev); + } + else if (!__Pyx_TypeCheck(ev, (PyTypeObject*)PyExc_StopIteration)) { + // 'steal' reference to ev + value = ev; + } + if (likely(value)) { + Py_XDECREF(tb); + Py_DECREF(et); + *pvalue = value; + return 0; + } + } else if (!__Pyx_PyErr_GivenExceptionMatches(et, PyExc_StopIteration)) { + __Pyx_ErrRestore(et, ev, tb); + return -1; + } + + // otherwise: normalise and check what that gives us + PyErr_NormalizeException(&et, &ev, &tb); + if (unlikely(!PyObject_TypeCheck(ev, (PyTypeObject*)PyExc_StopIteration))) { + // looks like normalisation failed - raise the new exception + __Pyx_ErrRestore(et, ev, tb); + return -1; + } + Py_XDECREF(tb); + Py_DECREF(et); +#if CYTHON_COMPILING_IN_LIMITED_API + value = PyObject_GetAttr(ev, PYIDENT("value")); +#else + value = ((PyStopIterationObject *)ev)->value; + Py_INCREF(value); +#endif + Py_DECREF(ev); +#if CYTHON_COMPILING_IN_LIMITED_API + if (unlikely(!value)) return -1; +#endif + *pvalue = value; + return 0; + +#if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_GRAAL || !CYTHON_ASSUME_SAFE_MACROS + limited_api_failure: + Py_XDECREF(et); + Py_XDECREF(tb); + Py_XDECREF(ev); + return -1; +#endif +} + +static CYTHON_INLINE +__Pyx_PySendResult __Pyx_Coroutine_status_from_result(PyObject **retval) { + if (*retval) { + return PYGEN_NEXT; + } else if (likely(__Pyx_PyGen__FetchStopIterationValue(__Pyx_PyThreadState_Current, retval) == 0)) { + //assert (*retval == Py_None); + return PYGEN_RETURN; + } else { + return PYGEN_ERROR; + } +} + +static CYTHON_INLINE +void __Pyx_Coroutine_ExceptionClear(__Pyx_ExcInfoStruct *exc_state) { +#if PY_VERSION_HEX >= 0x030B00a4 + Py_CLEAR(exc_state->exc_value); +#else + PyObject *t, *v, *tb; + t = exc_state->exc_type; + v = exc_state->exc_value; + tb = exc_state->exc_traceback; + + exc_state->exc_type = NULL; + exc_state->exc_value = NULL; + exc_state->exc_traceback = NULL; + + Py_XDECREF(t); + Py_XDECREF(v); + Py_XDECREF(tb); +#endif +} + +#define __Pyx_Coroutine_AlreadyRunningError(gen) (__Pyx__Coroutine_AlreadyRunningError(gen), (PyObject*)NULL) +static void __Pyx__Coroutine_AlreadyRunningError(__pyx_CoroutineObject *gen) { + const char *msg; + CYTHON_MAYBE_UNUSED_VAR(gen); + if ((0)) { + #ifdef __Pyx_Coroutine_USED + } else if (__Pyx_Coroutine_Check((PyObject*)gen)) { + msg = "coroutine already executing"; + #endif + #ifdef __Pyx_AsyncGen_USED + } else if (__Pyx_AsyncGen_CheckExact((PyObject*)gen)) { + msg = "async generator already executing"; + #endif + } else { + msg = "generator already executing"; + } + PyErr_SetString(PyExc_ValueError, msg); +} + +static void __Pyx_Coroutine_AlreadyTerminatedError(PyObject *gen, PyObject *value, int closing) { + CYTHON_MAYBE_UNUSED_VAR(gen); + CYTHON_MAYBE_UNUSED_VAR(closing); + #ifdef __Pyx_Coroutine_USED + if (!closing && __Pyx_Coroutine_Check(gen)) { + // `self` is an exhausted coroutine: raise an error, + // except when called from gen_close(), which should + // always be a silent method. + PyErr_SetString(PyExc_RuntimeError, "cannot reuse already awaited coroutine"); + } else + #endif + if (value) { + // `gen` is an exhausted generator: + // only set exception if called from send(). + #ifdef __Pyx_AsyncGen_USED + if (__Pyx_AsyncGen_CheckExact(gen)) + PyErr_SetNone(PyExc_StopAsyncIteration); + else + #endif + PyErr_SetNone(PyExc_StopIteration); + } +} + +static +__Pyx_PySendResult __Pyx_Coroutine_SendEx(__pyx_CoroutineObject *self, PyObject *value, PyObject **result, int closing) { + __Pyx_PyThreadState_declare + PyThreadState *tstate; + __Pyx_ExcInfoStruct *exc_state; + PyObject *retval; + + assert(__Pyx_Coroutine_get_is_running(self)); // Callers should ensure is_running + + if (unlikely(self->resume_label == -1)) { + __Pyx_Coroutine_AlreadyTerminatedError((PyObject*)self, value, closing); + return PYGEN_ERROR; + } + +#if CYTHON_FAST_THREAD_STATE + __Pyx_PyThreadState_assign + tstate = $local_tstate_cname; +#else + tstate = __Pyx_PyThreadState_Current; +#endif + + // Traceback/Frame rules pre-Py3.7: + // - on entry, save external exception state in self->gi_exc_state, restore it on exit + // - on exit, keep internally generated exceptions in self->gi_exc_state, clear everything else + // - on entry, set "f_back" pointer of internal exception traceback to (current) outer call frame + // - on exit, clear "f_back" of internal exception traceback + // - do not touch external frames and tracebacks + + // Traceback/Frame rules for Py3.7+ (CYTHON_USE_EXC_INFO_STACK): + // - on entry, push internal exception state in self->gi_exc_state on the exception stack + // - on exit, keep internally generated exceptions in self->gi_exc_state, clear everything else + // - on entry, set "f_back" pointer of internal exception traceback to (current) outer call frame + // - on exit, clear "f_back" of internal exception traceback + // - do not touch external frames and tracebacks + + // In the Limited API/PyPy + // - on entry, save external exception state in self->gi_exc_state, restore it on exit + // - on exit, keep internally generated exceptions in self->gi_exc_state, clear everything else + // - don't mess with f_back because we can't work out how to do that + // - do not touch external frames and tracebacks + + exc_state = &self->gi_exc_state; + if (exc_state->exc_value) { + #if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_PYPY + // FIXME - it'd be nice to handle f_back + #else + // Generators always return to their most recent caller, not + // necessarily their creator. + PyObject *exc_tb; + #if PY_VERSION_HEX >= 0x030B00a4 && !CYTHON_COMPILING_IN_CPYTHON + // owned reference! + exc_tb = PyException_GetTraceback(exc_state->exc_value); + #elif PY_VERSION_HEX >= 0x030B00a4 + exc_tb = ((PyBaseExceptionObject*) exc_state->exc_value)->traceback; + #else + exc_tb = exc_state->exc_traceback; + #endif + if (exc_tb) { + PyTracebackObject *tb = (PyTracebackObject *) exc_tb; + PyFrameObject *f = tb->tb_frame; + + assert(f->f_back == NULL); + #if PY_VERSION_HEX >= 0x030B00A1 + // PyThreadState_GetFrame returns NULL if there isn't a current frame + // which is a valid state so no need to check + f->f_back = PyThreadState_GetFrame(tstate); + #else + Py_XINCREF(tstate->frame); + f->f_back = tstate->frame; + #endif + #if PY_VERSION_HEX >= 0x030B00a4 && !CYTHON_COMPILING_IN_CPYTHON + Py_DECREF(exc_tb); + #endif + } + #endif + } + +#if CYTHON_USE_EXC_INFO_STACK + // See https://bugs.python.org/issue25612 + exc_state->previous_item = tstate->exc_info; + tstate->exc_info = exc_state; +#else + if (exc_state->exc_type) { + // We were in an except handler when we left, + // restore the exception state which was put aside. + __Pyx_ExceptionSwap(&exc_state->exc_type, &exc_state->exc_value, &exc_state->exc_traceback); + // self->exc_* now holds the exception state of the caller + } else { + // save away the exception state of the caller + __Pyx_Coroutine_ExceptionClear(exc_state); + __Pyx_ExceptionSave(&exc_state->exc_type, &exc_state->exc_value, &exc_state->exc_traceback); + } +#endif + + retval = self->body(self, tstate, value); + +#if CYTHON_USE_EXC_INFO_STACK + // See https://bugs.python.org/issue25612 + exc_state = &self->gi_exc_state; + tstate->exc_info = exc_state->previous_item; + exc_state->previous_item = NULL; + // Cut off the exception frame chain so that we can reconnect it on re-entry above. + __Pyx_Coroutine_ResetFrameBackpointer(exc_state); +#endif + + *result = retval; + + if (self->resume_label == -1) { + // terminated => return or error? + return likely(retval) ? PYGEN_RETURN : PYGEN_ERROR; + } + return PYGEN_NEXT; +} + +static CYTHON_INLINE void __Pyx_Coroutine_ResetFrameBackpointer(__Pyx_ExcInfoStruct *exc_state) { + // Don't keep the reference to f_back any longer than necessary. It + // may keep a chain of frames alive or it could create a reference + // cycle. +#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API + // FIXME: what to do in PyPy? + CYTHON_UNUSED_VAR(exc_state); +#else + PyObject *exc_tb; + + #if PY_VERSION_HEX >= 0x030B00a4 + if (!exc_state->exc_value) return; + // owned reference! + exc_tb = PyException_GetTraceback(exc_state->exc_value); + #else + exc_tb = exc_state->exc_traceback; + #endif + + if (likely(exc_tb)) { + PyTracebackObject *tb = (PyTracebackObject *) exc_tb; + PyFrameObject *f = tb->tb_frame; + Py_CLEAR(f->f_back); + #if PY_VERSION_HEX >= 0x030B00a4 + Py_DECREF(exc_tb); + #endif + } +#endif +} + +#define __Pyx_Coroutine_MethodReturnFromResult(gen, result, retval, iternext) \ + ((result) == PYGEN_NEXT ? (retval) : __Pyx__Coroutine_MethodReturnFromResult(gen, result, retval, iternext)) + +static PyObject * +__Pyx__Coroutine_MethodReturnFromResult(PyObject* gen, __Pyx_PySendResult result, PyObject *retval, int iternext) { + CYTHON_MAYBE_UNUSED_VAR(gen); + if (likely(result == PYGEN_RETURN)) { + // return values pass through StopIteration or StopAsyncIteration + int is_async = 0; + #ifdef __Pyx_AsyncGen_USED + is_async = __Pyx_AsyncGen_CheckExact(gen); + #endif + __Pyx_ReturnWithStopIteration(retval, is_async, iternext); + Py_XDECREF(retval); + } + return NULL; +} + +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE +PyObject *__Pyx_PyGen_Send(PyGenObject *gen, PyObject *arg) { +#if PY_VERSION_HEX <= 0x030A00A1 + return _PyGen_Send(gen, arg); +#else + PyObject *result; + // PyIter_Send() asserts non-NULL arg + if (PyIter_Send((PyObject*)gen, arg ? arg : Py_None, &result) == PYGEN_RETURN) { + if (PyAsyncGen_CheckExact(gen)) { + assert(result == Py_None); + PyErr_SetNone(PyExc_StopAsyncIteration); + } + else if (result == Py_None) { + PyErr_SetNone(PyExc_StopIteration); + } + else { +#if PY_VERSION_HEX < 0x030d00A1 + _PyGen_SetStopIterationValue(result); +#else + if (!PyTuple_Check(result) && !PyExceptionInstance_Check(result)) { + // delay instantiation if possible + PyErr_SetObject(PyExc_StopIteration, result); + } else { + PyObject *exc = __Pyx_PyObject_CallOneArg(PyExc_StopIteration, result); + if (likely(exc != NULL)) { + PyErr_SetObject(PyExc_StopIteration, exc); + Py_DECREF(exc); + } + } +#endif + } + Py_DECREF(result); + result = NULL; + } + return result; +#endif +} +#endif + +static CYTHON_INLINE __Pyx_PySendResult +__Pyx_Coroutine_FinishDelegation(__pyx_CoroutineObject *gen, PyObject** retval) { + __Pyx_PySendResult result; + PyObject *val = NULL; + assert(__Pyx_Coroutine_get_is_running(gen)); + __Pyx_Coroutine_Undelegate(gen); + __Pyx_PyGen__FetchStopIterationValue(__Pyx_PyThreadState_Current, &val); + // val == NULL on failure => pass on exception + result = __Pyx_Coroutine_SendEx(gen, val, retval, 0); + Py_XDECREF(val); + return result; +} + +#if CYTHON_USE_AM_SEND +static __Pyx_PySendResult +__Pyx_Coroutine_SendToDelegate(__pyx_CoroutineObject *gen, __Pyx_pyiter_sendfunc gen_am_send, PyObject *value, PyObject **retval) { + PyObject *ret = NULL; + __Pyx_PySendResult delegate_result, result; + assert(__Pyx_Coroutine_get_is_running(gen)); + // we assume that gen->yieldfrom cannot change as long as 'gen->is_running' is set => no safety INCREF() + delegate_result = gen_am_send(gen->yieldfrom, value, &ret); + if (delegate_result == PYGEN_NEXT) { + assert (ret != NULL); + *retval = ret; + return PYGEN_NEXT; + } + //assert (delegate_result == PYGEN_ERROR ? ret == NULL : ret != NULL); + assert (delegate_result != PYGEN_ERROR || ret == NULL); + __Pyx_Coroutine_Undelegate(gen); + result = __Pyx_Coroutine_SendEx(gen, ret, retval, 0); + Py_XDECREF(ret); + return result; +} +#endif + +static PyObject *__Pyx_Coroutine_Send(PyObject *self, PyObject *value) { + PyObject *retval = NULL; + __Pyx_PySendResult result = __Pyx_Coroutine_AmSend(self, value, &retval); + return __Pyx_Coroutine_MethodReturnFromResult(self, result, retval, 0); +} + +static __Pyx_PySendResult +__Pyx_Coroutine_AmSend(PyObject *self, PyObject *value, PyObject **retval) { + __Pyx_PySendResult result; + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject*) self; + if (unlikely(__Pyx_Coroutine_test_and_set_is_running(gen))) { + *retval = __Pyx_Coroutine_AlreadyRunningError(gen); + return PYGEN_ERROR; + } + #if CYTHON_USE_AM_SEND + if (gen->yieldfrom_am_send) { + result = __Pyx_Coroutine_SendToDelegate(gen, gen->yieldfrom_am_send, value, retval); + } else + #endif + if (gen->yieldfrom) { + PyObject *yf = gen->yieldfrom; + PyObject *ret; + #if !CYTHON_USE_AM_SEND + // Py3.10 puts "am_send" into "gen->yieldfrom_am_send" instead of using these special cases. + // See "__Pyx_Coroutine_Set_Owned_Yield_From()" above. + #ifdef __Pyx_Generator_USED + if (__Pyx_Generator_CheckExact(yf)) { + ret = __Pyx_Coroutine_Send(yf, value); + } else + #endif + #ifdef __Pyx_Coroutine_USED + if (__Pyx_Coroutine_Check(yf)) { + ret = __Pyx_Coroutine_Send(yf, value); + } else + #endif + #ifdef __Pyx_AsyncGen_USED + if (__pyx_PyAsyncGenASend_CheckExact(yf)) { + ret = __Pyx_async_gen_asend_send(yf, value); + } else + #endif + #if CYTHON_COMPILING_IN_CPYTHON + if (PyGen_CheckExact(yf)) { + ret = __Pyx_PyGen_Send((PyGenObject*)yf, value == Py_None ? NULL : value); + } else + if (PyCoro_CheckExact(yf)) { + ret = __Pyx_PyGen_Send((PyGenObject*)yf, value == Py_None ? NULL : value); + } else + #endif + #endif + { + #if !CYTHON_COMPILING_IN_LIMITED_API || __PYX_LIMITED_VERSION_HEX >= 0x03080000 + // PyIter_Check() is needed here but broken in the Py3.7 Limited API. + if (value == Py_None && PyIter_Check(yf)) + ret = __Pyx_PyIter_Next_Plain(yf); + else + #endif + ret = __Pyx_PyObject_CallMethod1(yf, PYIDENT("send"), value); + } + if (likely(ret)) { + __Pyx_Coroutine_unset_is_running(gen); + *retval = ret; + return PYGEN_NEXT; + } + result = __Pyx_Coroutine_FinishDelegation(gen, retval); + } else { + result = __Pyx_Coroutine_SendEx(gen, value, retval, 0); + } + __Pyx_Coroutine_unset_is_running(gen); + return result; +} + +// This helper function is used by gen_close and gen_throw to +// close a subiterator being delegated to by yield-from. +static int __Pyx_Coroutine_CloseIter(__pyx_CoroutineObject *gen, PyObject *yf) { + __Pyx_PySendResult result; + PyObject *retval = NULL; + CYTHON_UNUSED_VAR(gen); + + assert(__Pyx_Coroutine_get_is_running(gen)); + + #ifdef __Pyx_Generator_USED + if (__Pyx_Generator_CheckExact(yf)) { + result = __Pyx_Coroutine_Close(yf, &retval); + } else + #endif + #ifdef __Pyx_Coroutine_USED + if (__Pyx_Coroutine_Check(yf)) { + result = __Pyx_Coroutine_Close(yf, &retval); + } else + if (__Pyx_CoroutineAwait_CheckExact(yf)) { + result = __Pyx_CoroutineAwait_Close((__pyx_CoroutineAwaitObject*)yf); + } else + #endif + #ifdef __Pyx_AsyncGen_USED + if (__pyx_PyAsyncGenASend_CheckExact(yf)) { + retval = __Pyx_async_gen_asend_close(yf, NULL); + // cannot fail + result = PYGEN_RETURN; + } else + if (__pyx_PyAsyncGenAThrow_CheckExact(yf)) { + retval = __Pyx_async_gen_athrow_close(yf, NULL); + // cannot fail + result = PYGEN_RETURN; + } else + #endif + { + PyObject *meth; + result = PYGEN_RETURN; + meth = __Pyx_PyObject_GetAttrStrNoError(yf, PYIDENT("close")); + if (unlikely(!meth)) { + if (unlikely(PyErr_Occurred())) { + PyErr_WriteUnraisable(yf); + } + } else { + retval = __Pyx_PyObject_CallNoArg(meth); + Py_DECREF(meth); + if (unlikely(!retval)) { + result = PYGEN_ERROR; + } + } + } + Py_XDECREF(retval); + return result == PYGEN_ERROR ? -1 : 0; +} + +static PyObject *__Pyx_Generator_Next(PyObject *self) { + __Pyx_PySendResult result; + PyObject *retval = NULL; + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject*) self; + if (unlikely(__Pyx_Coroutine_test_and_set_is_running(gen))) { + return __Pyx_Coroutine_AlreadyRunningError(gen); + } + #if CYTHON_USE_AM_SEND + if (gen->yieldfrom_am_send) { + result = __Pyx_Coroutine_SendToDelegate(gen, gen->yieldfrom_am_send, Py_None, &retval); + } else + #endif + if (gen->yieldfrom) { + PyObject *yf = gen->yieldfrom; + PyObject *ret; + // YieldFrom code ensures that yf is an iterator + #ifdef __Pyx_Generator_USED + if (__Pyx_Generator_CheckExact(yf)) { + ret = __Pyx_Generator_Next(yf); + } else + #endif + #ifdef __Pyx_Coroutine_USED + // See https://github.com/cython/cython/issues/1999 + if (__Pyx_Coroutine_CheckExact(yf)) { + ret = __Pyx_Coroutine_Send(yf, Py_None); + } else + #endif + #if CYTHON_COMPILING_IN_CPYTHON && (PY_VERSION_HEX < 0x030A00A3 || !CYTHON_USE_AM_SEND) + // _PyGen_Send() is not needed in 3.10+ due to "am_send" + if (PyGen_CheckExact(yf)) { + ret = __Pyx_PyGen_Send((PyGenObject*)yf, NULL); + } else + #endif + ret = __Pyx_PyIter_Next_Plain(yf); + if (likely(ret)) { + __Pyx_Coroutine_unset_is_running(gen); + return ret; + } + result = __Pyx_Coroutine_FinishDelegation(gen, &retval); + } else { + result = __Pyx_Coroutine_SendEx(gen, Py_None, &retval, 0); + } + __Pyx_Coroutine_unset_is_running(gen); + + return __Pyx_Coroutine_MethodReturnFromResult(self, result, retval, 1); +} + +static PyObject *__Pyx_Coroutine_Close_Method(PyObject *self, PyObject *arg) { + PyObject *retval = NULL; + __Pyx_PySendResult result; + CYTHON_UNUSED_VAR(arg); + result = __Pyx_Coroutine_Close(self, &retval); + if (unlikely(result == PYGEN_ERROR)) + return NULL; + Py_XDECREF(retval); + Py_RETURN_NONE; +} + +static __Pyx_PySendResult +__Pyx_Coroutine_Close(PyObject *self, PyObject **retval) { + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; + __Pyx_PySendResult result; + PyObject *yf; + int err = 0; + + if (unlikely(__Pyx_Coroutine_test_and_set_is_running(gen))) { + *retval = __Pyx_Coroutine_AlreadyRunningError(gen); + return PYGEN_ERROR; + } + yf = gen->yieldfrom; + + if (yf) { + Py_INCREF(yf); + err = __Pyx_Coroutine_CloseIter(gen, yf); + __Pyx_Coroutine_Undelegate(gen); + Py_DECREF(yf); + } + if (err == 0) + PyErr_SetNone(PyExc_GeneratorExit); + result = __Pyx_Coroutine_SendEx(gen, NULL, retval, 1); + if (result == PYGEN_ERROR) { + // WARNING: *retval == NULL ! + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_Coroutine_unset_is_running(gen); + if (!__Pyx_PyErr_Occurred()) { + return PYGEN_RETURN; + } else if (likely(__Pyx_PyErr_ExceptionMatches2(PyExc_GeneratorExit, PyExc_StopIteration))) { + __Pyx_PyErr_Clear(); + return PYGEN_RETURN; + } + return PYGEN_ERROR; + } else if (likely(result == PYGEN_RETURN && *retval == Py_None)) { + __Pyx_Coroutine_unset_is_running(gen); + return PYGEN_RETURN; + } else { + const char *msg; + Py_DECREF(*retval); + *retval = NULL; + if ((0)) { + #ifdef __Pyx_Coroutine_USED + } else if (__Pyx_Coroutine_Check(self)) { + msg = "coroutine ignored GeneratorExit"; + #endif + #ifdef __Pyx_AsyncGen_USED + } else if (__Pyx_AsyncGen_CheckExact(self)) { + msg = "async generator ignored GeneratorExit"; + #endif + } else { + msg = "generator ignored GeneratorExit"; + } + PyErr_SetString(PyExc_RuntimeError, msg); + __Pyx_Coroutine_unset_is_running(gen); + return PYGEN_ERROR; + } +} + +static PyObject *__Pyx__Coroutine_Throw(PyObject *self, PyObject *typ, PyObject *val, PyObject *tb, + PyObject *args, int close_on_genexit) { + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; + PyObject *yf; + + if (unlikely(__Pyx_Coroutine_test_and_set_is_running(gen))) + return __Pyx_Coroutine_AlreadyRunningError(gen); + + yf = gen->yieldfrom; + if (yf) { + __Pyx_PySendResult result; + PyObject *ret; + Py_INCREF(yf); + if (__Pyx_PyErr_GivenExceptionMatches(typ, PyExc_GeneratorExit) && close_on_genexit) { + // Asynchronous generators *should not* be closed right away. + // We have to allow some awaits to work it through, hence the + // `close_on_genexit` parameter here. + int err = __Pyx_Coroutine_CloseIter(gen, yf); + Py_DECREF(yf); + __Pyx_Coroutine_Undelegate(gen); + if (err < 0) + goto propagate_exception; + goto throw_here; + } + if (0 + #ifdef __Pyx_Generator_USED + || __Pyx_Generator_CheckExact(yf) + #endif + #ifdef __Pyx_Coroutine_USED + || __Pyx_Coroutine_Check(yf) + #endif + ) { + ret = __Pyx__Coroutine_Throw(yf, typ, val, tb, args, close_on_genexit); + #ifdef __Pyx_Coroutine_USED + } else if (__Pyx_CoroutineAwait_CheckExact(yf)) { + ret = __Pyx__Coroutine_Throw(((__pyx_CoroutineAwaitObject*)yf)->coroutine, typ, val, tb, args, close_on_genexit); + #endif + } else { + PyObject *meth = __Pyx_PyObject_GetAttrStrNoError(yf, PYIDENT("throw")); + if (unlikely(!meth)) { + Py_DECREF(yf); + if (unlikely(PyErr_Occurred())) { + __Pyx_Coroutine_unset_is_running(gen); + return NULL; + } + __Pyx_Coroutine_Undelegate(gen); + goto throw_here; + } + if (likely(args)) { + ret = __Pyx_PyObject_Call(meth, args, NULL); + } else { + // "tb" or even "val" might be NULL, but that also correctly terminates the argument list + PyObject *cargs[4] = {NULL, typ, val, tb}; + ret = __Pyx_PyObject_FastCall(meth, cargs+1, 3 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); + } + Py_DECREF(meth); + } + Py_DECREF(yf); + if (ret) { + __Pyx_Coroutine_unset_is_running(gen); + return ret; + } + + result = __Pyx_Coroutine_FinishDelegation(gen, &ret); + __Pyx_Coroutine_unset_is_running(gen); + return __Pyx_Coroutine_MethodReturnFromResult(self, result, ret, 0); + } +throw_here: + __Pyx_Raise(typ, val, tb, NULL); + +propagate_exception: + { + PyObject *retval = NULL; + __Pyx_PySendResult result = __Pyx_Coroutine_SendEx(gen, NULL, &retval, 0); + __Pyx_Coroutine_unset_is_running(gen); + return __Pyx_Coroutine_MethodReturnFromResult(self, result, retval, 0); + } +} + +static PyObject *__Pyx_Coroutine_Throw(PyObject *self, PyObject *args) { + PyObject *typ; + PyObject *val = NULL; + PyObject *tb = NULL; + + if (unlikely(!PyArg_UnpackTuple(args, "throw", 1, 3, &typ, &val, &tb))) + return NULL; + + return __Pyx__Coroutine_Throw(self, typ, val, tb, args, 1); +} + +static CYTHON_INLINE int __Pyx_Coroutine_traverse_excstate(__Pyx_ExcInfoStruct *exc_state, visitproc visit, void *arg) { +#if PY_VERSION_HEX >= 0x030B00a4 + Py_VISIT(exc_state->exc_value); +#else + Py_VISIT(exc_state->exc_type); + Py_VISIT(exc_state->exc_value); + Py_VISIT(exc_state->exc_traceback); +#endif + return 0; +} + +static int __Pyx_Coroutine_traverse(__pyx_CoroutineObject *gen, visitproc visit, void *arg) { + { + int e = __Pyx_call_type_traverse((PyObject*)gen, 1, visit, arg); + if (e) return e; + } + Py_VISIT(gen->closure); + Py_VISIT(gen->classobj); + Py_VISIT(gen->yieldfrom); + return __Pyx_Coroutine_traverse_excstate(&gen->gi_exc_state, visit, arg); +} + +static int __Pyx_Coroutine_clear(PyObject *self) { + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; + + Py_CLEAR(gen->closure); + Py_CLEAR(gen->classobj); + __Pyx_Coroutine_Undelegate(gen); + __Pyx_Coroutine_ExceptionClear(&gen->gi_exc_state); +#ifdef __Pyx_AsyncGen_USED + if (__Pyx_AsyncGen_CheckExact(self)) { + Py_CLEAR(((__pyx_PyAsyncGenObject*)gen)->ag_finalizer); + } +#endif + Py_CLEAR(gen->gi_code); + Py_CLEAR(gen->gi_frame); + Py_CLEAR(gen->gi_name); + Py_CLEAR(gen->gi_qualname); + Py_CLEAR(gen->gi_modulename); + return 0; +} + +static void __Pyx_Coroutine_dealloc(PyObject *self) { + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; + + PyObject_GC_UnTrack(gen); + if (gen->gi_weakreflist != NULL) + PyObject_ClearWeakRefs(self); + + if (gen->resume_label >= 0) { + // Generator is paused or unstarted, so we need to close + PyObject_GC_Track(self); +#if CYTHON_USE_TP_FINALIZE + if (unlikely(PyObject_CallFinalizerFromDealloc(self))) +#else + { + destructor del = __Pyx_PyObject_GetSlot(gen, tp_del, destructor); + if (del) del(self); + } + if (unlikely(Py_REFCNT(self) > 0)) +#endif + { + // resurrected. :( + return; + } + PyObject_GC_UnTrack(self); + } + +#ifdef __Pyx_AsyncGen_USED + if (__Pyx_AsyncGen_CheckExact(self)) { + /* We have to handle this case for asynchronous generators + right here, because this code has to be between UNTRACK + and GC_Del. */ + Py_CLEAR(((__pyx_PyAsyncGenObject*)self)->ag_finalizer); + } +#endif + __Pyx_Coroutine_clear(self); + __Pyx_PyHeapTypeObject_GC_Del(gen); +} + +#if CYTHON_USE_TP_FINALIZE +static void __Pyx_Coroutine_del(PyObject *self) { + PyObject *error_type, *error_value, *error_traceback; + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; + __Pyx_PyThreadState_declare + + if (gen->resume_label < 0) { + // already terminated => nothing to clean up + return; + } + + __Pyx_PyThreadState_assign + + // Save the current exception, if any. + __Pyx_ErrFetch(&error_type, &error_value, &error_traceback); + +#ifdef __Pyx_AsyncGen_USED + if (__Pyx_AsyncGen_CheckExact(self)) { + __pyx_PyAsyncGenObject *agen = (__pyx_PyAsyncGenObject*)self; + PyObject *finalizer = agen->ag_finalizer; + if (finalizer && !agen->ag_closed) { + PyObject *res = __Pyx_PyObject_CallOneArg(finalizer, self); + if (unlikely(!res)) { + PyErr_WriteUnraisable(self); + } else { + Py_DECREF(res); + } + // Restore the saved exception. + __Pyx_ErrRestore(error_type, error_value, error_traceback); + return; + } + } +#endif + + if (unlikely(gen->resume_label == 0 && !error_value)) { +#ifdef __Pyx_Coroutine_USED +#ifdef __Pyx_Generator_USED + // only warn about (async) coroutines + if (!__Pyx_Generator_CheckExact(self)) +#endif + { + // untrack dead object as we are executing Python code (which might trigger GC) + PyObject_GC_UnTrack(self); + if (unlikely(PyErr_WarnFormat(PyExc_RuntimeWarning, 1, "coroutine '%.50S' was never awaited", gen->gi_qualname) < 0)) + PyErr_WriteUnraisable(self); + PyObject_GC_Track(self); + } +#endif /*__Pyx_Coroutine_USED*/ + } else { + PyObject *retval = NULL; + __Pyx_PySendResult result = __Pyx_Coroutine_Close(self, &retval); + if (result == PYGEN_ERROR) { + PyErr_WriteUnraisable(self); + } else { + Py_XDECREF(retval); + } + } + + // Restore the saved exception. + __Pyx_ErrRestore(error_type, error_value, error_traceback); +} +#endif + +static PyObject * +__Pyx_Coroutine_get_name(__pyx_CoroutineObject *self, void *context) +{ + PyObject *name = self->gi_name; + CYTHON_UNUSED_VAR(context); + // avoid NULL pointer dereference during garbage collection + if (unlikely(!name)) name = Py_None; + Py_INCREF(name); + return name; +} + +static int +__Pyx_Coroutine_set_name(__pyx_CoroutineObject *self, PyObject *value, void *context) +{ + CYTHON_UNUSED_VAR(context); + if (unlikely(value == NULL || !PyUnicode_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "__name__ must be set to a string object"); + return -1; + } + Py_INCREF(value); + __Pyx_Py_XDECREF_SET(self->gi_name, value); + return 0; +} + +static PyObject * +__Pyx_Coroutine_get_qualname(__pyx_CoroutineObject *self, void *context) +{ + PyObject *name = self->gi_qualname; + CYTHON_UNUSED_VAR(context); + // avoid NULL pointer dereference during garbage collection + if (unlikely(!name)) name = Py_None; + Py_INCREF(name); + return name; +} + +static int +__Pyx_Coroutine_set_qualname(__pyx_CoroutineObject *self, PyObject *value, void *context) +{ + CYTHON_UNUSED_VAR(context); + if (unlikely(value == NULL || !PyUnicode_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "__qualname__ must be set to a string object"); + return -1; + } + Py_INCREF(value); + __Pyx_Py_XDECREF_SET(self->gi_qualname, value); + return 0; +} + +static PyObject * +__Pyx__Coroutine_get_frame(__pyx_CoroutineObject *self) +{ +#if !CYTHON_COMPILING_IN_LIMITED_API + PyObject *frame; + #if PY_VERSION_HEX >= 0x030d0000 + Py_BEGIN_CRITICAL_SECTION(self); + #endif + frame = self->gi_frame; + if (!frame) { + if (unlikely(!self->gi_code)) { + // Avoid doing something stupid, e.g. during garbage collection. + Py_RETURN_NONE; + } + // The coroutine doesn't know what module it's in so can't fill in proper globals. + // In principle this could be solved by storing a reference to the module in the coroutine, + // but in practice it probably isn't worth the extra memory. + // Therefore, just supply a blank dict. + PyObject *globals = PyDict_New(); + if (unlikely(!globals)) return NULL; + frame = (PyObject *) PyFrame_New( + PyThreadState_Get(), /*PyThreadState *tstate,*/ + (PyCodeObject*) self->gi_code, /*PyCodeObject *code,*/ + globals, /*PyObject *globals,*/ + 0 /*PyObject *locals*/ + ); + Py_DECREF(globals); + if (unlikely(!frame)) + return NULL; + // handle potential race initializing the frame + if (unlikely(self->gi_frame)) { + Py_DECREF(frame); + frame = self->gi_frame; + } else { + // keep the frame cached once it's created + self->gi_frame = frame; + } + } + Py_INCREF(frame); + #if PY_VERSION_HEX >= 0x030d0000 + Py_END_CRITICAL_SECTION(); + #endif + return frame; +#else + // In the limited API there probably isn't much we can usefully do to get a frame + CYTHON_UNUSED_VAR(self); + Py_RETURN_NONE; +#endif +} + +static PyObject * +__Pyx_Coroutine_get_frame(__pyx_CoroutineObject *self, void *context) { + CYTHON_UNUSED_VAR(context); + PyObject *frame = self->gi_frame; + if (frame) + return __Pyx_NewRef(frame); + return __Pyx__Coroutine_get_frame(self); +} + +static __pyx_CoroutineObject *__Pyx__Coroutine_New( + PyTypeObject* type, __pyx_coroutine_body_t body, PyObject *code, PyObject *closure, + PyObject *name, PyObject *qualname, PyObject *module_name) { + __pyx_CoroutineObject *gen = PyObject_GC_New(__pyx_CoroutineObject, type); + if (unlikely(!gen)) + return NULL; + return __Pyx__Coroutine_NewInit(gen, body, code, closure, name, qualname, module_name); +} + +static __pyx_CoroutineObject *__Pyx__Coroutine_NewInit( + __pyx_CoroutineObject *gen, __pyx_coroutine_body_t body, PyObject *code, PyObject *closure, + PyObject *name, PyObject *qualname, PyObject *module_name) { + gen->body = body; + gen->closure = closure; + Py_XINCREF(closure); + gen->is_running = 0; + gen->resume_label = 0; + gen->classobj = NULL; + gen->yieldfrom = NULL; + gen->yieldfrom_am_send = NULL; + #if PY_VERSION_HEX >= 0x030B00a4 && !CYTHON_COMPILING_IN_LIMITED_API + gen->gi_exc_state.exc_value = NULL; + #else + gen->gi_exc_state.exc_type = NULL; + gen->gi_exc_state.exc_value = NULL; + gen->gi_exc_state.exc_traceback = NULL; + #endif +#if CYTHON_USE_EXC_INFO_STACK + gen->gi_exc_state.previous_item = NULL; +#endif + gen->gi_weakreflist = NULL; + Py_XINCREF(qualname); + gen->gi_qualname = qualname; + Py_XINCREF(name); + gen->gi_name = name; + Py_XINCREF(module_name); + gen->gi_modulename = module_name; + Py_XINCREF(code); + gen->gi_code = code; + gen->gi_frame = NULL; + + PyObject_GC_Track(gen); + return gen; +} + + +static char __Pyx_Coroutine_test_and_set_is_running(__pyx_CoroutineObject *gen) { + // Working on the basis that: + // 1. is_running is the main thing needed to keep generators thread-safe. They can't be + // run simultaneously from multiple threads so as long as we track this correctly + // then all is good. + // 2. They aren't *ultra* high performance, and so critical sections (locking) is appropriate + // instead of atomics. + char result; + #if PY_VERSION_HEX >= 0x030d0000 && !CYTHON_COMPILING_IN_LIMITED_API + Py_BEGIN_CRITICAL_SECTION(gen); + #endif + result = gen->is_running; + gen->is_running = 1; + #if PY_VERSION_HEX >= 0x030d0000 && !CYTHON_COMPILING_IN_LIMITED_API + Py_END_CRITICAL_SECTION(); + #endif + return result; +} +static void __Pyx_Coroutine_unset_is_running(__pyx_CoroutineObject *gen) { + #if PY_VERSION_HEX >= 0x030d0000 && !CYTHON_COMPILING_IN_LIMITED_API + Py_BEGIN_CRITICAL_SECTION(gen); + #endif + assert(gen->is_running); + gen->is_running = 0; + #if PY_VERSION_HEX >= 0x030d0000 && !CYTHON_COMPILING_IN_LIMITED_API + Py_END_CRITICAL_SECTION(); + #endif +} +static char __Pyx_Coroutine_get_is_running(__pyx_CoroutineObject *gen) { + char result; + #if PY_VERSION_HEX >= 0x030d0000 && !CYTHON_COMPILING_IN_LIMITED_API + Py_BEGIN_CRITICAL_SECTION(gen); + #endif + result = gen->is_running; + #if PY_VERSION_HEX >= 0x030d0000 && !CYTHON_COMPILING_IN_LIMITED_API + Py_END_CRITICAL_SECTION(); + #endif + return result; +} +static PyObject *__Pyx_Coroutine_get_is_running_getter(PyObject *gen, void *closure) { + CYTHON_UNUSED_VAR(closure); + char result = __Pyx_Coroutine_get_is_running((__pyx_CoroutineObject*)gen); + if (result) Py_RETURN_TRUE; + else Py_RETURN_FALSE; +} + +#if __PYX_HAS_PY_AM_SEND == 2 +static void __Pyx_SetBackportTypeAmSend(PyTypeObject *type, __Pyx_PyAsyncMethodsStruct *static_amsend_methods, __Pyx_pyiter_sendfunc am_send) { + Py_ssize_t ptr_offset = (char*)(type->tp_as_async) - (char*)type; + if (ptr_offset < 0 || ptr_offset > type->tp_basicsize) { + // The pointer isn't to somewhere within the type. This must be a cached type that's already been updated. + return; + } + + // Copy the standard Python bits of it. + memcpy((void*)static_amsend_methods, (void*)(type->tp_as_async), sizeof(*type->tp_as_async)); + static_amsend_methods->am_send = am_send; + + // Replace. + type->tp_as_async = __Pyx_SlotTpAsAsync(static_amsend_methods); +} +#endif + +// In earlier versions of Python an object with no __dict__ and not __slots__ is assumed +// to be pickleable by default. Coroutine-wrappers have significant state so shouldn't be. +// Therefore provide a default implementation. +// Something similar applies to heaptypes (i.e. with type_specs) with protocols 0 and 1 +// even in more recent versions. +// We are applying this to all Python versions (hence the commented out version guard) +// to make the behaviour explicit. +// #if CYTHON_USE_TYPE_SPECS +static PyObject *__Pyx_Coroutine_fail_reduce_ex(PyObject *self, PyObject *arg) { + CYTHON_UNUSED_VAR(arg); + + __Pyx_TypeName self_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE((PyObject*)self)); + PyErr_Format(PyExc_TypeError, "cannot pickle '" __Pyx_FMT_TYPENAME "' object", + self_type_name); + __Pyx_DECREF_TypeName(self_type_name); + return NULL; +} +// #endif + +//////////////////// Coroutine //////////////////// +//@requires: CoroutineBase +//@requires: ExtensionTypes.c::CallTypeTraverse +//@substitute: naming + +static void __Pyx_CoroutineAwait_dealloc(PyObject *self) { + PyObject_GC_UnTrack(self); + Py_CLEAR(((__pyx_CoroutineAwaitObject*)self)->coroutine); + __Pyx_PyHeapTypeObject_GC_Del(self); +} + +static int __Pyx_CoroutineAwait_traverse(__pyx_CoroutineAwaitObject *self, visitproc visit, void *arg) { + { + int e = __Pyx_call_type_traverse((PyObject*)self, 1, visit, arg); + if (e) return e; + } + Py_VISIT(self->coroutine); + return 0; +} + +static int __Pyx_CoroutineAwait_clear(__pyx_CoroutineAwaitObject *self) { + Py_CLEAR(self->coroutine); + return 0; +} + +static PyObject *__Pyx_CoroutineAwait_Next(__pyx_CoroutineAwaitObject *self) { + return __Pyx_Generator_Next(self->coroutine); +} + +static PyObject *__Pyx_CoroutineAwait_Send(__pyx_CoroutineAwaitObject *self, PyObject *value) { + return __Pyx_Coroutine_Send(self->coroutine, value); +} + +#if __PYX_HAS_PY_AM_SEND +static __Pyx_PySendResult __Pyx_CoroutineAwait_AmSend(PyObject *self, PyObject *value, PyObject **retval) { + return __Pyx_Coroutine_AmSend(((__pyx_CoroutineAwaitObject*)self)->coroutine, value, retval); +} +#endif + +static PyObject *__Pyx_CoroutineAwait_Throw(__pyx_CoroutineAwaitObject *self, PyObject *args) { + return __Pyx_Coroutine_Throw(self->coroutine, args); +} + +static __Pyx_PySendResult __Pyx_CoroutineAwait_Close(__pyx_CoroutineAwaitObject *self) { + PyObject *retval = NULL; + __Pyx_PySendResult result = __Pyx_Coroutine_Close(self->coroutine, &retval); + Py_XDECREF(retval); + return result; +} + +static PyObject *__Pyx_CoroutineAwait_Close_Method(__pyx_CoroutineAwaitObject *self, PyObject *arg) { + PyObject *retval = NULL; + __Pyx_PySendResult result; + CYTHON_UNUSED_VAR(arg); + result = __Pyx_Coroutine_Close(self->coroutine, &retval); + if (unlikely(result == PYGEN_ERROR)) + return NULL; + Py_XDECREF(retval); + Py_RETURN_NONE; +} + +static PyObject *__Pyx_CoroutineAwait_self(PyObject *self) { + Py_INCREF(self); + return self; +} + +#if !CYTHON_COMPILING_IN_PYPY +static PyObject *__Pyx_CoroutineAwait_no_new(PyTypeObject *type, PyObject *args, PyObject *kwargs) { + CYTHON_UNUSED_VAR(type); + CYTHON_UNUSED_VAR(args); + CYTHON_UNUSED_VAR(kwargs); + PyErr_SetString(PyExc_TypeError, "cannot instantiate type, use 'await coroutine' instead"); + return NULL; +} +#endif + +static PyMethodDef __pyx_CoroutineAwait_methods[] = { + {"send", (PyCFunction) __Pyx_CoroutineAwait_Send, METH_O, + PyDoc_STR("send(arg) -> send 'arg' into coroutine,\nreturn next yielded value or raise StopIteration.")}, + {"throw", (PyCFunction) __Pyx_CoroutineAwait_Throw, METH_VARARGS, + PyDoc_STR("throw(typ[,val[,tb]]) -> raise exception in coroutine,\nreturn next yielded value or raise StopIteration.")}, + {"close", (PyCFunction) __Pyx_CoroutineAwait_Close_Method, METH_NOARGS, PyDoc_STR("close() -> raise GeneratorExit inside coroutine.")}, +// only needed with type-specs, but included in all versions for clarity +// #if CYTHON_USE_TYPE_SPECS + {"__reduce_ex__", (PyCFunction) __Pyx_Coroutine_fail_reduce_ex, METH_O, 0}, + {"__reduce__", (PyCFunction) __Pyx_Coroutine_fail_reduce_ex, METH_NOARGS, 0}, +// #endif + {0, 0, 0, 0} +}; + +static PyType_Slot __pyx_CoroutineAwaitType_slots[] = { + {Py_tp_dealloc, (void *)__Pyx_CoroutineAwait_dealloc}, + {Py_tp_traverse, (void *)__Pyx_CoroutineAwait_traverse}, + {Py_tp_clear, (void *)__Pyx_CoroutineAwait_clear}, +#if !CYTHON_COMPILING_IN_PYPY + {Py_tp_new, (void *)__Pyx_CoroutineAwait_no_new}, +#endif + {Py_tp_methods, (void *)__pyx_CoroutineAwait_methods}, + {Py_tp_iter, (void *)__Pyx_CoroutineAwait_self}, + {Py_tp_iternext, (void *)__Pyx_CoroutineAwait_Next}, +#if __PYX_HAS_PY_AM_SEND == 1 + {Py_am_send, (void *)__Pyx_CoroutineAwait_AmSend}, +#endif + {0, 0}, +}; + +static PyType_Spec __pyx_CoroutineAwaitType_spec = { + __PYX_TYPE_MODULE_PREFIX "coroutine_wrapper", + sizeof(__pyx_CoroutineAwaitObject), + 0, +#if PY_VERSION_HEX >= 0x030A0000 + Py_TPFLAGS_IMMUTABLETYPE | +#endif + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | __Pyx_TPFLAGS_HAVE_AM_SEND, /*tp_flags*/ + __pyx_CoroutineAwaitType_slots +}; + +#if __PYX_HAS_PY_AM_SEND == 2 // backport +static __Pyx_PyAsyncMethodsStruct __pyx_CoroutineAwait_as_async; +#endif + +static CYTHON_INLINE PyObject *__Pyx__Coroutine_await(PyObject *coroutine) { + __pyx_CoroutineAwaitObject *await = PyObject_GC_New(__pyx_CoroutineAwaitObject, CGLOBAL(__pyx_CoroutineAwaitType)); + if (unlikely(!await)) return NULL; + Py_INCREF(coroutine); + await->coroutine = coroutine; + PyObject_GC_Track(await); + return (PyObject*)await; +} + +static PyObject *__Pyx_Coroutine_await(PyObject *coroutine) { + if (unlikely(!coroutine || !__Pyx_Coroutine_Check(coroutine))) { + PyErr_SetString(PyExc_TypeError, "invalid input, expected coroutine"); + return NULL; + } + return __Pyx__Coroutine_await(coroutine); +} + +static PyMethodDef __pyx_Coroutine_methods[] = { + {"send", (PyCFunction) __Pyx_Coroutine_Send, METH_O, + PyDoc_STR("send(arg) -> send 'arg' into coroutine,\nreturn next iterated value or raise StopIteration.")}, + {"throw", (PyCFunction) __Pyx_Coroutine_Throw, METH_VARARGS, + PyDoc_STR("throw(typ[,val[,tb]]) -> raise exception in coroutine,\nreturn next iterated value or raise StopIteration.")}, + {"close", (PyCFunction) __Pyx_Coroutine_Close_Method, METH_NOARGS, PyDoc_STR("close() -> raise GeneratorExit inside coroutine.")}, + {"__reduce_ex__", (PyCFunction) __Pyx_Coroutine_fail_reduce_ex, METH_O, 0}, + {"__reduce__", (PyCFunction) __Pyx_Coroutine_fail_reduce_ex, METH_NOARGS, 0}, + {0, 0, 0, 0} +}; + +static PyMemberDef __pyx_Coroutine_memberlist[] = { + {"cr_await", T_OBJECT, offsetof(__pyx_CoroutineObject, yieldfrom), READONLY, + PyDoc_STR("object being awaited, or None")}, + {"cr_code", T_OBJECT, offsetof(__pyx_CoroutineObject, gi_code), READONLY, NULL}, + {"__module__", T_OBJECT, offsetof(__pyx_CoroutineObject, gi_modulename), 0, 0}, + {"__weaklistoffset__", T_PYSSIZET, offsetof(__pyx_CoroutineObject, gi_weakreflist), READONLY, 0}, + {0, 0, 0, 0, 0} +}; + +static PyGetSetDef __pyx_Coroutine_getsets[] = { + {"__name__", (getter)__Pyx_Coroutine_get_name, (setter)__Pyx_Coroutine_set_name, + PyDoc_STR("name of the coroutine"), 0}, + {"__qualname__", (getter)__Pyx_Coroutine_get_qualname, (setter)__Pyx_Coroutine_set_qualname, + PyDoc_STR("qualified name of the coroutine"), 0}, + {"cr_frame", (getter)__Pyx_Coroutine_get_frame, NULL, + PyDoc_STR("Frame of the coroutine"), 0}, + // getter rather than member for thread safety. + {"cr_running", __Pyx_Coroutine_get_is_running_getter, NULL, NULL, NULL}, + {0, 0, 0, 0, 0} +}; + +static PyType_Slot __pyx_CoroutineType_slots[] = { + {Py_tp_dealloc, (void *)__Pyx_Coroutine_dealloc}, + {Py_am_await, (void *)&__Pyx_Coroutine_await}, + {Py_tp_traverse, (void *)__Pyx_Coroutine_traverse}, + {Py_tp_methods, (void *)__pyx_Coroutine_methods}, + {Py_tp_members, (void *)__pyx_Coroutine_memberlist}, + {Py_tp_getset, (void *)__pyx_Coroutine_getsets}, + {Py_tp_getattro, (void *) PyObject_GenericGetAttr}, +#if CYTHON_USE_TP_FINALIZE + {Py_tp_finalize, (void *)__Pyx_Coroutine_del}, +#endif +#if __PYX_HAS_PY_AM_SEND == 1 + {Py_am_send, (void *)__Pyx_Coroutine_AmSend}, +#endif + {0, 0}, +}; + +static PyType_Spec __pyx_CoroutineType_spec = { + __PYX_TYPE_MODULE_PREFIX "coroutine", + sizeof(__pyx_CoroutineObject), + 0, +#if PY_VERSION_HEX >= 0x030A0000 + Py_TPFLAGS_IMMUTABLETYPE | +#endif + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_HAVE_FINALIZE | __Pyx_TPFLAGS_HAVE_AM_SEND, /*tp_flags*/ + __pyx_CoroutineType_slots +}; + +#if __PYX_HAS_PY_AM_SEND == 2 +static __Pyx_PyAsyncMethodsStruct __pyx_Coroutine_as_async; +#endif + +static int __pyx_Coroutine_init(PyObject *module) { + $modulestatetype_cname *mstate; + CYTHON_MAYBE_UNUSED_VAR(module); + // on Windows, C-API functions can't be used in slots statically + mstate = __Pyx_PyModule_GetState(module); + mstate->__pyx_CoroutineType = __Pyx_FetchCommonTypeFromSpec( + mstate->__pyx_CommonTypesMetaclassType, module, &__pyx_CoroutineType_spec, NULL); + if (unlikely(!mstate->__pyx_CoroutineType)) + return -1; +#if __PYX_HAS_PY_AM_SEND == 2 + __Pyx_SetBackportTypeAmSend(mstate->__pyx_CoroutineType, &__pyx_Coroutine_as_async, &__Pyx_Coroutine_AmSend); +#endif + +#ifdef __Pyx_IterableCoroutine_USED + if (unlikely(__pyx_IterableCoroutine_init(module) == -1)) + return -1; +#endif + + mstate->__pyx_CoroutineAwaitType = __Pyx_FetchCommonTypeFromSpec(NULL, module, &__pyx_CoroutineAwaitType_spec, NULL); + if (unlikely(!mstate->__pyx_CoroutineAwaitType)) + return -1; +#if __PYX_HAS_PY_AM_SEND == 2 + __Pyx_SetBackportTypeAmSend(mstate->__pyx_CoroutineAwaitType, &__pyx_CoroutineAwait_as_async, &__Pyx_CoroutineAwait_AmSend); +#endif + + return 0; +} + + +//////////////////// IterableCoroutine.proto //////////////////// + +#define __Pyx_IterableCoroutine_USED + +#undef __Pyx_Coroutine_Check +#define __Pyx_Coroutine_Check(obj) (__Pyx_Coroutine_CheckExact(obj) || __Pyx_IS_TYPE(obj, CGLOBAL(__pyx_IterableCoroutineType))) + +#define __Pyx_IterableCoroutine_New(body, code, closure, name, qualname, module_name) \ + __Pyx__Coroutine_New(CGLOBAL(__pyx_IterableCoroutineType), body, code, closure, name, qualname, module_name) + +static int __pyx_IterableCoroutine_init(PyObject *module);/*proto*/ + + +//////////////////// IterableCoroutine //////////////////// +//@requires: Coroutine +//@requires: CommonStructures.c::FetchCommonType +//@requires: CommonStructures.c::CommonTypesMetaclass +//@substitute: naming + +static PyType_Slot __pyx_IterableCoroutineType_slots[] = { + {Py_tp_dealloc, (void *)__Pyx_Coroutine_dealloc}, + {Py_am_await, (void *)&__Pyx_Coroutine_await}, + {Py_tp_traverse, (void *)__Pyx_Coroutine_traverse}, + {Py_tp_iter, (void *)__Pyx_Coroutine_await}, + {Py_tp_iternext, (void *)__Pyx_Generator_Next}, + {Py_tp_methods, (void *)__pyx_Coroutine_methods}, + {Py_tp_members, (void *)__pyx_Coroutine_memberlist}, + {Py_tp_getset, (void *)__pyx_Coroutine_getsets}, + {Py_tp_getattro, (void *) PyObject_GenericGetAttr}, +#if CYTHON_USE_TP_FINALIZE + {Py_tp_finalize, (void *)__Pyx_Coroutine_del}, +#endif +#if __PYX_HAS_PY_AM_SEND == 1 + {Py_am_send, (void *)__Pyx_Coroutine_AmSend}, +#endif + {0, 0}, +}; + +static PyType_Spec __pyx_IterableCoroutineType_spec = { + __PYX_TYPE_MODULE_PREFIX "iterable_coroutine", + sizeof(__pyx_CoroutineObject), + 0, +#if PY_VERSION_HEX >= 0x030A0000 + Py_TPFLAGS_IMMUTABLETYPE | +#endif + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_HAVE_FINALIZE | __Pyx_TPFLAGS_HAVE_AM_SEND, /*tp_flags*/ + __pyx_IterableCoroutineType_slots +}; + + +static int __pyx_IterableCoroutine_init(PyObject *module) { + $modulestatetype_cname *mstate = __Pyx_PyModule_GetState(module); + mstate->__pyx_IterableCoroutineType = __Pyx_FetchCommonTypeFromSpec( + mstate->__pyx_CommonTypesMetaclassType, module, &__pyx_IterableCoroutineType_spec, NULL); + if (unlikely(!mstate->__pyx_IterableCoroutineType)) + return -1; +#if __PYX_HAS_PY_AM_SEND == 2 + __Pyx_SetBackportTypeAmSend(mstate->__pyx_IterableCoroutineType, &__pyx_Coroutine_as_async, &__Pyx_Coroutine_AmSend); +#endif + return 0; +} + + +//////////////////// Generator //////////////////// +//@requires: CoroutineBase +//@substitute: naming + +static PyMethodDef __pyx_Generator_methods[] = { + {"send", (PyCFunction) __Pyx_Coroutine_Send, METH_O, + PyDoc_STR("send(arg) -> send 'arg' into generator,\nreturn next yielded value or raise StopIteration.")}, + {"throw", (PyCFunction) __Pyx_Coroutine_Throw, METH_VARARGS, + PyDoc_STR("throw(typ[,val[,tb]]) -> raise exception in generator,\nreturn next yielded value or raise StopIteration.")}, + {"close", (PyCFunction) __Pyx_Coroutine_Close_Method, METH_NOARGS, + PyDoc_STR("close() -> raise GeneratorExit inside generator.")}, + {"__reduce_ex__", (PyCFunction) __Pyx_Coroutine_fail_reduce_ex, METH_O, 0}, + {"__reduce__", (PyCFunction) __Pyx_Coroutine_fail_reduce_ex, METH_NOARGS, 0}, + {0, 0, 0, 0} +}; + +static PyMemberDef __pyx_Generator_memberlist[] = { + {"gi_yieldfrom", T_OBJECT, offsetof(__pyx_CoroutineObject, yieldfrom), READONLY, + PyDoc_STR("object being iterated by 'yield from', or None")}, + {"gi_code", T_OBJECT, offsetof(__pyx_CoroutineObject, gi_code), READONLY, NULL}, + {"__module__", T_OBJECT, offsetof(__pyx_CoroutineObject, gi_modulename), 0, 0}, + {"__weaklistoffset__", T_PYSSIZET, offsetof(__pyx_CoroutineObject, gi_weakreflist), READONLY, 0}, + {0, 0, 0, 0, 0} +}; + +static PyGetSetDef __pyx_Generator_getsets[] = { + {"__name__", (getter)__Pyx_Coroutine_get_name, (setter)__Pyx_Coroutine_set_name, + PyDoc_STR("name of the generator"), 0}, + {"__qualname__", (getter)__Pyx_Coroutine_get_qualname, (setter)__Pyx_Coroutine_set_qualname, + PyDoc_STR("qualified name of the generator"), 0}, + {"gi_frame", (getter)__Pyx_Coroutine_get_frame, NULL, + PyDoc_STR("Frame of the generator"), 0}, + {"gi_running", __Pyx_Coroutine_get_is_running_getter, NULL, NULL, NULL}, + {0, 0, 0, 0, 0} +}; + +static PyType_Slot __pyx_GeneratorType_slots[] = { + {Py_tp_dealloc, (void *)__Pyx_Coroutine_dealloc}, + {Py_tp_traverse, (void *)__Pyx_Coroutine_traverse}, + {Py_tp_iter, (void *)PyObject_SelfIter}, + {Py_tp_iternext, (void *)__Pyx_Generator_Next}, + {Py_tp_methods, (void *)__pyx_Generator_methods}, + {Py_tp_members, (void *)__pyx_Generator_memberlist}, + {Py_tp_getset, (void *)__pyx_Generator_getsets}, + {Py_tp_getattro, (void *) PyObject_GenericGetAttr}, +#if CYTHON_USE_TP_FINALIZE + {Py_tp_finalize, (void *)__Pyx_Coroutine_del}, +#endif +#if __PYX_HAS_PY_AM_SEND == 1 + {Py_am_send, (void *)__Pyx_Coroutine_AmSend}, +#endif + {0, 0}, +}; + +static PyType_Spec __pyx_GeneratorType_spec = { + __PYX_TYPE_MODULE_PREFIX "generator", + sizeof(__pyx_CoroutineObject), + 0, +#if PY_VERSION_HEX >= 0x030A0000 + Py_TPFLAGS_IMMUTABLETYPE | +#endif + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_HAVE_FINALIZE | __Pyx_TPFLAGS_HAVE_AM_SEND, /*tp_flags*/ + __pyx_GeneratorType_slots +}; + +#if __PYX_HAS_PY_AM_SEND == 2 +static __Pyx_PyAsyncMethodsStruct __pyx_Generator_as_async; +#endif + +static int __pyx_Generator_init(PyObject *module) { + $modulestatetype_cname *mstate = __Pyx_PyModule_GetState(module); + mstate->__pyx_GeneratorType = __Pyx_FetchCommonTypeFromSpec( + mstate->__pyx_CommonTypesMetaclassType, module, &__pyx_GeneratorType_spec, NULL); + if (unlikely(!mstate->__pyx_GeneratorType)) { + return -1; + } +#if __PYX_HAS_PY_AM_SEND == 2 + __Pyx_SetBackportTypeAmSend(mstate->__pyx_GeneratorType, &__pyx_Generator_as_async, &__Pyx_Coroutine_AmSend); +#endif + return 0; +} + +static PyObject *__Pyx_Generator_GetInlinedResult(PyObject *self) { + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject*) self; + PyObject *retval = NULL; + if (unlikely(__Pyx_Coroutine_test_and_set_is_running(gen))) { + return __Pyx_Coroutine_AlreadyRunningError(gen); + } + __Pyx_PySendResult result = __Pyx_Coroutine_SendEx(gen, Py_None, &retval, 0); + __Pyx_Coroutine_unset_is_running(gen); + (void) result; + assert (result == PYGEN_RETURN || result == PYGEN_ERROR); + assert ((result == PYGEN_RETURN && retval != NULL) || (result == PYGEN_ERROR && retval == NULL)); + return retval; +} + + +/////////////// ReturnWithStopIteration.proto /////////////// + +static CYTHON_INLINE void __Pyx_ReturnWithStopIteration(PyObject* value, int async, int iternext); /*proto*/ + +/////////////// ReturnWithStopIteration /////////////// +//@requires: Exceptions.c::PyErrFetchRestore +//@requires: Exceptions.c::PyThreadStateGet +//@requires: ObjectHandling.c::PyObjectCallOneArg +//@substitute: naming + +// 1) Instantiating an exception just to pass back a value is costly. +// 2) CPython 3.12 cannot separate exception type and value +// 3) Passing a tuple as value into PyErr_SetObject() passes its items on as arguments. +// 4) Passing an exception as value will interpret it as an exception on unpacking and raise it (or unpack its value). +// 5) If there is currently an exception being handled, we need to chain it. +// 6) CPython < 3.14a1 does not implement vectorcalls for exceptions. + +static void __Pyx__ReturnWithStopIteration(PyObject* value, int async); /*proto*/ + +static CYTHON_INLINE void __Pyx_ReturnWithStopIteration(PyObject* value, int async, int iternext) { + if (value == Py_None) { + if (async || !iternext) + PyErr_SetNone(async ? PyExc_StopAsyncIteration : PyExc_StopIteration); + // for regular iternext, then we don't have to return StopIteration and can just return NULL + return; + } + __Pyx__ReturnWithStopIteration(value, async); +} + +static void __Pyx__ReturnWithStopIteration(PyObject* value, int async) { +#if CYTHON_COMPILING_IN_CPYTHON + __Pyx_PyThreadState_declare +#endif + PyObject *exc; + PyObject *exc_type = async ? PyExc_StopAsyncIteration : PyExc_StopIteration; +#if CYTHON_COMPILING_IN_CPYTHON + if ((PY_VERSION_HEX >= (0x030C00A6)) || unlikely(PyTuple_Check(value) || PyExceptionInstance_Check(value))) { + if (PY_VERSION_HEX >= (0x030e00A1)) { + exc = __Pyx_PyObject_CallOneArg(exc_type, value); + } else { + // Before Py3.14a1, CPython doesn't implement vectorcall for exceptions. + PyObject *args_tuple = PyTuple_New(1); + if (unlikely(!args_tuple)) return; + Py_INCREF(value); + PyTuple_SET_ITEM(args_tuple, 0, value); + exc = PyObject_Call(exc_type, args_tuple, NULL); + Py_DECREF(args_tuple); + } + if (unlikely(!exc)) return; + } else { + // it's safe to avoid instantiating the exception + Py_INCREF(value); + exc = value; + } + #if CYTHON_FAST_THREAD_STATE + __Pyx_PyThreadState_assign + #if CYTHON_USE_EXC_INFO_STACK + if (!$local_tstate_cname->exc_info->exc_value) + #else + if (!$local_tstate_cname->exc_type) + #endif + { + // no chaining needed => avoid the overhead in PyErr_SetObject() + Py_INCREF(exc_type); + __Pyx_ErrRestore(exc_type, exc, NULL); + return; + } + #endif +#else + exc = __Pyx_PyObject_CallOneArg(exc_type, value); + if (unlikely(!exc)) return; +#endif + PyErr_SetObject(exc_type, exc); + Py_DECREF(exc); +} + +//////////////////// Coro_CheckExact.proto //////////////// + +#if CYTHON_COMPILING_IN_LIMITED_API +static int __Pyx_PyCoro_CheckExact(PyObject *o); /* proto */ +#else +#define __Pyx_PyCoro_CheckExact PyCoro_CheckExact +#endif + +/////////////////// Coro_CheckExact.module_state_decls ////////// + +#if CYTHON_COMPILING_IN_LIMITED_API +PyObject *__Pyx_CachedCoroType; +#endif + +////////////////// Coro_CheckExact.init //////////////// + +#if CYTHON_COMPILING_IN_LIMITED_API +{ + PyObject *typesModule=NULL; + typesModule = PyImport_ImportModule("types"); + if (typesModule) { + CGLOBAL(__Pyx_CachedCoroType) = PyObject_GetAttrString(typesModule, "CoroutineType"); + Py_DECREF(typesModule); + } +} // error handling follows +#endif + +/////////////// Coro_CheckExact.cleanup //////////////// + +#if CYTHON_COMPILING_IN_LIMITED_API +Py_CLEAR(CGLOBAL(__Pyx_CachedCoroType)); +#endif + +/////////////////// Coro_CheckExact ///////////////////// + +#if CYTHON_COMPILING_IN_LIMITED_API +static int __Pyx_PyCoro_CheckExact(PyObject *o) { + return (PyObject*)Py_TYPE(o) == CGLOBAL(__Pyx_CachedCoroType); +} +#endif diff --git a/venv/lib/python3.10/site-packages/Cython/Utility/CpdefEnums.pyx b/venv/lib/python3.10/site-packages/Cython/Utility/CpdefEnums.pyx new file mode 100644 index 0000000000000000000000000000000000000000..efd391f61bc0e0457a8d581dd4ef5acd664f8ee8 --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Utility/CpdefEnums.pyx @@ -0,0 +1,103 @@ +#################### EnumBase #################### + +cimport cython + +cdef extern from *: + int PY_VERSION_HEX + +# @cython.internal +cdef object __Pyx_EnumBase +from enum import IntEnum as __Pyx_EnumBase + +cdef object __Pyx_FlagBase +from enum import IntFlag as __Pyx_FlagBase + +#################### EnumType #################### +#@requires: EnumBase + +cdef extern from *: + object {{enum_to_pyint_func}}({{name}} value) + +# create new IntFlag() - the assumption is that C enums are sufficiently commonly +# used as flags that this is the most appropriate base class +{{name}} = __Pyx_FlagBase('{{name}}', [ + {{for item in items}} + ('{{item}}', {{enum_to_pyint_func}}({{item}})), + {{endfor}} + # Try to look up the module name dynamically if possible +], module=globals().get("__module__", '{{static_modname}}')) + +if PY_VERSION_HEX >= 0x030B0000: + # Python 3.11 starts making the behaviour of flags stricter + # (only including powers of 2 when iterating). Since we're using + # "flag" because C enums *might* be used as flags, not because + # we want strict flag behaviour, manually undo some of this. + {{name}}._member_names_ = list({{name}}.__members__) + +{{if enum_doc is not None}} +{{name}}.__doc__ = {{ repr(enum_doc) }} +{{endif}} + + +#################### CppScopedEnumType #################### +#@requires: EnumBase +cdef dict __Pyx_globals = globals() + +__Pyx_globals["{{name}}"] = __Pyx_EnumBase('{{name}}', [ + {{for item in items}} + ('{{item}}', <{{underlying_type}}>({{name}}.{{item}})), + {{endfor}} +], module=__Pyx_globals.get("__module__", '{{static_modname}}')) + +{{if enum_doc is not None}} +__Pyx_globals["{{name}}"].__doc__ = {{ repr(enum_doc) }} +{{endif}} + + +#################### EnumTypeToPy #################### + +{{if module_name}} +cdef object __pyx_imported_enum_{{funcname}} = None +{{endif}} + +@cname("{{funcname}}") +cdef {{funcname}}({{name}} c_val): + cdef object __pyx_enum +{{if module_name}} + global __pyx_imported_enum_{{funcname}} + # There's a complication here: the Python enum wrapping is only generated + # for enums defined in the same module that they're used in. Therefore, if + # the enum was cimported from a different module, we try to import it. + # If that fails we return an int equivalent as the next best option. + if __pyx_imported_enum_{{funcname}} is None: + try: + from {{module_name}} import {{name}} as __pyx_imported_enum_{{funcname}} + except ImportError: + __pyx_imported_enum_{{funcname}} = False # False indicates "don't try again" + import warnings + warnings.warn( + f"enum class {{name}} not importable from {{module_name}}. " + "You are probably using a cpdef enum declared in a .pxd file that " + "does not have a .py or .pyx file.") + if __pyx_imported_enum_{{funcname}} is False: + # shortcut - if the import failed there's no point repeating it + # (and repeating the warning) + return <{{underlying_type}}>c_val + __pyx_enum = __pyx_imported_enum_{{funcname}} +{{else}} + __pyx_enum = {{name}} +{{endif}} + # TODO - Cython only manages to optimize C enums to a switch currently + if 0: + pass +{{for item in items}} + elif c_val == {{name}}.{{item}}: + return __pyx_enum.{{item}} +{{endfor}} + else: + underlying_c_val = <{{underlying_type}}>c_val +{{if is_flag}} + return __pyx_enum(underlying_c_val) +{{else}} + raise ValueError(f"{underlying_c_val} is not a valid {{name}}") +{{endif}} diff --git a/venv/lib/python3.10/site-packages/Cython/Utility/CppConvert.pyx b/venv/lib/python3.10/site-packages/Cython/Utility/CppConvert.pyx new file mode 100644 index 0000000000000000000000000000000000000000..074bca9808d085522591a5990916f5d2bb6e457b --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Utility/CppConvert.pyx @@ -0,0 +1,282 @@ +# TODO: Figure out how many of the pass-by-value copies the compiler can eliminate. + + +#################### string.from_py #################### + +cdef extern from *: + cdef cppclass string "{{type}}": + string() except + + string(char* c_str, size_t size) except + + cdef const char* __Pyx_PyObject_AsStringAndSize(object, Py_ssize_t*) except NULL + +@cname("{{cname}}") +cdef string {{cname}}(object o) except *: + cdef Py_ssize_t length = 0 + cdef const char* data = __Pyx_PyObject_AsStringAndSize(o, &length) + return string(data, length) + + +#################### string.to_py #################### + +#cimport cython +#from libcpp.string cimport string +cdef extern from *: + const Py_ssize_t PY_SSIZE_T_MAX + cdef cppclass string "{{type}}": + char* data() + size_t size() + +{{for py_type in ['PyObject', 'PyUnicode', 'PyBytes', 'PyByteArray']}} +cdef extern from *: + cdef object __Pyx_{{py_type}}_FromStringAndSize(const char*, size_t) + +@cname("{{cname.replace("PyObject", py_type, 1)}}") +cdef inline object {{cname.replace("PyObject", py_type, 1)}}(const string& s): + if s.size() > PY_SSIZE_T_MAX: + raise MemoryError() + return __Pyx_{{py_type}}_FromStringAndSize(s.data(), s.size()) +{{endfor}} + + +#################### vector.from_py #################### +#@requires: ObjectHandling.c::LengthHint + +cdef extern from *: + cdef cppclass vector "std::vector" [T]: + void push_back(T&) except + + void reserve(size_t) except + + + cdef Py_ssize_t __Pyx_PyObject_LengthHint(object o, Py_ssize_t defaultval) except -1 + +@cname("{{cname}}") +cdef vector[X] {{cname}}(object o) except *: + + cdef vector[X] v + cdef Py_ssize_t s = __Pyx_PyObject_LengthHint(o, 0) + + if s > 0: + v.reserve( s) + + for item in o: + v.push_back(item) + + return v + + +#################### vector.to_py #################### + +cdef extern from *: + cdef cppclass vector "std::vector" [T]: + size_t size() + T& operator[](size_t) + +cdef extern from "Python.h": + void Py_INCREF(object) + list PyList_New(Py_ssize_t size) + int __Pyx_PyList_SET_ITEM(object list, Py_ssize_t i, object o) except -1 + const Py_ssize_t PY_SSIZE_T_MAX + +@cname("{{cname}}") +cdef object {{cname}}(const vector[X]& v): + if v.size() > PY_SSIZE_T_MAX: + raise MemoryError() + v_size_signed = v.size() + + o = PyList_New(v_size_signed) + + cdef Py_ssize_t i + cdef object item + + for i in range(v_size_signed): + item = v[i] + Py_INCREF(item) + __Pyx_PyList_SET_ITEM(o, i, item) + + return o + +#################### list.from_py #################### + +cdef extern from *: + cdef cppclass cpp_list "std::list" [T]: + void push_back(T&) except + + +@cname("{{cname}}") +cdef cpp_list[X] {{cname}}(object o) except *: + cdef cpp_list[X] l + for item in o: + l.push_back(item) + return l + + +#################### list.to_py #################### + +cimport cython + +cdef extern from *: + cdef cppclass cpp_list "std::list" [T]: + cppclass const_iterator: + T& operator*() + const_iterator operator++() + bint operator!=(const_iterator) + const_iterator begin() + const_iterator end() + size_t size() + +cdef extern from "Python.h": + void Py_INCREF(object) + list PyList_New(Py_ssize_t size) + void __Pyx_PyList_SET_ITEM(object list, Py_ssize_t i, object o) + cdef Py_ssize_t PY_SSIZE_T_MAX + +@cname("{{cname}}") +cdef object {{cname}}(const cpp_list[X]& v): + if v.size() > PY_SSIZE_T_MAX: + raise MemoryError() + + o = PyList_New( v.size()) + + cdef object item + cdef Py_ssize_t i = 0 + cdef cpp_list[X].const_iterator iter = v.begin() + + while iter != v.end(): + item = cython.operator.dereference(iter) + Py_INCREF(item) + __Pyx_PyList_SET_ITEM(o, i, item) + cython.operator.preincrement(iter) + i += 1 + + return o + + +#################### set.from_py #################### + +cdef extern from *: + cdef cppclass set "std::{{maybe_unordered}}set" [T]: + void insert(T&) except + + +@cname("{{cname}}") +cdef set[X] {{cname}}(object o) except *: + cdef set[X] s + for item in o: + s.insert(item) + return s + + +#################### set.to_py #################### + +cimport cython + +cdef extern from *: + cdef cppclass cpp_set "std::{{maybe_unordered}}set" [T]: + cppclass const_iterator: + T& operator*() + const_iterator operator++() + bint operator!=(const_iterator) + const_iterator begin() + const_iterator end() + +@cname("{{cname}}") +cdef object {{cname}}(const cpp_set[X]& s): + return {v for v in s} + +#################### pair.from_py #################### + +cdef extern from *: + cdef cppclass pair "std::pair" [T, U]: + pair() except + + pair(T&, U&) except + + +@cname("{{cname}}") +cdef pair[X,Y] {{cname}}(object o) except *: + x, y = o + return pair[X,Y](x, y) + + +#################### pair.to_py #################### + +cdef extern from *: + cdef cppclass pair "std::pair" [T, U]: + T first + U second + +@cname("{{cname}}") +cdef object {{cname}}(const pair[X,Y]& p): + return p.first, p.second + + +#################### map.from_py #################### + +cdef extern from *: + cdef cppclass pair "std::pair" [T, U]: + pair(T&, U&) except + + cdef cppclass map "std::{{maybe_unordered}}map" [T, U]: + void insert(pair[T, U]&) except + + cdef cppclass vector "std::vector" [T]: + pass + + +@cname("{{cname}}") +cdef map[X,Y] {{cname}}(object o) except *: + cdef map[X,Y] m + for key, value in o.items(): + m.insert(pair[X,Y](key, value)) + return m + + +#################### map.to_py #################### +# TODO: Work out const so that this can take a const +# reference rather than pass by value. + +cimport cython + +cdef extern from *: + cdef cppclass map "std::{{maybe_unordered}}map" [T, U]: + cppclass value_type: + T first + U second + cppclass const_iterator: + value_type& operator*() + const_iterator operator++() + bint operator!=(const_iterator) + const_iterator begin() + const_iterator end() + +@cname("{{cname}}") +cdef object {{cname}}(const map[X,Y]& s): + o = {} + cdef const map[X,Y].value_type *key_value + cdef map[X,Y].const_iterator iter = s.begin() + while iter != s.end(): + key_value = &cython.operator.dereference(iter) + o[key_value.first] = key_value.second + cython.operator.preincrement(iter) + return o + + +#################### complex.from_py #################### + +cdef extern from *: + cdef cppclass std_complex "std::complex" [T]: + std_complex() + std_complex(T, T) except + + +@cname("{{cname}}") +cdef std_complex[X] {{cname}}(object o) except *: + cdef double complex z = o + return std_complex[X](z.real, z.imag) + + +#################### complex.to_py #################### + +cdef extern from *: + cdef cppclass std_complex "std::complex" [T]: + X real() + X imag() + +@cname("{{cname}}") +cdef object {{cname}}(const std_complex[X]& z): + cdef double complex tmp + tmp.real = z.real() + tmp.imag = z.imag() + return tmp diff --git a/venv/lib/python3.10/site-packages/Cython/Utility/CppSupport.cpp b/venv/lib/python3.10/site-packages/Cython/Utility/CppSupport.cpp new file mode 100644 index 0000000000000000000000000000000000000000..1e48fc196a102aa6e66cdd848a566c4dff27f2e0 --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Utility/CppSupport.cpp @@ -0,0 +1,143 @@ +/////////////// CppExceptionConversion.proto /////////////// + +#ifndef __Pyx_CppExn2PyErr +#include +#include +#include +#include + +static void __Pyx_CppExn2PyErr() { + // Catch a handful of different errors here and turn them into the + // equivalent Python errors. + try { + if (PyErr_Occurred()) + ; // let the latest Python exn pass through and ignore the current one + else + throw; + } catch (const std::bad_alloc& exn) { + PyErr_SetString(PyExc_MemoryError, exn.what()); + } catch (const std::bad_cast& exn) { + PyErr_SetString(PyExc_TypeError, exn.what()); + } catch (const std::bad_typeid& exn) { + PyErr_SetString(PyExc_TypeError, exn.what()); + } catch (const std::domain_error& exn) { + PyErr_SetString(PyExc_ValueError, exn.what()); + } catch (const std::invalid_argument& exn) { + PyErr_SetString(PyExc_ValueError, exn.what()); + } catch (const std::ios_base::failure& exn) { + // Unfortunately, in standard C++ we have no way of distinguishing EOF + // from other errors here; be careful with the exception mask + PyErr_SetString(PyExc_IOError, exn.what()); + } catch (const std::out_of_range& exn) { + // Change out_of_range to IndexError + PyErr_SetString(PyExc_IndexError, exn.what()); + } catch (const std::overflow_error& exn) { + PyErr_SetString(PyExc_OverflowError, exn.what()); + } catch (const std::range_error& exn) { + PyErr_SetString(PyExc_ArithmeticError, exn.what()); + } catch (const std::underflow_error& exn) { + PyErr_SetString(PyExc_ArithmeticError, exn.what()); + } catch (const std::exception& exn) { + PyErr_SetString(PyExc_RuntimeError, exn.what()); + } + catch (...) + { + PyErr_SetString(PyExc_RuntimeError, "Unknown exception"); + } +} +#endif + +/////////////// PythranConversion.proto /////////////// + +template +auto __Pyx_pythran_to_python(T &&value) -> decltype(to_python( + typename pythonic::returnable::type>::type>::type{std::forward(value)})) +{ + using returnable_type = typename pythonic::returnable::type>::type>::type; + return to_python(returnable_type{std::forward(value)}); +} + +#define __Pyx_PythranShapeAccessor(x) (pythonic::builtins::getattr(pythonic::types::attr::SHAPE{}, x)) + +////////////// MoveIfSupported.proto ////////////////// + +#if CYTHON_USE_CPP_STD_MOVE + #include + #define __PYX_STD_MOVE_IF_SUPPORTED(x) std::move(x) +#else + #define __PYX_STD_MOVE_IF_SUPPORTED(x) x +#endif + +////////////// EnumClassDecl.proto ////////////////// +//@proto_block: utility_code_proto_before_types + +#if defined (_MSC_VER) + #if _MSC_VER >= 1910 + #define __PYX_ENUM_CLASS_DECL enum + #else + #define __PYX_ENUM_CLASS_DECL + #endif +#else + #define __PYX_ENUM_CLASS_DECL enum +#endif + +////////////// OptionalLocals.proto //////////////// +//@proto_block: utility_code_proto_before_types + +#include +#if defined(CYTHON_USE_BOOST_OPTIONAL) + // fallback mode - std::optional is preferred but this gives + // people with a less up-to-date compiler a chance + #include + #define __Pyx_Optional_BaseType boost::optional +#else + #include + // since std::optional is a C++17 features, a templated using declaration should be safe + // (although it could be replaced with a define) + template + using __Pyx_Optional_BaseType = std::optional; +#endif + +// This class reuses as much of the implementation of std::optional as possible. +// The only place it differs significantly is the assignment operators, which use +// "emplace" (thus requiring move/copy constructors, but not move/copy +// assignment operators). This is preferred because it lets us work with assignable +// types (for example those with const members) +template +class __Pyx_Optional_Type : private __Pyx_Optional_BaseType { +public: + using __Pyx_Optional_BaseType::__Pyx_Optional_BaseType; + using __Pyx_Optional_BaseType::has_value; + using __Pyx_Optional_BaseType::operator*; + using __Pyx_Optional_BaseType::operator->; +#if __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1600) + __Pyx_Optional_Type& operator=(const __Pyx_Optional_Type& rhs) { + this->emplace(*rhs); + return *this; + } + __Pyx_Optional_Type& operator=(__Pyx_Optional_Type&& rhs) { + this->emplace(std::move(*rhs)); + return *this; + } + template + __Pyx_Optional_Type& operator=(U&& rhs) { + this->emplace(std::forward(rhs)); + return *this; + } +#else + // Note - the "cpp_locals" feature is designed to require C++14. + // This pre-c++11 fallback is largely untested, and definitely won't work + // in all the cases that the more modern version does + using __Pyx_Optional_BaseType::operator=; // the chances are emplace can't work... +#endif +}; + +//////////////////////// DefaultPlacementNew.proto /////////////////////// + +#include + +// avoid having to know the name of the class being constructed (e.g. when user is accessing through a typedef) +template +void __Pyx_default_placement_construct(T* x) { + new (static_cast(x)) T(); +} diff --git a/venv/lib/python3.10/site-packages/Cython/Utility/CythonFunction.c b/venv/lib/python3.10/site-packages/Cython/Utility/CythonFunction.c new file mode 100644 index 0000000000000000000000000000000000000000..634a2810c05403d5ddc8276fc38328b543d67f40 --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Utility/CythonFunction.c @@ -0,0 +1,1805 @@ + +//////////////////// CythonFunctionShared.proto //////////////////// + +#define __Pyx_CyFunction_USED + +#define __Pyx_CYFUNCTION_STATICMETHOD 0x01 +#define __Pyx_CYFUNCTION_CLASSMETHOD 0x02 +#define __Pyx_CYFUNCTION_CCLASS 0x04 +#define __Pyx_CYFUNCTION_COROUTINE 0x08 + +#define __Pyx_CyFunction_GetClosure(f) \ + (((__pyx_CyFunctionObject *) (f))->func_closure) + +#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_CyFunction_GetClassObj(f) \ + (((__pyx_CyFunctionObject *) (f))->func_classobj) +#else + #define __Pyx_CyFunction_GetClassObj(f) \ + ((PyObject*) ((PyCMethodObject *) (f))->mm_class) +#endif +#define __Pyx_CyFunction_SetClassObj(f, classobj) \ + __Pyx__CyFunction_SetClassObj((__pyx_CyFunctionObject *) (f), (classobj)) + +#define __Pyx_CyFunction_Defaults(type, f) \ + ((type *)(((__pyx_CyFunctionObject *) (f))->defaults)) +#define __Pyx_CyFunction_SetDefaultsGetter(f, g) \ + ((__pyx_CyFunctionObject *) (f))->defaults_getter = (g) + + +typedef struct { +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject_HEAD + // We can't "inherit" from func, but we can use it as a data store + PyObject *func; +#elif PY_VERSION_HEX < 0x030900B1 + PyCFunctionObject func; +#else + // PEP-573: PyCFunctionObject + mm_class + PyCMethodObject func; +#endif +#if CYTHON_BACKPORT_VECTORCALL || \ + (CYTHON_COMPILING_IN_LIMITED_API && CYTHON_METH_FASTCALL) + __pyx_vectorcallfunc func_vectorcall; +#endif +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *func_weakreflist; +#endif + PyObject *func_dict; + PyObject *func_name; + PyObject *func_qualname; + PyObject *func_doc; + PyObject *func_globals; + PyObject *func_code; + PyObject *func_closure; +#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + // No-args super() class cell + PyObject *func_classobj; +#endif + // Dynamic default args and annotations + PyObject *defaults; + int flags; + + // Defaults info + PyObject *defaults_tuple; /* Const defaults tuple */ + PyObject *defaults_kwdict; /* Const kwonly defaults dict */ + PyObject *(*defaults_getter)(PyObject *); + PyObject *func_annotations; /* function annotations dict */ + + // Coroutine marker + PyObject *func_is_coroutine; +} __pyx_CyFunctionObject; + +#undef __Pyx_CyOrPyCFunction_Check +#define __Pyx_CyFunction_Check(obj) __Pyx_TypeCheck(obj, CGLOBAL(__pyx_CyFunctionType)) +#define __Pyx_CyOrPyCFunction_Check(obj) __Pyx_TypeCheck2(obj, CGLOBAL(__pyx_CyFunctionType), &PyCFunction_Type) +#define __Pyx_CyFunction_CheckExact(obj) __Pyx_IS_TYPE(obj, CGLOBAL(__pyx_CyFunctionType)) +static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void (*cfunc)(void));/*proto*/ +#undef __Pyx_IsSameCFunction +#define __Pyx_IsSameCFunction(func, cfunc) __Pyx__IsSameCyOrCFunction(func, cfunc) + +static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject* op, PyMethodDef *ml, + int flags, PyObject* qualname, + PyObject *closure, + PyObject *module, PyObject *globals, + PyObject* code); + +static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj); +static CYTHON_INLINE PyObject *__Pyx_CyFunction_InitDefaults(PyObject *func, + PyTypeObject *defaults_type); +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *m, + PyObject *tuple); +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *m, + PyObject *dict); +static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *m, + PyObject *dict); + + +static int __pyx_CyFunction_init(PyObject *module); + +#if CYTHON_METH_FASTCALL +static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); +static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); +static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); +static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); +#if CYTHON_BACKPORT_VECTORCALL || CYTHON_COMPILING_IN_LIMITED_API +#define __Pyx_CyFunction_func_vectorcall(f) (((__pyx_CyFunctionObject*)f)->func_vectorcall) +#else +#define __Pyx_CyFunction_func_vectorcall(f) (((PyCFunctionObject*)f)->vectorcall) +#endif +#endif + +//////////////////// CythonFunctionShared //////////////////// +//@requires: CommonStructures.c::FetchCommonType +//@requires: CommonStructures.c::CommonTypesMetaclass +//@requires: ObjectHandling.c::PyMethodNew +//@requires: ObjectHandling.c::PyVectorcallFastCallDict +//@requires: ModuleSetupCode.c::IncludeStructmemberH +//@requires: ObjectHandling.c::PyObjectGetAttrStr +//@requires: ObjectHandling.c::CachedMethodType +//@requires: ExtensionTypes.c::CallTypeTraverse +//@requires: Synchronization.c::CriticalSections +//@substitute: naming + +#if CYTHON_COMPILING_IN_LIMITED_API +static CYTHON_INLINE int __Pyx__IsSameCyOrCFunctionNoMethod(PyObject *func, void (*cfunc)(void)) { + if (__Pyx_CyFunction_Check(func)) { + return PyCFunction_GetFunction(((__pyx_CyFunctionObject*)func)->func) == (PyCFunction) cfunc; + } else if (PyCFunction_Check(func)) { + return PyCFunction_GetFunction(func) == (PyCFunction) cfunc; + } + return 0; +} + +static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void (*cfunc)(void)) { + if ((PyObject*)Py_TYPE(func) == CGLOBAL(__Pyx_CachedMethodType)) { + int result; + PyObject *newFunc = PyObject_GetAttr(func, PYIDENT("__func__")); + if (unlikely(!newFunc)) { + PyErr_Clear(); // It's only an optimization, so don't throw an error + return 0; + } + result = __Pyx__IsSameCyOrCFunctionNoMethod(newFunc, cfunc); + Py_DECREF(newFunc); + return result; + } + return __Pyx__IsSameCyOrCFunctionNoMethod(func, cfunc); +} +#else +static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void (*cfunc)(void)) { + if (PyMethod_Check(func)) { + func = PyMethod_GET_FUNCTION(func); + } + return __Pyx_CyOrPyCFunction_Check(func) && __Pyx_CyOrPyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc; +} +#endif + +static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj) { +#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + __Pyx_Py_XDECREF_SET( + __Pyx_CyFunction_GetClassObj(f), + ((classobj) ? __Pyx_NewRef(classobj) : NULL)); +#else + __Pyx_Py_XDECREF_SET( + // assigning to "mm_class", which is a "PyTypeObject*" + ((PyCMethodObject *) (f))->mm_class, + (PyTypeObject*)((classobj) ? __Pyx_NewRef(classobj) : NULL)); +#endif +} + +static PyObject * +__Pyx_CyFunction_get_doc_locked(__pyx_CyFunctionObject *op) +{ + if (unlikely(op->func_doc == NULL)) { +#if CYTHON_COMPILING_IN_LIMITED_API + op->func_doc = PyObject_GetAttrString(op->func, "__doc__"); + if (unlikely(!op->func_doc)) return NULL; +#else + if (((PyCFunctionObject*)op)->m_ml->ml_doc) { + op->func_doc = PyUnicode_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc); + if (unlikely(op->func_doc == NULL)) + return NULL; + } else { + Py_INCREF(Py_None); + return Py_None; + } +#endif /* CYTHON_COMPILING_IN_LIMITED_API */ + } + Py_INCREF(op->func_doc); + return op->func_doc; +} + +static PyObject * +__Pyx_CyFunction_get_doc(__pyx_CyFunctionObject *op, void *closure) { + PyObject *result; + CYTHON_UNUSED_VAR(closure); + __Pyx_BEGIN_CRITICAL_SECTION(op); + result = __Pyx_CyFunction_get_doc_locked(op); + __Pyx_END_CRITICAL_SECTION(); + return result; +} + +static int +__Pyx_CyFunction_set_doc(__pyx_CyFunctionObject *op, PyObject *value, void *context) +{ + CYTHON_UNUSED_VAR(context); + if (value == NULL) { + // Mark as deleted + value = Py_None; + } + Py_INCREF(value); + __Pyx_BEGIN_CRITICAL_SECTION(op); + __Pyx_Py_XDECREF_SET(op->func_doc, value); + __Pyx_END_CRITICAL_SECTION(); + return 0; +} + +static PyObject * +__Pyx_CyFunction_get_name_locked(__pyx_CyFunctionObject *op) +{ + if (unlikely(op->func_name == NULL)) { +#if CYTHON_COMPILING_IN_LIMITED_API + op->func_name = PyObject_GetAttrString(op->func, "__name__"); +#else + op->func_name = PyUnicode_InternFromString(((PyCFunctionObject*)op)->m_ml->ml_name); +#endif /* CYTHON_COMPILING_IN_LIMITED_API */ + if (unlikely(op->func_name == NULL)) + return NULL; + } + Py_INCREF(op->func_name); + return op->func_name; +} + +static PyObject * +__Pyx_CyFunction_get_name(__pyx_CyFunctionObject *op, void *context) +{ + PyObject *result = NULL; + CYTHON_UNUSED_VAR(context); + __Pyx_BEGIN_CRITICAL_SECTION(op); + result = __Pyx_CyFunction_get_name_locked(op); + __Pyx_END_CRITICAL_SECTION(); + return result; +} + +static int +__Pyx_CyFunction_set_name(__pyx_CyFunctionObject *op, PyObject *value, void *context) +{ + CYTHON_UNUSED_VAR(context); + if (unlikely(value == NULL || !PyUnicode_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "__name__ must be set to a string object"); + return -1; + } + Py_INCREF(value); + __Pyx_BEGIN_CRITICAL_SECTION(op); + __Pyx_Py_XDECREF_SET(op->func_name, value); + __Pyx_END_CRITICAL_SECTION(); + return 0; +} + +static PyObject * +__Pyx_CyFunction_get_qualname(__pyx_CyFunctionObject *op, void *context) +{ + CYTHON_UNUSED_VAR(context); + PyObject *result; + __Pyx_BEGIN_CRITICAL_SECTION(op); + Py_INCREF(op->func_qualname); + result = op->func_qualname; + __Pyx_END_CRITICAL_SECTION(); + return result; +} + +static int +__Pyx_CyFunction_set_qualname(__pyx_CyFunctionObject *op, PyObject *value, void *context) +{ + CYTHON_UNUSED_VAR(context); + if (unlikely(value == NULL || !PyUnicode_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "__qualname__ must be set to a string object"); + return -1; + } + Py_INCREF(value); + __Pyx_BEGIN_CRITICAL_SECTION(op); + __Pyx_Py_XDECREF_SET(op->func_qualname, value); + __Pyx_END_CRITICAL_SECTION(); + return 0; +} + +static PyObject * +__Pyx_CyFunction_get_dict_locked(__pyx_CyFunctionObject *op) +{ + if (unlikely(op->func_dict == NULL)) { + op->func_dict = PyDict_New(); + if (unlikely(op->func_dict == NULL)) + return NULL; + } + Py_INCREF(op->func_dict); + return op->func_dict; +} + +static PyObject * +__Pyx_CyFunction_get_dict(__pyx_CyFunctionObject *op, void *context) +{ + CYTHON_UNUSED_VAR(context); + PyObject *result; + __Pyx_BEGIN_CRITICAL_SECTION(op); + result = __Pyx_CyFunction_get_dict_locked(op); + __Pyx_END_CRITICAL_SECTION(); + return result; +} + +static int +__Pyx_CyFunction_set_dict(__pyx_CyFunctionObject *op, PyObject *value, void *context) +{ + CYTHON_UNUSED_VAR(context); + if (unlikely(value == NULL)) { + PyErr_SetString(PyExc_TypeError, + "function's dictionary may not be deleted"); + return -1; + } + if (unlikely(!PyDict_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "setting function's dictionary to a non-dict"); + return -1; + } + Py_INCREF(value); + __Pyx_BEGIN_CRITICAL_SECTION(op); + __Pyx_Py_XDECREF_SET(op->func_dict, value); + __Pyx_END_CRITICAL_SECTION(); + return 0; +} + +static PyObject * +__Pyx_CyFunction_get_globals(__pyx_CyFunctionObject *op, void *context) +{ + CYTHON_UNUSED_VAR(context); + // Globals is read-only so no critical sections + Py_INCREF(op->func_globals); + return op->func_globals; +} + +static PyObject * +__Pyx_CyFunction_get_closure(__pyx_CyFunctionObject *op, void *context) +{ + CYTHON_UNUSED_VAR(op); + CYTHON_UNUSED_VAR(context); + Py_INCREF(Py_None); + return Py_None; +} + +static PyObject * +__Pyx_CyFunction_get_code(__pyx_CyFunctionObject *op, void *context) +{ + // code is read-only so no critical sections + PyObject* result = (op->func_code) ? op->func_code : Py_None; + CYTHON_UNUSED_VAR(context); + Py_INCREF(result); + return result; +} + +static int +__Pyx_CyFunction_init_defaults(__pyx_CyFunctionObject *op) { + int result = 0; + PyObject *res = op->defaults_getter((PyObject *) op); + if (unlikely(!res)) + return -1; + + // Cache result + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + op->defaults_tuple = PyTuple_GET_ITEM(res, 0); + Py_INCREF(op->defaults_tuple); + op->defaults_kwdict = PyTuple_GET_ITEM(res, 1); + Py_INCREF(op->defaults_kwdict); + #else + op->defaults_tuple = __Pyx_PySequence_ITEM(res, 0); + if (unlikely(!op->defaults_tuple)) result = -1; + else { + op->defaults_kwdict = __Pyx_PySequence_ITEM(res, 1); + if (unlikely(!op->defaults_kwdict)) result = -1; + } + #endif + Py_DECREF(res); + return result; +} + +static int +__Pyx_CyFunction_set_defaults(__pyx_CyFunctionObject *op, PyObject* value, void *context) { + CYTHON_UNUSED_VAR(context); + if (!value) { + // del => explicit None to prevent rebuilding + value = Py_None; + } else if (unlikely(value != Py_None && !PyTuple_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "__defaults__ must be set to a tuple object"); + return -1; + } + PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__defaults__ will not " + "currently affect the values used in function calls", 1); + Py_INCREF(value); + __Pyx_BEGIN_CRITICAL_SECTION(op); + __Pyx_Py_XDECREF_SET(op->defaults_tuple, value); + __Pyx_END_CRITICAL_SECTION(); + return 0; +} + +static PyObject * +__Pyx_CyFunction_get_defaults_locked(__pyx_CyFunctionObject *op) { + PyObject* result = op->defaults_tuple; + if (unlikely(!result)) { + if (op->defaults_getter) { + if (unlikely(__Pyx_CyFunction_init_defaults(op) < 0)) return NULL; + result = op->defaults_tuple; + } else { + result = Py_None; + } + } + Py_INCREF(result); + return result; +} + +static PyObject * +__Pyx_CyFunction_get_defaults(__pyx_CyFunctionObject *op, void *context) { + PyObject* result = NULL; + CYTHON_UNUSED_VAR(context); + __Pyx_BEGIN_CRITICAL_SECTION(op); + result = __Pyx_CyFunction_get_defaults_locked(op); + __Pyx_END_CRITICAL_SECTION(); + return result; +} + +static int +__Pyx_CyFunction_set_kwdefaults(__pyx_CyFunctionObject *op, PyObject* value, void *context) { + CYTHON_UNUSED_VAR(context); + if (!value) { + // del => explicit None to prevent rebuilding + value = Py_None; + } else if (unlikely(value != Py_None && !PyDict_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "__kwdefaults__ must be set to a dict object"); + return -1; + } + PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__kwdefaults__ will not " + "currently affect the values used in function calls", 1); + Py_INCREF(value); + __Pyx_BEGIN_CRITICAL_SECTION(op); + __Pyx_Py_XDECREF_SET(op->defaults_kwdict, value); + __Pyx_END_CRITICAL_SECTION(); + return 0; +} + +static PyObject * +__Pyx_CyFunction_get_kwdefaults_locked(__pyx_CyFunctionObject *op) { + PyObject* result = op->defaults_kwdict; + if (unlikely(!result)) { + if (op->defaults_getter) { + if (unlikely(__Pyx_CyFunction_init_defaults(op) < 0)) return NULL; + result = op->defaults_kwdict; + } else { + result = Py_None; + } + } + Py_INCREF(result); + return result; +} + +static PyObject * +__Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject *op, void *context) { + PyObject* result; + CYTHON_UNUSED_VAR(context); + __Pyx_BEGIN_CRITICAL_SECTION(op); + result = __Pyx_CyFunction_get_kwdefaults_locked(op); + __Pyx_END_CRITICAL_SECTION(); + return result; +} + +static int +__Pyx_CyFunction_set_annotations(__pyx_CyFunctionObject *op, PyObject* value, void *context) { + CYTHON_UNUSED_VAR(context); + if (!value || value == Py_None) { + value = NULL; + } else if (unlikely(!PyDict_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "__annotations__ must be set to a dict object"); + return -1; + } + Py_XINCREF(value); + __Pyx_BEGIN_CRITICAL_SECTION(op); + __Pyx_Py_XDECREF_SET(op->func_annotations, value); + __Pyx_END_CRITICAL_SECTION(); + return 0; +} + +static PyObject * +__Pyx_CyFunction_get_annotations_locked(__pyx_CyFunctionObject *op) { + PyObject* result = op->func_annotations; + if (unlikely(!result)) { + result = PyDict_New(); + if (unlikely(!result)) return NULL; + op->func_annotations = result; + } + Py_INCREF(result); + return result; +} + +static PyObject * +__Pyx_CyFunction_get_annotations(__pyx_CyFunctionObject *op, void *context) { + PyObject *result; + CYTHON_UNUSED_VAR(context); + __Pyx_BEGIN_CRITICAL_SECTION(op); + result = __Pyx_CyFunction_get_annotations_locked(op); + __Pyx_END_CRITICAL_SECTION(); + return result; +} + +static PyObject * +__Pyx_CyFunction_get_is_coroutine_value(__pyx_CyFunctionObject *op) { + int is_coroutine = op->flags & __Pyx_CYFUNCTION_COROUTINE; + if (is_coroutine) { + PyObject *is_coroutine_value, *module, *fromlist, *marker = PYIDENT("_is_coroutine"); + fromlist = PyList_New(1); + if (unlikely(!fromlist)) return NULL; + Py_INCREF(marker); +#if CYTHON_ASSUME_SAFE_MACROS + PyList_SET_ITEM(fromlist, 0, marker); +#else + if (unlikely(PyList_SetItem(fromlist, 0, marker) < 0)) { + Py_DECREF(marker); + Py_DECREF(fromlist); + return NULL; + } +#endif + module = PyImport_ImportModuleLevelObject(PYIDENT("asyncio.coroutines"), NULL, NULL, fromlist, 0); + Py_DECREF(fromlist); + if (unlikely(!module)) goto ignore; + is_coroutine_value = __Pyx_PyObject_GetAttrStr(module, marker); + Py_DECREF(module); + if (likely(is_coroutine_value)) { + return is_coroutine_value; + } +ignore: + PyErr_Clear(); + } + + return __Pyx_PyBool_FromLong(is_coroutine); +} + +static PyObject * +__Pyx_CyFunction_get_is_coroutine(__pyx_CyFunctionObject *op, void *context) { + PyObject *result; + CYTHON_UNUSED_VAR(context); + if (op->func_is_coroutine) { + return __Pyx_NewRef(op->func_is_coroutine); + } + + result = __Pyx_CyFunction_get_is_coroutine_value(op); + if (unlikely(!result)) + return NULL; + + __Pyx_BEGIN_CRITICAL_SECTION(op); + // Guard against concurrent initialisation. + if (op->func_is_coroutine) { + Py_DECREF(result); + result = __Pyx_NewRef(op->func_is_coroutine); + } else { + op->func_is_coroutine = __Pyx_NewRef(result); + } + __Pyx_END_CRITICAL_SECTION(); + return result; +} + +//static PyObject * +//__Pyx_CyFunction_get_signature(__pyx_CyFunctionObject *op, void *context) { +// PyObject *inspect_module, *signature_class, *signature; +// CYTHON_UNUSED_VAR(context); +// // from inspect import Signature +// inspect_module = PyImport_ImportModuleLevelObject(PYIDENT("inspect"), NULL, NULL, NULL, 0); +// if (unlikely(!inspect_module)) +// goto bad; +// signature_class = __Pyx_PyObject_GetAttrStr(inspect_module, PYIDENT("Signature")); +// Py_DECREF(inspect_module); +// if (unlikely(!signature_class)) +// goto bad; +// // return Signature.from_function(op) +// signature = PyObject_CallMethodObjArgs(signature_class, PYIDENT("from_function"), op, NULL); +// Py_DECREF(signature_class); +// if (likely(signature)) +// return signature; +//bad: +// // make sure we raise an AttributeError from this property on any errors +// if (!PyErr_ExceptionMatches(PyExc_AttributeError)) +// PyErr_SetString(PyExc_AttributeError, "failed to calculate __signature__"); +// return NULL; +//} + +static void __Pyx_CyFunction_raise_argument_count_error(__pyx_CyFunctionObject *func, const char* message, Py_ssize_t size) { +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *py_name = __Pyx_CyFunction_get_name(func, NULL); + if (!py_name) return; + PyErr_Format(PyExc_TypeError, + "%.200S() %s (%" CYTHON_FORMAT_SSIZE_T "d given)", + py_name, message, size); + Py_DECREF(py_name); +#else + const char* name = ((PyCFunctionObject*)func)->m_ml->ml_name; + PyErr_Format(PyExc_TypeError, + "%.200s() %s (%" CYTHON_FORMAT_SSIZE_T "d given)", + name, message, size); +#endif +} + +static void __Pyx_CyFunction_raise_type_error(__pyx_CyFunctionObject *func, const char* message) { +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *py_name = __Pyx_CyFunction_get_name(func, NULL); + if (!py_name) return; + PyErr_Format(PyExc_TypeError, + "%.200S() %s", + py_name, message); + Py_DECREF(py_name); +#else + const char* name = ((PyCFunctionObject*)func)->m_ml->ml_name; + PyErr_Format(PyExc_TypeError, + "%.200s() %s", + name, message); +#endif +} + + +#if CYTHON_COMPILING_IN_LIMITED_API +static PyObject * +__Pyx_CyFunction_get_module(__pyx_CyFunctionObject *op, void *context) { + CYTHON_UNUSED_VAR(context); + return PyObject_GetAttrString(op->func, "__module__"); +} + +static int +__Pyx_CyFunction_set_module(__pyx_CyFunctionObject *op, PyObject* value, void *context) { + CYTHON_UNUSED_VAR(context); + return PyObject_SetAttrString(op->func, "__module__", value); +} +#endif + +static PyGetSetDef __pyx_CyFunction_getsets[] = { + {"func_doc", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, + {"__doc__", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, + {"func_name", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, + {"__name__", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, + {"__qualname__", (getter)__Pyx_CyFunction_get_qualname, (setter)__Pyx_CyFunction_set_qualname, 0, 0}, + {"func_dict", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, + {"__dict__", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, + {"func_globals", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, + {"__globals__", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, + {"func_closure", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, + {"__closure__", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, + {"func_code", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, + {"__code__", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, + {"func_defaults", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, + {"__defaults__", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, + {"__kwdefaults__", (getter)__Pyx_CyFunction_get_kwdefaults, (setter)__Pyx_CyFunction_set_kwdefaults, 0, 0}, + {"__annotations__", (getter)__Pyx_CyFunction_get_annotations, (setter)__Pyx_CyFunction_set_annotations, 0, 0}, + {"_is_coroutine", (getter)__Pyx_CyFunction_get_is_coroutine, 0, 0, 0}, +// {"__signature__", (getter)__Pyx_CyFunction_get_signature, 0, 0, 0}, +#if CYTHON_COMPILING_IN_LIMITED_API + {"__module__", (getter)__Pyx_CyFunction_get_module, (setter)__Pyx_CyFunction_set_module, 0, 0}, +#endif + {0, 0, 0, 0, 0} +}; + +static PyMemberDef __pyx_CyFunction_members[] = { +#if !CYTHON_COMPILING_IN_LIMITED_API + {"__module__", T_OBJECT, offsetof(PyCFunctionObject, m_module), 0, 0}, +#endif + {"__dictoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_dict), READONLY, 0}, +#if CYTHON_METH_FASTCALL +#if CYTHON_BACKPORT_VECTORCALL || CYTHON_COMPILING_IN_LIMITED_API + {"__vectorcalloffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_vectorcall), READONLY, 0}, +#else + {"__vectorcalloffset__", T_PYSSIZET, offsetof(PyCFunctionObject, vectorcall), READONLY, 0}, +#endif +#if CYTHON_COMPILING_IN_LIMITED_API + {"__weaklistoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_weakreflist), READONLY, 0}, +#else + {"__weaklistoffset__", T_PYSSIZET, offsetof(PyCFunctionObject, m_weakreflist), READONLY, 0}, +#endif +#endif + {0, 0, 0, 0, 0} +}; + +static PyObject * +__Pyx_CyFunction_reduce(__pyx_CyFunctionObject *m, PyObject *args) +{ + PyObject *result = NULL; + CYTHON_UNUSED_VAR(args); + __Pyx_BEGIN_CRITICAL_SECTION(m); + Py_INCREF(m->func_qualname); + result = m->func_qualname; + __Pyx_END_CRITICAL_SECTION(); + return result; +} + +static PyMethodDef __pyx_CyFunction_methods[] = { + {"__reduce__", (PyCFunction)__Pyx_CyFunction_reduce, METH_VARARGS, 0}, + {0, 0, 0, 0} +}; + + +#if CYTHON_COMPILING_IN_LIMITED_API +#define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func_weakreflist) +#else +#define __Pyx_CyFunction_weakreflist(cyfunc) (((PyCFunctionObject*)cyfunc)->m_weakreflist) +#endif + +static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject *op, PyMethodDef *ml, int flags, PyObject* qualname, + PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) { +#if !CYTHON_COMPILING_IN_LIMITED_API + PyCFunctionObject *cf = (PyCFunctionObject*) op; +#endif + if (unlikely(op == NULL)) + return NULL; +#if CYTHON_COMPILING_IN_LIMITED_API + // Note that we end up with a circular reference to op. This isn't + // a disaster, but in an ideal world it'd be nice to avoid it. + op->func = PyCFunction_NewEx(ml, (PyObject*)op, module); + if (unlikely(!op->func)) return NULL; +#endif + op->flags = flags; + __Pyx_CyFunction_weakreflist(op) = NULL; +#if !CYTHON_COMPILING_IN_LIMITED_API + cf->m_ml = ml; + cf->m_self = (PyObject *) op; +#endif + Py_XINCREF(closure); + op->func_closure = closure; +#if !CYTHON_COMPILING_IN_LIMITED_API + Py_XINCREF(module); + cf->m_module = module; +#endif + op->func_dict = NULL; + op->func_name = NULL; + Py_INCREF(qualname); + op->func_qualname = qualname; + op->func_doc = NULL; +#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + op->func_classobj = NULL; +#else + ((PyCMethodObject*)op)->mm_class = NULL; +#endif + op->func_globals = globals; + Py_INCREF(op->func_globals); + Py_XINCREF(code); + op->func_code = code; + // Dynamic Default args + op->defaults = NULL; + op->defaults_tuple = NULL; + op->defaults_kwdict = NULL; + op->defaults_getter = NULL; + op->func_annotations = NULL; + op->func_is_coroutine = NULL; +#if CYTHON_METH_FASTCALL + switch (ml->ml_flags & (METH_VARARGS | METH_FASTCALL | METH_NOARGS | METH_O | METH_KEYWORDS | METH_METHOD)) { + case METH_NOARGS: + __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_NOARGS; + break; + case METH_O: + __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_O; + break; + // case METH_FASTCALL is not used + case METH_METHOD | METH_FASTCALL | METH_KEYWORDS: + __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD; + break; + case METH_FASTCALL | METH_KEYWORDS: + __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS; + break; + // case METH_VARARGS is not used + case METH_VARARGS | METH_KEYWORDS: + __Pyx_CyFunction_func_vectorcall(op) = NULL; + break; + default: + PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction"); + Py_DECREF(op); + return NULL; + } +#endif + return (PyObject *) op; +} + +static int +__Pyx_CyFunction_clear(__pyx_CyFunctionObject *m) +{ + Py_CLEAR(m->func_closure); +#if CYTHON_COMPILING_IN_LIMITED_API + Py_CLEAR(m->func); +#else + Py_CLEAR(((PyCFunctionObject*)m)->m_module); +#endif + Py_CLEAR(m->func_dict); + Py_CLEAR(m->func_name); + Py_CLEAR(m->func_qualname); + Py_CLEAR(m->func_doc); + Py_CLEAR(m->func_globals); + Py_CLEAR(m->func_code); +#if !CYTHON_COMPILING_IN_LIMITED_API +#if PY_VERSION_HEX < 0x030900B1 + Py_CLEAR(__Pyx_CyFunction_GetClassObj(m)); +#else + { + PyObject *cls = (PyObject*) ((PyCMethodObject *) (m))->mm_class; + ((PyCMethodObject *) (m))->mm_class = NULL; + Py_XDECREF(cls); + } +#endif +#endif + Py_CLEAR(m->defaults_tuple); + Py_CLEAR(m->defaults_kwdict); + Py_CLEAR(m->func_annotations); + Py_CLEAR(m->func_is_coroutine); + + Py_CLEAR(m->defaults); + + return 0; +} + +static void __Pyx__CyFunction_dealloc(__pyx_CyFunctionObject *m) +{ + if (__Pyx_CyFunction_weakreflist(m) != NULL) + PyObject_ClearWeakRefs((PyObject *) m); + __Pyx_CyFunction_clear(m); + __Pyx_PyHeapTypeObject_GC_Del(m); +} + +static void __Pyx_CyFunction_dealloc(__pyx_CyFunctionObject *m) +{ + PyObject_GC_UnTrack(m); + __Pyx__CyFunction_dealloc(m); +} + +static int __Pyx_CyFunction_traverse(__pyx_CyFunctionObject *m, visitproc visit, void *arg) +{ + { + int e = __Pyx_call_type_traverse((PyObject*)m, 1, visit, arg); + if (e) return e; + } + Py_VISIT(m->func_closure); +#if CYTHON_COMPILING_IN_LIMITED_API + Py_VISIT(m->func); +#else + Py_VISIT(((PyCFunctionObject*)m)->m_module); +#endif + Py_VISIT(m->func_dict); + __Pyx_VISIT_CONST(m->func_name); + __Pyx_VISIT_CONST(m->func_qualname); + Py_VISIT(m->func_doc); + Py_VISIT(m->func_globals); + // The code objects that we generate only contain plain constants and can never participate in reference cycles. + __Pyx_VISIT_CONST(m->func_code); +#if !CYTHON_COMPILING_IN_LIMITED_API + Py_VISIT(__Pyx_CyFunction_GetClassObj(m)); +#endif + Py_VISIT(m->defaults_tuple); + Py_VISIT(m->defaults_kwdict); + Py_VISIT(m->func_is_coroutine); + Py_VISIT(m->defaults); + + return 0; +} + +static PyObject* +__Pyx_CyFunction_repr(__pyx_CyFunctionObject *op) +{ + PyObject *repr; + __Pyx_BEGIN_CRITICAL_SECTION(op); + repr = PyUnicode_FromFormat("", + op->func_qualname, (void *)op); + __Pyx_END_CRITICAL_SECTION(); + return repr; +} + +static PyObject * __Pyx_CyFunction_CallMethod(PyObject *func, PyObject *self, PyObject *arg, PyObject *kw) { + // originally copied from PyCFunction_Call() in CPython's Objects/methodobject.c +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *f = ((__pyx_CyFunctionObject*)func)->func; + PyCFunction meth; + int flags; + meth = PyCFunction_GetFunction(f); + if (unlikely(!meth)) return NULL; + flags = PyCFunction_GetFlags(f); + if (unlikely(flags < 0)) return NULL; +#else + PyCFunctionObject* f = (PyCFunctionObject*)func; + PyCFunction meth = f->m_ml->ml_meth; + int flags = f->m_ml->ml_flags; +#endif + Py_ssize_t size; + + switch (flags & (METH_VARARGS | METH_KEYWORDS | METH_NOARGS | METH_O)) { + case METH_VARARGS: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) + return (*meth)(self, arg); + break; + case METH_VARARGS | METH_KEYWORDS: + return (*(PyCFunctionWithKeywords)(void(*)(void))meth)(self, arg, kw); + case METH_NOARGS: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) { +#if CYTHON_ASSUME_SAFE_SIZE + size = PyTuple_GET_SIZE(arg); +#else + size = PyTuple_Size(arg); + if (unlikely(size < 0)) return NULL; +#endif + if (likely(size == 0)) + return (*meth)(self, NULL); + __Pyx_CyFunction_raise_argument_count_error( + (__pyx_CyFunctionObject*)func, + "takes no arguments", size); + return NULL; + } + break; + case METH_O: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) { +#if CYTHON_ASSUME_SAFE_SIZE + size = PyTuple_GET_SIZE(arg); +#else + size = PyTuple_Size(arg); + if (unlikely(size < 0)) return NULL; +#endif + if (likely(size == 1)) { + PyObject *result, *arg0; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + arg0 = PyTuple_GET_ITEM(arg, 0); + #else + arg0 = __Pyx_PySequence_ITEM(arg, 0); if (unlikely(!arg0)) return NULL; + #endif + result = (*meth)(self, arg0); + #if !(CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS) + Py_DECREF(arg0); + #endif + return result; + } + __Pyx_CyFunction_raise_argument_count_error( + (__pyx_CyFunctionObject*)func, + "takes exactly one argument", size); + return NULL; + } + break; + default: + PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction"); + return NULL; + } + __Pyx_CyFunction_raise_type_error( + (__pyx_CyFunctionObject*)func, "takes no keyword arguments"); + return NULL; +} + +static CYTHON_INLINE PyObject *__Pyx_CyFunction_Call(PyObject *func, PyObject *arg, PyObject *kw) { + PyObject *self, *result; +#if CYTHON_COMPILING_IN_LIMITED_API + // PyCFunction_GetSelf returns a borrowed reference + self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)func)->func); + if (unlikely(!self) && PyErr_Occurred()) return NULL; +#else + self = ((PyCFunctionObject*)func)->m_self; +#endif + result = __Pyx_CyFunction_CallMethod(func, self, arg, kw); + return result; +} + +static PyObject *__Pyx_CyFunction_CallAsMethod(PyObject *func, PyObject *args, PyObject *kw) { + PyObject *result; + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *) func; + +#if CYTHON_METH_FASTCALL && (CYTHON_VECTORCALL || CYTHON_BACKPORT_VECTORCALL) + // Prefer vectorcall if available. This is not the typical case, as + // CPython would normally use vectorcall directly instead of tp_call. + __pyx_vectorcallfunc vc = __Pyx_CyFunction_func_vectorcall(cyfunc); + if (vc) { +#if CYTHON_ASSUME_SAFE_MACROS && CYTHON_ASSUME_SAFE_SIZE + return __Pyx_PyVectorcall_FastCallDict(func, vc, &PyTuple_GET_ITEM(args, 0), (size_t)PyTuple_GET_SIZE(args), kw); +#else + // avoid unused function warning + (void) &__Pyx_PyVectorcall_FastCallDict; + return PyVectorcall_Call(func, args, kw); +#endif + } +#endif + + if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) { + Py_ssize_t argc; + PyObject *new_args; + PyObject *self; + +#if CYTHON_ASSUME_SAFE_SIZE + argc = PyTuple_GET_SIZE(args); +#else + argc = PyTuple_Size(args); + if (unlikely(argc < 0)) return NULL; +#endif + new_args = PyTuple_GetSlice(args, 1, argc); + + if (unlikely(!new_args)) + return NULL; + + self = PyTuple_GetItem(args, 0); + if (unlikely(!self)) { + Py_DECREF(new_args); + PyErr_Format(PyExc_TypeError, + "unbound method %.200S() needs an argument", + cyfunc->func_qualname); + return NULL; + } + + result = __Pyx_CyFunction_CallMethod(func, self, new_args, kw); + Py_DECREF(new_args); + } else { + result = __Pyx_CyFunction_Call(func, args, kw); + } + return result; +} + +#if CYTHON_METH_FASTCALL && (CYTHON_VECTORCALL || CYTHON_BACKPORT_VECTORCALL) +// Check that kwnames is empty (if you want to allow keyword arguments, +// simply pass kwnames=NULL) and figure out what to do with "self". +// Return value: +// 1: self = args[0] +// 0: self = cyfunc->func.m_self +// -1: error +static CYTHON_INLINE int __Pyx_CyFunction_Vectorcall_CheckArgs(__pyx_CyFunctionObject *cyfunc, Py_ssize_t nargs, PyObject *kwnames) +{ + int ret = 0; + if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) { + if (unlikely(nargs < 1)) { + __Pyx_CyFunction_raise_type_error( + cyfunc, "needs an argument"); + return -1; + } + ret = 1; + } + if (unlikely(kwnames) && unlikely(__Pyx_PyTuple_GET_SIZE(kwnames))) { + __Pyx_CyFunction_raise_type_error( + cyfunc, "takes no keyword arguments"); + return -1; + } + return ret; +} + +static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) +{ + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; +#if CYTHON_BACKPORT_VECTORCALL + Py_ssize_t nargs = (Py_ssize_t)nargsf; +#else + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); +#endif + PyObject *self; +#if CYTHON_COMPILING_IN_LIMITED_API + PyCFunction meth = PyCFunction_GetFunction(cyfunc->func); + if (unlikely(!meth)) return NULL; +#else + PyCFunction meth = ((PyCFunctionObject*)cyfunc)->m_ml->ml_meth; +#endif + + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: +#if CYTHON_COMPILING_IN_LIMITED_API + // PyCFunction_GetSelf returns a borrowed reference + self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)cyfunc)->func); + if (unlikely(!self) && PyErr_Occurred()) return NULL; +#else + self = ((PyCFunctionObject*)cyfunc)->m_self; +#endif + break; + default: + return NULL; + } + + if (unlikely(nargs != 0)) { + __Pyx_CyFunction_raise_argument_count_error( + cyfunc, "takes no arguments", nargs); + return NULL; + } + return meth(self, NULL); +} + +static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) +{ + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; +#if CYTHON_BACKPORT_VECTORCALL + Py_ssize_t nargs = (Py_ssize_t)nargsf; +#else + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); +#endif + PyObject *self; +#if CYTHON_COMPILING_IN_LIMITED_API + PyCFunction meth = PyCFunction_GetFunction(cyfunc->func); + if (unlikely(!meth)) return NULL; +#else + PyCFunction meth = ((PyCFunctionObject*)cyfunc)->m_ml->ml_meth; +#endif + + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: +#if CYTHON_COMPILING_IN_LIMITED_API + // PyCFunction_GetSelf returns a borrowed reference + self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)cyfunc)->func); + if (unlikely(!self) && PyErr_Occurred()) return NULL; +#else + self = ((PyCFunctionObject*)cyfunc)->m_self; +#endif + break; + default: + return NULL; + } + + if (unlikely(nargs != 1)) { + __Pyx_CyFunction_raise_argument_count_error( + cyfunc, "takes exactly one argument", nargs); + return NULL; + } + return meth(self, args[0]); +} + +static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) +{ + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; +#if CYTHON_BACKPORT_VECTORCALL + Py_ssize_t nargs = (Py_ssize_t)nargsf; +#else + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); +#endif + PyObject *self; +#if CYTHON_COMPILING_IN_LIMITED_API + PyCFunction meth = PyCFunction_GetFunction(cyfunc->func); + if (unlikely(!meth)) return NULL; +#else + PyCFunction meth = ((PyCFunctionObject*)cyfunc)->m_ml->ml_meth; +#endif + + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: +#if CYTHON_COMPILING_IN_LIMITED_API + // PyCFunction_GetSelf returns a borrowed reference + self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)cyfunc)->func); + if (unlikely(!self) && PyErr_Occurred()) return NULL; +#else + self = ((PyCFunctionObject*)cyfunc)->m_self; +#endif + break; + default: + return NULL; + } + + return ((__Pyx_PyCFunctionFastWithKeywords)(void(*)(void))meth)(self, args, nargs, kwnames); +} + +static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) +{ + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; + PyTypeObject *cls = (PyTypeObject *) __Pyx_CyFunction_GetClassObj(cyfunc); +#if CYTHON_BACKPORT_VECTORCALL + Py_ssize_t nargs = (Py_ssize_t)nargsf; +#else + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); +#endif + PyObject *self; +#if CYTHON_COMPILING_IN_LIMITED_API + PyCFunction meth = PyCFunction_GetFunction(cyfunc->func); + if (unlikely(!meth)) return NULL; +#else + PyCFunction meth = ((PyCFunctionObject*)cyfunc)->m_ml->ml_meth; +#endif + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: +#if CYTHON_COMPILING_IN_LIMITED_API + // PyCFunction_GetSelf returns a borrowed reference + self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)cyfunc)->func); + if (unlikely(!self) && PyErr_Occurred()) return NULL; +#else + self = ((PyCFunctionObject*)cyfunc)->m_self; +#endif + break; + default: + return NULL; + } + + return ((__Pyx_PyCMethod)(void(*)(void))meth)(self, cls, args, (size_t)nargs, kwnames); +} +#endif + +static PyType_Slot __pyx_CyFunctionType_slots[] = { + {Py_tp_dealloc, (void *)__Pyx_CyFunction_dealloc}, + {Py_tp_repr, (void *)__Pyx_CyFunction_repr}, + {Py_tp_call, (void *)__Pyx_CyFunction_CallAsMethod}, + {Py_tp_traverse, (void *)__Pyx_CyFunction_traverse}, + {Py_tp_clear, (void *)__Pyx_CyFunction_clear}, + {Py_tp_methods, (void *)__pyx_CyFunction_methods}, + {Py_tp_members, (void *)__pyx_CyFunction_members}, + {Py_tp_getset, (void *)__pyx_CyFunction_getsets}, + {Py_tp_descr_get, (void *)__Pyx_PyMethod_New}, + {0, 0}, +}; + +static PyType_Spec __pyx_CyFunctionType_spec = { + __PYX_TYPE_MODULE_PREFIX "cython_function_or_method", + sizeof(__pyx_CyFunctionObject), + 0, +#ifdef Py_TPFLAGS_METHOD_DESCRIPTOR + Py_TPFLAGS_METHOD_DESCRIPTOR | +#endif +#if CYTHON_METH_FASTCALL +#if defined(Py_TPFLAGS_HAVE_VECTORCALL) + Py_TPFLAGS_HAVE_VECTORCALL | +#elif defined(_Py_TPFLAGS_HAVE_VECTORCALL) + _Py_TPFLAGS_HAVE_VECTORCALL | +#endif +#endif // CYTHON_METH_FASTCALL +#if PY_VERSION_HEX >= 0x030A0000 + Py_TPFLAGS_IMMUTABLETYPE | +#endif + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE, /*tp_flags*/ + __pyx_CyFunctionType_slots +}; + +static int __pyx_CyFunction_init(PyObject *module) { + $modulestatetype_cname *mstate = __Pyx_PyModule_GetState(module); + mstate->__pyx_CyFunctionType = __Pyx_FetchCommonTypeFromSpec( + mstate->__pyx_CommonTypesMetaclassType, module, &__pyx_CyFunctionType_spec, NULL); + if (unlikely(mstate->__pyx_CyFunctionType == NULL)) { + return -1; + } + return 0; +} + +static CYTHON_INLINE PyObject *__Pyx_CyFunction_InitDefaults(PyObject *func, PyTypeObject *defaults_type) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + + m->defaults = PyObject_CallObject((PyObject*)defaults_type, NULL); // _PyObject_New(defaults_type); + if (unlikely(!m->defaults)) + return NULL; + return m->defaults; +} + +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *func, PyObject *tuple) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->defaults_tuple = tuple; + Py_INCREF(tuple); +} + +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *func, PyObject *dict) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->defaults_kwdict = dict; + Py_INCREF(dict); +} + +static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *func, PyObject *dict) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->func_annotations = dict; + Py_INCREF(dict); +} + + +//////////////////// CythonFunction.proto //////////////////// + +static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, + int flags, PyObject* qualname, + PyObject *closure, + PyObject *module, PyObject *globals, + PyObject* code); + +//////////////////// CythonFunction //////////////////// +//@requires: CythonFunctionShared + +static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, int flags, PyObject* qualname, + PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) { + PyObject *op = __Pyx_CyFunction_Init( + PyObject_GC_New(__pyx_CyFunctionObject, CGLOBAL(__pyx_CyFunctionType)), + ml, flags, qualname, closure, module, globals, code + ); + if (likely(op)) { + PyObject_GC_Track(op); + } + return op; +} + +//////////////////// CyFunctionClassCell.proto //////////////////// +static int __Pyx_CyFunction_InitClassCell(PyObject *cyfunctions, PyObject *classobj);/*proto*/ + +//////////////////// CyFunctionClassCell //////////////////// +//@requires: CythonFunctionShared + +static int __Pyx_CyFunction_InitClassCell(PyObject *cyfunctions, PyObject *classobj) { + Py_ssize_t i, count = __Pyx_PyList_GET_SIZE(cyfunctions); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(count < 0)) return -1; + #endif + + for (i = 0; i < count; i++) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS && !CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS + PyList_GET_ITEM(cyfunctions, i); +#else + __Pyx_PySequence_ITEM(cyfunctions, i); + if (unlikely(!m)) + return -1; +#endif + __Pyx_CyFunction_SetClassObj(m, classobj); +#if !(CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS && !CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS) + Py_DECREF((PyObject*)m); +#endif + } + return 0; +} + + +//////////////////// FusedFunction.proto //////////////////// + +typedef struct { + __pyx_CyFunctionObject func; + PyObject *__signatures__; + PyObject *self; +#if CYTHON_COMPILING_IN_LIMITED_API + PyMethodDef *ml; +#endif +} __pyx_FusedFunctionObject; + +static PyObject *__pyx_FusedFunction_New(PyMethodDef *ml, int flags, + PyObject *qualname, PyObject *closure, + PyObject *module, PyObject *globals, + PyObject *code); + +static int __pyx_FusedFunction_clear(__pyx_FusedFunctionObject *self); +static int __pyx_FusedFunction_init(PyObject *module); + +#define __Pyx_FusedFunction_USED + +//////////////////// FusedFunction //////////////////// +//@requires: CythonFunctionShared +//@substitute: naming + +static PyObject * +__pyx_FusedFunction_New(PyMethodDef *ml, int flags, + PyObject *qualname, PyObject *closure, + PyObject *module, PyObject *globals, + PyObject *code) +{ + PyObject *op = __Pyx_CyFunction_Init( + // __pyx_CyFunctionObject is correct below since that's the cast that we want. + PyObject_GC_New(__pyx_CyFunctionObject, CGLOBAL(__pyx_FusedFunctionType)), + ml, flags, qualname, closure, module, globals, code + ); + if (likely(op)) { + __pyx_FusedFunctionObject *fusedfunc = (__pyx_FusedFunctionObject *) op; + fusedfunc->__signatures__ = NULL; + fusedfunc->self = NULL; + #if CYTHON_COMPILING_IN_LIMITED_API + fusedfunc->ml = ml; + #endif + PyObject_GC_Track(op); + } + return op; +} + +static void +__pyx_FusedFunction_dealloc(__pyx_FusedFunctionObject *self) +{ + PyObject_GC_UnTrack(self); + Py_CLEAR(self->self); + Py_CLEAR(self->__signatures__); + __Pyx__CyFunction_dealloc((__pyx_CyFunctionObject *) self); +} + +static int +__pyx_FusedFunction_traverse(__pyx_FusedFunctionObject *self, + visitproc visit, + void *arg) +{ + // Visiting the type is handled in the CyFunction traverse if needed + Py_VISIT(self->self); + Py_VISIT(self->__signatures__); + return __Pyx_CyFunction_traverse((__pyx_CyFunctionObject *) self, visit, arg); +} + +static int +__pyx_FusedFunction_clear(__pyx_FusedFunctionObject *self) +{ + Py_CLEAR(self->self); + Py_CLEAR(self->__signatures__); + return __Pyx_CyFunction_clear((__pyx_CyFunctionObject *) self); +} + + +static __pyx_FusedFunctionObject * +__pyx_FusedFunction_descr_get_locked(__pyx_FusedFunctionObject *func, PyObject *obj) +{ + PyObject *module; + __pyx_FusedFunctionObject *meth; + #if CYTHON_COMPILING_IN_LIMITED_API + module = __Pyx_CyFunction_get_module((__pyx_CyFunctionObject *) func, NULL); + if ((unlikely(!module))) return NULL; + #else + module = ((PyCFunctionObject *) func)->m_module; + #endif + + meth = (__pyx_FusedFunctionObject *) __pyx_FusedFunction_New( + #if CYTHON_COMPILING_IN_LIMITED_API + func->ml, + #else + ((PyCFunctionObject *) func)->m_ml, + #endif + ((__pyx_CyFunctionObject *) func)->flags, + ((__pyx_CyFunctionObject *) func)->func_qualname, + ((__pyx_CyFunctionObject *) func)->func_closure, + module, + ((__pyx_CyFunctionObject *) func)->func_globals, + ((__pyx_CyFunctionObject *) func)->func_code); + #if CYTHON_COMPILING_IN_LIMITED_API + Py_DECREF(module); + #endif + if (unlikely(!meth)) + return NULL; + + Py_XINCREF(func->func.defaults); + meth->func.defaults = func->func.defaults; + + __Pyx_CyFunction_SetClassObj(meth, __Pyx_CyFunction_GetClassObj(func)); + + Py_XINCREF(func->__signatures__); + meth->__signatures__ = func->__signatures__; + + Py_XINCREF(func->func.defaults_tuple); + meth->func.defaults_tuple = func->func.defaults_tuple; + + Py_XINCREF(obj); + meth->self = obj; + return meth; +} + +static PyObject * +__pyx_FusedFunction_descr_get(PyObject *self, PyObject *obj, PyObject *type) +{ + __pyx_FusedFunctionObject *func, *meth; + + func = (__pyx_FusedFunctionObject *) self; + + if (func->self || func->func.flags & __Pyx_CYFUNCTION_STATICMETHOD) { + // Do not allow rebinding and don't do anything for static methods + Py_INCREF(self); + return self; + } + + if (obj == Py_None) + obj = NULL; + + if (func->func.flags & __Pyx_CYFUNCTION_CLASSMETHOD) + obj = type; + + if (obj == NULL) { + // We aren't actually binding to anything, save the effort of rebinding + Py_INCREF(self); + return self; + } + + __Pyx_BEGIN_CRITICAL_SECTION(func); + meth = __pyx_FusedFunction_descr_get_locked(func, obj); + __Pyx_END_CRITICAL_SECTION() + + return (PyObject *) meth; +} + +static PyObject * +_obj_to_string(PyObject *obj) +{ + if (PyUnicode_CheckExact(obj)) + return __Pyx_NewRef(obj); + else if (PyType_Check(obj)) + return PyObject_GetAttr(obj, PYIDENT("__name__")); + else + return PyObject_Str(obj); +} + +static PyObject * +__pyx_FusedFunction_getitem(__pyx_FusedFunctionObject *self, PyObject *idx) +{ + PyObject *signature = NULL; + PyObject *unbound_result_func; + PyObject *result_func = NULL; + + if (unlikely(self->__signatures__ == NULL)) { + PyErr_SetString(PyExc_TypeError, "Function is not fused"); + return NULL; + } + + if (PyTuple_Check(idx)) { + Py_ssize_t n = __Pyx_PyTuple_GET_SIZE(idx); + PyObject *list; + int i; + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(n < 0)) return NULL; + #endif + + list = PyList_New(n); + if (unlikely(!list)) + return NULL; + + for (i = 0; i < n; i++) { + PyObject *string; +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + PyObject *item = PyTuple_GET_ITEM(idx, i); +#else + PyObject *item = __Pyx_PySequence_ITEM(idx, i); if (unlikely(!item)) goto __pyx_err; +#endif + string = _obj_to_string(item); +#if !(CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS) + Py_DECREF(item); +#endif + if (unlikely(!string)) goto __pyx_err; + if (__Pyx_PyList_SET_ITEM(list, i, string) < (0)) goto __pyx_err; + } + + signature = PyUnicode_Join(PYUNICODE("|"), list); +__pyx_err:; + Py_DECREF(list); + } else { + signature = _obj_to_string(idx); + } + + if (unlikely(!signature)) + return NULL; + + unbound_result_func = PyObject_GetItem(self->__signatures__, signature); + + if (likely(unbound_result_func)) { + if (self->self) { + __pyx_FusedFunctionObject *unbound = (__pyx_FusedFunctionObject *) unbound_result_func; + + // TODO: move this to InitClassCell + __Pyx_CyFunction_SetClassObj(unbound, __Pyx_CyFunction_GetClassObj(self)); + + result_func = __pyx_FusedFunction_descr_get(unbound_result_func, + self->self, self->self); + } else { + result_func = unbound_result_func; + Py_INCREF(result_func); + } + } + + Py_DECREF(signature); + Py_XDECREF(unbound_result_func); + + return result_func; +} + +static PyObject * +__pyx_FusedFunction_callfunction(PyObject *func, PyObject *args, PyObject *kw) +{ + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *) func; + int static_specialized = (cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD && + !((__pyx_FusedFunctionObject *) func)->__signatures__); + + if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !static_specialized) { + return __Pyx_CyFunction_CallAsMethod(func, args, kw); + } else { + return __Pyx_CyFunction_Call(func, args, kw); + } +} + +// Note: the 'self' from method binding is passed in in the args tuple, +// whereas PyCFunctionObject's m_self is passed in as the first +// argument to the C function. For extension methods we need +// to pass 'self' as 'm_self' and not as the first element of the +// args tuple. + +static PyObject * +__pyx_FusedFunction_call(PyObject *func, PyObject *args, PyObject *kw) +{ + __pyx_FusedFunctionObject *binding_func = (__pyx_FusedFunctionObject *) func; + Py_ssize_t argc = __Pyx_PyTuple_GET_SIZE(args); + PyObject *new_args = NULL; + __pyx_FusedFunctionObject *new_func = NULL; + PyObject *result = NULL; + int is_staticmethod = binding_func->func.flags & __Pyx_CYFUNCTION_STATICMETHOD; + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(argc < 0)) return NULL; + #endif + + if (binding_func->self) { + // Bound method call, put 'self' in the args tuple + PyObject *self; + Py_ssize_t i; + new_args = PyTuple_New(argc + 1); + if (unlikely(!new_args)) + return NULL; + + self = binding_func->self; + + Py_INCREF(self); + if (__Pyx_PyTuple_SET_ITEM(new_args, 0, self) < (0)) goto bad; + self = NULL; + + for (i = 0; i < argc; i++) { +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + PyObject *item = PyTuple_GET_ITEM(args, i); + Py_INCREF(item); +#else + PyObject *item = __Pyx_PySequence_ITEM(args, i); if (unlikely(!item)) goto bad; +#endif + if (__Pyx_PyTuple_SET_ITEM(new_args, i + 1, item) < (0)) goto bad; + } + + args = new_args; + } + + if (binding_func->__signatures__) { + PyObject *tup; + if (is_staticmethod && binding_func->func.flags & __Pyx_CYFUNCTION_CCLASS) { + // FIXME: this seems wrong, but we must currently pass the signatures dict as 'self' argument + tup = PyTuple_Pack(3, args, + kw == NULL ? Py_None : kw, + binding_func->func.defaults_tuple); + if (unlikely(!tup)) goto bad; + new_func = (__pyx_FusedFunctionObject *) __Pyx_CyFunction_CallMethod( + func, binding_func->__signatures__, tup, NULL); + } else { + tup = PyTuple_Pack(4, binding_func->__signatures__, args, + kw == NULL ? Py_None : kw, + binding_func->func.defaults_tuple); + if (unlikely(!tup)) goto bad; + new_func = (__pyx_FusedFunctionObject *) __pyx_FusedFunction_callfunction(func, tup, NULL); + } + Py_DECREF(tup); + + if (unlikely(!new_func)) + goto bad; + + __Pyx_CyFunction_SetClassObj(new_func, __Pyx_CyFunction_GetClassObj(binding_func)); + + func = (PyObject *) new_func; + } + + result = __pyx_FusedFunction_callfunction(func, args, kw); +bad: + Py_XDECREF(new_args); + Py_XDECREF((PyObject *) new_func); + return result; +} + +static PyMemberDef __pyx_FusedFunction_members[] = { + {"__signatures__", + T_OBJECT, + offsetof(__pyx_FusedFunctionObject, __signatures__), + READONLY, + 0}, + {"__self__", T_OBJECT_EX, offsetof(__pyx_FusedFunctionObject, self), READONLY, 0}, + // For heap-types __module__ appears not to be inherited (so redeclare) + #if !CYTHON_COMPILING_IN_LIMITED_API + {"__module__", T_OBJECT, offsetof(PyCFunctionObject, m_module), 0, 0}, + #endif + {0, 0, 0, 0, 0}, +}; + +static PyGetSetDef __pyx_FusedFunction_getsets[] = { + // __doc__ is None for the fused function type, but we need it to be + // a descriptor for the instance's __doc__, so rebuild the descriptor in our subclass + // (all other descriptors are inherited) + {"__doc__", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, + // For heap-types __module__ appears not to be inherited (so redeclare) + #if CYTHON_COMPILING_IN_LIMITED_API + {"__module__", (getter)__Pyx_CyFunction_get_module, (setter)__Pyx_CyFunction_set_module, 0, 0}, + #endif + {0, 0, 0, 0, 0} +}; + +static PyType_Slot __pyx_FusedFunctionType_slots[] = { + {Py_tp_dealloc, (void *)__pyx_FusedFunction_dealloc}, + {Py_tp_call, (void *)__pyx_FusedFunction_call}, + {Py_tp_traverse, (void *)__pyx_FusedFunction_traverse}, + {Py_tp_clear, (void *)__pyx_FusedFunction_clear}, + {Py_tp_members, (void *)__pyx_FusedFunction_members}, + {Py_tp_getset, (void *)__pyx_FusedFunction_getsets}, + {Py_tp_descr_get, (void *)__pyx_FusedFunction_descr_get}, + {Py_mp_subscript, (void *)__pyx_FusedFunction_getitem}, + {0, 0}, +}; + +static PyType_Spec __pyx_FusedFunctionType_spec = { + __PYX_TYPE_MODULE_PREFIX "fused_cython_function", + sizeof(__pyx_FusedFunctionObject), + 0, +#if PY_VERSION_HEX >= 0x030A0000 + Py_TPFLAGS_IMMUTABLETYPE | +#endif + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + __pyx_FusedFunctionType_slots +}; + +static int __pyx_FusedFunction_init(PyObject *module) { + $modulestatetype_cname *mstate = __Pyx_PyModule_GetState(module); + PyObject *bases = PyTuple_Pack(1, mstate->__pyx_CyFunctionType); + if (unlikely(!bases)) { + return -1; + } + mstate->__pyx_FusedFunctionType = __Pyx_FetchCommonTypeFromSpec( + mstate->__pyx_CommonTypesMetaclassType, module, &__pyx_FusedFunctionType_spec, bases); + Py_DECREF(bases); + if (unlikely(mstate->__pyx_FusedFunctionType == NULL)) { + return -1; + } + return 0; +} + +//////////////////// ClassMethod.proto //////////////////// + +#if !CYTHON_COMPILING_IN_LIMITED_API +#include "descrobject.h" +#endif +CYTHON_UNUSED static PyObject* __Pyx_Method_ClassMethod(PyObject *method); /*proto*/ + +//////////////////// ClassMethod //////////////////// +//@requires: ObjectHandling.c::CachedMethodType + +static PyObject* __Pyx_Method_ClassMethod(PyObject *method) { +#if CYTHON_COMPILING_IN_PYPY && PYPY_VERSION_NUM <= 0x05080000 + if (PyObject_TypeCheck(method, &PyWrapperDescr_Type)) { + // cdef classes + return PyClassMethod_New(method); + } +#else +#if CYTHON_COMPILING_IN_PYPY + // special C-API function only in PyPy >= 5.9 + if (PyMethodDescr_Check(method)) +#else + if (__Pyx_TypeCheck(method, &PyMethodDescr_Type)) +#endif + { +#if CYTHON_COMPILING_IN_LIMITED_API + return PyErr_Format( + PyExc_SystemError, + "Cython cannot yet handle classmethod on a MethodDescriptorType (%S) in limited API mode. " + "This is most likely a classmethod in a cdef class method with binding=False. " + "Try setting 'binding' to True.", + method); +#elif CYTHON_COMPILING_IN_GRAAL + // cdef classes + PyTypeObject *d_type = PyDescrObject_GetType(method); + return PyDescr_NewClassMethod(d_type, PyMethodDescrObject_GetMethod(method)); +#else + // cdef classes + PyMethodDescrObject *descr = (PyMethodDescrObject *)method; + PyTypeObject *d_type = descr->d_common.d_type; + return PyDescr_NewClassMethod(d_type, descr->d_method); +#endif + } +#endif +#if !CYTHON_COMPILING_IN_LIMITED_API + else if (PyMethod_Check(method)) { + // python classes + return PyClassMethod_New(PyMethod_GET_FUNCTION(method)); + } + else { + return PyClassMethod_New(method); + } +#else + { + PyObject *func=NULL; + PyObject *builtins, *classmethod, *classmethod_str, *result=NULL; + if (__Pyx_TypeCheck(method, CGLOBAL(__Pyx_CachedMethodType))) { + func = PyObject_GetAttrString(method, "__func__"); + if (!func) goto bad; + } else { + func = method; + Py_INCREF(func); + } + builtins = PyEval_GetBuiltins(); // borrowed + if (unlikely(!builtins)) goto bad; + classmethod_str = PyUnicode_FromString("classmethod"); + if (unlikely(!classmethod_str)) goto bad; + classmethod = PyObject_GetItem(builtins, classmethod_str); + Py_DECREF(classmethod_str); + if (unlikely(!classmethod)) goto bad; + result = PyObject_CallFunctionObjArgs(classmethod, func, NULL); + Py_DECREF(classmethod); + + bad: + Py_XDECREF(func); + return result; + } +#endif + +} diff --git a/venv/lib/python3.10/site-packages/Cython/Utility/Dataclasses.c b/venv/lib/python3.10/site-packages/Cython/Utility/Dataclasses.c new file mode 100644 index 0000000000000000000000000000000000000000..ab6c01fb865932c5214c7347fcebbd41cab9b0e9 --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Utility/Dataclasses.c @@ -0,0 +1,185 @@ +///////////////////// ModuleLoader.proto ////////////////////////// + +static PyObject* __Pyx_LoadInternalModule(const char* name, const char* fallback_code); /* proto */ + +//////////////////// ModuleLoader /////////////////////// +//@requires: CommonStructures.c::FetchSharedCythonModule + +static PyObject* __Pyx_LoadInternalModule(const char* name, const char* fallback_code) { + // We want to be able to use the contents of the standard library dataclasses module where available. + // If those objects aren't available (due to Python version) then a simple fallback is substituted + // instead, which largely just fails with a not-implemented error. + // + // The fallbacks are placed in the "shared abi module" as a convenient internal place to + // store them + + PyObject *shared_abi_module = 0, *module = 0; +#if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 + PyObject *result; +#endif + + shared_abi_module = __Pyx_FetchSharedCythonABIModule(); + if (!shared_abi_module) return NULL; + +#if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 + if (PyObject_GetOptionalAttrString(shared_abi_module, name, &result) != 0) { + Py_DECREF(shared_abi_module); + return result; + } +#else + if (PyObject_HasAttrString(shared_abi_module, name)) { + PyObject* result = PyObject_GetAttrString(shared_abi_module, name); + Py_DECREF(shared_abi_module); + return result; + } +#endif + + // the best and simplest case is simply to defer to the standard library (if available) + module = PyImport_ImportModule(name); + if (!module) { + PyObject *localDict, *runValue, *builtins, *modulename; + if (!PyErr_ExceptionMatches(PyExc_ImportError)) goto bad; + PyErr_Clear(); /* this is reasonably likely (especially on older versions of Python) */ + modulename = PyUnicode_FromFormat("_cython_" CYTHON_ABI ".%s", name); + if (!modulename) goto bad; +#if CYTHON_COMPILING_IN_CPYTHON + module = PyImport_AddModuleObject(modulename); /* borrowed */ +#else + module = PyImport_AddModule(PyBytes_AsString(modulename)); /* borrowed */ +#endif + Py_DECREF(modulename); + if (!module) goto bad; + Py_INCREF(module); + if (PyObject_SetAttrString(shared_abi_module, name, module) < 0) goto bad; + localDict = PyModule_GetDict(module); /* borrowed */ + if (!localDict) goto bad; + builtins = PyEval_GetBuiltins(); /* borrowed */ + if (!builtins) goto bad; + if (PyDict_SetItemString(localDict, "__builtins__", builtins) <0) goto bad; + +#if CYTHON_COMPILING_IN_LIMITED_API + { + PyObject *compiled = Py_CompileString(fallback_code, "", Py_file_input); + if (!compiled) goto bad; + runValue = PyEval_EvalCode(compiled, localDict, localDict); + Py_DECREF(compiled); + } +#else + runValue = PyRun_String(fallback_code, Py_file_input, localDict, localDict); +#endif + if (!runValue) goto bad; + Py_DECREF(runValue); + } + goto shared_cleanup; + + bad: + Py_CLEAR(module); + shared_cleanup: + Py_XDECREF(shared_abi_module); + return module; +} + +///////////////////// SpecificModuleLoader.proto ////////////////////// +//@substitute: tempita + +static PyObject* __Pyx_Load_{{cname}}_Module(void); /* proto */ + + +//////////////////// SpecificModuleLoader /////////////////////// +//@requires: ModuleLoader + +static PyObject* __Pyx_Load_{{cname}}_Module(void) { + return __Pyx_LoadInternalModule("{{cname}}", {{py_code}}); +} + +//////////////////// DataclassesCallHelper.proto //////////////////////// + +static PyObject* __Pyx_DataclassesCallHelper(PyObject *callable, PyObject *kwds); /* proto */ + +//////////////////// DataclassesCallHelper //////////////////////// + +// The signature of a few of the dataclasses module functions has +// been expanded over the years. Cython always passes the full set +// of arguments from the most recent version we know of, so needs +// to remove any arguments that don't exist on earlier versions. + +static int __Pyx_DataclassesCallHelper_FilterToDict(PyObject *callable, PyObject *kwds, PyObject *new_kwds, PyObject *args_list, int is_kwonly) { + Py_ssize_t size, i; + size = PySequence_Size(args_list); + if (unlikely(size < 0)) return -1; + + for (i=0; i' +_HAS_DEFAULT_FACTORY = _HAS_DEFAULT_FACTORY_CLASS() + +def dataclass(*args, **kwds): + raise NotImplementedError("Standard library 'dataclasses' module" + "is unavailable, likely due to the version of Python you're using.") + +# Markers for the various kinds of fields and pseudo-fields. +class _FIELD_BASE: + def __init__(self, name): + self.name = name + def __repr__(self): + return self.name +_FIELD = _FIELD_BASE('_FIELD') +_FIELD_CLASSVAR = _FIELD_BASE('_FIELD_CLASSVAR') +_FIELD_INITVAR = _FIELD_BASE('_FIELD_INITVAR') + +def field(*ignore, **kwds): + default = kwds.pop("default", MISSING) + default_factory = kwds.pop("default_factory", MISSING) + init = kwds.pop("init", True) + repr = kwds.pop("repr", True) + hash = kwds.pop("hash", None) + compare = kwds.pop("compare", True) + metadata = kwds.pop("metadata", None) + kw_only = kwds.pop("kw_only", None) + + if kwds: + raise ValueError("field received unexpected keyword arguments: %s" + % list(kwds.keys())) + if default is not MISSING and default_factory is not MISSING: + raise ValueError('cannot specify both default and default_factory') + if ignore: + raise ValueError("'field' does not take any positional arguments") + return Field(default, default_factory, init, + repr, hash, compare, metadata, kw_only) diff --git a/venv/lib/python3.10/site-packages/Cython/Utility/Embed.c b/venv/lib/python3.10/site-packages/Cython/Utility/Embed.c new file mode 100644 index 0000000000000000000000000000000000000000..5c27239dcb93beee18d06799d325fb4765be7058 --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Utility/Embed.c @@ -0,0 +1,125 @@ +//////////////////// MainFunction //////////////////// + +#ifdef __FreeBSD__ +#include +#endif + +#if defined(_WIN32) || defined(WIN32) || defined(MS_WINDOWS) +int %(wmain_method)s(int argc, wchar_t **argv) +#else +static int __Pyx_main(int argc, wchar_t **argv) +#endif +{ + /* 754 requires that FP exceptions run in "no stop" mode by default, + * and until C vendors implement C99's ways to control FP exceptions, + * Python requires non-stop mode. Alas, some platforms enable FP + * exceptions by default. Here we disable them. + */ +#ifdef __FreeBSD__ + fp_except_t m; + + m = fpgetmask(); + fpsetmask(m & ~FP_X_OFL); +#endif +#if PY_VERSION_HEX < 0x03080000 + if (argc && argv) + Py_SetProgramName(argv[0]); +#endif + + if (PyImport_AppendInittab("%(module_name)s", PyInit_%(module_name)s) < 0) return 1; + +#if PY_VERSION_HEX < 0x03080000 + Py_Initialize(); + if (argc && argv) + PySys_SetArgv(argc, argv); +#else + { + PyStatus status; + + PyConfig config; + PyConfig_InitPythonConfig(&config); + // Disable parsing command line arguments + config.parse_argv = 0; + + if (argc && argv) { + status = PyConfig_SetString(&config, &config.program_name, argv[0]); + if (PyStatus_Exception(status)) { + PyConfig_Clear(&config); + return 1; + } + + status = PyConfig_SetArgv(&config, argc, argv); + if (PyStatus_Exception(status)) { + PyConfig_Clear(&config); + return 1; + } + } + + status = Py_InitializeFromConfig(&config); + if (PyStatus_Exception(status)) { + PyConfig_Clear(&config); + return 1; + } + + PyConfig_Clear(&config); + } +#endif + + { /* init module '%(module_name)s' as '__main__' */ + PyObject* m = NULL; + %(module_is_main)s = 1; + m = PyImport_ImportModule("%(module_name)s"); + + if (!m && PyErr_Occurred()) { + PyErr_Print(); /* This exits with the right code if SystemExit. */ + return 1; + } + Py_XDECREF(m); + } + if (Py_FinalizeEx() < 0) + return 2; + return 0; +} + + +#if !defined(_WIN32) && !defined(WIN32) && !defined(MS_WINDOWS) +#include + +int +%(main_method)s(int argc, char **argv) +{ + if (!argc) { + return __Pyx_main(0, NULL); + } + else { + int i, res; + wchar_t **argv_copy = (wchar_t **)malloc(sizeof(wchar_t*)*argc); + /* We need a second copy, as Python might modify the first one. */ + wchar_t **argv_copy2 = (wchar_t **)malloc(sizeof(wchar_t*)*argc); + char *oldloc = strdup(setlocale(LC_ALL, NULL)); + if (!argv_copy || !argv_copy2 || !oldloc) { + fprintf(stderr, "out of memory\\n"); + free(argv_copy); + free(argv_copy2); + free(oldloc); + return 1; + } + res = 0; + setlocale(LC_ALL, ""); + for (i = 0; i < argc; i++) { + argv_copy2[i] = argv_copy[i] = Py_DecodeLocale(argv[i], NULL); + if (!argv_copy[i]) res = 1; /* failure, but continue to simplify cleanup */ + } + setlocale(LC_ALL, oldloc); + free(oldloc); + if (res == 0) + res = __Pyx_main(argc, argv_copy); + for (i = 0; i < argc; i++) { + PyMem_RawFree(argv_copy2[i]); + } + free(argv_copy); + free(argv_copy2); + return res; + } +} +#endif diff --git a/venv/lib/python3.10/site-packages/Cython/Utility/Exceptions.c b/venv/lib/python3.10/site-packages/Cython/Utility/Exceptions.c new file mode 100644 index 0000000000000000000000000000000000000000..edd7817756295fd5faac149c162cfde367734e33 --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Utility/Exceptions.c @@ -0,0 +1,1012 @@ +// Exception raising code +// +// Exceptions are raised by __Pyx_Raise() and stored as plain +// type/value/tb in PyThreadState->curexc_*. When being caught by an +// 'except' statement, curexc_* is moved over to exc_* by +// __Pyx_GetException() + + +/////////////// AssertionsEnabled.init /////////////// + +if (likely(__Pyx_init_assertions_enabled() == 0)); else +// error propagation code is appended automatically + +/////////////// AssertionsEnabled.proto /////////////// + +#if CYTHON_COMPILING_IN_LIMITED_API || (CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030C0000) + // Py_OptimizeFlag is deprecated in Py3.12+ and not available in the Limited API. + static int __pyx_assertions_enabled_flag; + #define __pyx_assertions_enabled() (__pyx_assertions_enabled_flag) + + static int __Pyx_init_assertions_enabled(void) { + PyObject *builtins, *debug, *debug_str; + int flag; + builtins = PyEval_GetBuiltins(); + if (!builtins) goto bad; + // Not using PYIDENT() here because we probably don't need the string more than this once. + debug_str = PyUnicode_FromStringAndSize("__debug__", 9); + if (!debug_str) goto bad; + debug = PyObject_GetItem(builtins, debug_str); + Py_DECREF(debug_str); + if (!debug) goto bad; + flag = PyObject_IsTrue(debug); + Py_DECREF(debug); + if (flag == -1) goto bad; + __pyx_assertions_enabled_flag = flag; + return 0; + bad: + __pyx_assertions_enabled_flag = 1; + // We (rarely) may not have an exception set, but the calling code will call PyErr_Occurred() either way. + return -1; + } +#else + #define __Pyx_init_assertions_enabled() (0) + #define __pyx_assertions_enabled() (!Py_OptimizeFlag) +#endif + + +/////////////// ErrOccurredWithGIL.proto /////////////// +static CYTHON_INLINE int __Pyx_ErrOccurredWithGIL(void); /* proto */ + +/////////////// ErrOccurredWithGIL /////////////// +static CYTHON_INLINE int __Pyx_ErrOccurredWithGIL(void) { + int err; + PyGILState_STATE _save = PyGILState_Ensure(); + err = !!PyErr_Occurred(); + PyGILState_Release(_save); + return err; +} + + +/////////////// PyThreadStateGet.proto /////////////// +//@substitute: naming + +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyThreadState_declare PyThreadState *$local_tstate_cname; +#define __Pyx_PyThreadState_assign $local_tstate_cname = __Pyx_PyThreadState_Current; +#if PY_VERSION_HEX >= 0x030C00A6 +#define __Pyx_PyErr_Occurred() ($local_tstate_cname->current_exception != NULL) +#define __Pyx_PyErr_CurrentExceptionType() ($local_tstate_cname->current_exception ? (PyObject*) Py_TYPE($local_tstate_cname->current_exception) : (PyObject*) NULL) +#else +#define __Pyx_PyErr_Occurred() ($local_tstate_cname->curexc_type != NULL) +#define __Pyx_PyErr_CurrentExceptionType() ($local_tstate_cname->curexc_type) +#endif +#else +// !CYTHON_FAST_THREAD_STATE +#define __Pyx_PyThreadState_declare +#define __Pyx_PyThreadState_assign +#define __Pyx_PyErr_Occurred() (PyErr_Occurred() != NULL) +#define __Pyx_PyErr_CurrentExceptionType() PyErr_Occurred() +#endif + + +/////////////// PyErrExceptionMatches.proto /////////////// +//@substitute: naming + +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState($local_tstate_cname, err) +static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err); +#else +#define __Pyx_PyErr_ExceptionMatches(err) PyErr_ExceptionMatches(err) +#endif + +/////////////// PyErrExceptionMatches /////////////// + +#if CYTHON_FAST_THREAD_STATE +static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { + Py_ssize_t i, n; + n = PyTuple_GET_SIZE(tuple); + // the tighter subtype checking in Py3 allows faster out-of-order comparison + for (i=0; i= 0x030C00A6 + PyObject *current_exception = tstate->current_exception; + if (unlikely(!current_exception)) return 0; + exc_type = (PyObject*) Py_TYPE(current_exception); + if (exc_type == err) return 1; +#else + exc_type = tstate->curexc_type; + if (exc_type == err) return 1; + if (unlikely(!exc_type)) return 0; +#endif + #if CYTHON_AVOID_BORROWED_REFS + Py_INCREF(exc_type); + #endif + if (unlikely(PyTuple_Check(err))) { + result = __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err); + } else { + result = __Pyx_PyErr_GivenExceptionMatches(exc_type, err); + } + #if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(exc_type); + #endif + return result; +} +#endif + +/////////////// PyErrFetchRestore.proto /////////////// +//@substitute: naming +//@requires: PyThreadStateGet + +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL) +#define __Pyx_ErrRestoreWithState(type, value, tb) __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb) +#define __Pyx_ErrFetchWithState(type, value, tb) __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb) +#define __Pyx_ErrRestore(type, value, tb) __Pyx_ErrRestoreInState($local_tstate_cname, type, value, tb) +#define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState($local_tstate_cname, type, value, tb) +static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); /*proto*/ +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); /*proto*/ + +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A6 +#define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL)) +#else +#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) +#endif + +#else +#define __Pyx_PyErr_Clear() PyErr_Clear() +#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) +#define __Pyx_ErrRestoreWithState(type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetchWithState(type, value, tb) PyErr_Fetch(type, value, tb) +#define __Pyx_ErrRestoreInState(tstate, type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetchInState(tstate, type, value, tb) PyErr_Fetch(type, value, tb) +#define __Pyx_ErrRestore(type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb) +#endif + +/////////////// PyErrFetchRestore /////////////// + +#if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { +#if PY_VERSION_HEX >= 0x030C00A6 + PyObject *tmp_value; + assert(type == NULL || (value != NULL && type == (PyObject*) Py_TYPE(value))); + if (value) { + #if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(((PyBaseExceptionObject*) value)->traceback != tb)) + #endif + // If this fails, we may lose the traceback but still set the expected exception below. + PyException_SetTraceback(value, tb); + } + tmp_value = tstate->current_exception; + tstate->current_exception = value; + Py_XDECREF(tmp_value); + Py_XDECREF(type); + Py_XDECREF(tb); +#else + PyObject *tmp_type, *tmp_value, *tmp_tb; + tmp_type = tstate->curexc_type; + tmp_value = tstate->curexc_value; + tmp_tb = tstate->curexc_traceback; + tstate->curexc_type = type; + tstate->curexc_value = value; + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +#endif +} + +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { +#if PY_VERSION_HEX >= 0x030C00A6 + PyObject* exc_value; + exc_value = tstate->current_exception; + tstate->current_exception = 0; + *value = exc_value; + *type = NULL; + *tb = NULL; + if (exc_value) { + *type = (PyObject*) Py_TYPE(exc_value); + Py_INCREF(*type); + #if CYTHON_COMPILING_IN_CPYTHON + *tb = ((PyBaseExceptionObject*) exc_value)->traceback; + Py_XINCREF(*tb); + #else + *tb = PyException_GetTraceback(exc_value); + #endif + } +#else + *type = tstate->curexc_type; + *value = tstate->curexc_value; + *tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; +#endif +} +#endif + +/////////////// RaiseException.proto /////////////// + +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); /*proto*/ + +/////////////// RaiseException /////////////// +//@requires: PyErrFetchRestore +//@requires: PyThreadStateGet + +// The following function is based on do_raise() from ceval.c. + +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { + PyObject* owned_instance = NULL; + if (tb == Py_None) { + tb = 0; + } else if (tb && !PyTraceBack_Check(tb)) { + PyErr_SetString(PyExc_TypeError, + "raise: arg 3 must be a traceback or None"); + goto bad; + } + if (value == Py_None) + value = 0; + + if (PyExceptionInstance_Check(type)) { + if (value) { + PyErr_SetString(PyExc_TypeError, + "instance exception may not have a separate value"); + goto bad; + } + value = type; + type = (PyObject*) Py_TYPE(value); + } else if (PyExceptionClass_Check(type)) { + // make sure value is an exception instance of type + PyObject *instance_class = NULL; + if (value && PyExceptionInstance_Check(value)) { + instance_class = (PyObject*) Py_TYPE(value); + if (instance_class != type) { + int is_subclass = PyObject_IsSubclass(instance_class, type); + if (!is_subclass) { + instance_class = NULL; + } else if (unlikely(is_subclass == -1)) { + // error on subclass test + goto bad; + } else { + // believe the instance + type = instance_class; + } + } + } + if (!instance_class) { + // instantiate the type now (we don't know when and how it will be caught) + // assuming that 'value' is an argument to the type's constructor + // not using PyErr_NormalizeException() to avoid ref-counting problems + PyObject *args; + if (!value) + args = PyTuple_New(0); + else if (PyTuple_Check(value)) { + Py_INCREF(value); + args = value; + } else + args = PyTuple_Pack(1, value); + if (!args) + goto bad; + owned_instance = PyObject_Call(type, args, NULL); + Py_DECREF(args); + if (!owned_instance) + goto bad; + value = owned_instance; + if (!PyExceptionInstance_Check(value)) { + PyErr_Format(PyExc_TypeError, + "calling %R should have returned an instance of " + "BaseException, not %R", + type, Py_TYPE(value)); + goto bad; + } + } + } else { + PyErr_SetString(PyExc_TypeError, + "raise: exception class must be a subclass of BaseException"); + goto bad; + } + + if (cause) { + PyObject *fixed_cause; + if (cause == Py_None) { + // raise ... from None + fixed_cause = NULL; + } else if (PyExceptionClass_Check(cause)) { + fixed_cause = PyObject_CallObject(cause, NULL); + if (fixed_cause == NULL) + goto bad; + } else if (PyExceptionInstance_Check(cause)) { + fixed_cause = cause; + Py_INCREF(fixed_cause); + } else { + PyErr_SetString(PyExc_TypeError, + "exception causes must derive from " + "BaseException"); + goto bad; + } + PyException_SetCause(value, fixed_cause); + } + + PyErr_SetObject(type, value); + + if (tb) { +#if PY_VERSION_HEX >= 0x030C00A6 + // If this fails, we just get a different exception, so ignore the return value. + PyException_SetTraceback(value, tb); +#elif CYTHON_FAST_THREAD_STATE + PyThreadState *tstate = __Pyx_PyThreadState_Current; + PyObject* tmp_tb = tstate->curexc_traceback; + if (tb != tmp_tb) { + Py_INCREF(tb); + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_tb); + } +#else + PyObject *tmp_type, *tmp_value, *tmp_tb; + PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb); + Py_INCREF(tb); + PyErr_Restore(tmp_type, tmp_value, tb); + Py_XDECREF(tmp_tb); +#endif + } + +bad: + Py_XDECREF(owned_instance); + return; +} + + +/////////////// GetTopmostException.proto /////////////// + +#if CYTHON_USE_EXC_INFO_STACK && CYTHON_FAST_THREAD_STATE +static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate); +#endif + +/////////////// GetTopmostException /////////////// + +#if CYTHON_USE_EXC_INFO_STACK && CYTHON_FAST_THREAD_STATE +// Copied from errors.c in CPython. +static _PyErr_StackItem * +__Pyx_PyErr_GetTopmostException(PyThreadState *tstate) +{ + _PyErr_StackItem *exc_info = tstate->exc_info; + while ((exc_info->exc_value == NULL || exc_info->exc_value == Py_None) && + exc_info->previous_item != NULL) + { + exc_info = exc_info->previous_item; + } + return exc_info; +} +#endif + + +/////////////// GetException.proto /////////////// +//@substitute: naming +//@requires: PyThreadStateGet + +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_GetException(type, value, tb) __Pyx__GetException($local_tstate_cname, type, value, tb) +static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); /*proto*/ +#else +static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb); /*proto*/ +#endif + +/////////////// GetException /////////////// + +#if CYTHON_FAST_THREAD_STATE +static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) +#else +static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) +#endif +{ + PyObject *local_type = NULL, *local_value, *local_tb = NULL; +#if CYTHON_FAST_THREAD_STATE + PyObject *tmp_type, *tmp_value, *tmp_tb; + #if PY_VERSION_HEX >= 0x030C0000 + local_value = tstate->current_exception; + tstate->current_exception = 0; + #else + local_type = tstate->curexc_type; + local_value = tstate->curexc_value; + local_tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; + #endif +#elif __PYX_LIMITED_VERSION_HEX > 0x030C0000 + local_value = PyErr_GetRaisedException(); +#else + PyErr_Fetch(&local_type, &local_value, &local_tb); +#endif + +#if __PYX_LIMITED_VERSION_HEX > 0x030C0000 + if (likely(local_value)) { + local_type = (PyObject*) Py_TYPE(local_value); + Py_INCREF(local_type); + local_tb = PyException_GetTraceback(local_value); + } +#else + // Note that In Python 3.12+ exceptions are already normalized + PyErr_NormalizeException(&local_type, &local_value, &local_tb); +#if CYTHON_FAST_THREAD_STATE + if (unlikely(tstate->curexc_type)) +#else + if (unlikely(PyErr_Occurred())) +#endif + goto bad; + + // Note that in Python 3.12 the traceback came directly from local_value anyway. + if (local_tb) { + if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0)) + goto bad; + } +#endif // __PYX_LIMITED_VERSION_HEX > 0x030C0000 + + // traceback may be NULL for freshly raised exceptions + Py_XINCREF(local_tb); + // exception state may be empty in parallel loops (code-gen error where we don't generate a + // top-level PyGILState_Ensure surrounding the whole loop, and so releasing the GIL temporarily + // wipes the whole thread state). + Py_XINCREF(local_type); + Py_XINCREF(local_value); + *type = local_type; + *value = local_value; + *tb = local_tb; + +#if CYTHON_FAST_THREAD_STATE + #if CYTHON_USE_EXC_INFO_STACK + { + _PyErr_StackItem *exc_info = tstate->exc_info; + #if PY_VERSION_HEX >= 0x030B00a4 + tmp_value = exc_info->exc_value; + exc_info->exc_value = local_value; + tmp_type = NULL; + tmp_tb = NULL; + Py_XDECREF(local_type); + Py_XDECREF(local_tb); + #else + tmp_type = exc_info->exc_type; + tmp_value = exc_info->exc_value; + tmp_tb = exc_info->exc_traceback; + exc_info->exc_type = local_type; + exc_info->exc_value = local_value; + exc_info->exc_traceback = local_tb; + #endif + } + #else + tmp_type = tstate->exc_type; + tmp_value = tstate->exc_value; + tmp_tb = tstate->exc_traceback; + tstate->exc_type = local_type; + tstate->exc_value = local_value; + tstate->exc_traceback = local_tb; + #endif + // Make sure tstate is in a consistent state when we XDECREF + // these objects (DECREF may run arbitrary code). + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +#elif __PYX_LIMITED_VERSION_HEX >= 0x030b0000 + PyErr_SetHandledException(local_value); + Py_XDECREF(local_value); + Py_XDECREF(local_type); + Py_XDECREF(local_tb); +#else + PyErr_SetExcInfo(local_type, local_value, local_tb); +#endif + + return 0; + +#if __PYX_LIMITED_VERSION_HEX <= 0x030C0000 +bad: + *type = 0; + *value = 0; + *tb = 0; + Py_XDECREF(local_type); + Py_XDECREF(local_value); + Py_XDECREF(local_tb); + return -1; +#endif +} + +/////////////// ReRaiseException.proto /////////////// + +static CYTHON_INLINE void __Pyx_ReraiseException(void); /*proto*/ + +/////////////// ReRaiseException /////////////// +//@requires: GetTopmostException + +static CYTHON_INLINE void __Pyx_ReraiseException(void) { + PyObject *type = NULL, *value = NULL, *tb = NULL; +#if CYTHON_FAST_THREAD_STATE + PyThreadState *tstate = PyThreadState_GET(); + #if CYTHON_USE_EXC_INFO_STACK + _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate); + value = exc_info->exc_value; + #if PY_VERSION_HEX >= 0x030B00a4 + if (unlikely(value == Py_None)) { + value = NULL; + } else if (value) { + Py_INCREF(value); + type = (PyObject*) Py_TYPE(value); + Py_INCREF(type); + tb = PyException_GetTraceback(value); + } + #else + type = exc_info->exc_type; + tb = exc_info->exc_traceback; + Py_XINCREF(type); + Py_XINCREF(value); + Py_XINCREF(tb); + #endif + #else + type = tstate->exc_type; + value = tstate->exc_value; + tb = tstate->exc_traceback; + Py_XINCREF(type); + Py_XINCREF(value); + Py_XINCREF(tb); + #endif +#else + PyErr_GetExcInfo(&type, &value, &tb); +#endif + if (unlikely(!type || type == Py_None)) { + Py_XDECREF(type); + Py_XDECREF(value); + Py_XDECREF(tb); + // message copied from Py3 + PyErr_SetString(PyExc_RuntimeError, + "No active exception to reraise"); + } else { + PyErr_Restore(type, value, tb); + } +} + +/////////////// SaveResetException.proto /////////////// +//@substitute: naming +//@requires: PyThreadStateGet + +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_ExceptionSave(type, value, tb) __Pyx__ExceptionSave($local_tstate_cname, type, value, tb) +static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); /*proto*/ +#define __Pyx_ExceptionReset(type, value, tb) __Pyx__ExceptionReset($local_tstate_cname, type, value, tb) +static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); /*proto*/ + +#else + +#define __Pyx_ExceptionSave(type, value, tb) PyErr_GetExcInfo(type, value, tb) +#define __Pyx_ExceptionReset(type, value, tb) PyErr_SetExcInfo(type, value, tb) +#endif + +/////////////// SaveResetException /////////////// +//@requires: GetTopmostException + +#if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { + #if CYTHON_USE_EXC_INFO_STACK && PY_VERSION_HEX >= 0x030B00a4 + _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate); + PyObject *exc_value = exc_info->exc_value; + if (exc_value == NULL || exc_value == Py_None) { + *value = NULL; + *type = NULL; + *tb = NULL; + } else { + *value = exc_value; + Py_INCREF(*value); + *type = (PyObject*) Py_TYPE(exc_value); + Py_INCREF(*type); + *tb = PyException_GetTraceback(exc_value); + } + #elif CYTHON_USE_EXC_INFO_STACK + _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate); + *type = exc_info->exc_type; + *value = exc_info->exc_value; + *tb = exc_info->exc_traceback; + Py_XINCREF(*type); + Py_XINCREF(*value); + Py_XINCREF(*tb); + #else + *type = tstate->exc_type; + *value = tstate->exc_value; + *tb = tstate->exc_traceback; + Py_XINCREF(*type); + Py_XINCREF(*value); + Py_XINCREF(*tb); + #endif +} + +static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { + #if CYTHON_USE_EXC_INFO_STACK && PY_VERSION_HEX >= 0x030B00a4 + _PyErr_StackItem *exc_info = tstate->exc_info; + PyObject *tmp_value = exc_info->exc_value; + exc_info->exc_value = value; + Py_XDECREF(tmp_value); + // TODO: avoid passing these at all + Py_XDECREF(type); + Py_XDECREF(tb); + #else + PyObject *tmp_type, *tmp_value, *tmp_tb; + #if CYTHON_USE_EXC_INFO_STACK + _PyErr_StackItem *exc_info = tstate->exc_info; + tmp_type = exc_info->exc_type; + tmp_value = exc_info->exc_value; + tmp_tb = exc_info->exc_traceback; + exc_info->exc_type = type; + exc_info->exc_value = value; + exc_info->exc_traceback = tb; + #else + tmp_type = tstate->exc_type; + tmp_value = tstate->exc_value; + tmp_tb = tstate->exc_traceback; + tstate->exc_type = type; + tstate->exc_value = value; + tstate->exc_traceback = tb; + #endif + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); + #endif +} +#endif + +/////////////// SwapException.proto /////////////// +//@substitute: naming +//@requires: PyThreadStateGet + +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_ExceptionSwap(type, value, tb) __Pyx__ExceptionSwap($local_tstate_cname, type, value, tb) +static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); /*proto*/ +#else +static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb); /*proto*/ +#endif + +/////////////// SwapException /////////////// + +#if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { + PyObject *tmp_type, *tmp_value, *tmp_tb; + #if CYTHON_USE_EXC_INFO_STACK && PY_VERSION_HEX >= 0x030B00a4 + _PyErr_StackItem *exc_info = tstate->exc_info; + tmp_value = exc_info->exc_value; + exc_info->exc_value = *value; + if (tmp_value == NULL || tmp_value == Py_None) { + Py_XDECREF(tmp_value); + tmp_value = NULL; + tmp_type = NULL; + tmp_tb = NULL; + } else { + // TODO: avoid swapping these at all + tmp_type = (PyObject*) Py_TYPE(tmp_value); + Py_INCREF(tmp_type); + #if CYTHON_COMPILING_IN_CPYTHON + tmp_tb = ((PyBaseExceptionObject*) tmp_value)->traceback; + Py_XINCREF(tmp_tb); + #else + tmp_tb = PyException_GetTraceback(tmp_value); + #endif + } + #elif CYTHON_USE_EXC_INFO_STACK + _PyErr_StackItem *exc_info = tstate->exc_info; + tmp_type = exc_info->exc_type; + tmp_value = exc_info->exc_value; + tmp_tb = exc_info->exc_traceback; + + exc_info->exc_type = *type; + exc_info->exc_value = *value; + exc_info->exc_traceback = *tb; + #else + tmp_type = tstate->exc_type; + tmp_value = tstate->exc_value; + tmp_tb = tstate->exc_traceback; + + tstate->exc_type = *type; + tstate->exc_value = *value; + tstate->exc_traceback = *tb; + #endif + + *type = tmp_type; + *value = tmp_value; + *tb = tmp_tb; +} + +#else + +static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb) { + PyObject *tmp_type, *tmp_value, *tmp_tb; + PyErr_GetExcInfo(&tmp_type, &tmp_value, &tmp_tb); + PyErr_SetExcInfo(*type, *value, *tb); + *type = tmp_type; + *value = tmp_value; + *tb = tmp_tb; +} +#endif + +/////////////// WriteUnraisableException.proto /////////////// + +static void __Pyx_WriteUnraisable(const char *name, int clineno, + int lineno, const char *filename, + int full_traceback, int nogil); /*proto*/ + +/////////////// WriteUnraisableException /////////////// +//@requires: PyErrFetchRestore +//@requires: PyThreadStateGet + +static void __Pyx_WriteUnraisable(const char *name, int clineno, + int lineno, const char *filename, + int full_traceback, int nogil) { + PyObject *old_exc, *old_val, *old_tb; + PyObject *ctx; + __Pyx_PyThreadState_declare + PyGILState_STATE state; + if (nogil) + state = PyGILState_Ensure(); + /* arbitrary, to suppress warning */ + else state = (PyGILState_STATE)0; + CYTHON_UNUSED_VAR(clineno); + CYTHON_UNUSED_VAR(lineno); + CYTHON_UNUSED_VAR(filename); + CYTHON_MAYBE_UNUSED_VAR(nogil); + + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&old_exc, &old_val, &old_tb); + if (full_traceback) { + Py_XINCREF(old_exc); + Py_XINCREF(old_val); + Py_XINCREF(old_tb); + __Pyx_ErrRestore(old_exc, old_val, old_tb); + PyErr_PrintEx(0); + } + ctx = PyUnicode_FromString(name); + __Pyx_ErrRestore(old_exc, old_val, old_tb); + if (!ctx) { + PyErr_WriteUnraisable(Py_None); + } else { + PyErr_WriteUnraisable(ctx); + Py_DECREF(ctx); + } + if (nogil) + PyGILState_Release(state); +} + +/////////////// CLineInTraceback.proto /////////////// + +#if CYTHON_CLINE_IN_TRACEBACK && CYTHON_CLINE_IN_TRACEBACK_RUNTIME +static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line);/*proto*/ +#else +#define __Pyx_CLineForTraceback(tstate, c_line) (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0) +#endif + +/////////////// CLineInTraceback /////////////// +//@requires: ObjectHandling.c::PyObjectGetAttrStrNoError +//@requires: ObjectHandling.c::PyDictVersioning +//@requires: PyErrFetchRestore +//@requires: Synchronization.c::CriticalSections + +#if CYTHON_CLINE_IN_TRACEBACK && CYTHON_CLINE_IN_TRACEBACK_RUNTIME +static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line) { + PyObject *use_cline; + PyObject *ptype, *pvalue, *ptraceback; +#if CYTHON_COMPILING_IN_CPYTHON + PyObject **cython_runtime_dict; +#endif + + CYTHON_MAYBE_UNUSED_VAR(tstate); + + if (unlikely(!NAMED_CGLOBAL(cython_runtime_cname))) { + // Very early error where the runtime module is not set up yet. + return c_line; + } + + __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); + +#if CYTHON_COMPILING_IN_CPYTHON + cython_runtime_dict = _PyObject_GetDictPtr(NAMED_CGLOBAL(cython_runtime_cname)); + if (likely(cython_runtime_dict)) { + __Pyx_BEGIN_CRITICAL_SECTION(*cython_runtime_dict); + __PYX_PY_DICT_LOOKUP_IF_MODIFIED( + use_cline, *cython_runtime_dict, + __Pyx_PyDict_GetItemStr(*cython_runtime_dict, PYIDENT("cline_in_traceback"))) + Py_XINCREF(use_cline); + __Pyx_END_CRITICAL_SECTION(); + } else +#endif + { + PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStrNoError(NAMED_CGLOBAL(cython_runtime_cname), PYIDENT("cline_in_traceback")); + if (use_cline_obj) { + use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True; + Py_INCREF(use_cline); + Py_DECREF(use_cline_obj); + } else { + PyErr_Clear(); + use_cline = NULL; + } + } + if (!use_cline) { + c_line = 0; + // No need to handle errors here when we reset the exception state just afterwards. + (void) PyObject_SetAttr(NAMED_CGLOBAL(cython_runtime_cname), PYIDENT("cline_in_traceback"), Py_False); + } + else if (use_cline == Py_False || (use_cline != Py_True && PyObject_Not(use_cline) != 0)) { + c_line = 0; + } + Py_XDECREF(use_cline); + __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); + return c_line; +} +#endif + +/////////////// AddTraceback.proto /////////////// + +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename); /*proto*/ + +/////////////// AddTraceback /////////////// +//@requires: ModuleSetupCode.c::CodeObjectCache +//@requires: CLineInTraceback +//@substitute: naming + +#include "compile.h" +#include "frameobject.h" +#include "traceback.h" +#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API && !defined(PYPY_VERSION) + #ifndef Py_BUILD_CORE + #define Py_BUILD_CORE 1 + #endif + #include "internal/pycore_frame.h" +#endif + +#if CYTHON_COMPILING_IN_LIMITED_API +static PyObject *__Pyx_PyCode_Replace_For_AddTraceback(PyObject *code, PyObject *scratch_dict, + PyObject *firstlineno, PyObject *name) { + PyObject *replace = NULL; + if (unlikely(PyDict_SetItemString(scratch_dict, "co_firstlineno", firstlineno))) return NULL; + if (unlikely(PyDict_SetItemString(scratch_dict, "co_name", name))) return NULL; + + replace = PyObject_GetAttrString(code, "replace"); + if (likely(replace)) { + PyObject *result = PyObject_Call(replace, EMPTY(tuple), scratch_dict); + Py_DECREF(replace); + return result; + } + PyErr_Clear(); + + return NULL; +} + +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename) { + PyObject *code_object = NULL, *py_py_line = NULL, *py_funcname = NULL, *dict = NULL; + PyObject *replace = NULL, *getframe = NULL, *frame = NULL; + PyObject *exc_type, *exc_value, *exc_traceback; + int success = 0; + if (c_line) { + // Avoid "unused" warning as long as we don't use this. + (void) $cfilenm_cname; + (void) __Pyx_CLineForTraceback(__Pyx_PyThreadState_Current, c_line); + } + + // DW - this is a horrendous hack, but I'm quite proud of it. Essentially + // we need to generate a frame with the right line number/filename/funcname. + // We do this by compiling a small bit of code that uses sys._getframe to get a + // frame, and then customizing the details of the code to match. + // We then run the code object and use the generated frame to set the traceback. + + PyErr_Fetch(&exc_type, &exc_value, &exc_traceback); + + code_object = $global_code_object_cache_find(c_line ? -c_line : py_line); + if (!code_object) { + code_object = Py_CompileString("_getframe()", filename, Py_eval_input); + if (unlikely(!code_object)) goto bad; + py_py_line = PyLong_FromLong(py_line); + if (unlikely(!py_py_line)) goto bad; + py_funcname = PyUnicode_FromString(funcname); + if (unlikely(!py_funcname)) goto bad; + dict = PyDict_New(); + if (unlikely(!dict)) goto bad; + { + PyObject *old_code_object = code_object; + code_object = __Pyx_PyCode_Replace_For_AddTraceback(code_object, dict, py_py_line, py_funcname); + Py_DECREF(old_code_object); + } + if (unlikely(!code_object)) goto bad; + + $global_code_object_cache_insert(c_line ? -c_line : py_line, code_object); + } else { + // The frame part still expects a dict + dict = PyDict_New(); + } + + // Note that getframe is borrowed + getframe = PySys_GetObject("_getframe"); + if (unlikely(!getframe)) goto bad; + // reuse dict as globals (nothing conflicts, and it saves an allocation) + if (unlikely(PyDict_SetItemString(dict, "_getframe", getframe))) goto bad; + + frame = PyEval_EvalCode(code_object, dict, dict); + if (unlikely(!frame) || frame == Py_None) goto bad; + success = 1; + + bad: + PyErr_Restore(exc_type, exc_value, exc_traceback); + Py_XDECREF(code_object); + Py_XDECREF(py_py_line); + Py_XDECREF(py_funcname); + Py_XDECREF(dict); + Py_XDECREF(replace); + + if (success) { + // Unfortunately an easy way to check the type of frame isn't in the + // limited API. The check against None should cover the most + // likely wrong answer though. + PyTraceBack_Here( + // Python < 0x03090000 didn't expose PyFrameObject + // but they all expose struct _frame as an opaque type + (struct _frame*)frame); + } + + Py_XDECREF(frame); +} +#else +static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( + const char *funcname, int c_line, + int py_line, const char *filename) { + PyCodeObject *py_code = NULL; + PyObject *py_funcname = NULL; + + if (c_line) { + py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, $cfilenm_cname, c_line); + if (!py_funcname) goto bad; + funcname = PyUnicode_AsUTF8(py_funcname); + if (!funcname) goto bad; + } + py_code = PyCode_NewEmpty(filename, funcname, py_line); + Py_XDECREF(py_funcname); /* XDECREF since it's only set on Py3 if cline */ + return py_code; +bad: + Py_XDECREF(py_funcname); + return NULL; +} + +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename) { + PyCodeObject *py_code = 0; + PyFrameObject *py_frame = 0; + PyThreadState *tstate = __Pyx_PyThreadState_Current; + PyObject *ptype, *pvalue, *ptraceback; + + if (c_line) { + c_line = __Pyx_CLineForTraceback(tstate, c_line); + } + + // Negate to avoid collisions between py and c lines. + py_code = $global_code_object_cache_find(c_line ? -c_line : py_line); + if (!py_code) { + __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); + py_code = __Pyx_CreateCodeObjectForTraceback( + funcname, c_line, py_line, filename); + if (!py_code) { + /* If the code object creation fails, then we should clear the + fetched exception references and propagate the new exception */ + Py_XDECREF(ptype); + Py_XDECREF(pvalue); + Py_XDECREF(ptraceback); + goto bad; + } + __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); + $global_code_object_cache_insert(c_line ? -c_line : py_line, py_code); + } + py_frame = PyFrame_New( + tstate, /*PyThreadState *tstate,*/ + py_code, /*PyCodeObject *code,*/ + NAMED_CGLOBAL(moddict_cname), /*PyObject *globals,*/ + 0 /*PyObject *locals*/ + ); + if (!py_frame) goto bad; + __Pyx_PyFrame_SetLineNumber(py_frame, py_line); + PyTraceBack_Here(py_frame); +bad: + Py_XDECREF(py_code); + Py_XDECREF(py_frame); +} +#endif diff --git a/venv/lib/python3.10/site-packages/Cython/Utility/ExtensionTypes.c b/venv/lib/python3.10/site-packages/Cython/Utility/ExtensionTypes.c new file mode 100644 index 0000000000000000000000000000000000000000..3fda0b792551c429a75edfef889a264cb8704878 --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Utility/ExtensionTypes.c @@ -0,0 +1,842 @@ +/////////////// FixUpExtensionType.proto /////////////// + +static CYTHON_INLINE int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type); /*proto*/ + +/////////////// FixUpExtensionType /////////////// +//@requires:ModuleSetupCode.c::IncludeStructmemberH +//@requires:StringTools.c::IncludeStringH +//@requires:SetItemOnTypeDict + +static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type) { +#if __PYX_LIMITED_VERSION_HEX > 0x030900B1 + CYTHON_UNUSED_VAR(spec); + CYTHON_UNUSED_VAR(type); + CYTHON_UNUSED_VAR(__Pyx__SetItemOnTypeDict); +#else + // Set tp_weakreflist, tp_dictoffset, tp_vectorcalloffset + // Copied and adapted from https://bugs.python.org/issue38140 + const PyType_Slot *slot = spec->slots; + int changed = 0; +#if !CYTHON_COMPILING_IN_LIMITED_API + while (slot && slot->slot && slot->slot != Py_tp_members) + slot++; + if (slot && slot->slot == Py_tp_members) { +#if !CYTHON_COMPILING_IN_CPYTHON + const +#endif // !CYTHON_COMPILING_IN_CPYTHON) + PyMemberDef *memb = (PyMemberDef*) slot->pfunc; + while (memb && memb->name) { + if (memb->name[0] == '_' && memb->name[1] == '_') { + if (strcmp(memb->name, "__weaklistoffset__") == 0) { + // The PyMemberDef must be a Py_ssize_t and readonly. + assert(memb->type == T_PYSSIZET); + assert(memb->flags == READONLY); + type->tp_weaklistoffset = memb->offset; + // FIXME: is it even worth calling PyType_Modified() here? + changed = 1; + } + else if (strcmp(memb->name, "__dictoffset__") == 0) { + // The PyMemberDef must be a Py_ssize_t and readonly. + assert(memb->type == T_PYSSIZET); + assert(memb->flags == READONLY); + type->tp_dictoffset = memb->offset; + // FIXME: is it even worth calling PyType_Modified() here? + changed = 1; + } +#if CYTHON_METH_FASTCALL + else if (strcmp(memb->name, "__vectorcalloffset__") == 0) { + // The PyMemberDef must be a Py_ssize_t and readonly. + assert(memb->type == T_PYSSIZET); + assert(memb->flags == READONLY); +#if PY_VERSION_HEX >= 0x030800b4 + type->tp_vectorcall_offset = memb->offset; +#else + type->tp_print = (printfunc) memb->offset; +#endif + // FIXME: is it even worth calling PyType_Modified() here? + changed = 1; + } +#endif // CYTHON_METH_FASTCALL +#if !CYTHON_COMPILING_IN_PYPY + else if (strcmp(memb->name, "__module__") == 0) { + // PyType_FromSpec() in CPython <= 3.9b1 overwrites this field with a constant string. + // See https://bugs.python.org/issue40703 + PyObject *descr; + // The PyMemberDef must be an object and normally readable, possibly writable. + assert(memb->type == T_OBJECT); + assert(memb->flags == 0 || memb->flags == READONLY); + descr = PyDescr_NewMember(type, memb); + if (unlikely(!descr)) + return -1; + int set_item_result = PyDict_SetItem(type->tp_dict, PyDescr_NAME(descr), descr); + Py_DECREF(descr); + if (unlikely(set_item_result < 0)) { + return -1; + } + changed = 1; + } +#endif // !CYTHON_COMPILING_IN_PYPY + } + memb++; + } + } +#endif // !CYTHON_COMPILING_IN_LIMITED_API +#if !CYTHON_COMPILING_IN_PYPY + slot = spec->slots; + while (slot && slot->slot && slot->slot != Py_tp_getset) + slot++; + if (slot && slot->slot == Py_tp_getset) { + PyGetSetDef *getset = (PyGetSetDef*) slot->pfunc; + while (getset && getset->name) { + if (getset->name[0] == '_' && getset->name[1] == '_' && strcmp(getset->name, "__module__") == 0) { + PyObject *descr = PyDescr_NewGetSet(type, getset); + if (unlikely(!descr)) + return -1; + #if CYTHON_COMPILING_IN_LIMITED_API + PyObject *pyname = PyUnicode_FromString(getset->name); + if (unlikely(!pyname)) { + Py_DECREF(descr); + return -1; + } + int set_item_result = __Pyx_SetItemOnTypeDict(type, pyname, descr); + Py_DECREF(pyname); + #else + CYTHON_UNUSED_VAR(__Pyx__SetItemOnTypeDict); + int set_item_result = PyDict_SetItem(type->tp_dict, PyDescr_NAME(descr), descr); + #endif + Py_DECREF(descr); + if (unlikely(set_item_result < 0)) { + return -1; + } + changed = 1; + } + ++getset; + } + } +#endif // !CYTHON_COMPILING_IN_PYPY + if (changed) + PyType_Modified(type); +#endif // PY_VERSION_HEX > 0x030900B1 + return 0; +} + + +/////////////// ValidateBasesTuple.proto /////////////// + +#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_USE_TYPE_SPECS +static int __Pyx_validate_bases_tuple(const char *type_name, Py_ssize_t dictoffset, PyObject *bases); /*proto*/ +#endif + +/////////////// ValidateBasesTuple /////////////// + +#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_USE_TYPE_SPECS +static int __Pyx_validate_bases_tuple(const char *type_name, Py_ssize_t dictoffset, PyObject *bases) { + // Loop over all bases (except the first) and check that those + // really are heap types. Otherwise, it would not be safe to + // subclass them. + // + // We also check tp_dictoffset: it is unsafe to inherit + // tp_dictoffset from a base class because the object structures + // would not be compatible. So, if our extension type doesn't set + // tp_dictoffset (i.e. there is no __dict__ attribute in the object + // structure), we need to check that none of the base classes sets + // it either. + Py_ssize_t i, n; +#if CYTHON_ASSUME_SAFE_SIZE + n = PyTuple_GET_SIZE(bases); +#else + n = PyTuple_Size(bases); + if (unlikely(n < 0)) return -1; +#endif + for (i = 1; i < n; i++) /* Skip first base */ + { + PyTypeObject *b; +#if CYTHON_AVOID_BORROWED_REFS + PyObject *b0 = PySequence_GetItem(bases, i); + if (!b0) return -1; +#elif CYTHON_ASSUME_SAFE_MACROS + PyObject *b0 = PyTuple_GET_ITEM(bases, i); +#else + PyObject *b0 = PyTuple_GetItem(bases, i); + if (!b0) return -1; +#endif + b = (PyTypeObject*) b0; + if (!__Pyx_PyType_HasFeature(b, Py_TPFLAGS_HEAPTYPE)) + { + __Pyx_TypeName b_name = __Pyx_PyType_GetFullyQualifiedName(b); + PyErr_Format(PyExc_TypeError, + "base class '" __Pyx_FMT_TYPENAME "' is not a heap type", b_name); + __Pyx_DECREF_TypeName(b_name); +#if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(b0); +#endif + return -1; + } + if (dictoffset == 0) + { + Py_ssize_t b_dictoffset = 0; +#if CYTHON_USE_TYPE_SLOTS + b_dictoffset = b->tp_dictoffset; +#else + PyObject *py_b_dictoffset = PyObject_GetAttrString((PyObject*)b, "__dictoffset__"); + if (!py_b_dictoffset) goto dictoffset_return; + b_dictoffset = PyLong_AsSsize_t(py_b_dictoffset); + Py_DECREF(py_b_dictoffset); + if (b_dictoffset == -1 && PyErr_Occurred()) goto dictoffset_return; +#endif + if (b_dictoffset) { + { + __Pyx_TypeName b_name = __Pyx_PyType_GetFullyQualifiedName(b); + PyErr_Format(PyExc_TypeError, + "extension type '%.200s' has no __dict__ slot, " + "but base type '" __Pyx_FMT_TYPENAME "' has: " + "either add 'cdef dict __dict__' to the extension type " + "or add '__slots__ = [...]' to the base type", + type_name, b_name); + __Pyx_DECREF_TypeName(b_name); + } +#if !CYTHON_USE_TYPE_SLOTS + dictoffset_return: +#endif +#if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(b0); +#endif + return -1; + } + } +#if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(b0); +#endif + } + return 0; +} +#endif + + +/////////////// PyType_Ready.proto /////////////// + +// unused when using type specs +CYTHON_UNUSED static int __Pyx_PyType_Ready(PyTypeObject *t);/*proto*/ + +/////////////// PyType_Ready /////////////// +//@requires: ObjectHandling.c::PyObjectCallMethod0 +//@requires: ValidateBasesTuple + +CYTHON_UNUSED static int __Pyx_PyType_HasMultipleInheritance(PyTypeObject *t) { + while (t) { + PyObject *bases = __Pyx_PyType_GetSlot(t, tp_bases, PyObject*); + if (bases) { + return 1; + } + t = __Pyx_PyType_GetSlot(t, tp_base, PyTypeObject*); + } + return 0; +} + +// Wrapper around PyType_Ready() with some runtime checks and fixes +// to deal with multiple inheritance. +static int __Pyx_PyType_Ready(PyTypeObject *t) { + +#if CYTHON_USE_TYPE_SPECS || !CYTHON_COMPILING_IN_CPYTHON || defined(PYSTON_MAJOR_VERSION) + // avoid C warning about unused helper function + (void)__Pyx_PyObject_CallMethod0; +#if CYTHON_USE_TYPE_SPECS + (void)__Pyx_validate_bases_tuple; +#endif + + return PyType_Ready(t); + +#else + int r; + + if (!__Pyx_PyType_HasMultipleInheritance(t)) { + // shortcut - if none of the base classes do multiple inheritance then we don't need to + // (and shouldn't) mess around with faking heaptypes. + return PyType_Ready(t); + } + PyObject *bases = __Pyx_PyType_GetSlot(t, tp_bases, PyObject*); + if (bases && unlikely(__Pyx_validate_bases_tuple(t->tp_name, t->tp_dictoffset, bases) == -1)) + return -1; + +#if !defined(PYSTON_MAJOR_VERSION) + { + // Make sure GC does not pick up our non-heap type as heap type with this hack! + // For details, see https://github.com/cython/cython/issues/3603 + int gc_was_enabled; + #if PY_VERSION_HEX >= 0x030A00b1 + // finally added in Py3.10 :) + gc_was_enabled = PyGC_Disable(); + (void)__Pyx_PyObject_CallMethod0; + + #else + // Call gc.disable() as a backwards compatible fallback, but only if needed. + PyObject *ret, *py_status; + PyObject *gc = NULL; + #if (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM+0 >= 0x07030400) && \ + !CYTHON_COMPILING_IN_GRAAL + // https://foss.heptapod.net/pypy/pypy/-/issues/3385 + gc = PyImport_GetModule(PYUNICODE("gc")); + #endif + if (unlikely(!gc)) gc = PyImport_Import(PYUNICODE("gc")); + if (unlikely(!gc)) return -1; + py_status = __Pyx_PyObject_CallMethod0(gc, PYUNICODE("isenabled")); + if (unlikely(!py_status)) { + Py_DECREF(gc); + return -1; + } + gc_was_enabled = __Pyx_PyObject_IsTrue(py_status); + Py_DECREF(py_status); + if (gc_was_enabled > 0) { + ret = __Pyx_PyObject_CallMethod0(gc, PYUNICODE("disable")); + if (unlikely(!ret)) { + Py_DECREF(gc); + return -1; + } + Py_DECREF(ret); + } else if (unlikely(gc_was_enabled == -1)) { + Py_DECREF(gc); + return -1; + } + #endif + + // As of https://github.com/python/cpython/issues/66277 + // PyType_Ready enforces that all bases of a non-heap type are + // non-heap. We know that this is the case for the solid base but + // other bases are heap allocated and are kept alive through the + // tp_bases reference. + // Other than this check, the Py_TPFLAGS_HEAPTYPE flag is unused + // in PyType_Ready(). + t->tp_flags |= Py_TPFLAGS_HEAPTYPE; +#if PY_VERSION_HEX >= 0x030A0000 + // As of https://github.com/python/cpython/pull/25520 + // PyType_Ready marks types as immutable if they are static types + // and requires the Py_TPFLAGS_IMMUTABLETYPE flag to mark types as + // immutable + // Manually set the Py_TPFLAGS_IMMUTABLETYPE flag, since the type + // is immutable + t->tp_flags |= Py_TPFLAGS_IMMUTABLETYPE; +#endif +#else + // avoid C warning about unused helper function + (void)__Pyx_PyObject_CallMethod0; +#endif + + r = PyType_Ready(t); + +#if !defined(PYSTON_MAJOR_VERSION) + t->tp_flags &= ~Py_TPFLAGS_HEAPTYPE; + + #if PY_VERSION_HEX >= 0x030A00b1 + if (gc_was_enabled) + PyGC_Enable(); + #else + if (gc_was_enabled) { + PyObject *tp, *v, *tb; + PyErr_Fetch(&tp, &v, &tb); + ret = __Pyx_PyObject_CallMethod0(gc, PYUNICODE("enable")); + if (likely(ret || r == -1)) { + Py_XDECREF(ret); + // do not overwrite exceptions raised by PyType_Ready() above + PyErr_Restore(tp, v, tb); + } else { + // PyType_Ready() succeeded, but gc.enable() failed. + Py_XDECREF(tp); + Py_XDECREF(v); + Py_XDECREF(tb); + r = -1; + } + } + Py_DECREF(gc); + #endif + } +#endif + + return r; +#endif +} + + +/////////////// PyTrashcan.proto /////////////// + +// These macros are taken from https://github.com/python/cpython/pull/11841 +// Unlike the Py_TRASHCAN_SAFE_BEGIN/Py_TRASHCAN_SAFE_END macros, they +// allow dealing correctly with subclasses. + +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03080000 +// https://github.com/python/cpython/pull/11841 merged so Cython reimplementation +// is no longer necessary +#define __Pyx_TRASHCAN_BEGIN Py_TRASHCAN_BEGIN +#define __Pyx_TRASHCAN_END Py_TRASHCAN_END + +#elif CYTHON_COMPILING_IN_CPYTHON + +#define __Pyx_TRASHCAN_BEGIN_CONDITION(op, cond) \ + do { \ + PyThreadState *_tstate = NULL; \ + // If "cond" is false, then _tstate remains NULL and the deallocator + // is run normally without involving the trashcan + if (cond) { \ + _tstate = PyThreadState_GET(); \ + if (_tstate->trash_delete_nesting >= PyTrash_UNWIND_LEVEL) { \ + // Store the object (to be deallocated later) and jump past + // Py_TRASHCAN_END, skipping the body of the deallocator + _PyTrash_thread_deposit_object((PyObject*)(op)); \ + break; \ + } \ + ++_tstate->trash_delete_nesting; \ + } + // The body of the deallocator is here. +#define __Pyx_TRASHCAN_END \ + if (_tstate) { \ + --_tstate->trash_delete_nesting; \ + if (_tstate->trash_delete_later && _tstate->trash_delete_nesting <= 0) \ + _PyTrash_thread_destroy_chain(); \ + } \ + } while (0); + +#define __Pyx_TRASHCAN_BEGIN(op, dealloc) __Pyx_TRASHCAN_BEGIN_CONDITION(op, \ + __Pyx_PyObject_GetSlot(op, tp_dealloc, destructor) == (destructor)(dealloc)) + +#else +// The trashcan is a no-op on other Python implementations +// or old CPython versions +#define __Pyx_TRASHCAN_BEGIN(op, dealloc) +#define __Pyx_TRASHCAN_END +#endif + +/////////////// CallNextTpDealloc.proto /////////////// + +static void __Pyx_call_next_tp_dealloc(PyObject* obj, destructor current_tp_dealloc); + +/////////////// CallNextTpDealloc /////////////// + +static void __Pyx_call_next_tp_dealloc(PyObject* obj, destructor current_tp_dealloc) { + PyTypeObject* type = Py_TYPE(obj); + destructor tp_dealloc = NULL; + /* try to find the first parent type that has a different tp_dealloc() function */ + while (type && __Pyx_PyType_GetSlot(type, tp_dealloc, destructor) != current_tp_dealloc) + type = __Pyx_PyType_GetSlot(type, tp_base, PyTypeObject*); + while (type && (tp_dealloc = __Pyx_PyType_GetSlot(type, tp_dealloc, destructor)) == current_tp_dealloc) + type = __Pyx_PyType_GetSlot(type, tp_base, PyTypeObject*); + if (type) + tp_dealloc(obj); +} + +/////////////// CallNextTpTraverse.proto /////////////// + +static int __Pyx_call_next_tp_traverse(PyObject* obj, visitproc v, void *a, traverseproc current_tp_traverse); + +/////////////// CallNextTpTraverse /////////////// + +static int __Pyx_call_next_tp_traverse(PyObject* obj, visitproc v, void *a, traverseproc current_tp_traverse) { + PyTypeObject* type = Py_TYPE(obj); + traverseproc tp_traverse = NULL; + /* try to find the first parent type that has a different tp_traverse() function */ + while (type && __Pyx_PyType_GetSlot(type, tp_traverse, traverseproc) != current_tp_traverse) + type = __Pyx_PyType_GetSlot(type, tp_base, PyTypeObject*); + while (type && (tp_traverse = __Pyx_PyType_GetSlot(type, tp_traverse, traverseproc)) == current_tp_traverse) + type = __Pyx_PyType_GetSlot(type, tp_base, PyTypeObject*); + if (type && tp_traverse) + return tp_traverse(obj, v, a); + // FIXME: really ignore? + return 0; +} + +/////////////// CallNextTpClear.proto /////////////// + +static void __Pyx_call_next_tp_clear(PyObject* obj, inquiry current_tp_clear); + +/////////////// CallNextTpClear /////////////// + +static void __Pyx_call_next_tp_clear(PyObject* obj, inquiry current_tp_clear) { + PyTypeObject* type = Py_TYPE(obj); + inquiry tp_clear = NULL; + /* try to find the first parent type that has a different tp_clear() function */ + while (type && __Pyx_PyType_GetSlot(type, tp_clear, inquiry) != current_tp_clear) + type = __Pyx_PyType_GetSlot(type, tp_base, PyTypeObject*); + while (type && (tp_clear = __Pyx_PyType_GetSlot(type, tp_clear, inquiry)) == current_tp_clear) + type = __Pyx_PyType_GetSlot(type, tp_base, PyTypeObject*); + if (type && tp_clear) + tp_clear(obj); +} + + +/////////////// SetupReduce.proto /////////////// + +static int __Pyx_setup_reduce(PyObject* type_obj); + +/////////////// SetupReduce /////////////// +//@requires: ObjectHandling.c::PyObjectGetAttrStrNoError +//@requires: ObjectHandling.c::PyObjectGetAttrStr +//@requires: SetItemOnTypeDict +//@requires: DelItemOnTypeDict + +static int __Pyx_setup_reduce_is_named(PyObject* meth, PyObject* name) { + int ret; + PyObject *name_attr; + + name_attr = __Pyx_PyObject_GetAttrStrNoError(meth, PYIDENT("__name__")); + if (likely(name_attr)) { + ret = PyObject_RichCompareBool(name_attr, name, Py_EQ); + } else { + ret = -1; + } + + if (unlikely(ret < 0)) { + PyErr_Clear(); + ret = 0; + } + + Py_XDECREF(name_attr); + return ret; +} + +static int __Pyx_setup_reduce(PyObject* type_obj) { + int ret = 0; + PyObject *object_reduce = NULL; + PyObject *object_getstate = NULL; + PyObject *object_reduce_ex = NULL; + PyObject *reduce = NULL; + PyObject *reduce_ex = NULL; + PyObject *reduce_cython = NULL; + PyObject *setstate = NULL; + PyObject *setstate_cython = NULL; + PyObject *getstate = NULL; + +#if CYTHON_USE_PYTYPE_LOOKUP + getstate = _PyType_Lookup((PyTypeObject*)type_obj, PYIDENT("__getstate__")); +#else + getstate = __Pyx_PyObject_GetAttrStrNoError(type_obj, PYIDENT("__getstate__")); + if (!getstate && PyErr_Occurred()) { + goto __PYX_BAD; + } +#endif + if (getstate) { + // Python 3.11 introduces object.__getstate__. Because it's version-specific failure to find it should not be an error +#if CYTHON_USE_PYTYPE_LOOKUP + object_getstate = _PyType_Lookup(&PyBaseObject_Type, PYIDENT("__getstate__")); +#else + object_getstate = __Pyx_PyObject_GetAttrStrNoError((PyObject*)&PyBaseObject_Type, PYIDENT("__getstate__")); + if (!object_getstate && PyErr_Occurred()) { + goto __PYX_BAD; + } +#endif + if (object_getstate != getstate) { + goto __PYX_GOOD; + } + } + +#if CYTHON_USE_PYTYPE_LOOKUP + object_reduce_ex = _PyType_Lookup(&PyBaseObject_Type, PYIDENT("__reduce_ex__")); if (!object_reduce_ex) goto __PYX_BAD; +#else + object_reduce_ex = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, PYIDENT("__reduce_ex__")); if (!object_reduce_ex) goto __PYX_BAD; +#endif + + reduce_ex = __Pyx_PyObject_GetAttrStr(type_obj, PYIDENT("__reduce_ex__")); if (unlikely(!reduce_ex)) goto __PYX_BAD; + if (reduce_ex == object_reduce_ex) { + +#if CYTHON_USE_PYTYPE_LOOKUP + object_reduce = _PyType_Lookup(&PyBaseObject_Type, PYIDENT("__reduce__")); if (!object_reduce) goto __PYX_BAD; +#else + object_reduce = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, PYIDENT("__reduce__")); if (!object_reduce) goto __PYX_BAD; +#endif + reduce = __Pyx_PyObject_GetAttrStr(type_obj, PYIDENT("__reduce__")); if (unlikely(!reduce)) goto __PYX_BAD; + + if (reduce == object_reduce || __Pyx_setup_reduce_is_named(reduce, PYIDENT("__reduce_cython__"))) { + reduce_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, PYIDENT("__reduce_cython__")); + if (likely(reduce_cython)) { + ret = __Pyx_SetItemOnTypeDict((PyTypeObject*)type_obj, PYIDENT("__reduce__"), reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD; + ret = __Pyx_DelItemOnTypeDict((PyTypeObject*)type_obj, PYIDENT("__reduce_cython__")); if (unlikely(ret < 0)) goto __PYX_BAD; + } else if (reduce == object_reduce || PyErr_Occurred()) { + // Ignore if we're done, i.e. if 'reduce' already has the right name and the original is gone. + // Otherwise: error. + goto __PYX_BAD; + } + + setstate = __Pyx_PyObject_GetAttrStrNoError(type_obj, PYIDENT("__setstate__")); + if (!setstate) PyErr_Clear(); + if (!setstate || __Pyx_setup_reduce_is_named(setstate, PYIDENT("__setstate_cython__"))) { + setstate_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, PYIDENT("__setstate_cython__")); + if (likely(setstate_cython)) { + ret = __Pyx_SetItemOnTypeDict((PyTypeObject*)type_obj, PYIDENT("__setstate__"), setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD; + ret = __Pyx_DelItemOnTypeDict((PyTypeObject*)type_obj, PYIDENT("__setstate_cython__")); if (unlikely(ret < 0)) goto __PYX_BAD; + } else if (!setstate || PyErr_Occurred()) { + // Ignore if we're done, i.e. if 'setstate' already has the right name and the original is gone. + // Otherwise: error. + goto __PYX_BAD; + } + } + PyType_Modified((PyTypeObject*)type_obj); + } + } + goto __PYX_GOOD; + +__PYX_BAD: + if (!PyErr_Occurred()) { + __Pyx_TypeName type_obj_name = + __Pyx_PyType_GetFullyQualifiedName((PyTypeObject*)type_obj); + PyErr_Format(PyExc_RuntimeError, + "Unable to initialize pickling for " __Pyx_FMT_TYPENAME, type_obj_name); + __Pyx_DECREF_TypeName(type_obj_name); + } + ret = -1; +__PYX_GOOD: +#if !CYTHON_USE_PYTYPE_LOOKUP + Py_XDECREF(object_reduce); + Py_XDECREF(object_reduce_ex); + Py_XDECREF(object_getstate); + Py_XDECREF(getstate); +#endif + Py_XDECREF(reduce); + Py_XDECREF(reduce_ex); + Py_XDECREF(reduce_cython); + Py_XDECREF(setstate); + Py_XDECREF(setstate_cython); + return ret; +} + + +/////////////// BinopSlot /////////////// + +static CYTHON_INLINE PyObject *{{func_name}}_maybe_call_slot(PyTypeObject* type, PyObject *left, PyObject *right {{extra_arg_decl}}) { + {{slot_type}} slot; +#if CYTHON_USE_TYPE_SLOTS + slot = type->tp_as_number ? type->tp_as_number->{{slot_name}} : NULL; +#else + slot = ({{slot_type}}) PyType_GetSlot(type, Py_{{slot_name}}); +#endif + return slot ? slot(left, right {{extra_arg}}) : __Pyx_NewRef(Py_NotImplemented); +} + +static PyObject *{{func_name}}(PyObject *left, PyObject *right {{extra_arg_decl}}) { + int maybe_self_is_left, maybe_self_is_right = 0; + maybe_self_is_left = Py_TYPE(left) == Py_TYPE(right) +#if CYTHON_USE_TYPE_SLOTS + || (Py_TYPE(left)->tp_as_number && Py_TYPE(left)->tp_as_number->{{slot_name}} == &{{func_name}}) +#endif + || __Pyx_TypeCheck(left, {{type_cname}}); + + // Optimize for the common case where the left operation is defined (and successful). + {{if not overloads_left}} + maybe_self_is_right = Py_TYPE(left) == Py_TYPE(right) +#if CYTHON_USE_TYPE_SLOTS + || (Py_TYPE(right)->tp_as_number && Py_TYPE(right)->tp_as_number->{{slot_name}} == &{{func_name}}) +#endif + || __Pyx_TypeCheck(right, {{type_cname}}); + {{endif}} + + if (maybe_self_is_left) { + PyObject *res; + + {{if overloads_right and not overloads_left}} + if (maybe_self_is_right) { + res = {{call_right}}; + if (res != Py_NotImplemented) return res; + Py_DECREF(res); + // Don't bother calling it again. + maybe_self_is_right = 0; + } + {{endif}} + + res = {{call_left}}; + if (res != Py_NotImplemented) return res; + Py_DECREF(res); + } + + {{if overloads_left}} + maybe_self_is_right = Py_TYPE(left) == Py_TYPE(right) +#if CYTHON_USE_TYPE_SLOTS + || (Py_TYPE(right)->tp_as_number && Py_TYPE(right)->tp_as_number->{{slot_name}} == &{{func_name}}) +#endif + || PyType_IsSubtype(Py_TYPE(right), {{type_cname}}); + {{endif}} + + if (maybe_self_is_right) { + return {{call_right}}; + } + return __Pyx_NewRef(Py_NotImplemented); +} + +/////////////// ValidateExternBase.proto /////////////// + +static int __Pyx_validate_extern_base(PyTypeObject *base); /* proto */ + +/////////////// ValidateExternBase /////////////// +//@requires: ObjectHandling.c::FormatTypeName + +static int __Pyx_validate_extern_base(PyTypeObject *base) { + Py_ssize_t itemsize; +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *py_itemsize; +#endif +#if !CYTHON_COMPILING_IN_LIMITED_API + itemsize = ((PyTypeObject *)base)->tp_itemsize; +#else + py_itemsize = PyObject_GetAttrString((PyObject*)base, "__itemsize__"); + if (!py_itemsize) + return -1; + itemsize = PyLong_AsSsize_t(py_itemsize); + Py_DECREF(py_itemsize); + py_itemsize = 0; + if (itemsize == (Py_ssize_t)-1 && PyErr_Occurred()) + return -1; +#endif + if (itemsize) { + __Pyx_TypeName b_name = __Pyx_PyType_GetFullyQualifiedName(base); + PyErr_Format(PyExc_TypeError, + "inheritance from PyVarObject types like '" __Pyx_FMT_TYPENAME "' not currently supported", b_name); + __Pyx_DECREF_TypeName(b_name); + return -1; + } + return 0; +} + +/////////////// CallTypeTraverse.proto ///////////////////// + +#if !CYTHON_USE_TYPE_SPECS || (!CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x03090000) +// Without type specs, we're never responsible for this. +// If we *know* the Python version is less that 3.9 we're also not responsible +#define __Pyx_call_type_traverse(o, always_call, visit, arg) 0 +#else +static int __Pyx_call_type_traverse(PyObject *o, int always_call, visitproc visit, void *arg); /* proto */ +#endif + +/////////////// CallTypeTraverse //////////////////////////// + +#if !CYTHON_USE_TYPE_SPECS || (!CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x03090000) +// nothing to do +#else +static int __Pyx_call_type_traverse(PyObject *o, int always_call, visitproc visit, void *arg) { + #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x03090000 + // We have to work out whether to call traverse based on the runtime version. + // __Pyx_get_runtime_version is always available so no need to require it. + if (__Pyx_get_runtime_version() < 0x03090000) return 0; + #endif + if (!always_call) { + // Written with reference to https://docs.python.org/3/howto/isolating-extensions.html + PyTypeObject *base = __Pyx_PyObject_GetSlot(o, tp_base, PyTypeObject*); + unsigned long flags = PyType_GetFlags(base); + if (flags & Py_TPFLAGS_HEAPTYPE) { + // The base class should have handled it + return 0; + } + } + Py_VISIT((PyObject*)Py_TYPE(o)); + return 0; +} +#endif + + +////////////////// LimitedApiGetTypeDict.proto ////////////////////// + +#if CYTHON_COMPILING_IN_LIMITED_API +// This is a little hacky - the Limited API works quite hard to stop us getting +// the dict of a type object. But apparently not hard enough... +// +// In future we should prefer to work with mutable types, and then make them immutable +// once we're done (pending C API support for this). +static PyObject *__Pyx_GetTypeDict(PyTypeObject *tp); /* proto */ +#endif + +////////////////// LimitedApiGetTypeDict ////////////////////// + +#if CYTHON_COMPILING_IN_LIMITED_API +static Py_ssize_t __Pyx_GetTypeDictOffset(void) { + PyObject *tp_dictoffset_o; + Py_ssize_t tp_dictoffset; + tp_dictoffset_o = PyObject_GetAttrString((PyObject*)(&PyType_Type), "__dictoffset__"); + if (unlikely(!tp_dictoffset_o)) return -1; + tp_dictoffset = PyLong_AsSsize_t(tp_dictoffset_o); + Py_DECREF(tp_dictoffset_o); + + if (unlikely(tp_dictoffset == 0)) { + PyErr_SetString( + PyExc_TypeError, + "'type' doesn't have a dictoffset"); + return -1; + } else if (unlikely(tp_dictoffset < 0)) { + // This isn't completely future proof. dictoffset can be + // negative, but isn't in Python <=3.13 (current at time + // of writing). It's awkward to calculate in the limited + // API because we need to know the object size. For now + // just raise an error and fix it if it every changes. + PyErr_SetString( + PyExc_TypeError, + "'type' has an unexpected negative dictoffset. " + "Please report this as Cython bug"); + return -1; + } + + return tp_dictoffset; +} + +static PyObject *__Pyx_GetTypeDict(PyTypeObject *tp) { + // TODO - if we ever support custom metatypes for extension types then + // we have to modify this caching. + static Py_ssize_t tp_dictoffset = 0; + if (unlikely(tp_dictoffset == 0)) { + tp_dictoffset = __Pyx_GetTypeDictOffset(); + // Note that negative dictoffsets are definitely allowed. + // A dictoffset of -1 seems unlikely but isn't obviously forbidden. + if (unlikely(tp_dictoffset == -1 && PyErr_Occurred())) { + tp_dictoffset = 0; // try again next time? + return NULL; + } + } + return *(PyObject**)((char*)tp + tp_dictoffset); +} +#endif + + +////////////////// SetItemOnTypeDict.proto ////////////////////////// +//@requires: LimitedApiGetTypeDict + +static int __Pyx__SetItemOnTypeDict(PyTypeObject *tp, PyObject *k, PyObject *v); /* proto */ + +#define __Pyx_SetItemOnTypeDict(tp, k, v) __Pyx__SetItemOnTypeDict((PyTypeObject*)tp, k, v) + +////////////////// SetItemOnTypeDict ////////////////////////// + +static int __Pyx__SetItemOnTypeDict(PyTypeObject *tp, PyObject *k, PyObject *v) { + int result; + PyObject *tp_dict; +#if CYTHON_COMPILING_IN_LIMITED_API + tp_dict = __Pyx_GetTypeDict(tp); + if (unlikely(!tp_dict)) return -1; +#else + tp_dict = tp->tp_dict; +#endif + result = PyDict_SetItem(tp_dict, k, v); + if (likely(!result)) { + PyType_Modified(tp); + if (unlikely(PyObject_HasAttr(v, PYIDENT("__set_name__")))) { + PyObject *setNameResult = PyObject_CallMethodObjArgs(v, PYIDENT("__set_name__"), (PyObject *) tp, k, NULL); + if (!setNameResult) return -1; + Py_DECREF(setNameResult); + } + } + return result; +} + +////////////////// DelItemOnTypeDict.proto ////////////////////////// + +static int __Pyx__DelItemOnTypeDict(PyTypeObject *tp, PyObject *k); /* proto */ + +#define __Pyx_DelItemOnTypeDict(tp, k) __Pyx__DelItemOnTypeDict((PyTypeObject*)tp, k) + +////////////////// DelItemOnTypeDict ////////////////////////// +//@requires: LimitedApiGetTypeDict + +static int __Pyx__DelItemOnTypeDict(PyTypeObject *tp, PyObject *k) { + int result; + PyObject *tp_dict; +#if CYTHON_COMPILING_IN_LIMITED_API + tp_dict = __Pyx_GetTypeDict(tp); + if (unlikely(!tp_dict)) return -1; +#else + tp_dict = tp->tp_dict; +#endif + result = PyDict_DelItem(tp_dict, k); + if (likely(!result)) PyType_Modified(tp); + return result; +} diff --git a/venv/lib/python3.10/site-packages/Cython/Utility/FunctionArguments.c b/venv/lib/python3.10/site-packages/Cython/Utility/FunctionArguments.c new file mode 100644 index 0000000000000000000000000000000000000000..0ba840510f1fac7524217612e2d61c5c81294d3d --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Utility/FunctionArguments.c @@ -0,0 +1,971 @@ +//////////////////// ArgTypeTest.proto //////////////////// + + +// Exact is 0 (False), 1 (True) or 2 (True and from annotation) +// The latter gives a small amount of extra error diagnostics +#define __Pyx_ArgTypeTest(obj, type, none_allowed, name, exact) \ + ((likely(__Pyx_IS_TYPE(obj, type) | (none_allowed && (obj == Py_None)))) ? 1 : \ + __Pyx__ArgTypeTest(obj, type, name, exact)) + +static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact); /*proto*/ + +//////////////////// ArgTypeTest //////////////////// + +static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact) +{ + __Pyx_TypeName type_name; + __Pyx_TypeName obj_type_name; + PyObject *extra_info = EMPTY(unicode); + int from_annotation_subclass = 0; + if (unlikely(!type)) { + PyErr_SetString(PyExc_SystemError, "Missing type object"); + return 0; + } + else if (!exact) { + if (likely(__Pyx_TypeCheck(obj, type))) return 1; + } else if (exact == 2) { + // type from annotation + if (__Pyx_TypeCheck(obj, type)) { + from_annotation_subclass = 1; + extra_info = PYUNICODE("Note that Cython is deliberately stricter than PEP-484 and rejects subclasses of builtin types. If you need to pass subclasses then set the 'annotation_typing' directive to False."); + } + } + type_name = __Pyx_PyType_GetFullyQualifiedName(type); + obj_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(obj)); + PyErr_Format(PyExc_TypeError, + "Argument '%.200s' has incorrect type (expected " __Pyx_FMT_TYPENAME + ", got " __Pyx_FMT_TYPENAME ")" +#if __PYX_LIMITED_VERSION_HEX < 0x030C0000 + "%s%U" +#endif + , name, type_name, obj_type_name +#if __PYX_LIMITED_VERSION_HEX < 0x030C0000 + , (from_annotation_subclass ? ". " : ""), extra_info +#endif + ); +#if __PYX_LIMITED_VERSION_HEX >= 0x030C0000 + // Set the extra_info as a note instead. In principle it'd be possible to do this + // from Python 3.11 up, but PyErr_GetRaisedException makes it much easier so do it + // from Python 3.12 instead. + if (exact == 2 && from_annotation_subclass) { + PyObject *res; + PyObject *vargs[2]; + vargs[0] = PyErr_GetRaisedException(); + vargs[1] = extra_info; + res = PyObject_VectorcallMethod(PYUNICODE("add_note"), vargs, 2, NULL); + Py_XDECREF(res); + PyErr_SetRaisedException(vargs[0]); + } +#endif + __Pyx_DECREF_TypeName(type_name); + __Pyx_DECREF_TypeName(obj_type_name); + return 0; +} + +//////////////////// RaiseArgTupleInvalid.proto //////////////////// + +static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact, + Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found); /*proto*/ + +//////////////////// RaiseArgTupleInvalid //////////////////// + +// __Pyx_RaiseArgtupleInvalid raises the correct exception when too +// many or too few positional arguments were found. This handles +// Py_ssize_t formatting correctly. + +static void __Pyx_RaiseArgtupleInvalid( + const char* func_name, + int exact, + Py_ssize_t num_min, + Py_ssize_t num_max, + Py_ssize_t num_found) +{ + Py_ssize_t num_expected; + const char *more_or_less; + + if (num_found < num_min) { + num_expected = num_min; + more_or_less = "at least"; + } else { + num_expected = num_max; + more_or_less = "at most"; + } + if (exact) { + more_or_less = "exactly"; + } + PyErr_Format(PyExc_TypeError, + "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)", + func_name, more_or_less, num_expected, + (num_expected == 1) ? "" : "s", num_found); +} + + +//////////////////// RaiseKeywordRequired.proto //////////////////// + +static void __Pyx_RaiseKeywordRequired(const char* func_name, PyObject* kw_name); /*proto*/ + +//////////////////// RaiseKeywordRequired //////////////////// + +static void __Pyx_RaiseKeywordRequired(const char* func_name, PyObject* kw_name) { + PyErr_Format(PyExc_TypeError, + "%s() needs keyword-only argument %U", func_name, kw_name); +} + + +//////////////////// RaiseDoubleKeywords.proto //////////////////// + +static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); /*proto*/ + +//////////////////// RaiseDoubleKeywords //////////////////// + +static void __Pyx_RaiseDoubleKeywordsError( + const char* func_name, + PyObject* kw_name) +{ + PyErr_Format(PyExc_TypeError, + "%s() got multiple values for keyword argument '%U'", func_name, kw_name); +} + + +//////////////////// RaiseMappingExpected.proto //////////////////// + +static void __Pyx_RaiseMappingExpectedError(PyObject* arg); /*proto*/ + +//////////////////// RaiseMappingExpected //////////////////// + +static void __Pyx_RaiseMappingExpectedError(PyObject* arg) { + __Pyx_TypeName arg_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(arg)); + PyErr_Format(PyExc_TypeError, + "'" __Pyx_FMT_TYPENAME "' object is not a mapping", arg_type_name); + __Pyx_DECREF_TypeName(arg_type_name); +} + + +//////////////////// KeywordStringCheck.proto //////////////////// + +static CYTHON_INLINE int __Pyx_CheckKeywordStrings(const char* function_name, PyObject *kw); /*proto*/ + +//////////////////// KeywordStringCheck //////////////////// + +// __Pyx_CheckKeywordStrings raises an error if non-string keywords +// were passed to a function. +// +// The "kw" argument is either a dict (for METH_VARARGS) or a tuple +// (for METH_FASTCALL), both non-empty. + +static int __Pyx_CheckKeywordStrings( + const char* function_name, + PyObject *kw) +{ + // PyPy appears to check keyword types at call time, not at unpacking time. +#if CYTHON_COMPILING_IN_PYPY && !defined(PyArg_ValidateKeywordArguments) + CYTHON_UNUSED_VAR(function_name); + CYTHON_UNUSED_VAR(kw); + return 0; +#else + + // Validate keyword types. + if (CYTHON_METH_FASTCALL && likely(PyTuple_Check(kw))) { + // On CPython >= 3.9, the FASTCALL protocol guarantees that keyword + // names are strings (see https://github.com/python/cpython/issues/81721) +#if PY_VERSION_HEX >= 0x03090000 + CYTHON_UNUSED_VAR(function_name); +#else + + Py_ssize_t kwsize; + #if CYTHON_ASSUME_SAFE_SIZE + kwsize = PyTuple_GET_SIZE(kw); + #else + kwsize = PyTuple_Size(kw); + if (unlikely(kwsize < 0)) return -1; + #endif + + for (Py_ssize_t pos = 0; pos < kwsize; pos++) { + PyObject* key = NULL; + #if CYTHON_ASSUME_SAFE_MACROS + key = PyTuple_GET_ITEM(kw, pos); + #else + key = PyTuple_GetItem(kw, pos); + if (unlikely(!key)) return -1; + #endif + + if (unlikely(!PyUnicode_Check(key))) { + PyErr_Format(PyExc_TypeError, + "%.200s() keywords must be strings", function_name); + return -1; + } + } +#endif + } else { + // Otherwise, 'kw' is a dict: check if it's unicode-keys-only and let Python set the error otherwise. + if (unlikely(!PyArg_ValidateKeywordArguments(kw))) return -1; + } + + return 0; +#endif +} + + +//////////////////// RejectKeywords.proto //////////////////// + +static void __Pyx_RejectKeywords(const char* function_name, PyObject *kwds); /*proto*/ + +//////////////////// RejectKeywords //////////////////// + +static void __Pyx_RejectKeywords(const char* function_name, PyObject *kwds) { + // Get the first keyword argument (there is at least one) and raise a TypeError for it. + PyObject *key = NULL; + if (CYTHON_METH_FASTCALL && likely(PyTuple_Check(kwds))) { + key = __Pyx_PySequence_ITEM(kwds, 0); + } else { + Py_ssize_t pos = 0; +#if !CYTHON_COMPILING_IN_PYPY || defined(PyArg_ValidateKeywordArguments) + // Check if dict is unicode-keys-only and let Python set the error otherwise. + if (unlikely(!PyArg_ValidateKeywordArguments(kwds))) return; +#endif + // Read first key. + PyDict_Next(kwds, &pos, &key, NULL); + Py_INCREF(key); + } + + if (likely(key)) { + PyErr_Format(PyExc_TypeError, + "%s() got an unexpected keyword argument '%U'", + function_name, key); + Py_DECREF(key); + } +} + + +//////////////////// ParseKeywords.proto //////////////////// + +static CYTHON_INLINE int __Pyx_ParseKeywords( + PyObject *kwds, PyObject *const *kwvalues, PyObject ** const argnames[], + PyObject *kwds2, PyObject *values[], + Py_ssize_t num_pos_args, Py_ssize_t num_kwargs, + const char* function_name, + int ignore_unknown_kwargs +); /*proto*/ + +//////////////////// ParseKeywords //////////////////// +//@requires: RaiseDoubleKeywords + +// __Pyx_ParseOptionalKeywords copies the optional/unknown keyword +// arguments from kwds into the dict kwds2. If kwds2 is NULL, unknown +// keywords will raise an invalid keyword error. +// +// When not using METH_FASTCALL, kwds is a dict and kwvalues is NULL. +// Otherwise, kwds is a tuple with keyword names and kwvalues is a C +// array with the corresponding values. +// +// Three kinds of errors are checked: 1) non-string keywords, 2) +// unexpected keywords and 3) overlap with positional arguments. +// +// If num_posargs is greater 0, it denotes the number of positional +// arguments that were passed and that must therefore not appear +// amongst the keywords as well. +// +// This method does not check for required keyword arguments. + +static int __Pyx_ValidateDuplicatePosArgs( + PyObject *kwds, + PyObject ** const argnames[], + PyObject ** const *first_kw_arg, + const char* function_name) +{ + PyObject ** const *name = argnames; + while (name != first_kw_arg) { + PyObject *key = **name; + int found = PyDict_Contains(kwds, key); + if (unlikely(found)) { + if (found == 1) __Pyx_RaiseDoubleKeywordsError(function_name, key); + goto bad; + } + name++; + } + return 0; + +bad: + return -1; +} + +#if CYTHON_USE_UNICODE_INTERNALS +static CYTHON_INLINE int __Pyx_UnicodeKeywordsEqual(PyObject *s1, PyObject *s2) { + int kind; + Py_ssize_t len = PyUnicode_GET_LENGTH(s1); + if (len != PyUnicode_GET_LENGTH(s2)) return 0; + + kind = PyUnicode_KIND(s1); + if (kind != PyUnicode_KIND(s2)) return 0; + + const void *data1 = PyUnicode_DATA(s1); + const void *data2 = PyUnicode_DATA(s2); + return (memcmp(data1, data2, (size_t) len * (size_t) kind) == 0); +} +#endif + +static int __Pyx_MatchKeywordArg_str( + PyObject *key, + PyObject ** const argnames[], + PyObject ** const *first_kw_arg, + size_t *index_found, + const char *function_name) +{ + PyObject ** const *name; + #if CYTHON_USE_UNICODE_INTERNALS + // The key hash is probably pre-calculated. + Py_hash_t key_hash = ((PyASCIIObject*)key)->hash; + if (unlikely(key_hash == -1)) { + key_hash = PyObject_Hash(key); + if (unlikely(key_hash == -1)) + goto bad; + } + #endif + + // Compare strings for non-interned matches. + name = first_kw_arg; + while (*name) { + PyObject *name_str = **name; + + #if CYTHON_USE_UNICODE_INTERNALS + // The hash value of our interned argument name is definitely pre-calculated. + if (key_hash == ((PyASCIIObject*)name_str)->hash && __Pyx_UnicodeKeywordsEqual(name_str, key)) { + *index_found = (size_t) (name - argnames); + return 1; + } + #else + + #if CYTHON_ASSUME_SAFE_SIZE + if (PyUnicode_GET_LENGTH(name_str) == PyUnicode_GET_LENGTH(key)) + #endif + { + int cmp = PyUnicode_Compare(name_str, key); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) { + *index_found = (size_t) (name - argnames); + return 1; + } + } + #endif + name++; + } + + // Not found in keyword parameters, check for (unlikely) duplicate positional argument. + name = argnames; + while (name != first_kw_arg) { + PyObject *name_str = **name; + + #if CYTHON_USE_UNICODE_INTERNALS + if (unlikely(key_hash == ((PyASCIIObject*)name_str)->hash)) { + if (__Pyx_UnicodeKeywordsEqual(name_str, key)) + goto arg_passed_twice; + } + + #else + + #if CYTHON_ASSUME_SAFE_SIZE + if (PyUnicode_GET_LENGTH(name_str) == PyUnicode_GET_LENGTH(key)) + #endif + { + if (unlikely(name_str == key)) goto arg_passed_twice; + int cmp = PyUnicode_Compare(name_str, key); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) goto arg_passed_twice; + } + + #endif + name++; + } + + return 0; + +arg_passed_twice: + __Pyx_RaiseDoubleKeywordsError(function_name, key); + goto bad; +bad: + return -1; +} + +static int __Pyx_MatchKeywordArg_nostr( + PyObject *key, + PyObject ** const argnames[], + PyObject ** const *first_kw_arg, + size_t *index_found, + const char *function_name) +{ + // Conservatively handle str subclasses. + PyObject ** const *name; + + if (unlikely(!PyUnicode_Check(key))) goto invalid_keyword_type; + + // Match keyword argument names. + name = first_kw_arg; + while (*name) { + int cmp = PyObject_RichCompareBool(**name, key, Py_EQ); + if (cmp == 1) { + *index_found = (size_t) (name - argnames); + return 1; + } + if (unlikely(cmp == -1)) goto bad; + name++; + } + // Reject collisions with positional arguments. + name = argnames; + while (name != first_kw_arg) { + int cmp = PyObject_RichCompareBool(**name, key, Py_EQ); + if (unlikely(cmp != 0)) { + if (cmp == 1) goto arg_passed_twice; + else goto bad; + } + name++; + } + return 0; + +arg_passed_twice: + __Pyx_RaiseDoubleKeywordsError(function_name, key); + goto bad; +invalid_keyword_type: + PyErr_Format(PyExc_TypeError, + "%.200s() keywords must be strings", function_name); + goto bad; +bad: + return -1; +} + +static CYTHON_INLINE int __Pyx_MatchKeywordArg( + PyObject *key, + PyObject ** const argnames[], + PyObject ** const *first_kw_arg, + size_t *index_found, + const char *function_name) +{ + // Optimise for plain str behaviour. + return likely(PyUnicode_CheckExact(key)) ? + __Pyx_MatchKeywordArg_str(key, argnames, first_kw_arg, index_found, function_name) : + __Pyx_MatchKeywordArg_nostr(key, argnames, first_kw_arg, index_found, function_name); +} + +static void __Pyx_RejectUnknownKeyword( + PyObject *kwds, + PyObject ** const argnames[], + PyObject ** const *first_kw_arg, + const char *function_name) +{ + // Find the first unknown keyword and raise an error. There must be at least one. + Py_ssize_t pos = 0; + PyObject *key = NULL; + + __Pyx_BEGIN_CRITICAL_SECTION(kwds); + while (PyDict_Next(kwds, &pos, &key, NULL)) { + // Quickly exclude the 'obviously' valid/known keyword arguments (exact pointer match). + PyObject** const *name = first_kw_arg; + while (*name && (**name != key)) name++; + + if (!*name) { + // No exact match found: + // compare against positional (always reject) and keyword (reject unknown) names. + #if CYTHON_AVOID_BORROWED_REFS + Py_INCREF(key); + #endif + + size_t index_found = 0; + int cmp = __Pyx_MatchKeywordArg(key, argnames, first_kw_arg, &index_found, function_name); + if (cmp != 1) { + if (cmp == 0) { + PyErr_Format(PyExc_TypeError, + "%s() got an unexpected keyword argument '%U'", + function_name, key); + } + #if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(key); + #endif + + break; + } + #if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(key); + #endif + } + } + __Pyx_END_CRITICAL_SECTION(); + + assert(PyErr_Occurred()); +} + +static int __Pyx_ParseKeywordDict( + PyObject *kwds, + PyObject ** const argnames[], + PyObject *values[], + Py_ssize_t num_pos_args, + Py_ssize_t num_kwargs, + const char* function_name, + int ignore_unknown_kwargs) +{ + PyObject** const *name; + PyObject** const *first_kw_arg = argnames + num_pos_args; + Py_ssize_t extracted = 0; + +#if !CYTHON_COMPILING_IN_PYPY || defined(PyArg_ValidateKeywordArguments) + // Check if dict is unicode-keys-only and let Python set the error otherwise. + if (unlikely(!PyArg_ValidateKeywordArguments(kwds))) return -1; +#endif + + // Extract declared keyword arguments. + name = first_kw_arg; + while (*name && num_kwargs > extracted) { + PyObject * key = **name; + PyObject *value; + int found = 0; + + #if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 + found = PyDict_GetItemRef(kwds, key, &value); + #else + value = PyDict_GetItemWithError(kwds, key); + if (value) { + Py_INCREF(value); + found = 1; + } else { + if (unlikely(PyErr_Occurred())) goto bad; + } + #endif + + if (found) { + if (unlikely(found < 0)) goto bad; + values[name-argnames] = value; + extracted++; + } + + name++; + } + + if (num_kwargs > extracted) { + if (ignore_unknown_kwargs) { + // Make sure the remaining kwargs are not duplicate posargs. + if (unlikely(__Pyx_ValidateDuplicatePosArgs(kwds, argnames, first_kw_arg, function_name) == -1)) + goto bad; + } else { + // Any remaining kwarg is an error. + __Pyx_RejectUnknownKeyword(kwds, argnames, first_kw_arg, function_name); + goto bad; + } + } + return 0; + +bad: + return -1; +} + +static int __Pyx_ParseKeywordDictToDict( + PyObject *kwds, + PyObject ** const argnames[], + PyObject *kwds2, + PyObject *values[], + Py_ssize_t num_pos_args, + const char* function_name) +{ + // Validate and parse keyword arguments from kwds dict. + PyObject** const *name; + PyObject** const *first_kw_arg = argnames + num_pos_args; + Py_ssize_t len; + +#if !CYTHON_COMPILING_IN_PYPY || defined(PyArg_ValidateKeywordArguments) + // Check if dict is unicode-keys-only and let Python set the error otherwise. + if (unlikely(!PyArg_ValidateKeywordArguments(kwds))) return -1; +#endif + + // Fast copy of all kwargs. + if (PyDict_Update(kwds2, kwds) < 0) goto bad; + + // Extract declared keyword arguments (if any). + name = first_kw_arg; + while (*name) { + PyObject *key = **name; + PyObject *value; + +#if !CYTHON_COMPILING_IN_LIMITED_API && (PY_VERSION_HEX >= 0x030d00A2 || defined(PyDict_Pop)) + int found = PyDict_Pop(kwds2, key, &value); + if (found) { + if (unlikely(found < 0)) goto bad; + values[name-argnames] = value; + } +#elif __PYX_LIMITED_VERSION_HEX >= 0x030d0000 + int found = PyDict_GetItemRef(kwds2, key, &value); + if (found) { + if (unlikely(found < 0)) goto bad; + values[name-argnames] = value; + if (unlikely(PyDict_DelItem(kwds2, key) < 0)) goto bad; + } +#else + // We use 'kwds2' as sentinel value to dict.pop() to avoid an exception on missing key. + #if CYTHON_COMPILING_IN_CPYTHON + value = _PyDict_Pop(kwds2, key, kwds2); + #else + value = CALL_UNBOUND_METHOD(PyDict_Type, "pop", kwds2, key, kwds2); + #endif + if (value == kwds2) { + // Not found. + Py_DECREF(value); + } else { + if (unlikely(!value)) goto bad; + values[name-argnames] = value; + } +#endif + name++; + } + + // If unmatched keywords remain, check for duplicates of positional arguments. + len = PyDict_Size(kwds2); + if (len > 0) { + return __Pyx_ValidateDuplicatePosArgs(kwds, argnames, first_kw_arg, function_name); + } else if (unlikely(len == -1)) { + goto bad; + } + + return 0; + +bad: + return -1; +} + +static int __Pyx_ParseKeywordsTuple( + PyObject *kwds, + PyObject * const *kwvalues, + PyObject ** const argnames[], + PyObject *kwds2, + PyObject *values[], + Py_ssize_t num_pos_args, + Py_ssize_t num_kwargs, + const char* function_name, + int ignore_unknown_kwargs) +{ + PyObject *key = NULL; + PyObject** const * name; + PyObject** const *first_kw_arg = argnames + num_pos_args; + + for (Py_ssize_t pos = 0; pos < num_kwargs; pos++) { +#if CYTHON_AVOID_BORROWED_REFS + key = __Pyx_PySequence_ITEM(kwds, pos); +#else + key = __Pyx_PyTuple_GET_ITEM(kwds, pos); +#endif +#if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely(!key)) goto bad; +#endif + + // Quick pointer search for interned parameter matches (will usually succeed). + name = first_kw_arg; + while (*name && (**name != key)) name++; + if (*name) { + // Declared keyword: **name == key + PyObject *value = kwvalues[pos]; + values[name-argnames] = __Pyx_NewRef(value); + } else { + size_t index_found = 0; + int cmp = __Pyx_MatchKeywordArg(key, argnames, first_kw_arg, &index_found, function_name); + + if (cmp == 1) { + // Found in declared keywords => assign value. + PyObject *value = kwvalues[pos]; + values[index_found] = __Pyx_NewRef(value); + } else { + if (unlikely(cmp == -1)) goto bad; + if (kwds2) { + PyObject *value = kwvalues[pos]; + if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad; + } else if (!ignore_unknown_kwargs) { + goto invalid_keyword; + } + } + } + + #if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(key); + key = NULL; + #endif + } + return 0; + +invalid_keyword: + PyErr_Format(PyExc_TypeError, + "%s() got an unexpected keyword argument '%U'", + function_name, key); + goto bad; +bad: + #if CYTHON_AVOID_BORROWED_REFS + Py_XDECREF(key); + #endif + return -1; +} + +static int __Pyx_ParseKeywords( + PyObject *kwds, + PyObject * const *kwvalues, + PyObject ** const argnames[], + PyObject *kwds2, + PyObject *values[], + Py_ssize_t num_pos_args, + Py_ssize_t num_kwargs, + const char* function_name, + int ignore_unknown_kwargs) +{ + // Only called if kwds contains at least one optional keyword argument. + if (CYTHON_METH_FASTCALL && likely(PyTuple_Check(kwds))) + return __Pyx_ParseKeywordsTuple(kwds, kwvalues, argnames, kwds2, values, num_pos_args, num_kwargs, function_name, ignore_unknown_kwargs); + else if (kwds2) + return __Pyx_ParseKeywordDictToDict(kwds, argnames, kwds2, values, num_pos_args, function_name); + else + return __Pyx_ParseKeywordDict(kwds, argnames, values, num_pos_args, num_kwargs, function_name, ignore_unknown_kwargs); +} + + +//////////////////// MergeKeywords.proto //////////////////// + +static int __Pyx_MergeKeywords(PyObject *kwdict, PyObject *source_mapping); /*proto*/ + +//////////////////// MergeKeywords //////////////////// +//@requires: RaiseDoubleKeywords +//@requires: Optimize.c::dict_iter + +static int __Pyx_MergeKeywords_dict(PyObject *kwdict, PyObject *source_dict) { + Py_ssize_t len1, len2; + + len2 = PyDict_Size(source_dict); + if (unlikely(len2 == -1)) return -1; + if (len2 == 0) { + // There's nothing to copy from an empty dict. + return 0; + } + + len1 = PyDict_Size(kwdict); + if (unlikely(len1 == -1)) return -1; + + if (len1 > 0) { + PyObject *key, *smaller_dict, *larger_dict; + Py_ssize_t ppos = 0; + int duplicates_found = 0; + + if (len1 <= len2) { + smaller_dict = kwdict; + larger_dict = source_dict; + } else { + smaller_dict = source_dict; + larger_dict = kwdict; + } + + __Pyx_BEGIN_CRITICAL_SECTION(smaller_dict); + while (PyDict_Next(smaller_dict, &ppos, &key, NULL)) { + #if CYTHON_AVOID_BORROWED_REFS || CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS + Py_INCREF(key); + #endif + if (unlikely(PyDict_Contains(larger_dict, key))) { + __Pyx_RaiseDoubleKeywordsError("function", key); + #if CYTHON_AVOID_BORROWED_REFS || CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS + Py_DECREF(key); + #endif + duplicates_found = 1; + break; + }; + #if CYTHON_AVOID_BORROWED_REFS || CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS + Py_DECREF(key); + #endif + } + __Pyx_END_CRITICAL_SECTION(); + + if (unlikely(duplicates_found)) + return -1; + } + + return PyDict_Update(kwdict, source_dict); +} + +static int __Pyx_MergeKeywords_any(PyObject *kwdict, PyObject *source_mapping) { + PyObject *iter, *key = NULL, *value = NULL; + int source_is_dict, result; + Py_ssize_t orig_length, ppos = 0; + + iter = __Pyx_dict_iterator(source_mapping, 0, PYIDENT("items"), &orig_length, &source_is_dict); + if (unlikely(!iter)) { + // slow fallback: try converting to dict, then iterate + PyObject *args; + if (unlikely(!PyErr_ExceptionMatches(PyExc_AttributeError))) goto bad; + PyErr_Clear(); + args = PyTuple_Pack(1, source_mapping); + if (likely(args)) { + PyObject *fallback = PyObject_Call((PyObject*)&PyDict_Type, args, NULL); + Py_DECREF(args); + if (likely(fallback)) { + result = __Pyx_MergeKeywords_dict(kwdict, fallback); + Py_DECREF(fallback); + return result; + } + } + if (unlikely(!iter)) goto bad; + } + + while (1) { + result = __Pyx_dict_iter_next(iter, orig_length, &ppos, &key, &value, NULL, source_is_dict); + if (unlikely(result < 0)) goto bad; + if (!result) break; + + #if PY_VERSION_HEX >= 0x030d0000 && !CYTHON_COMPILING_IN_LIMITED_API + { + int inserted = PyDict_SetDefaultRef(kwdict, key, value, NULL); + if (unlikely(inserted != 0)) { + if (inserted == 1) __Pyx_RaiseDoubleKeywordsError("function", key); + result = -1; + } + } + #else + if (unlikely(PyDict_Contains(kwdict, key))) { + __Pyx_RaiseDoubleKeywordsError("function", key); + result = -1; + } else { + result = PyDict_SetItem(kwdict, key, value); + } + #endif + + Py_DECREF(key); + Py_DECREF(value); + if (unlikely(result < 0)) goto bad; + } + Py_XDECREF(iter); + return 0; + +bad: + Py_XDECREF(iter); + return -1; +} + +static CYTHON_INLINE int __Pyx_MergeKeywords(PyObject *kwdict, PyObject *source_mapping) { + assert(PyDict_Check(kwdict)); + if (likely(PyDict_Check(source_mapping))) { + return __Pyx_MergeKeywords_dict(kwdict, source_mapping); + } else { + return __Pyx_MergeKeywords_any(kwdict, source_mapping); + } +} + + +/////////////// fastcall.proto /////////////// + +// We define various functions and macros with two variants: +//..._FASTCALL and ..._VARARGS + +// The first is used when METH_FASTCALL is enabled and the second is used +// otherwise. If the Python implementation does not support METH_FASTCALL +// (because it's an old version of CPython or it's not CPython at all), +// then the ..._FASTCALL macros simply alias ..._VARARGS + +#if CYTHON_AVOID_BORROWED_REFS + #define __Pyx_ArgRef_VARARGS(args, i) __Pyx_PySequence_ITEM(args, i) +#elif CYTHON_ASSUME_SAFE_MACROS + #define __Pyx_ArgRef_VARARGS(args, i) __Pyx_NewRef(__Pyx_PyTuple_GET_ITEM(args, i)) +#else + #define __Pyx_ArgRef_VARARGS(args, i) __Pyx_XNewRef(PyTuple_GetItem(args, i)) +#endif + +#define __Pyx_NumKwargs_VARARGS(kwds) PyDict_Size(kwds) +#define __Pyx_KwValues_VARARGS(args, nargs) NULL +#define __Pyx_GetKwValue_VARARGS(kw, kwvalues, s) __Pyx_PyDict_GetItemStrWithError(kw, s) +#define __Pyx_KwargsAsDict_VARARGS(kw, kwvalues) PyDict_Copy(kw) +#if CYTHON_METH_FASTCALL + #define __Pyx_ArgRef_FASTCALL(args, i) __Pyx_NewRef(args[i]) + #define __Pyx_NumKwargs_FASTCALL(kwds) __Pyx_PyTuple_GET_SIZE(kwds) + #define __Pyx_KwValues_FASTCALL(args, nargs) ((args) + (nargs)) + static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 || CYTHON_COMPILING_IN_LIMITED_API + CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues);/*proto*/ + #else + #define __Pyx_KwargsAsDict_FASTCALL(kw, kwvalues) _PyStack_AsDict(kwvalues, kw) + #endif +#else + #define __Pyx_ArgRef_FASTCALL __Pyx_ArgRef_VARARGS + #define __Pyx_NumKwargs_FASTCALL __Pyx_NumKwargs_VARARGS + #define __Pyx_KwValues_FASTCALL __Pyx_KwValues_VARARGS + #define __Pyx_GetKwValue_FASTCALL __Pyx_GetKwValue_VARARGS + #define __Pyx_KwargsAsDict_FASTCALL __Pyx_KwargsAsDict_VARARGS +#endif + +#define __Pyx_ArgsSlice_VARARGS(args, start, stop) PyTuple_GetSlice(args, start, stop) + +#if CYTHON_METH_FASTCALL || (CYTHON_COMPILING_IN_CPYTHON && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS) +#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) __Pyx_PyTuple_FromArray(args + start, stop - start) +#else +#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) PyTuple_GetSlice(args, start, stop) +#endif + +/////////////// fastcall /////////////// +//@requires: ObjectHandling.c::TupleAndListFromArray +//@requires: StringTools.c::UnicodeEquals + +#if CYTHON_METH_FASTCALL +// kwnames: tuple with names of keyword arguments +// kwvalues: C array with values of keyword arguments +// s: str with the keyword name to look for +static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s) +{ + // Search the kwnames array for s and return the corresponding value. + // We do two loops: a first one to compare pointers (which will find a + // match if the name in kwnames is interned, given that s is interned + // by Cython). A second loop compares the actual strings. + Py_ssize_t i, n = __Pyx_PyTuple_GET_SIZE(kwnames); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(n == -1)) return NULL; + #endif + for (i = 0; i < n; i++) + { + PyObject *namei = __Pyx_PyTuple_GET_ITEM(kwnames, i); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely(!namei)) return NULL; + #endif + if (s == namei) return kwvalues[i]; + } + for (i = 0; i < n; i++) + { + PyObject *namei = __Pyx_PyTuple_GET_ITEM(kwnames, i); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely(!namei)) return NULL; + #endif + int eq = __Pyx_PyUnicode_Equals(s, namei, Py_EQ); + if (unlikely(eq != 0)) { + if (unlikely(eq < 0)) return NULL; /* error */ + return kwvalues[i]; + } + } + return NULL; /* not found (no exception set) */ +} + +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 || CYTHON_COMPILING_IN_LIMITED_API +CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues) { + Py_ssize_t i, nkwargs; + PyObject *dict; +#if !CYTHON_ASSUME_SAFE_SIZE + nkwargs = PyTuple_Size(kwnames); + if (unlikely(nkwargs < 0)) return NULL; +#else + nkwargs = PyTuple_GET_SIZE(kwnames); +#endif + + dict = PyDict_New(); + if (unlikely(!dict)) + return NULL; + + for (i=0; i use modules as is. + PyErr_Clear(); + return module; + } + Py_DECREF(spec); + Py_DECREF(module); + } else if (PyErr_Occurred()) { + PyErr_Clear(); + } +#endif + + return __Pyx__ImportDottedModule(name, parts_tuple); +} + + +/////////////// ImportDottedModuleRelFirst.proto /////////////// + +static PyObject *__Pyx_ImportDottedModuleRelFirst(PyObject *name, PyObject *parts_tuple); /*proto*/ + +/////////////// ImportDottedModuleRelFirst /////////////// +//@requires: ImportDottedModule +//@requires: Import + +static PyObject *__Pyx_ImportDottedModuleRelFirst(PyObject *name, PyObject *parts_tuple) { + PyObject *module; + PyObject *from_list = NULL; + module = __Pyx_Import(name, from_list, -1); + Py_XDECREF(from_list); + if (module) { + if (parts_tuple) { + module = __Pyx_ImportDottedModule_WalkParts(module, name, parts_tuple); + } + return module; + } + if (unlikely(!PyErr_ExceptionMatches(PyExc_ImportError))) + return NULL; + PyErr_Clear(); + // try absolute import + return __Pyx_ImportDottedModule(name, parts_tuple); +} + + +/////////////// Import.proto /////////////// + +static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level); /*proto*/ + +/////////////// Import /////////////// +//@requires: ObjectHandling.c::PyObjectGetAttrStr +//@requires:StringTools.c::IncludeStringH + +static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { + PyObject *module = 0; + PyObject *empty_dict = 0; + PyObject *empty_list = 0; + empty_dict = PyDict_New(); + if (unlikely(!empty_dict)) + goto bad; + if (level == -1) { + const char* package_sep = strchr(__Pyx_MODULE_NAME, '.'); + if (package_sep != (0)) { + /* try package relative import first */ + module = PyImport_ImportModuleLevelObject( + name, NAMED_CGLOBAL(moddict_cname), empty_dict, from_list, 1); + if (unlikely(!module)) { + if (unlikely(!PyErr_ExceptionMatches(PyExc_ImportError))) + goto bad; + PyErr_Clear(); + } + } + level = 0; /* try absolute import on failure */ + } + if (!module) { + module = PyImport_ImportModuleLevelObject( + name, NAMED_CGLOBAL(moddict_cname), empty_dict, from_list, level); + } +bad: + Py_XDECREF(empty_dict); + Py_XDECREF(empty_list); + return module; +} + + +/////////////// ImportFrom.proto /////////////// + +static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name); /*proto*/ + +/////////////// ImportFrom /////////////// +//@requires: ObjectHandling.c::PyObjectGetAttrStr + +static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) { + PyObject* value = __Pyx_PyObject_GetAttrStr(module, name); + if (unlikely(!value) && PyErr_ExceptionMatches(PyExc_AttributeError)) { + // 'name' may refer to a (sub-)module which has not finished initialization + // yet, and may not be assigned as an attribute to its parent, so try + // finding it by full name. + const char* module_name_str = 0; + PyObject* module_name = 0; + PyObject* module_dot = 0; + PyObject* full_name = 0; + PyErr_Clear(); + module_name_str = PyModule_GetName(module); + if (unlikely(!module_name_str)) { goto modbad; } + module_name = PyUnicode_FromString(module_name_str); + if (unlikely(!module_name)) { goto modbad; } + module_dot = PyUnicode_Concat(module_name, PYUNICODE(".")); + if (unlikely(!module_dot)) { goto modbad; } + full_name = PyUnicode_Concat(module_dot, name); + if (unlikely(!full_name)) { goto modbad; } + #if (CYTHON_COMPILING_IN_PYPY && PYPY_VERSION_NUM < 0x07030400) || \ + CYTHON_COMPILING_IN_GRAAL + { + PyObject *modules = PyImport_GetModuleDict(); + if (unlikely(!modules)) + goto modbad; + value = PyObject_GetItem(modules, full_name); + } + #else + value = PyImport_GetModule(full_name); + #endif + + modbad: + Py_XDECREF(full_name); + Py_XDECREF(module_dot); + Py_XDECREF(module_name); + } + if (unlikely(!value)) { + PyErr_Format(PyExc_ImportError, "cannot import name %S", name); + } + return value; +} + + +/////////////// ImportStar /////////////// +//@substitute: naming + +/* import_all_from is an unexposed function from ceval.c */ + +static int +__Pyx_import_all_from(PyObject *locals, PyObject *v) +{ + PyObject *all = PyObject_GetAttrString(v, "__all__"); + PyObject *dict, *name, *value; + int skip_leading_underscores = 0; + int pos, err; + + if (all == NULL) { + if (!PyErr_ExceptionMatches(PyExc_AttributeError)) + return -1; /* Unexpected error */ + PyErr_Clear(); + dict = PyObject_GetAttrString(v, "__dict__"); + if (dict == NULL) { + if (!PyErr_ExceptionMatches(PyExc_AttributeError)) + return -1; + PyErr_SetString(PyExc_ImportError, + "from-import-* object has no __dict__ and no __all__"); + return -1; + } + all = PyMapping_Keys(dict); + Py_DECREF(dict); + if (all == NULL) + return -1; + skip_leading_underscores = 1; + } + + for (pos = 0, err = 0; ; pos++) { + name = PySequence_GetItem(all, pos); + if (name == NULL) { + if (!PyErr_ExceptionMatches(PyExc_IndexError)) + err = -1; + else + PyErr_Clear(); + break; + } + if (skip_leading_underscores && likely(PyUnicode_Check(name))) { + Py_ssize_t length = __Pyx_PyUnicode_GET_LENGTH(name); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(length < 0)) { + Py_DECREF(name); + return -1; + } + #endif + if (likely(length) && __Pyx_PyUnicode_READ_CHAR(name, 0) == '_') { + Py_DECREF(name); + continue; + } + } + value = PyObject_GetAttr(v, name); + if (value == NULL) + err = -1; + else if (PyDict_CheckExact(locals)) + err = PyDict_SetItem(locals, name, value); + else + err = PyObject_SetItem(locals, name, value); + Py_DECREF(name); + Py_XDECREF(value); + if (err != 0) + break; + } + Py_DECREF(all); + return err; +} + + +static int ${import_star}(PyObject* m) { + + int i; + int ret = -1; + const char* s; + PyObject *locals = 0; + PyObject *list = 0; + PyObject *utf8_name = 0; + PyObject *name; + PyObject *item; + PyObject *import_obj; + Py_ssize_t size; + ${modulestatetype_cname} *mstate = __Pyx_PyModule_GetState(m); + + locals = PyDict_New(); if (!locals) goto bad; + if (__Pyx_import_all_from(locals, m) < 0) goto bad; + list = PyDict_Items(locals); if (!list) goto bad; + + size = __Pyx_PyList_GET_SIZE(list); + #if !CYTHON_ASSUME_SAFE_SIZE + if (size < 0) goto bad; + #endif + for(i=0; i= 201112L +#include +#endif + +#if (defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L) || __cplusplus >= 201103L +#define __PYX_GET_STRUCT_ALIGNMENT_$cyversion(s) alignof(s) +#else +// best guess at what the alignment could be since we can't measure it +#define __PYX_GET_STRUCT_ALIGNMENT_$cyversion(s) sizeof(void*) +#endif + +enum __Pyx_ImportType_CheckSize_$cyversion { + __Pyx_ImportType_CheckSize_Error_$cyversion = 0, + __Pyx_ImportType_CheckSize_Warn_$cyversion = 1, + __Pyx_ImportType_CheckSize_Ignore_$cyversion = 2 +}; + +static PyTypeObject *__Pyx_ImportType_$cyversion(PyObject* module, const char *module_name, const char *class_name, size_t size, size_t alignment, enum __Pyx_ImportType_CheckSize_$cyversion check_size); /*proto*/ + +#endif + +/////////////// TypeImport /////////////// +//@substitute: naming + +// Note that this goes into headers so CYTHON_COMPILING_IN_LIMITED_API may not be available. + +#ifndef __PYX_HAVE_RT_ImportType_$cyversion +#define __PYX_HAVE_RT_ImportType_$cyversion +static PyTypeObject *__Pyx_ImportType_$cyversion(PyObject *module, const char *module_name, const char *class_name, + size_t size, size_t alignment, enum __Pyx_ImportType_CheckSize_$cyversion check_size) +{ + PyObject *result = 0; + Py_ssize_t basicsize; + Py_ssize_t itemsize; +#if defined(Py_LIMITED_API) || (defined(CYTHON_COMPILING_IN_LIMITED_API) && CYTHON_COMPILING_IN_LIMITED_API) + PyObject *py_basicsize; + PyObject *py_itemsize; +#endif + + result = PyObject_GetAttrString(module, class_name); + if (!result) + goto bad; + if (!PyType_Check(result)) { + PyErr_Format(PyExc_TypeError, + "%.200s.%.200s is not a type object", + module_name, class_name); + goto bad; + } +#if !( defined(Py_LIMITED_API) || (defined(CYTHON_COMPILING_IN_LIMITED_API) && CYTHON_COMPILING_IN_LIMITED_API) ) + basicsize = ((PyTypeObject *)result)->tp_basicsize; + itemsize = ((PyTypeObject *)result)->tp_itemsize; +#else + if (size == 0) { + return (PyTypeObject *)result; + } + py_basicsize = PyObject_GetAttrString(result, "__basicsize__"); + if (!py_basicsize) + goto bad; + basicsize = PyLong_AsSsize_t(py_basicsize); + Py_DECREF(py_basicsize); + py_basicsize = 0; + if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred()) + goto bad; + py_itemsize = PyObject_GetAttrString(result, "__itemsize__"); + if (!py_itemsize) + goto bad; + itemsize = PyLong_AsSsize_t(py_itemsize); + Py_DECREF(py_itemsize); + py_itemsize = 0; + if (itemsize == (Py_ssize_t)-1 && PyErr_Occurred()) + goto bad; +#endif + if (itemsize) { + // If itemsize is smaller than the alignment the struct can end up with some extra + // padding at the end. In this case we need to work out the maximum size that + // the padding could be when calculating the range of valid struct sizes. + if (size % alignment) { + // if this is true we've probably calculated the alignment wrongly + // (most likely because alignof isn't available) + alignment = size % alignment; + } + if (itemsize < (Py_ssize_t)alignment) + itemsize = (Py_ssize_t)alignment; + } + if ((size_t)(basicsize + itemsize) < size) { + PyErr_Format(PyExc_ValueError, + "%.200s.%.200s size changed, may indicate binary incompatibility. " + "Expected %zd from C header, got %zd from PyObject", + module_name, class_name, size, basicsize+itemsize); + goto bad; + } + // varobjects almost have structs between basicsize and basicsize + itemsize + // but the struct isn't always one of the two limiting values + if (check_size == __Pyx_ImportType_CheckSize_Error_$cyversion && + ((size_t)basicsize > size || (size_t)(basicsize + itemsize) < size)) { + PyErr_Format(PyExc_ValueError, + "%.200s.%.200s size changed, may indicate binary incompatibility. " + "Expected %zd from C header, got %zd-%zd from PyObject", + module_name, class_name, size, basicsize, basicsize+itemsize); + goto bad; + } + else if (check_size == __Pyx_ImportType_CheckSize_Warn_$cyversion && (size_t)basicsize > size) { + if (PyErr_WarnFormat(NULL, 0, + "%.200s.%.200s size changed, may indicate binary incompatibility. " + "Expected %zd from C header, got %zd from PyObject", + module_name, class_name, size, basicsize) < 0) { + goto bad; + } + } + /* check_size == __Pyx_ImportType_CheckSize_Ignore does not warn nor error */ + return (PyTypeObject *)result; +bad: + Py_XDECREF(result); + return NULL; +} +#endif + +/////////////// FunctionImport.proto /////////////// +//@substitute: naming + +static int __Pyx_ImportFunction_$cyversion(PyObject *module, const char *funcname, void (**f)(void), const char *sig); /*proto*/ + +/////////////// FunctionImport /////////////// +//@substitute: naming + +#ifndef __PYX_HAVE_RT_ImportFunction_$cyversion +#define __PYX_HAVE_RT_ImportFunction_$cyversion +static int __Pyx_ImportFunction_$cyversion(PyObject *module, const char *funcname, void (**f)(void), const char *sig) { + PyObject *d = 0; + PyObject *cobj = 0; + union { + void (*fp)(void); + void *p; + } tmp; + + d = PyObject_GetAttrString(module, "$api_name"); + if (!d) + goto bad; +#if (defined(Py_LIMITED_API) && Py_LIMITED_API >= 0x030d0000) || (!defined(Py_LIMITED_API) && PY_VERSION_HEX >= 0x030d0000) + PyDict_GetItemStringRef(d, funcname, &cobj); +#else + cobj = PyDict_GetItemString(d, funcname); + Py_XINCREF(cobj); +#endif + if (!cobj) { + PyErr_Format(PyExc_ImportError, + "%.200s does not export expected C function %.200s", + PyModule_GetName(module), funcname); + goto bad; + } + if (!PyCapsule_IsValid(cobj, sig)) { + PyErr_Format(PyExc_TypeError, + "C function %.200s.%.200s has wrong signature (expected %.500s, got %.500s)", + PyModule_GetName(module), funcname, sig, PyCapsule_GetName(cobj)); + goto bad; + } + tmp.p = PyCapsule_GetPointer(cobj, sig); + *f = tmp.fp; + if (!(*f)) + goto bad; + Py_DECREF(d); + Py_DECREF(cobj); + return 0; +bad: + Py_XDECREF(d); + Py_XDECREF(cobj); + return -1; +} +#endif + +/////////////// FunctionExport.proto /////////////// + +static int __Pyx_ExportFunction(const char *name, void (*f)(void), const char *sig); /*proto*/ + +/////////////// FunctionExport /////////////// +//@substitute: naming + +static int __Pyx_ExportFunction(const char *name, void (*f)(void), const char *sig) { + PyObject *d = 0; + PyObject *cobj = 0; + union { + void (*fp)(void); + void *p; + } tmp; + + d = PyObject_GetAttrString($module_cname, "$api_name"); + if (!d) { + PyErr_Clear(); + d = PyDict_New(); + if (!d) + goto bad; + Py_INCREF(d); + if (PyModule_AddObject($module_cname, "$api_name", d) < 0) + goto bad; + } + tmp.fp = f; + cobj = PyCapsule_New(tmp.p, sig, 0); + if (!cobj) + goto bad; + if (PyDict_SetItemString(d, name, cobj) < 0) + goto bad; + Py_DECREF(cobj); + Py_DECREF(d); + return 0; +bad: + Py_XDECREF(cobj); + Py_XDECREF(d); + return -1; +} + +/////////////// VoidPtrImport.proto /////////////// +//@substitute: naming + +static int __Pyx_ImportVoidPtr_$cyversion(PyObject *module, const char *name, void **p, const char *sig); /*proto*/ + +/////////////// VoidPtrImport /////////////// +//@substitute: naming + +#ifndef __PYX_HAVE_RT_ImportVoidPtr_$cyversion +#define __PYX_HAVE_RT_ImportVoidPtr_$cyversion +static int __Pyx_ImportVoidPtr_$cyversion(PyObject *module, const char *name, void **p, const char *sig) { + PyObject *d = 0; + PyObject *cobj = 0; + + d = PyObject_GetAttrString(module, "$api_name"); + if (!d) + goto bad; +// potentially defined in headers so we can't rely on __PYX_LIMITED_VERSION_HEX +#if (defined(Py_LIMITED_API) && Py_LIMITED_API >= 0x030d0000) || (!defined(Py_LIMITED_API) && PY_VERSION_HEX >= 0x030d0000) + PyDict_GetItemStringRef(d, name, &cobj); +#else + cobj = PyDict_GetItemString(d, name); + Py_XINCREF(cobj); +#endif + if (!cobj) { + PyErr_Format(PyExc_ImportError, + "%.200s does not export expected C variable %.200s", + PyModule_GetName(module), name); + goto bad; + } + if (!PyCapsule_IsValid(cobj, sig)) { + PyErr_Format(PyExc_TypeError, + "C variable %.200s.%.200s has wrong signature (expected %.500s, got %.500s)", + PyModule_GetName(module), name, sig, PyCapsule_GetName(cobj)); + goto bad; + } + *p = PyCapsule_GetPointer(cobj, sig); + if (!(*p)) + goto bad; + Py_DECREF(d); + Py_DECREF(cobj); + return 0; +bad: + Py_XDECREF(d); + Py_XDECREF(cobj); + return -1; +} +#endif + +/////////////// VoidPtrExport.proto /////////////// + +static int __Pyx_ExportVoidPtr(PyObject *name, void *p, const char *sig); /*proto*/ + +/////////////// VoidPtrExport /////////////// +//@substitute: naming +//@requires: ObjectHandling.c::PyObjectSetAttrStr + +static int __Pyx_ExportVoidPtr(PyObject *name, void *p, const char *sig) { + PyObject *d; + PyObject *cobj = 0; + + if (__Pyx_PyDict_GetItemRef(NAMED_CGLOBAL(moddict_cname), PYIDENT("$api_name"), &d) == -1) + goto bad; + if (!d) { + d = PyDict_New(); + if (!d) + goto bad; + if (__Pyx_PyObject_SetAttrStr($module_cname, PYIDENT("$api_name"), d) < 0) + goto bad; + } + cobj = PyCapsule_New(p, sig, 0); + if (!cobj) + goto bad; + if (PyDict_SetItem(d, name, cobj) < 0) + goto bad; + Py_DECREF(cobj); + Py_DECREF(d); + return 0; +bad: + Py_XDECREF(cobj); + Py_XDECREF(d); + return -1; +} + + +/////////////// SetVTable.proto /////////////// + +static int __Pyx_SetVtable(PyTypeObject* typeptr , void* vtable); /*proto*/ + +/////////////// SetVTable /////////////// + +static int __Pyx_SetVtable(PyTypeObject *type, void *vtable) { + PyObject *ob = PyCapsule_New(vtable, 0, 0); + if (unlikely(!ob)) + goto bad; +#if CYTHON_COMPILING_IN_LIMITED_API + if (unlikely(PyObject_SetAttr((PyObject *) type, PYIDENT("__pyx_vtable__"), ob) < 0)) +#else + if (unlikely(PyDict_SetItem(type->tp_dict, PYIDENT("__pyx_vtable__"), ob) < 0)) +#endif + goto bad; + Py_DECREF(ob); + return 0; +bad: + Py_XDECREF(ob); + return -1; +} + + +/////////////// GetVTable.proto /////////////// + +static void* __Pyx_GetVtable(PyTypeObject *type); /*proto*/ + +/////////////// GetVTable /////////////// + +static void* __Pyx_GetVtable(PyTypeObject *type) { + void* ptr; +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *ob = PyObject_GetAttr((PyObject *)type, PYIDENT("__pyx_vtable__")); +#else + PyObject *ob = PyObject_GetItem(type->tp_dict, PYIDENT("__pyx_vtable__")); +#endif + if (!ob) + goto bad; + ptr = PyCapsule_GetPointer(ob, 0); + if (!ptr && !PyErr_Occurred()) + PyErr_SetString(PyExc_RuntimeError, "invalid vtable found for imported type"); + Py_DECREF(ob); + return ptr; +bad: + Py_XDECREF(ob); + return NULL; +} + + +/////////////// MergeVTables.proto /////////////// +//@requires: GetVTable + +static int __Pyx_MergeVtables(PyTypeObject *type); /*proto*/ + +/////////////// MergeVTables /////////////// + +static int __Pyx_MergeVtables(PyTypeObject *type) { + int i=0; + Py_ssize_t size; + void** base_vtables; + __Pyx_TypeName tp_base_name = NULL; + __Pyx_TypeName base_name = NULL; + void* unknown = (void*)-1; + PyObject* bases = __Pyx_PyType_GetSlot(type, tp_bases, PyObject*); + int base_depth = 0; + { + PyTypeObject* base = __Pyx_PyType_GetSlot(type, tp_base, PyTypeObject*); + while (base) { + base_depth += 1; + base = __Pyx_PyType_GetSlot(base, tp_base, PyTypeObject*); + } + } + base_vtables = (void**) PyMem_Malloc(sizeof(void*) * (size_t)(base_depth + 1)); + base_vtables[0] = unknown; + // Could do MRO resolution of individual methods in the future, assuming + // compatible vtables, but for now simply require a common vtable base. + // Note that if the vtables of various bases are extended separately, + // resolution isn't possible and we must reject it just as when the + // instance struct is so extended. (It would be good to also do this + // check when a multiple-base class is created in pure Python as well.) +#if CYTHON_COMPILING_IN_LIMITED_API + size = PyTuple_Size(bases); + if (size < 0) goto other_failure; +#else + size = PyTuple_GET_SIZE(bases); +#endif + for (i = 1; i < size; i++) { + PyObject *basei; + void* base_vtable; +#if CYTHON_AVOID_BORROWED_REFS + basei = PySequence_GetItem(bases, i); + if (unlikely(!basei)) goto other_failure; +#elif !CYTHON_ASSUME_SAFE_MACROS + basei = PyTuple_GetItem(bases, i); + if (unlikely(!basei)) goto other_failure; +#else + basei = PyTuple_GET_ITEM(bases, i); +#endif + base_vtable = __Pyx_GetVtable((PyTypeObject*)basei); +#if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(basei); +#endif + if (base_vtable != NULL) { + int j; + PyTypeObject* base = __Pyx_PyType_GetSlot(type, tp_base, PyTypeObject*); + for (j = 0; j < base_depth; j++) { + if (base_vtables[j] == unknown) { + base_vtables[j] = __Pyx_GetVtable(base); + base_vtables[j + 1] = unknown; + } + if (base_vtables[j] == base_vtable) { + break; + } else if (base_vtables[j] == NULL) { + // No more potential matching bases (with vtables). + goto bad; + } + base = __Pyx_PyType_GetSlot(base, tp_base, PyTypeObject*); + } + } + } + PyErr_Clear(); + PyMem_Free(base_vtables); + return 0; +bad: + { + PyTypeObject* basei = NULL; + PyTypeObject* tp_base = __Pyx_PyType_GetSlot(type, tp_base, PyTypeObject*); + tp_base_name = __Pyx_PyType_GetFullyQualifiedName(tp_base); +#if CYTHON_AVOID_BORROWED_REFS + basei = (PyTypeObject*)PySequence_GetItem(bases, i); + if (unlikely(!basei)) goto really_bad; +#elif !CYTHON_ASSUME_SAFE_MACROS + basei = (PyTypeObject*)PyTuple_GetItem(bases, i); + if (unlikely(!basei)) goto really_bad; +#else + basei = (PyTypeObject*)PyTuple_GET_ITEM(bases, i); +#endif + base_name = __Pyx_PyType_GetFullyQualifiedName(basei); +#if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(basei); +#endif + } + PyErr_Format(PyExc_TypeError, + "multiple bases have vtable conflict: '" __Pyx_FMT_TYPENAME "' and '" __Pyx_FMT_TYPENAME "'", tp_base_name, base_name); +#if CYTHON_AVOID_BORROWED_REFS || !CYTHON_ASSUME_SAFE_MACROS +really_bad: // bad has failed! +#endif + __Pyx_DECREF_TypeName(tp_base_name); + __Pyx_DECREF_TypeName(base_name); +#if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_AVOID_BORROWED_REFS || !CYTHON_ASSUME_SAFE_MACROS +other_failure: +#endif + PyMem_Free(base_vtables); + return -1; +} + +/////////////// ImportNumPyArray.module_state_decls ////////////// +//@requires: Synchronization.c::Atomics + +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING && CYTHON_ATOMICS +__pyx_atomic_ptr_type __pyx_numpy_ndarray; +#else +// If freethreading but not atomics, then this is guarded by ndarray_mutex +// in __Pyx__ImportNumPyArrayTypeIfAvailable +PyObject *__pyx_numpy_ndarray; +#endif + +/////////////// ImportNumPyArray.proto /////////////// + +static PyObject* __Pyx_ImportNumPyArrayTypeIfAvailable(void); /*proto*/ + +/////////////// ImportNumPyArray.cleanup /////////////// + +// I'm not actually worried about thread-safety in the cleanup function. +// The CYTHON_ATOMICS code is only for the type-casting. +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING && CYTHON_ATOMICS +{ + PyObject* old = (PyObject*)__pyx_atomic_pointer_exchange(&CGLOBAL(__pyx_numpy_ndarray), NULL); + Py_XDECREF(old); +} +#else +Py_CLEAR(CGLOBAL(__pyx_numpy_ndarray)); +#endif + +/////////////// ImportNumPyArray /////////////// +//@requires: ImportExport.c::Import + +static PyObject* __Pyx__ImportNumPyArray(void) { + PyObject *numpy_module, *ndarray_object = NULL; + numpy_module = __Pyx_Import(PYIDENT("numpy"), NULL, 0); + if (likely(numpy_module)) { + ndarray_object = PyObject_GetAttrString(numpy_module, "ndarray"); + Py_DECREF(numpy_module); + } + if (unlikely(!ndarray_object)) { + // ImportError, AttributeError, ... + PyErr_Clear(); + } + if (unlikely(!ndarray_object || !PyObject_TypeCheck(ndarray_object, &PyType_Type))) { + Py_XDECREF(ndarray_object); + Py_INCREF(Py_None); + ndarray_object = Py_None; + } + return ndarray_object; +} + +// Returns a borrowed reference, and encapsulates all thread safety stuff needed +static CYTHON_INLINE PyObject* __Pyx__ImportNumPyArrayTypeIfAvailable(void) { +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + static PyMutex ndarray_mutex = {0}; +#endif +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING && CYTHON_ATOMICS + PyObject *result = (PyObject*)__pyx_atomic_pointer_load_relaxed(&CGLOBAL(__pyx_numpy_ndarray)); + if (unlikely(!result)) { + PyMutex_Lock(&ndarray_mutex); + // Now we've got the lock and know that no-one else is modifying it, check again + // that it hasn't already been set. + result = (PyObject*)__pyx_atomic_pointer_load_acquire(&CGLOBAL(__pyx_numpy_ndarray)); + if (!result) { + result = __Pyx__ImportNumPyArray(); + __pyx_atomic_pointer_exchange(&CGLOBAL(__pyx_numpy_ndarray), result); + } + PyMutex_Unlock(&ndarray_mutex); + } + return result; +#else +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING // but not atomics + PyMutex_Lock(&ndarray_mutex); +#endif + if (unlikely(!CGLOBAL(__pyx_numpy_ndarray))) + { + CGLOBAL(__pyx_numpy_ndarray) = __Pyx__ImportNumPyArray(); + } +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING // but not atomics + PyMutex_Unlock(&ndarray_mutex); +#endif + return CGLOBAL(__pyx_numpy_ndarray); +#endif +} + +static CYTHON_INLINE PyObject* __Pyx_ImportNumPyArrayTypeIfAvailable(void) { + PyObject *result = __Pyx__ImportNumPyArrayTypeIfAvailable(); + Py_INCREF(result); + return result; +} diff --git a/venv/lib/python3.10/site-packages/Cython/Utility/MemoryView.pxd b/venv/lib/python3.10/site-packages/Cython/Utility/MemoryView.pxd new file mode 100644 index 0000000000000000000000000000000000000000..e6ad0fe6ebc7cadc56d3e90c60eb87a1d5323ed1 --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Utility/MemoryView.pxd @@ -0,0 +1,187 @@ +# from cpython cimport ... + +cimport cython +cdef extern from "Python.h": + ctypedef struct PyObject + ctypedef void *PyThread_type_lock + +cdef extern from *: + ctypedef struct {{memviewslice_name}}: + pass + + ctypedef struct __pyx_buffer "Py_buffer": + PyObject *obj + + ctypedef struct __Pyx_TypeInfo: + pass + + cdef struct __pyx_memoryview "__pyx_memoryview_obj": + Py_buffer view + PyObject *obj + const __Pyx_TypeInfo *typeinfo + + ctypedef int __pyx_atomic_int_type + + {{memviewslice_name}} slice_copy_contig "__pyx_memoryview_copy_new_contig"( + {{memviewslice_name}} *from_mvs, + char *mode, int ndim, + size_t sizeof_dtype, int contig_flag, + bint dtype_is_object) except * nogil + bint slice_is_contig "__pyx_memviewslice_is_contig" ( + {{memviewslice_name}} mvs, char order, int ndim) nogil + bint slices_overlap "__pyx_slices_overlap" ({{memviewslice_name}} *slice1, + {{memviewslice_name}} *slice2, + int ndim, size_t itemsize) nogil + +@cname("__pyx_array") +cdef class array: + + cdef: + char *data + Py_ssize_t len + char *format + int ndim + Py_ssize_t *_shape + Py_ssize_t *_strides + Py_ssize_t itemsize + unicode mode # FIXME: this should have been a simple 'char' + bytes _format + void (*callback_free_data)(void *data) noexcept + # cdef object _memview + cdef bint free_data + cdef bint dtype_is_object + + @cname('get_memview') + cdef get_memview(self) + +@cname("__pyx_array_allocate_buffer") +cdef int _allocate_buffer(array self) except -1 + +@cname("__pyx_array_new") +cdef array array_cwrapper(tuple shape, Py_ssize_t itemsize, char *format, const char *c_mode, char *buf) + +@cname('__pyx_memoryview') +cdef class memoryview: + + cdef object obj + cdef object _size + cdef object _array_interface + cdef PyThread_type_lock lock + cdef __pyx_atomic_int_type acquisition_count + cdef Py_buffer view + cdef int flags + cdef bint dtype_is_object + cdef const __Pyx_TypeInfo *typeinfo + + cdef char *get_item_pointer(memoryview self, object index) except NULL + cdef is_slice(self, obj) + cdef setitem_slice_assignment(self, dst, src) + cdef setitem_slice_assign_scalar(self, memoryview dst, value) + cdef setitem_indexed(self, index, value) + cdef convert_item_to_object(self, char *itemp) + cdef assign_item_from_object(self, char *itemp, object value) + cdef _get_base(self) + +@cname('__pyx_memoryview_new') +cdef memoryview_cwrapper(object o, int flags, bint dtype_is_object, const __Pyx_TypeInfo *typeinfo) + +@cname('__pyx_memoryview_check') +cdef inline bint memoryview_check(object o) noexcept: + return isinstance(o, memoryview) + +@cname('__pyx_memview_slice') +cdef memoryview memview_slice(memoryview memview, object indices) + +@cname('__pyx_memoryview_slice_memviewslice') +cdef int slice_memviewslice( + {{memviewslice_name}} *dst, + Py_ssize_t shape, Py_ssize_t stride, Py_ssize_t suboffset, + int dim, int new_ndim, int *suboffset_dim, + Py_ssize_t start, Py_ssize_t stop, Py_ssize_t step, + int have_start, int have_stop, int have_step, + bint is_slice) except -1 nogil + +@cname('__pyx_pybuffer_index') +cdef char *pybuffer_index(Py_buffer *view, char *bufp, Py_ssize_t index, + Py_ssize_t dim) except NULL + +@cname('__pyx_memslice_transpose') +cdef int transpose_memslice({{memviewslice_name}} *memslice) except -1 nogil + +@cname('__pyx_memoryview_fromslice') +cdef memoryview_fromslice({{memviewslice_name}} memviewslice, + int ndim, + object (*to_object_func)(char *), + int (*to_dtype_func)(char *, object) except 0, + bint dtype_is_object) + +@cname('__pyx_memoryview_get_slice_from_memoryview') +cdef {{memviewslice_name}} *get_slice_from_memview(memoryview memview, + {{memviewslice_name}} *mslice) except NULL + +@cname('__pyx_memoryview_slice_copy') +cdef void slice_copy(memoryview memview, {{memviewslice_name}} *dst) noexcept + +@cname('__pyx_memoryview_copy_object') +cdef memoryview_copy(memoryview memview) + +@cname('__pyx_memoryview_copy_object_from_slice') +cdef memoryview_copy_from_slice(memoryview memview, {{memviewslice_name}} *memviewslice) + +@cname('__pyx_get_best_slice_order') +cdef char get_best_order({{memviewslice_name}} *mslice, int ndim) noexcept nogil + +@cname('__pyx_memoryview_slice_get_size') +cdef Py_ssize_t slice_get_size({{memviewslice_name}} *src, int ndim) noexcept nogil + +@cname('__pyx_fill_contig_strides_array') +cdef Py_ssize_t fill_contig_strides_array( + Py_ssize_t *shape, Py_ssize_t *strides, Py_ssize_t stride, + int ndim, char order) noexcept nogil + +@cname('__pyx_memoryview_copy_data_to_temp') +cdef void *copy_data_to_temp({{memviewslice_name}} *src, + {{memviewslice_name}} *tmpslice, + char order, + int ndim) except NULL nogil + +@cname('__pyx_memoryview_err_extents') +cdef int _err_extents(int i, Py_ssize_t extent1, + Py_ssize_t extent2) except -1 with gil + +@cname('__pyx_memoryview_err_dim') +cdef int _err_dim(PyObject *error, str msg, int dim) except -1 with gil + +@cname('__pyx_memoryview_err') +cdef int _err(PyObject *error, str msg) except -1 with gil + +@cname('__pyx_memoryview_err_no_memory') +cdef int _err_no_memory() except -1 with gil + +@cname('__pyx_memoryview_copy_contents') +cdef int memoryview_copy_contents({{memviewslice_name}} src, + {{memviewslice_name}} dst, + int src_ndim, int dst_ndim, + bint dtype_is_object) except -1 nogil + +@cname('__pyx_memoryview_broadcast_leading') +cdef void broadcast_leading({{memviewslice_name}} *mslice, + int ndim, + int ndim_other) noexcept nogil + +@cname('__pyx_memoryview_refcount_copying') +cdef void refcount_copying({{memviewslice_name}} *dst, bint dtype_is_object, int ndim, bint inc) noexcept nogil + +@cname('__pyx_memoryview_refcount_objects_in_slice') +cdef void refcount_objects_in_slice(char *data, Py_ssize_t *shape, + Py_ssize_t *strides, int ndim, bint inc) noexcept + +@cname('__pyx_memoryview_slice_assign_scalar') +cdef void slice_assign_scalar({{memviewslice_name}} *dst, int ndim, + size_t itemsize, void *item, + bint dtype_is_object) noexcept nogil + +@cname('__pyx_memoryview__slice_assign_scalar') +cdef void _slice_assign_scalar(char *data, Py_ssize_t *shape, + Py_ssize_t *strides, int ndim, + size_t itemsize, void *item) noexcept nogil diff --git a/venv/lib/python3.10/site-packages/Cython/Utility/MemoryView.pyx b/venv/lib/python3.10/site-packages/Cython/Utility/MemoryView.pyx new file mode 100644 index 0000000000000000000000000000000000000000..7ec91a80056188dac000f1331b273a731a53da65 --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Utility/MemoryView.pyx @@ -0,0 +1,1481 @@ +#################### View.MemoryView #################### + +# cython: language_level=3 +# cython: binding=False + +# This utility provides cython.array and cython.view.memoryview + +from __future__ import absolute_import + +cimport cython + +# from cpython cimport ... +cdef extern from "Python.h": + ctypedef struct PyObject + int PyIndex_Check(object) + PyObject *PyExc_IndexError + PyObject *PyExc_ValueError + +cdef extern from "pythread.h": + ctypedef void *PyThread_type_lock + + PyThread_type_lock PyThread_allocate_lock() + void PyThread_free_lock(PyThread_type_lock) + +cdef extern from "": + void *memset(void *b, int c, size_t len) + +cdef extern from *: + bint __PYX_CYTHON_ATOMICS_ENABLED() + bint __PYX_GET_CYTHON_COMPILING_IN_CPYTHON_FREETHREADING() + int PyObject_GetBuffer(object, Py_buffer *, int) except -1 + void PyBuffer_Release(Py_buffer *) + + ctypedef struct PyObject + ctypedef Py_ssize_t Py_intptr_t + void Py_INCREF(PyObject *) + void Py_DECREF(PyObject *) + + void* PyMem_Malloc(size_t n) + void PyMem_Free(void *p) + void* PyObject_Malloc(size_t n) + void PyObject_Free(void *p) + + cdef struct __pyx_memoryview "__pyx_memoryview_obj": + Py_buffer view + PyObject *obj + const __Pyx_TypeInfo *typeinfo + + ctypedef struct {{memviewslice_name}}: + __pyx_memoryview *memview + char *data + Py_ssize_t shape[{{max_dims}}] + Py_ssize_t strides[{{max_dims}}] + Py_ssize_t suboffsets[{{max_dims}}] + + void __PYX_INC_MEMVIEW({{memviewslice_name}} *memslice, int have_gil) + void __PYX_XCLEAR_MEMVIEW({{memviewslice_name}} *memslice, int have_gil) + + ctypedef struct __pyx_buffer "Py_buffer": + PyObject *obj + + PyObject *Py_None + + cdef enum: + PyBUF_C_CONTIGUOUS, + PyBUF_F_CONTIGUOUS, + PyBUF_ANY_CONTIGUOUS + PyBUF_FORMAT + PyBUF_WRITABLE + PyBUF_STRIDES + PyBUF_INDIRECT + PyBUF_ND + PyBUF_RECORDS + PyBUF_RECORDS_RO + + ctypedef struct __Pyx_TypeInfo: + pass + +cdef extern from *: + ctypedef int __pyx_atomic_int_type + {{memviewslice_name}} slice_copy_contig "__pyx_memoryview_copy_new_contig"( + {{memviewslice_name}} *from_mvs, + const char *mode, int ndim, + size_t sizeof_dtype, int contig_flag, + bint dtype_is_object) except * nogil + bint slice_is_contig "__pyx_memviewslice_is_contig" ( + {{memviewslice_name}} mvs, char order, int ndim) nogil + bint slices_overlap "__pyx_slices_overlap" ({{memviewslice_name}} *slice1, + {{memviewslice_name}} *slice2, + int ndim, size_t itemsize) nogil + + +cdef extern from "": + void *malloc(size_t) nogil + void free(void *) nogil + void *memcpy(void *dest, void *src, size_t n) nogil + +# the sequence abstract base class +cdef object __pyx_collections_abc_Sequence "__pyx_collections_abc_Sequence" +try: + __pyx_collections_abc_Sequence = __import__("collections.abc").abc.Sequence +except: + # it isn't a big problem if this fails + __pyx_collections_abc_Sequence = None + +# +### cython.array class +# + +@cython.collection_type("sequence") +@cname("__pyx_array") +cdef class array: + + cdef: + char *data + Py_ssize_t len + char *format + int ndim + Py_ssize_t *_shape + Py_ssize_t *_strides + Py_ssize_t itemsize + unicode mode # FIXME: this should have been a simple 'char' + bytes _format + void (*callback_free_data)(void *data) noexcept + # cdef object _memview + cdef bint free_data + cdef bint dtype_is_object + + def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None, + mode="c", bint allocate_buffer=True): + + cdef int idx + cdef Py_ssize_t dim + + self.ndim = len(shape) + self.itemsize = itemsize + + if not self.ndim: + raise ValueError, "Empty shape tuple for cython.array" + + if itemsize <= 0: + raise ValueError, "itemsize <= 0 for cython.array" + + if not isinstance(format, bytes): + format = format.encode('ASCII') + self._format = format # keep a reference to the byte string + self.format = self._format + + # use single malloc() for both shape and strides + self._shape = PyObject_Malloc(sizeof(Py_ssize_t)*self.ndim*2) + self._strides = self._shape + self.ndim + + if not self._shape: + raise MemoryError, "unable to allocate shape and strides." + + # cdef Py_ssize_t dim, stride + for idx, dim in enumerate(shape): + if dim <= 0: + raise ValueError, f"Invalid shape in axis {idx}: {dim}." + self._shape[idx] = dim + + cdef char order + if mode == 'c': + order = b'C' + self.mode = u'c' + elif mode == 'fortran': + order = b'F' + self.mode = u'fortran' + else: + raise ValueError, f"Invalid mode, expected 'c' or 'fortran', got {mode}" + + self.len = fill_contig_strides_array(self._shape, self._strides, itemsize, self.ndim, order) + + self.free_data = allocate_buffer + self.dtype_is_object = format == b'O' + + if allocate_buffer: + _allocate_buffer(self) + + @cname('getbuffer') + def __getbuffer__(self, Py_buffer *info, int flags): + cdef int bufmode = -1 + if flags & (PyBUF_C_CONTIGUOUS | PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS): + if self.mode == u"c": + bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + elif self.mode == u"fortran": + bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + if not (flags & bufmode): + raise ValueError, "Can only create a buffer that is contiguous in memory." + info.buf = self.data + info.len = self.len + + if flags & PyBUF_STRIDES: + info.ndim = self.ndim + info.shape = self._shape + info.strides = self._strides + else: + info.ndim = 1 + info.shape = &self.len if flags & PyBUF_ND else NULL + info.strides = NULL + + info.suboffsets = NULL + info.itemsize = self.itemsize + info.readonly = 0 + info.format = self.format if flags & PyBUF_FORMAT else NULL + info.obj = self + + def __dealloc__(array self): + if self.callback_free_data != NULL: + self.callback_free_data(self.data) + elif self.free_data and self.data is not NULL: + if self.dtype_is_object: + refcount_objects_in_slice(self.data, self._shape, self._strides, self.ndim, inc=False) + free(self.data) + PyObject_Free(self._shape) + + @property + def memview(self): + return self.get_memview() + + @cname('get_memview') + cdef get_memview(self): + flags = PyBUF_ANY_CONTIGUOUS|PyBUF_FORMAT|PyBUF_WRITABLE + return memoryview(self, flags, self.dtype_is_object) + + def __len__(self): + return self._shape[0] + + def __getattr__(self, attr): + return getattr(self.memview, attr) + + def __getitem__(self, item): + return self.memview[item] + + def __setitem__(self, item, value): + self.memview[item] = value + + # Sequence methods + try: + count = __pyx_collections_abc_Sequence.count + index = __pyx_collections_abc_Sequence.index + except: + pass + +@cname("__pyx_array_allocate_buffer") +cdef int _allocate_buffer(array self) except -1: + # use malloc() for backwards compatibility + # in case external code wants to change the data pointer + cdef Py_ssize_t i + cdef PyObject **p + + self.free_data = True + self.data = malloc(self.len) + if not self.data: + raise MemoryError, "unable to allocate array data." + + if self.dtype_is_object: + p = self.data + for i in range(self.len // self.itemsize): + p[i] = Py_None + Py_INCREF(Py_None) + return 0 + + +@cname("__pyx_array_new") +cdef array array_cwrapper(tuple shape, Py_ssize_t itemsize, char *format, const char *c_mode, char *buf): + cdef array result + cdef str mode = "fortran" if c_mode[0] == b'f' else "c" # this often comes from a constant C string. + + if buf is NULL: + result = array.__new__(array, shape, itemsize, format, mode) + else: + result = array.__new__(array, shape, itemsize, format, mode, allocate_buffer=False) + result.data = buf + + return result + + +# +### Memoryview constants and cython.view.memoryview class +# + +# Disable generic_contiguous, as it makes trouble verifying contiguity: +# - 'contiguous' or '::1' means the dimension is contiguous with dtype +# - 'indirect_contiguous' means a contiguous list of pointers +# - dtype contiguous must be contiguous in the first or last dimension +# from the start, or from the dimension following the last indirect dimension +# +# e.g. +# int[::indirect_contiguous, ::contiguous, :] +# +# is valid (list of pointers to 2d fortran-contiguous array), but +# +# int[::generic_contiguous, ::contiguous, :] +# +# would mean you'd have assert dimension 0 to be indirect (and pointer contiguous) at runtime. +# So it doesn't bring any performance benefit, and it's only confusing. + +@cname('__pyx_MemviewEnum') +cdef class Enum(object): + cdef object name + def __init__(self, name): + self.name = name + def __repr__(self): + return self.name + +cdef generic = Enum("") +cdef strided = Enum("") # default +cdef indirect = Enum("") +# Disable generic_contiguous, as it is a troublemaker +#cdef generic_contiguous = Enum("") +cdef contiguous = Enum("") +cdef indirect_contiguous = Enum("") + +# 'follow' is implied when the first or last axis is ::1 + + +# pre-allocate thread locks for reuse +## note that this could be implemented in a more beautiful way in "normal" Cython, +## but this code gets merged into the user module and not everything works there. +cdef int __pyx_memoryview_thread_locks_used = 0 +cdef PyThread_type_lock[{{THREAD_LOCKS_PREALLOCATED}}] __pyx_memoryview_thread_locks = [ +{{for _ in range(THREAD_LOCKS_PREALLOCATED)}} + PyThread_allocate_lock(), +{{endfor}} +] + + +@cname('__pyx_memoryview') +cdef class memoryview: + + cdef object obj + cdef object _size + cdef object _array_interface + cdef PyThread_type_lock lock + cdef __pyx_atomic_int_type acquisition_count + cdef Py_buffer view + cdef int flags + cdef bint dtype_is_object + cdef const __Pyx_TypeInfo *typeinfo + + def __cinit__(memoryview self, object obj, int flags, bint dtype_is_object=False): + self.obj = obj + self.flags = flags + if type(self) is memoryview or obj is not None: + PyObject_GetBuffer(obj, &self.view, flags) + if self.view.obj == NULL: + (<__pyx_buffer *> &self.view).obj = Py_None + Py_INCREF(Py_None) + + if not __PYX_CYTHON_ATOMICS_ENABLED(): + global __pyx_memoryview_thread_locks_used + if (__pyx_memoryview_thread_locks_used < {{THREAD_LOCKS_PREALLOCATED}} and + # preallocated locks cannot be made thread-safe in freethreading + not __PYX_GET_CYTHON_COMPILING_IN_CPYTHON_FREETHREADING()): + self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] + __pyx_memoryview_thread_locks_used += 1 + if self.lock is NULL: + self.lock = PyThread_allocate_lock() + if self.lock is NULL: + raise MemoryError + + if flags & PyBUF_FORMAT: + self.dtype_is_object = (self.view.format[0] == b'O' and self.view.format[1] == b'\0') + else: + self.dtype_is_object = dtype_is_object + + assert (&self.acquisition_count) % sizeof(__pyx_atomic_int_type) == 0 + self.typeinfo = NULL + + def __dealloc__(memoryview self): + if self.obj is not None: + PyBuffer_Release(&self.view) + elif (<__pyx_buffer *> &self.view).obj == Py_None: + # Undo the incref in __cinit__() above. + (<__pyx_buffer *> &self.view).obj = NULL + Py_DECREF(Py_None) + + cdef int i + global __pyx_memoryview_thread_locks_used + if self.lock != NULL: + for i in range(0 if __PYX_GET_CYTHON_COMPILING_IN_CPYTHON_FREETHREADING() else __pyx_memoryview_thread_locks_used): + if __pyx_memoryview_thread_locks[i] is self.lock: + __pyx_memoryview_thread_locks_used -= 1 + if i != __pyx_memoryview_thread_locks_used: + __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = ( + __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i]) + break + else: + PyThread_free_lock(self.lock) + + cdef char *get_item_pointer(memoryview self, object index) except NULL: + cdef Py_ssize_t dim + cdef char *itemp = self.view.buf + + for dim, idx in enumerate(index): + itemp = pybuffer_index(&self.view, itemp, idx, dim) + + return itemp + + #@cname('__pyx_memoryview_getitem') + def __getitem__(memoryview self, object index): + if index is Ellipsis: + return self + + have_slices, indices = _unellipsify(index, self.view.ndim) + + cdef char *itemp + if have_slices: + return memview_slice(self, indices) + else: + itemp = self.get_item_pointer(indices) + return self.convert_item_to_object(itemp) + + def __setitem__(memoryview self, object index, object value): + if self.view.readonly: + raise TypeError, "Cannot assign to read-only memoryview" + + have_slices, index = _unellipsify(index, self.view.ndim) + + if have_slices: + obj = self.is_slice(value) + if obj is not None: + self.setitem_slice_assignment(self[index], obj) + else: + self.setitem_slice_assign_scalar(self[index], value) + else: + self.setitem_indexed(index, value) + + cdef is_slice(self, obj): + if not isinstance(obj, memoryview): + try: + obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, + self.dtype_is_object) + except TypeError: + return None + + return obj + + cdef setitem_slice_assignment(self, dst, src): + cdef {{memviewslice_name}} dst_slice + cdef {{memviewslice_name}} src_slice + cdef {{memviewslice_name}} msrc = get_slice_from_memview(src, &src_slice)[0] + cdef {{memviewslice_name}} mdst = get_slice_from_memview(dst, &dst_slice)[0] + + memoryview_copy_contents(msrc, mdst, src.ndim, dst.ndim, self.dtype_is_object) + + cdef setitem_slice_assign_scalar(self, memoryview dst, value): + cdef int array[128] + cdef void *tmp = NULL + cdef void *item + + cdef {{memviewslice_name}} *dst_slice + cdef {{memviewslice_name}} tmp_slice + dst_slice = get_slice_from_memview(dst, &tmp_slice) + + if self.view.itemsize > sizeof(array): + tmp = PyMem_Malloc(self.view.itemsize) + if tmp == NULL: + raise MemoryError + item = tmp + else: + item = array + + try: + if self.dtype_is_object: + ( item)[0] = value + else: + self.assign_item_from_object( item, value) + + # It would be easy to support indirect dimensions, but it's easier + # to disallow :) + if self.view.suboffsets != NULL: + assert_direct_dimensions(self.view.suboffsets, self.view.ndim) + slice_assign_scalar(dst_slice, dst.view.ndim, self.view.itemsize, + item, self.dtype_is_object) + finally: + PyMem_Free(tmp) + + cdef setitem_indexed(self, index, value): + cdef char *itemp = self.get_item_pointer(index) + self.assign_item_from_object(itemp, value) + + cdef convert_item_to_object(self, char *itemp): + """Only used if instantiated manually by the user, or if Cython doesn't + know how to convert the type""" + import struct + cdef bytes bytesitem + # Do a manual and complete check here instead of this easy hack + bytesitem = itemp[:self.view.itemsize] + try: + result = struct.unpack(self.view.format, bytesitem) + except struct.error: + raise ValueError, "Unable to convert item to object" + else: + if len(self.view.format) == 1: + return result[0] + return result + + cdef assign_item_from_object(self, char *itemp, object value): + """Only used if instantiated manually by the user, or if Cython doesn't + know how to convert the type""" + import struct + cdef char c + cdef bytes bytesvalue + cdef Py_ssize_t i + + if isinstance(value, tuple): + bytesvalue = struct.pack(self.view.format, *value) + else: + bytesvalue = struct.pack(self.view.format, value) + + for i, c in enumerate(bytesvalue): + itemp[i] = c + + @cname('getbuffer') + def __getbuffer__(self, Py_buffer *info, int flags): + if flags & PyBUF_WRITABLE and self.view.readonly: + raise ValueError, "Cannot create writable memory view from read-only memoryview" + + if flags & PyBUF_ND: + info.shape = self.view.shape + else: + info.shape = NULL + + if flags & PyBUF_STRIDES: + info.strides = self.view.strides + else: + info.strides = NULL + + if flags & PyBUF_INDIRECT: + info.suboffsets = self.view.suboffsets + else: + info.suboffsets = NULL + + if flags & PyBUF_FORMAT: + info.format = self.view.format + else: + info.format = NULL + + info.buf = self.view.buf + info.ndim = self.view.ndim + info.itemsize = self.view.itemsize + info.len = self.view.len + info.readonly = self.view.readonly + info.obj = self + + # Some properties that have the same semantics as in NumPy + @property + def T(self): + cdef _memoryviewslice result = memoryview_copy(self) + transpose_memslice(&result.from_slice) + return result + + @property + def base(self): + return self._get_base() + + cdef _get_base(self): + return self.obj + + @property + def shape(self): + return tuple([length for length in self.view.shape[:self.view.ndim]]) + + @property + def strides(self): + if self.view.strides == NULL: + # Note: we always ask for strides, so if this is not set it's a bug + raise ValueError, "Buffer view does not expose strides" + + return tuple([stride for stride in self.view.strides[:self.view.ndim]]) + + @property + def suboffsets(self): + if self.view.suboffsets == NULL: + return (-1,) * self.view.ndim + + return tuple([suboffset for suboffset in self.view.suboffsets[:self.view.ndim]]) + + @property + def ndim(self): + return self.view.ndim + + @property + def itemsize(self): + return self.view.itemsize + + @property + def nbytes(self): + return self.size * self.view.itemsize + + @property + def size(self): + if self._size is None: + result = 1 + + for length in self.view.shape[:self.view.ndim]: + result *= length + + self._size = result + + return self._size + + def __len__(self): + if self.view.ndim >= 1: + return self.view.shape[0] + + return 0 + + def __repr__(self): + return "" % (self.base.__class__.__name__, + id(self)) + + def __str__(self): + return "" % (self.base.__class__.__name__,) + + # Support the same attributes as memoryview slices + def is_c_contig(self): + cdef {{memviewslice_name}} *mslice + cdef {{memviewslice_name}} tmp + mslice = get_slice_from_memview(self, &tmp) + return slice_is_contig(mslice[0], 'C', self.view.ndim) + + def is_f_contig(self): + cdef {{memviewslice_name}} *mslice + cdef {{memviewslice_name}} tmp + mslice = get_slice_from_memview(self, &tmp) + return slice_is_contig(mslice[0], 'F', self.view.ndim) + + def copy(self): + cdef {{memviewslice_name}} mslice + cdef int flags = self.flags & ~PyBUF_F_CONTIGUOUS + + slice_copy(self, &mslice) + mslice = slice_copy_contig(&mslice, "c", self.view.ndim, + self.view.itemsize, + flags|PyBUF_C_CONTIGUOUS, + self.dtype_is_object) + + return memoryview_copy_from_slice(self, &mslice) + + def copy_fortran(self): + cdef {{memviewslice_name}} src, dst + cdef int flags = self.flags & ~PyBUF_C_CONTIGUOUS + + slice_copy(self, &src) + dst = slice_copy_contig(&src, "fortran", self.view.ndim, + self.view.itemsize, + flags|PyBUF_F_CONTIGUOUS, + self.dtype_is_object) + + return memoryview_copy_from_slice(self, &dst) + + +@cname('__pyx_memoryview_new') +cdef memoryview_cwrapper(object o, int flags, bint dtype_is_object, const __Pyx_TypeInfo *typeinfo): + cdef memoryview result = memoryview(o, flags, dtype_is_object) + result.typeinfo = typeinfo + return result + +@cname('__pyx_memoryview_check') +cdef inline bint memoryview_check(object o) noexcept: + return isinstance(o, memoryview) + +cdef tuple _unellipsify(object index, int ndim): + """ + Replace all ellipses with full slices and fill incomplete indices with + full slices. + """ + cdef Py_ssize_t idx + tup = index if isinstance(index, tuple) else (index,) + + result = [slice(None)] * ndim + have_slices = False + seen_ellipsis = False + idx = 0 + for item in tup: + if item is Ellipsis: + if not seen_ellipsis: + idx += ndim - len(tup) + seen_ellipsis = True + have_slices = True + else: + if isinstance(item, slice): + have_slices = True + elif not PyIndex_Check(item): + raise TypeError, f"Cannot index with type '{type(item)}'" + result[idx] = item + idx += 1 + + nslices = ndim - idx + return have_slices or nslices, tuple(result) + +cdef int assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim) except -1: + for suboffset in suboffsets[:ndim]: + if suboffset >= 0: + raise ValueError, "Indirect dimensions not supported" + return 0 # return type just used as an error flag + +# +### Slicing a memoryview +# + +@cname('__pyx_memview_slice') +cdef memoryview memview_slice(memoryview memview, object indices): + cdef int new_ndim = 0, suboffset_dim = -1, dim + cdef bint negative_step + cdef {{memviewslice_name}} src, dst + cdef {{memviewslice_name}} *p_src + + # dst is copied by value in memoryview_fromslice -- initialize it + # src is never copied + memset(&dst, 0, sizeof(dst)) + + cdef _memoryviewslice memviewsliceobj + + assert memview.view.ndim > 0 + + if isinstance(memview, _memoryviewslice): + memviewsliceobj = memview + p_src = &memviewsliceobj.from_slice + else: + slice_copy(memview, &src) + p_src = &src + + # Note: don't use variable src at this point + # SubNote: we should be able to declare variables in blocks... + + # memoryview_fromslice() will inc our dst slice + dst.memview = p_src.memview + dst.data = p_src.data + + # Put everything in temps to avoid this bloody warning: + # "Argument evaluation order in C function call is undefined and + # may not be as expected" + cdef {{memviewslice_name}} *p_dst = &dst + cdef int *p_suboffset_dim = &suboffset_dim + cdef Py_ssize_t start, stop, step, cindex + cdef bint have_start, have_stop, have_step + + for dim, index in enumerate(indices): + if PyIndex_Check(index): + cindex = index + slice_memviewslice( + p_dst, p_src.shape[dim], p_src.strides[dim], p_src.suboffsets[dim], + dim, new_ndim, p_suboffset_dim, + cindex, 0, 0, # start, stop, step + 0, 0, 0, # have_{start,stop,step} + False) + elif index is None: + p_dst.shape[new_ndim] = 1 + p_dst.strides[new_ndim] = 0 + p_dst.suboffsets[new_ndim] = -1 + new_ndim += 1 + else: + start = index.start or 0 + stop = index.stop or 0 + step = index.step or 0 + + have_start = index.start is not None + have_stop = index.stop is not None + have_step = index.step is not None + + slice_memviewslice( + p_dst, p_src.shape[dim], p_src.strides[dim], p_src.suboffsets[dim], + dim, new_ndim, p_suboffset_dim, + start, stop, step, + have_start, have_stop, have_step, + True) + new_ndim += 1 + + if isinstance(memview, _memoryviewslice): + return memoryview_fromslice(dst, new_ndim, + memviewsliceobj.to_object_func, + memviewsliceobj.to_dtype_func, + memview.dtype_is_object) + else: + return memoryview_fromslice(dst, new_ndim, NULL, NULL, + memview.dtype_is_object) + + +# +### Slicing in a single dimension of a memoryviewslice +# + +@cname('__pyx_memoryview_slice_memviewslice') +cdef int slice_memviewslice( + {{memviewslice_name}} *dst, + Py_ssize_t shape, Py_ssize_t stride, Py_ssize_t suboffset, + int dim, int new_ndim, int *suboffset_dim, + Py_ssize_t start, Py_ssize_t stop, Py_ssize_t step, + int have_start, int have_stop, int have_step, + bint is_slice) except -1 nogil: + """ + Create a new slice dst given slice src. + + dim - the current src dimension (indexing will make dimensions + disappear) + new_dim - the new dst dimension + suboffset_dim - pointer to a single int initialized to -1 to keep track of + where slicing offsets should be added + """ + + cdef Py_ssize_t new_shape + cdef bint negative_step + + if not is_slice: + # index is a normal integer-like index + if start < 0: + start += shape + if not 0 <= start < shape: + _err_dim(PyExc_IndexError, "Index out of bounds (axis %d)", dim) + else: + # index is a slice + if have_step: + negative_step = step < 0 + if step == 0: + _err_dim(PyExc_ValueError, "Step may not be zero (axis %d)", dim) + else: + negative_step = False + step = 1 + + # check our bounds and set defaults + if have_start: + if start < 0: + start += shape + if start < 0: + start = 0 + elif start >= shape: + if negative_step: + start = shape - 1 + else: + start = shape + else: + if negative_step: + start = shape - 1 + else: + start = 0 + + if have_stop: + if stop < 0: + stop += shape + if stop < 0: + stop = 0 + elif stop > shape: + stop = shape + else: + if negative_step: + stop = -1 + else: + stop = shape + + # len = ceil( (stop - start) / step ) + with cython.cdivision(True): + new_shape = (stop - start) // step + + if (stop - start) - step * new_shape: + new_shape += 1 + + if new_shape < 0: + new_shape = 0 + + # shape/strides/suboffsets + dst.strides[new_ndim] = stride * step + dst.shape[new_ndim] = new_shape + dst.suboffsets[new_ndim] = suboffset + + # Add the slicing or indexing offsets to the right suboffset or base data * + if suboffset_dim[0] < 0: + dst.data += start * stride + else: + dst.suboffsets[suboffset_dim[0]] += start * stride + + if suboffset >= 0: + if not is_slice: + if new_ndim == 0: + dst.data = ( dst.data)[0] + suboffset + else: + _err_dim(PyExc_IndexError, "All dimensions preceding dimension %d " + "must be indexed and not sliced", dim) + else: + suboffset_dim[0] = new_ndim + + return 0 + +# +### Index a memoryview +# +@cname('__pyx_pybuffer_index') +cdef char *pybuffer_index(Py_buffer *view, char *bufp, Py_ssize_t index, + Py_ssize_t dim) except NULL: + cdef Py_ssize_t shape, stride, suboffset = -1 + cdef Py_ssize_t itemsize = view.itemsize + cdef char *resultp + + if view.ndim == 0: + shape = view.len // itemsize + stride = itemsize + else: + shape = view.shape[dim] + stride = view.strides[dim] + if view.suboffsets != NULL: + suboffset = view.suboffsets[dim] + + if index < 0: + index += view.shape[dim] + if index < 0: + raise IndexError, f"Out of bounds on buffer access (axis {dim})" + + if index >= shape: + raise IndexError, f"Out of bounds on buffer access (axis {dim})" + + resultp = bufp + index * stride + if suboffset >= 0: + resultp = ( resultp)[0] + suboffset + + return resultp + +# +### Transposing a memoryviewslice +# +@cname('__pyx_memslice_transpose') +cdef int transpose_memslice({{memviewslice_name}} *memslice) except -1 nogil: + cdef int ndim = memslice.memview.view.ndim + + cdef Py_ssize_t *shape = memslice.shape + cdef Py_ssize_t *strides = memslice.strides + + # reverse strides and shape + cdef int i, j + for i in range(ndim // 2): + j = ndim - 1 - i + strides[i], strides[j] = strides[j], strides[i] + shape[i], shape[j] = shape[j], shape[i] + + if memslice.suboffsets[i] >= 0 or memslice.suboffsets[j] >= 0: + _err(PyExc_ValueError, "Cannot transpose memoryview with indirect dimensions") + + return 0 + +# +### Creating new memoryview objects from slices and memoryviews +# +@cython.collection_type("sequence") +@cname('__pyx_memoryviewslice') +cdef class _memoryviewslice(memoryview): + "Internal class for passing memoryview slices to Python" + + # We need this to keep our shape/strides/suboffset pointers valid + cdef {{memviewslice_name}} from_slice + # We need this only to print it's class' name + cdef object from_object + + cdef object (*to_object_func)(char *) + cdef int (*to_dtype_func)(char *, object) except 0 + + def __dealloc__(self): + __PYX_XCLEAR_MEMVIEW(&self.from_slice, 1) + + cdef convert_item_to_object(self, char *itemp): + if self.to_object_func != NULL: + return self.to_object_func(itemp) + else: + return memoryview.convert_item_to_object(self, itemp) + + cdef assign_item_from_object(self, char *itemp, object value): + if self.to_dtype_func != NULL: + self.to_dtype_func(itemp, value) + else: + memoryview.assign_item_from_object(self, itemp, value) + + cdef _get_base(self): + return self.from_object + + # Sequence methods + try: + count = __pyx_collections_abc_Sequence.count + index = __pyx_collections_abc_Sequence.index + except: + pass + +try: + if __pyx_collections_abc_Sequence: + # The main value of registering _memoryviewslice as a + # Sequence is that it can be used in structural pattern + # matching in Python 3.10+ + __pyx_collections_abc_Sequence.register(_memoryviewslice) + __pyx_collections_abc_Sequence.register(array) +except: + pass # ignore failure, it's a minor issue + +@cname('__pyx_memoryview_fromslice') +cdef memoryview_fromslice({{memviewslice_name}} memviewslice, + int ndim, + object (*to_object_func)(char *), + int (*to_dtype_func)(char *, object) except 0, + bint dtype_is_object): + + cdef _memoryviewslice result + + if memviewslice.memview == Py_None: + return None + + # assert 0 < ndim <= memviewslice.memview.view.ndim, ( + # ndim, memviewslice.memview.view.ndim) + + result = _memoryviewslice.__new__(_memoryviewslice, None, 0, dtype_is_object) + + result.from_slice = memviewslice + __PYX_INC_MEMVIEW(&memviewslice, 1) + + result.from_object = ( memviewslice.memview)._get_base() + result.typeinfo = memviewslice.memview.typeinfo + + result.view = memviewslice.memview.view + result.view.buf = memviewslice.data + result.view.ndim = ndim + (<__pyx_buffer *> &result.view).obj = Py_None + Py_INCREF(Py_None) + + if (memviewslice.memview).flags & PyBUF_WRITABLE: + result.flags = PyBUF_RECORDS + else: + result.flags = PyBUF_RECORDS_RO + + result.view.shape = result.from_slice.shape + result.view.strides = result.from_slice.strides + + # only set suboffsets if actually used, otherwise set to NULL to improve compatibility + result.view.suboffsets = NULL + for suboffset in result.from_slice.suboffsets[:ndim]: + if suboffset >= 0: + result.view.suboffsets = result.from_slice.suboffsets + break + + result.view.len = result.view.itemsize + for length in result.view.shape[:ndim]: + result.view.len *= length + + result.to_object_func = to_object_func + result.to_dtype_func = to_dtype_func + + return result + +@cname('__pyx_memoryview_get_slice_from_memoryview') +cdef {{memviewslice_name}} *get_slice_from_memview(memoryview memview, + {{memviewslice_name}} *mslice) except NULL: + cdef _memoryviewslice obj + if isinstance(memview, _memoryviewslice): + obj = memview + return &obj.from_slice + else: + slice_copy(memview, mslice) + return mslice + +@cname('__pyx_memoryview_slice_copy') +cdef void slice_copy(memoryview memview, {{memviewslice_name}} *dst) noexcept: + cdef int dim + cdef (Py_ssize_t*) shape, strides, suboffsets + + shape = memview.view.shape + strides = memview.view.strides + suboffsets = memview.view.suboffsets + + dst.memview = <__pyx_memoryview *> memview + dst.data = memview.view.buf + + for dim in range(memview.view.ndim): + dst.shape[dim] = shape[dim] + dst.strides[dim] = strides[dim] + dst.suboffsets[dim] = suboffsets[dim] if suboffsets else -1 + +@cname('__pyx_memoryview_copy_object') +cdef memoryview_copy(memoryview memview): + "Create a new memoryview object" + cdef {{memviewslice_name}} memviewslice + slice_copy(memview, &memviewslice) + return memoryview_copy_from_slice(memview, &memviewslice) + +@cname('__pyx_memoryview_copy_object_from_slice') +cdef memoryview_copy_from_slice(memoryview memview, {{memviewslice_name}} *memviewslice): + """ + Create a new memoryview object from a given memoryview object and slice. + """ + cdef object (*to_object_func)(char *) + cdef int (*to_dtype_func)(char *, object) except 0 + + if isinstance(memview, _memoryviewslice): + to_object_func = (<_memoryviewslice> memview).to_object_func + to_dtype_func = (<_memoryviewslice> memview).to_dtype_func + else: + to_object_func = NULL + to_dtype_func = NULL + + return memoryview_fromslice(memviewslice[0], memview.view.ndim, + to_object_func, to_dtype_func, + memview.dtype_is_object) + + +# +### Copy the contents of a memoryview slices +# +cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) noexcept nogil: + return -arg if arg < 0 else arg + +@cname('__pyx_get_best_slice_order') +cdef char get_best_order({{memviewslice_name}} *mslice, int ndim) noexcept nogil: + """ + Figure out the best memory access order for a given slice. + """ + cdef int i + cdef Py_ssize_t c_stride = 0 + cdef Py_ssize_t f_stride = 0 + + for i in range(ndim - 1, -1, -1): + if mslice.shape[i] > 1: + c_stride = mslice.strides[i] + break + + for i in range(ndim): + if mslice.shape[i] > 1: + f_stride = mslice.strides[i] + break + + if abs_py_ssize_t(c_stride) <= abs_py_ssize_t(f_stride): + return 'C' + else: + return 'F' + +@cython.cdivision(True) +cdef void _copy_strided_to_strided(char *src_data, Py_ssize_t *src_strides, + char *dst_data, Py_ssize_t *dst_strides, + Py_ssize_t *src_shape, Py_ssize_t *dst_shape, + int ndim, size_t itemsize) noexcept nogil: + # Note: src_extent is 1 if we're broadcasting + # dst_extent always >= src_extent as we don't do reductions + cdef Py_ssize_t i + cdef Py_ssize_t src_extent = src_shape[0] + cdef Py_ssize_t dst_extent = dst_shape[0] + cdef Py_ssize_t src_stride = src_strides[0] + cdef Py_ssize_t dst_stride = dst_strides[0] + + if ndim == 1: + if (src_stride > 0 and dst_stride > 0 and + src_stride == itemsize == dst_stride): + memcpy(dst_data, src_data, itemsize * dst_extent) + else: + for i in range(dst_extent): + memcpy(dst_data, src_data, itemsize) + src_data += src_stride + dst_data += dst_stride + else: + for i in range(dst_extent): + _copy_strided_to_strided(src_data, src_strides + 1, + dst_data, dst_strides + 1, + src_shape + 1, dst_shape + 1, + ndim - 1, itemsize) + src_data += src_stride + dst_data += dst_stride + +cdef void copy_strided_to_strided({{memviewslice_name}} *src, + {{memviewslice_name}} *dst, + int ndim, size_t itemsize) noexcept nogil: + _copy_strided_to_strided(src.data, src.strides, dst.data, dst.strides, + src.shape, dst.shape, ndim, itemsize) + +@cname('__pyx_memoryview_slice_get_size') +cdef Py_ssize_t slice_get_size({{memviewslice_name}} *src, int ndim) noexcept nogil: + "Return the size of the memory occupied by the slice in number of bytes" + cdef Py_ssize_t shape, size = src.memview.view.itemsize + + for shape in src.shape[:ndim]: + size *= shape + + return size + +@cname('__pyx_fill_contig_strides_array') +cdef Py_ssize_t fill_contig_strides_array( + Py_ssize_t *shape, Py_ssize_t *strides, Py_ssize_t stride, + int ndim, char order) noexcept nogil: + """ + Fill the strides array for a slice with C or F contiguous strides. + This is like PyBuffer_FillContiguousStrides, but compatible with py < 2.6 + """ + cdef int idx + + if order == 'F': + for idx in range(ndim): + strides[idx] = stride + stride *= shape[idx] + else: + for idx in range(ndim - 1, -1, -1): + strides[idx] = stride + stride *= shape[idx] + + return stride + +@cname('__pyx_memoryview_copy_data_to_temp') +cdef void *copy_data_to_temp({{memviewslice_name}} *src, + {{memviewslice_name}} *tmpslice, + char order, + int ndim) except NULL nogil: + """ + Copy a direct slice to temporary contiguous memory. The caller should free + the result when done. + """ + cdef int i + cdef void *result + + cdef size_t itemsize = src.memview.view.itemsize + cdef size_t size = slice_get_size(src, ndim) + + result = malloc(size) + if not result: + _err_no_memory() + + # tmpslice[0] = src + tmpslice.data = result + tmpslice.memview = src.memview + for i in range(ndim): + tmpslice.shape[i] = src.shape[i] + tmpslice.suboffsets[i] = -1 + + fill_contig_strides_array(&tmpslice.shape[0], &tmpslice.strides[0], itemsize, ndim, order) + + # We need to broadcast strides again + for i in range(ndim): + if tmpslice.shape[i] == 1: + tmpslice.strides[i] = 0 + + if slice_is_contig(src[0], order, ndim): + memcpy(result, src.data, size) + else: + copy_strided_to_strided(src, tmpslice, ndim, itemsize) + + return result + +# Use 'with gil' functions and avoid 'with gil' blocks, as the code within the blocks +# has temporaries that need the GIL to clean up +@cname('__pyx_memoryview_err_extents') +cdef int _err_extents(int i, Py_ssize_t extent1, + Py_ssize_t extent2) except -1 with gil: + raise ValueError, f"got differing extents in dimension {i} (got {extent1} and {extent2})" + +@cname('__pyx_memoryview_err_dim') +cdef int _err_dim(PyObject *error, str msg, int dim) except -1 with gil: + raise error, msg % dim + +@cname('__pyx_memoryview_err') +cdef int _err(PyObject *error, str msg) except -1 with gil: + raise error, msg + +@cname('__pyx_memoryview_err_no_memory') +cdef int _err_no_memory() except -1 with gil: + raise MemoryError + + +@cname('__pyx_memoryview_copy_contents') +cdef int memoryview_copy_contents({{memviewslice_name}} src, + {{memviewslice_name}} dst, + int src_ndim, int dst_ndim, + bint dtype_is_object) except -1 nogil: + """ + Copy memory from slice src to slice dst. + Check for overlapping memory and verify the shapes. + """ + cdef void *tmpdata = NULL + cdef size_t itemsize = src.memview.view.itemsize + cdef int i + cdef char order = get_best_order(&src, src_ndim) + cdef bint broadcasting = False + cdef bint direct_copy = False + cdef {{memviewslice_name}} tmp + + if src_ndim < dst_ndim: + broadcast_leading(&src, src_ndim, dst_ndim) + elif dst_ndim < src_ndim: + broadcast_leading(&dst, dst_ndim, src_ndim) + + cdef int ndim = max(src_ndim, dst_ndim) + + for i in range(ndim): + if src.shape[i] != dst.shape[i]: + if src.shape[i] == 1: + broadcasting = True + src.strides[i] = 0 + else: + _err_extents(i, dst.shape[i], src.shape[i]) + + if src.suboffsets[i] >= 0: + _err_dim(PyExc_ValueError, "Dimension %d is not direct", i) + + if slices_overlap(&src, &dst, ndim, itemsize): + # slices overlap, copy to temp, copy temp to dst + if not slice_is_contig(src, order, ndim): + order = get_best_order(&dst, ndim) + + tmpdata = copy_data_to_temp(&src, &tmp, order, ndim) + src = tmp + + if not broadcasting: + # See if both slices have equal contiguity, in that case perform a + # direct copy. This only works when we are not broadcasting. + if slice_is_contig(src, 'C', ndim): + direct_copy = slice_is_contig(dst, 'C', ndim) + elif slice_is_contig(src, 'F', ndim): + direct_copy = slice_is_contig(dst, 'F', ndim) + + if direct_copy: + # Contiguous slices with same order + refcount_copying(&dst, dtype_is_object, ndim, inc=False) + memcpy(dst.data, src.data, slice_get_size(&src, ndim)) + refcount_copying(&dst, dtype_is_object, ndim, inc=True) + free(tmpdata) + return 0 + + if order == 'F' == get_best_order(&dst, ndim): + # see if both slices have Fortran order, transpose them to match our + # C-style indexing order + transpose_memslice(&src) + transpose_memslice(&dst) + + refcount_copying(&dst, dtype_is_object, ndim, inc=False) + copy_strided_to_strided(&src, &dst, ndim, itemsize) + refcount_copying(&dst, dtype_is_object, ndim, inc=True) + + free(tmpdata) + return 0 + +@cname('__pyx_memoryview_broadcast_leading') +cdef void broadcast_leading({{memviewslice_name}} *mslice, + int ndim, + int ndim_other) noexcept nogil: + cdef int i + cdef int offset = ndim_other - ndim + + for i in range(ndim - 1, -1, -1): + mslice.shape[i + offset] = mslice.shape[i] + mslice.strides[i + offset] = mslice.strides[i] + mslice.suboffsets[i + offset] = mslice.suboffsets[i] + + for i in range(offset): + mslice.shape[i] = 1 + mslice.strides[i] = mslice.strides[0] + mslice.suboffsets[i] = -1 + +# +### Take care of refcounting the objects in slices. Do this separately from any copying, +### to minimize acquiring the GIL +# + +@cname('__pyx_memoryview_refcount_copying') +cdef void refcount_copying({{memviewslice_name}} *dst, bint dtype_is_object, int ndim, bint inc) noexcept nogil: + # incref or decref the objects in the destination slice if the dtype is object + if dtype_is_object: + refcount_objects_in_slice_with_gil(dst.data, dst.shape, dst.strides, ndim, inc) + +@cname('__pyx_memoryview_refcount_objects_in_slice_with_gil') +cdef void refcount_objects_in_slice_with_gil(char *data, Py_ssize_t *shape, + Py_ssize_t *strides, int ndim, + bint inc) noexcept with gil: + refcount_objects_in_slice(data, shape, strides, ndim, inc) + +@cname('__pyx_memoryview_refcount_objects_in_slice') +cdef void refcount_objects_in_slice(char *data, Py_ssize_t *shape, + Py_ssize_t *strides, int ndim, bint inc) noexcept: + cdef Py_ssize_t i + cdef Py_ssize_t stride = strides[0] + + for i in range(shape[0]): + if ndim == 1: + if inc: + Py_INCREF(( data)[0]) + else: + Py_DECREF(( data)[0]) + else: + refcount_objects_in_slice(data, shape + 1, strides + 1, ndim - 1, inc) + + data += stride + +# +### Scalar to slice assignment +# +@cname('__pyx_memoryview_slice_assign_scalar') +cdef void slice_assign_scalar({{memviewslice_name}} *dst, int ndim, + size_t itemsize, void *item, + bint dtype_is_object) noexcept nogil: + refcount_copying(dst, dtype_is_object, ndim, inc=False) + _slice_assign_scalar(dst.data, dst.shape, dst.strides, ndim, itemsize, item) + refcount_copying(dst, dtype_is_object, ndim, inc=True) + + +@cname('__pyx_memoryview__slice_assign_scalar') +cdef void _slice_assign_scalar(char *data, Py_ssize_t *shape, + Py_ssize_t *strides, int ndim, + size_t itemsize, void *item) noexcept nogil: + cdef Py_ssize_t i + cdef Py_ssize_t stride = strides[0] + cdef Py_ssize_t extent = shape[0] + + if ndim == 1: + for i in range(extent): + memcpy(data, item, itemsize) + data += stride + else: + for i in range(extent): + _slice_assign_scalar(data, shape + 1, strides + 1, ndim - 1, itemsize, item) + data += stride + + +############### BufferFormatFromTypeInfo ############### +cdef extern from *: + ctypedef struct __Pyx_StructField + + cdef enum: + __PYX_BUF_FLAGS_PACKED_STRUCT + __PYX_BUF_FLAGS_INTEGER_COMPLEX + + ctypedef struct __Pyx_TypeInfo: + char* name + const __Pyx_StructField* fields + size_t size + size_t arraysize[8] + int ndim + char typegroup + char is_unsigned + int flags + + ctypedef struct __Pyx_StructField: + const __Pyx_TypeInfo* type + char* name + size_t offset + + ctypedef struct __Pyx_BufFmt_StackElem: + const __Pyx_StructField* field + size_t parent_offset + + #ctypedef struct __Pyx_BufFmt_Context: + # __Pyx_StructField root + __Pyx_BufFmt_StackElem* head + + struct __pyx_typeinfo_string: + char string[3] + + __pyx_typeinfo_string __Pyx_TypeInfoToFormat(const __Pyx_TypeInfo *) + + +@cname('__pyx_format_from_typeinfo') +cdef bytes format_from_typeinfo(const __Pyx_TypeInfo *type): + cdef const __Pyx_StructField *field + cdef __pyx_typeinfo_string fmt + cdef bytes part, result + cdef Py_ssize_t i + + if type.typegroup == 'S': + assert type.fields != NULL + assert type.fields.type != NULL + + if type.flags & __PYX_BUF_FLAGS_PACKED_STRUCT: + alignment = b'^' + else: + alignment = b'' + + parts = [b"T{"] + field = type.fields + + while field.type: + part = format_from_typeinfo(field.type) + parts.append(part + b':' + field.name + b':') + field += 1 + + result = alignment.join(parts) + b'}' + else: + fmt = __Pyx_TypeInfoToFormat(type) + result = fmt.string + if type.arraysize[0]: + extents = [f"{type.arraysize[i]}" for i in range(type.ndim)] + result = f"({u','.join(extents)})".encode('ascii') + result + + return result diff --git a/venv/lib/python3.10/site-packages/Cython/Utility/MemoryView_C.c b/venv/lib/python3.10/site-packages/Cython/Utility/MemoryView_C.c new file mode 100644 index 0000000000000000000000000000000000000000..851bd2923ea8cf64febdf6e876bce01f29860f7e --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Utility/MemoryView_C.c @@ -0,0 +1,889 @@ +////////// MemviewSliceStruct.proto ////////// +//@proto_block: utility_code_proto_before_types + +/* memoryview slice struct */ +struct {{memview_struct_name}}; + +typedef struct { + struct {{memview_struct_name}} *memview; + char *data; + Py_ssize_t shape[{{max_dims}}]; + Py_ssize_t strides[{{max_dims}}]; + Py_ssize_t suboffsets[{{max_dims}}]; +} {{memviewslice_name}}; + +// used for "len(memviewslice)" +#define __Pyx_MemoryView_Len(m) (m.shape[0]) + + +/////////////// ObjectToMemviewSlice.proto /////////////// + +static CYTHON_INLINE {{memviewslice_name}} {{funcname}}(PyObject *, int writable_flag); + + +////////// MemviewSliceInit.proto ////////// + +// vsnprintf +#include + +#define __Pyx_BUF_MAX_NDIMS %(BUF_MAX_NDIMS)d + +#define __Pyx_MEMVIEW_DIRECT 1 +#define __Pyx_MEMVIEW_PTR 2 +#define __Pyx_MEMVIEW_FULL 4 +#define __Pyx_MEMVIEW_CONTIG 8 +#define __Pyx_MEMVIEW_STRIDED 16 +#define __Pyx_MEMVIEW_FOLLOW 32 + +#define __Pyx_IS_C_CONTIG 1 +#define __Pyx_IS_F_CONTIG 2 + +static int __Pyx_init_memviewslice( + struct __pyx_memoryview_obj *memview, + int ndim, + __Pyx_memviewslice *memviewslice, + int memview_is_new_reference); + +static CYTHON_INLINE int __pyx_add_acquisition_count_locked( + __pyx_atomic_int_type *acquisition_count, PyThread_type_lock lock); +static CYTHON_INLINE int __pyx_sub_acquisition_count_locked( + __pyx_atomic_int_type *acquisition_count, PyThread_type_lock lock); + +#define __pyx_get_slice_count_pointer(memview) (&memview->acquisition_count) +#define __PYX_INC_MEMVIEW(slice, have_gil) __Pyx_INC_MEMVIEW(slice, have_gil, __LINE__) +#define __PYX_XCLEAR_MEMVIEW(slice, have_gil) __Pyx_XCLEAR_MEMVIEW(slice, have_gil, __LINE__) +static CYTHON_INLINE void __Pyx_INC_MEMVIEW({{memviewslice_name}} *, int, int); +static CYTHON_INLINE void __Pyx_XCLEAR_MEMVIEW({{memviewslice_name}} *, int, int); + + +/////////////// MemviewSliceIndex.proto /////////////// + +static CYTHON_INLINE char *__pyx_memviewslice_index_full( + const char *bufp, Py_ssize_t idx, Py_ssize_t stride, Py_ssize_t suboffset); + + +/////////////// ObjectToMemviewSlice /////////////// +//@requires: MemviewSliceValidateAndInit + +static CYTHON_INLINE {{memviewslice_name}} {{funcname}}(PyObject *obj, int writable_flag) { + {{memviewslice_name}} result = {{memslice_init}}; + __Pyx_BufFmt_StackElem stack[{{struct_nesting_depth}}]; + int axes_specs[] = { {{axes_specs}} }; + int retcode; + + if (obj == Py_None) { + /* We don't bother to refcount None */ + result.memview = (struct __pyx_memoryview_obj *) Py_None; + return result; + } + + retcode = __Pyx_ValidateAndInit_memviewslice(axes_specs, {{c_or_f_flag}}, + {{buf_flag}} | writable_flag, {{ndim}}, + &{{dtype_typeinfo}}, stack, + &result, obj); + + if (unlikely(retcode == -1)) + goto __pyx_fail; + + return result; +__pyx_fail: + result.memview = NULL; + result.data = NULL; + return result; +} + + +/////////////// MemviewSliceValidateAndInit.proto /////////////// + +static int __Pyx_ValidateAndInit_memviewslice( + int *axes_specs, + int c_or_f_flag, + int buf_flags, + int ndim, + const __Pyx_TypeInfo *dtype, + __Pyx_BufFmt_StackElem stack[], + __Pyx_memviewslice *memviewslice, + PyObject *original_obj); + +/////////////// MemviewSliceValidateAndInit /////////////// +//@requires: Buffer.c::TypeInfoCompare +//@requires: Buffer.c::BufferFormatStructs +//@requires: Buffer.c::BufferFormatCheck + +static int +__pyx_check_strides(Py_buffer *buf, int dim, int ndim, int spec) +{ + if (buf->shape[dim] <= 1) + return 1; + + if (buf->strides) { + if (spec & __Pyx_MEMVIEW_CONTIG) { + if (spec & (__Pyx_MEMVIEW_PTR|__Pyx_MEMVIEW_FULL)) { + if (unlikely(buf->strides[dim] != sizeof(void *))) { + PyErr_Format(PyExc_ValueError, + "Buffer is not indirectly contiguous " + "in dimension %d.", dim); + goto fail; + } + } else if (unlikely(buf->strides[dim] != buf->itemsize)) { + PyErr_SetString(PyExc_ValueError, + "Buffer and memoryview are not contiguous " + "in the same dimension."); + goto fail; + } + } + + if (spec & __Pyx_MEMVIEW_FOLLOW) { + Py_ssize_t stride = buf->strides[dim]; + if (stride < 0) + stride = -stride; + if (unlikely(stride < buf->itemsize)) { + PyErr_SetString(PyExc_ValueError, + "Buffer and memoryview are not contiguous " + "in the same dimension."); + goto fail; + } + } + } else { + if (unlikely(spec & __Pyx_MEMVIEW_CONTIG && dim != ndim - 1)) { + PyErr_Format(PyExc_ValueError, + "C-contiguous buffer is not contiguous in " + "dimension %d", dim); + goto fail; + } else if (unlikely(spec & (__Pyx_MEMVIEW_PTR))) { + PyErr_Format(PyExc_ValueError, + "C-contiguous buffer is not indirect in " + "dimension %d", dim); + goto fail; + } else if (unlikely(buf->suboffsets)) { + PyErr_SetString(PyExc_ValueError, + "Buffer exposes suboffsets but no strides"); + goto fail; + } + } + + return 1; +fail: + return 0; +} + +static int +__pyx_check_suboffsets(Py_buffer *buf, int dim, int ndim, int spec) +{ + CYTHON_UNUSED_VAR(ndim); + // Todo: without PyBUF_INDIRECT we may not have suboffset information, i.e., the + // ptr may not be set to NULL but may be uninitialized? + if (spec & __Pyx_MEMVIEW_DIRECT) { + if (unlikely(buf->suboffsets && buf->suboffsets[dim] >= 0)) { + PyErr_Format(PyExc_ValueError, + "Buffer not compatible with direct access " + "in dimension %d.", dim); + goto fail; + } + } + + if (spec & __Pyx_MEMVIEW_PTR) { + if (unlikely(!buf->suboffsets || (buf->suboffsets[dim] < 0))) { + PyErr_Format(PyExc_ValueError, + "Buffer is not indirectly accessible " + "in dimension %d.", dim); + goto fail; + } + } + + return 1; +fail: + return 0; +} + +static int +__pyx_verify_contig(Py_buffer *buf, int ndim, int c_or_f_flag) +{ + int i; + + if (c_or_f_flag & __Pyx_IS_F_CONTIG) { + Py_ssize_t stride = 1; + for (i = 0; i < ndim; i++) { + if (unlikely(stride * buf->itemsize != buf->strides[i] && buf->shape[i] > 1)) { + PyErr_SetString(PyExc_ValueError, + "Buffer not fortran contiguous."); + goto fail; + } + stride = stride * buf->shape[i]; + } + } else if (c_or_f_flag & __Pyx_IS_C_CONTIG) { + Py_ssize_t stride = 1; + for (i = ndim - 1; i >- 1; i--) { + if (unlikely(stride * buf->itemsize != buf->strides[i] && buf->shape[i] > 1)) { + PyErr_SetString(PyExc_ValueError, + "Buffer not C contiguous."); + goto fail; + } + stride = stride * buf->shape[i]; + } + } + + return 1; +fail: + return 0; +} + +static int __Pyx_ValidateAndInit_memviewslice( + int *axes_specs, + int c_or_f_flag, + int buf_flags, + int ndim, + const __Pyx_TypeInfo *dtype, + __Pyx_BufFmt_StackElem stack[], + __Pyx_memviewslice *memviewslice, + PyObject *original_obj) +{ + struct __pyx_memoryview_obj *memview, *new_memview; + __Pyx_RefNannyDeclarations + Py_buffer *buf; + int i, spec = 0, retval = -1; + __Pyx_BufFmt_Context ctx; + int from_memoryview = __pyx_memoryview_check(original_obj); + + __Pyx_RefNannySetupContext("ValidateAndInit_memviewslice", 0); + + if (from_memoryview && __pyx_typeinfo_cmp(dtype, ((struct __pyx_memoryview_obj *) + original_obj)->typeinfo)) { + /* We have a matching dtype, skip format parsing */ + memview = (struct __pyx_memoryview_obj *) original_obj; + new_memview = NULL; + } else { + memview = (struct __pyx_memoryview_obj *) __pyx_memoryview_new( + original_obj, buf_flags, 0, dtype); + new_memview = memview; + if (unlikely(!memview)) + goto fail; + } + + buf = &memview->view; + if (unlikely(buf->ndim != ndim)) { + PyErr_Format(PyExc_ValueError, + "Buffer has wrong number of dimensions (expected %d, got %d)", + ndim, buf->ndim); + goto fail; + } + + if (new_memview) { + __Pyx_BufFmt_Init(&ctx, stack, dtype); + if (unlikely(!__Pyx_BufFmt_CheckString(&ctx, buf->format))) goto fail; + } + + if (unlikely((unsigned) buf->itemsize != dtype->size)) { + PyErr_Format(PyExc_ValueError, + "Item size of buffer (%" CYTHON_FORMAT_SSIZE_T "u byte%s) " + "does not match size of '%s' (%" CYTHON_FORMAT_SSIZE_T "u byte%s)", + buf->itemsize, + (buf->itemsize > 1) ? "s" : "", + dtype->name, + dtype->size, + (dtype->size > 1) ? "s" : ""); + goto fail; + } + + /* Check axes */ + if (buf->len > 0) { + // 0-sized arrays do not undergo these checks since their strides are + // irrelevant and they are always both C- and F-contiguous. + for (i = 0; i < ndim; i++) { + spec = axes_specs[i]; + if (unlikely(!__pyx_check_strides(buf, i, ndim, spec))) + goto fail; + if (unlikely(!__pyx_check_suboffsets(buf, i, ndim, spec))) + goto fail; + } + + /* Check contiguity */ + if (unlikely(buf->strides && !__pyx_verify_contig(buf, ndim, c_or_f_flag))) + goto fail; + } + + /* Initialize */ + if (unlikely(__Pyx_init_memviewslice(memview, ndim, memviewslice, + new_memview != NULL) == -1)) { + goto fail; + } + + retval = 0; + goto no_fail; + +fail: + Py_XDECREF((PyObject*)new_memview); + retval = -1; + +no_fail: + __Pyx_RefNannyFinishContext(); + return retval; +} + + +////////// MemviewSliceInit ////////// + +static int +__Pyx_init_memviewslice(struct __pyx_memoryview_obj *memview, + int ndim, + {{memviewslice_name}} *memviewslice, + int memview_is_new_reference) +{ + __Pyx_RefNannyDeclarations + int i, retval=-1; + Py_buffer *buf = &memview->view; + __Pyx_RefNannySetupContext("init_memviewslice", 0); + + if (unlikely(memviewslice->memview || memviewslice->data)) { + PyErr_SetString(PyExc_ValueError, + "memviewslice is already initialized!"); + goto fail; + } + + if (buf->strides) { + for (i = 0; i < ndim; i++) { + memviewslice->strides[i] = buf->strides[i]; + } + } else { + Py_ssize_t stride = buf->itemsize; + for (i = ndim - 1; i >= 0; i--) { + memviewslice->strides[i] = stride; + stride *= buf->shape[i]; + } + } + + for (i = 0; i < ndim; i++) { + memviewslice->shape[i] = buf->shape[i]; + if (buf->suboffsets) { + memviewslice->suboffsets[i] = buf->suboffsets[i]; + } else { + memviewslice->suboffsets[i] = -1; + } + } + + memviewslice->memview = memview; + memviewslice->data = (char *)buf->buf; + if (__pyx_add_acquisition_count(memview) == 0 && !memview_is_new_reference) { + Py_INCREF((PyObject*)memview); + } + retval = 0; + goto no_fail; + +fail: + /* Don't decref, the memoryview may be borrowed. Let the caller do the cleanup */ + /* __Pyx_XDECREF(memviewslice->memview); */ + memviewslice->memview = 0; + memviewslice->data = 0; + retval = -1; +no_fail: + __Pyx_RefNannyFinishContext(); + return retval; +} + +#ifndef Py_NO_RETURN +// available since Py3.3 +#define Py_NO_RETURN +#endif + +static void __pyx_fatalerror(const char *fmt, ...) Py_NO_RETURN { + va_list vargs; + char msg[200]; + +#if PY_VERSION_HEX >= 0x030A0000 || defined(HAVE_STDARG_PROTOTYPES) + va_start(vargs, fmt); +#else + va_start(vargs); +#endif + vsnprintf(msg, 200, fmt, vargs); + va_end(vargs); + + Py_FatalError(msg); +} + +static CYTHON_INLINE int +__pyx_add_acquisition_count_locked(__pyx_atomic_int_type *acquisition_count, + PyThread_type_lock lock) +{ + int result; + PyThread_acquire_lock(lock, 1); + result = (*acquisition_count)++; + PyThread_release_lock(lock); + return result; +} + +static CYTHON_INLINE int +__pyx_sub_acquisition_count_locked(__pyx_atomic_int_type *acquisition_count, + PyThread_type_lock lock) +{ + int result; + PyThread_acquire_lock(lock, 1); + result = (*acquisition_count)--; + PyThread_release_lock(lock); + return result; +} + + +static CYTHON_INLINE void +__Pyx_INC_MEMVIEW({{memviewslice_name}} *memslice, int have_gil, int lineno) +{ + __pyx_nonatomic_int_type old_acquisition_count; + struct {{memview_struct_name}} *memview = memslice->memview; + if (unlikely(!memview || (PyObject *) memview == Py_None)) { + // Allow uninitialized memoryview assignment and do not ref-count None. + return; + } + + old_acquisition_count = __pyx_add_acquisition_count(memview); + if (unlikely(old_acquisition_count <= 0)) { + if (likely(old_acquisition_count == 0)) { + // First acquisition => keep the memoryview object alive. + if (have_gil) { + Py_INCREF((PyObject *) memview); + } else { + PyGILState_STATE _gilstate = PyGILState_Ensure(); + Py_INCREF((PyObject *) memview); + PyGILState_Release(_gilstate); + } + } else { + __pyx_fatalerror("Acquisition count is %d (line %d)", + old_acquisition_count+1, lineno); + } + } +} + +static CYTHON_INLINE void __Pyx_XCLEAR_MEMVIEW({{memviewslice_name}} *memslice, + int have_gil, int lineno) { + __pyx_nonatomic_int_type old_acquisition_count; + struct {{memview_struct_name}} *memview = memslice->memview; + + if (unlikely(!memview || (PyObject *) memview == Py_None)) { + // Do not ref-count None. + memslice->memview = NULL; + return; + } + + old_acquisition_count = __pyx_sub_acquisition_count(memview); + memslice->data = NULL; + if (likely(old_acquisition_count > 1)) { + // Still other slices out there => we do not own the reference. + memslice->memview = NULL; + } else if (likely(old_acquisition_count == 1)) { + // Last slice => discard owned Python reference to memoryview object. + if (have_gil) { + Py_CLEAR(memslice->memview); + } else { + PyGILState_STATE _gilstate = PyGILState_Ensure(); + Py_CLEAR(memslice->memview); + PyGILState_Release(_gilstate); + } + } else { + __pyx_fatalerror("Acquisition count is %d (line %d)", + old_acquisition_count-1, lineno); + } +} + + +////////// MemviewSliceCopyTemplate.proto ////////// + +static {{memviewslice_name}} +__pyx_memoryview_copy_new_contig(const __Pyx_memviewslice *from_mvs, + const char *mode, int ndim, + size_t sizeof_dtype, int contig_flag, + int dtype_is_object); + + +////////// MemviewSliceCopyTemplate ////////// + +static {{memviewslice_name}} +__pyx_memoryview_copy_new_contig(const __Pyx_memviewslice *from_mvs, + const char *mode, int ndim, + size_t sizeof_dtype, int contig_flag, + int dtype_is_object) +{ + __Pyx_RefNannyDeclarations + int i; + __Pyx_memviewslice new_mvs = {{memslice_init}}; + struct __pyx_memoryview_obj *from_memview = from_mvs->memview; + Py_buffer *buf = &from_memview->view; + PyObject *shape_tuple = NULL; + PyObject *temp_int = NULL; + struct __pyx_array_obj *array_obj = NULL; + struct __pyx_memoryview_obj *memview_obj = NULL; + + __Pyx_RefNannySetupContext("__pyx_memoryview_copy_new_contig", 0); + + for (i = 0; i < ndim; i++) { + if (unlikely(from_mvs->suboffsets[i] >= 0)) { + PyErr_Format(PyExc_ValueError, "Cannot copy memoryview slice with " + "indirect dimensions (axis %d)", i); + goto fail; + } + } + + shape_tuple = PyTuple_New(ndim); + if (unlikely(!shape_tuple)) { + goto fail; + } + __Pyx_GOTREF(shape_tuple); + + + for(i = 0; i < ndim; i++) { + temp_int = PyLong_FromSsize_t(from_mvs->shape[i]); + if(unlikely(!temp_int)) { + goto fail; + } else { +#if CYTHON_ASSUME_SAFE_MACROS + PyTuple_SET_ITEM(shape_tuple, i, temp_int); +#else + if (PyTuple_SetItem(shape_tuple, i, temp_int) < 0) { + goto fail; + } +#endif + temp_int = NULL; + } + } + + array_obj = __pyx_array_new(shape_tuple, sizeof_dtype, buf->format, mode, NULL); + if (unlikely(!array_obj)) { + goto fail; + } + __Pyx_GOTREF(array_obj); + + memview_obj = (struct __pyx_memoryview_obj *) __pyx_memoryview_new( + (PyObject *) array_obj, contig_flag, + dtype_is_object, + from_mvs->memview->typeinfo); + if (unlikely(!memview_obj)) + goto fail; + + /* initialize new_mvs */ + if (unlikely(__Pyx_init_memviewslice(memview_obj, ndim, &new_mvs, 1) < 0)) + goto fail; + + if (unlikely(__pyx_memoryview_copy_contents(*from_mvs, new_mvs, ndim, ndim, + dtype_is_object) < 0)) + goto fail; + + goto no_fail; + +fail: + __Pyx_XDECREF((PyObject *) new_mvs.memview); + new_mvs.memview = NULL; + new_mvs.data = NULL; +no_fail: + __Pyx_XDECREF(shape_tuple); + __Pyx_XDECREF(temp_int); + __Pyx_XDECREF((PyObject *) array_obj); + __Pyx_RefNannyFinishContext(); + return new_mvs; +} + + +////////// CopyContentsUtility.proto ///////// + +#define {{func_cname}}(slice) \ + __pyx_memoryview_copy_new_contig(&slice, "{{mode}}", {{ndim}}, \ + sizeof({{dtype_decl}}), {{contig_flag}}, \ + {{dtype_is_object}}) + + +////////// OverlappingSlices.proto ////////// + +static int __pyx_slices_overlap({{memviewslice_name}} *slice1, + {{memviewslice_name}} *slice2, + int ndim, size_t itemsize); + + +////////// OverlappingSlices ////////// + +/* Based on numpy's core/src/multiarray/array_assign.c */ + +/* Gets a half-open range [start, end) which contains the array data */ +static void +__pyx_get_array_memory_extents({{memviewslice_name}} *slice, + void **out_start, void **out_end, + int ndim, size_t itemsize) +{ + char *start, *end; + int i; + + start = end = slice->data; + + for (i = 0; i < ndim; i++) { + Py_ssize_t stride = slice->strides[i]; + Py_ssize_t extent = slice->shape[i]; + + if (extent == 0) { + *out_start = *out_end = start; + return; + } else { + if (stride > 0) + end += stride * (extent - 1); + else + start += stride * (extent - 1); + } + } + + /* Return a half-open range */ + *out_start = start; + *out_end = end + itemsize; +} + +/* Returns 1 if the arrays have overlapping data, 0 otherwise */ +static int +__pyx_slices_overlap({{memviewslice_name}} *slice1, + {{memviewslice_name}} *slice2, + int ndim, size_t itemsize) +{ + void *start1, *end1, *start2, *end2; + + __pyx_get_array_memory_extents(slice1, &start1, &end1, ndim, itemsize); + __pyx_get_array_memory_extents(slice2, &start2, &end2, ndim, itemsize); + + return (start1 < end2) && (start2 < end1); +} + + +////////// MemviewSliceCheckContig.proto ////////// + +#define __pyx_memviewslice_is_contig_{{contig_type}}{{ndim}}(slice) \ + __pyx_memviewslice_is_contig(slice, '{{contig_type}}', {{ndim}}) + + +////////// MemviewSliceIsContig.proto ////////// + +static int __pyx_memviewslice_is_contig(const {{memviewslice_name}} mvs, char order, int ndim);/*proto*/ + + +////////// MemviewSliceIsContig ////////// + +static int +__pyx_memviewslice_is_contig(const {{memviewslice_name}} mvs, char order, int ndim) +{ + int i, index, step, start; + Py_ssize_t itemsize = mvs.memview->view.itemsize; + + if (order == 'F') { + step = 1; + start = 0; + } else { + step = -1; + start = ndim - 1; + } + + for (i = 0; i < ndim; i++) { + index = start + step * i; + if (mvs.suboffsets[index] >= 0 || mvs.strides[index] != itemsize) + return 0; + + itemsize *= mvs.shape[index]; + } + + return 1; +} + + +/////////////// MemviewSliceIndex /////////////// + +static CYTHON_INLINE char * +__pyx_memviewslice_index_full(const char *bufp, Py_ssize_t idx, + Py_ssize_t stride, Py_ssize_t suboffset) +{ + bufp = bufp + idx * stride; + if (suboffset >= 0) { + bufp = *((char **) bufp) + suboffset; + } + return (char *) bufp; +} + + +/////////////// MemviewDtypeToObject.proto /////////////// + +{{if to_py_function}} +static CYTHON_INLINE PyObject *{{get_function}}(const char *itemp); /* proto */ +{{endif}} + +{{if from_py_function}} +static CYTHON_INLINE int {{set_function}}(const char *itemp, PyObject *obj); /* proto */ +{{endif}} + +/////////////// MemviewDtypeToObject /////////////// + +{{#__pyx_memview__to_object}} + +/* Convert a dtype to or from a Python object */ + +{{if to_py_function}} +static CYTHON_INLINE PyObject *{{get_function}}(const char *itemp) { + return (PyObject *) {{to_py_function}}(*({{dtype}} *) itemp); +} +{{endif}} + +{{if from_py_function}} +static CYTHON_INLINE int {{set_function}}(const char *itemp, PyObject *obj) { + {{dtype}} value = {{from_py_function}}(obj); + if (unlikely({{error_condition}})) + return 0; + *({{dtype}} *) itemp = value; + return 1; +} +{{endif}} + + +/////////////// MemviewObjectToObject.proto /////////////// + +/* Function callbacks (for memoryview object) for dtype object */ +static PyObject *{{get_function}}(const char *itemp); /* proto */ +static int {{set_function}}(const char *itemp, PyObject *obj); /* proto */ + + +/////////////// MemviewObjectToObject /////////////// + +static PyObject *{{get_function}}(const char *itemp) { + PyObject *result = *(PyObject **) itemp; + Py_INCREF(result); + return result; +} + +static int {{set_function}}(const char *itemp, PyObject *obj) { + Py_INCREF(obj); + Py_DECREF(*(PyObject **) itemp); + *(PyObject **) itemp = obj; + return 1; +} + +/////////// ToughSlice ////////// + +/* Dimension is indexed with 'start:stop:step' */ + +if (unlikely(__pyx_memoryview_slice_memviewslice( + &{{dst}}, + {{src}}.shape[{{dim}}], {{src}}.strides[{{dim}}], {{src}}.suboffsets[{{dim}}], + {{dim}}, + {{new_ndim}}, + &{{get_suboffset_dim()}}, + {{start}}, + {{stop}}, + {{step}}, + {{int(have_start)}}, + {{int(have_stop)}}, + {{int(have_step)}}, + 1) < 0)) +{ + {{error_goto}} +} + + +////////// SimpleSlice ////////// + +/* Dimension is indexed with ':' only */ + +{{dst}}.shape[{{new_ndim}}] = {{src}}.shape[{{dim}}]; +{{dst}}.strides[{{new_ndim}}] = {{src}}.strides[{{dim}}]; + +{{if access == 'direct'}} + {{dst}}.suboffsets[{{new_ndim}}] = -1; +{{else}} + {{dst}}.suboffsets[{{new_ndim}}] = {{src}}.suboffsets[{{dim}}]; + if ({{src}}.suboffsets[{{dim}}] >= 0) + {{get_suboffset_dim()}} = {{new_ndim}}; +{{endif}} + + +////////// SliceIndex ////////// + +// Dimension is indexed with an integer, we could use the ToughSlice +// approach, but this is faster + +{ + Py_ssize_t __pyx_tmp_idx = {{idx}}; + + {{if wraparound or boundscheck}} + Py_ssize_t __pyx_tmp_shape = {{src}}.shape[{{dim}}]; + {{endif}} + + Py_ssize_t __pyx_tmp_stride = {{src}}.strides[{{dim}}]; + {{if wraparound}} + if (__pyx_tmp_idx < 0) + __pyx_tmp_idx += __pyx_tmp_shape; + {{endif}} + + {{if boundscheck}} + if (unlikely(!__Pyx_is_valid_index(__pyx_tmp_idx, __pyx_tmp_shape))) { + {{if not have_gil}} + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); + {{endif}} + + PyErr_SetString(PyExc_IndexError, + "Index out of bounds (axis {{dim}})"); + + {{if not have_gil}} + PyGILState_Release(__pyx_gilstate_save); + {{endif}} + + {{error_goto}} + } + {{endif}} + + {{if all_dimensions_direct}} + {{dst}}.data += __pyx_tmp_idx * __pyx_tmp_stride; + {{else}} + if ({{get_suboffset_dim()}} < 0) { + {{dst}}.data += __pyx_tmp_idx * __pyx_tmp_stride; + + /* This dimension is the first dimension, or is preceded by */ + /* direct or indirect dimensions that are indexed away. */ + /* Hence suboffset_dim must be less than zero, and we can have */ + /* our data pointer refer to another block by dereferencing. */ + /* slice.data -> B -> C becomes slice.data -> C */ + + {{if indirect}} + { + Py_ssize_t __pyx_tmp_suboffset = {{src}}.suboffsets[{{dim}}]; + + {{if generic}} + if (__pyx_tmp_suboffset >= 0) + {{endif}} + + {{dst}}.data = *((char **) {{dst}}.data) + __pyx_tmp_suboffset; + } + {{endif}} + + } else { + {{dst}}.suboffsets[{{get_suboffset_dim()}}] += __pyx_tmp_idx * __pyx_tmp_stride; + + /* Note: dimension can not be indirect, the compiler will have */ + /* issued an error */ + } + + {{endif}} +} + + +////////// FillStrided1DScalar.proto ////////// + +static void +__pyx_fill_slice_{{dtype_name}}({{type_decl}} *p, Py_ssize_t extent, Py_ssize_t stride, + size_t itemsize, void *itemp); + +////////// FillStrided1DScalar ////////// + +/* Fill a slice with a scalar value. The dimension is direct and strided or contiguous */ +/* This can be used as a callback for the memoryview object to efficiently assign a scalar */ +/* Currently unused */ +static void +__pyx_fill_slice_{{dtype_name}}({{type_decl}} *p, Py_ssize_t extent, Py_ssize_t stride, + size_t itemsize, void *itemp) +{ + Py_ssize_t i; + {{type_decl}} item = *(({{type_decl}} *) itemp); + {{type_decl}} *endp; + + stride /= sizeof({{type_decl}}); + endp = p + stride * extent; + + while (p < endp) { + *p = item; + p += stride; + } +} diff --git a/venv/lib/python3.10/site-packages/Cython/Utility/ModuleSetupCode.c b/venv/lib/python3.10/site-packages/Cython/Utility/ModuleSetupCode.c new file mode 100644 index 0000000000000000000000000000000000000000..e0da247ac067e5697d7137cd897c230dd701a483 --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Utility/ModuleSetupCode.c @@ -0,0 +1,3051 @@ +/////////////// InitLimitedAPI /////////////// + +#if defined(Py_LIMITED_API) + #if !defined(CYTHON_LIMITED_API) + // Use Py_LIMITED_API as the main control for Cython's limited API mode. + // However it's still possible to define CYTHON_LIMITED_API alone to + // force Cython to use Limited-API code without enforcing it in Python. + #define CYTHON_LIMITED_API 1 + #endif +#elif defined(CYTHON_LIMITED_API) + #ifdef _MSC_VER + #pragma message ("Limited API usage is enabled with 'CYTHON_LIMITED_API' but 'Py_LIMITED_API' does not define a Python target version. Consider setting 'Py_LIMITED_API' instead.") + #else + #warning Limited API usage is enabled with 'CYTHON_LIMITED_API' but 'Py_LIMITED_API' does not define a Python target version. Consider setting 'Py_LIMITED_API' instead. + #endif +#endif + +/////////////// CModulePreamble /////////////// + +#include /* For offsetof */ +#ifndef offsetof + #define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) +#endif + +#if !defined(_WIN32) && !defined(WIN32) && !defined(MS_WINDOWS) + #ifndef __stdcall + #define __stdcall + #endif + #ifndef __cdecl + #define __cdecl + #endif + #ifndef __fastcall + #define __fastcall + #endif +#endif + +#ifndef DL_IMPORT + #define DL_IMPORT(t) t +#endif +#ifndef DL_EXPORT + #define DL_EXPORT(t) t +#endif + +// For use in DL_IMPORT/DL_EXPORT macros. +#define __PYX_COMMA , + +#ifndef HAVE_LONG_LONG + // CPython has required PY_LONG_LONG support for years, even if HAVE_LONG_LONG is not defined for us + #define HAVE_LONG_LONG +#endif + +#ifndef PY_LONG_LONG + #define PY_LONG_LONG LONG_LONG +#endif + +#ifndef Py_HUGE_VAL + #define Py_HUGE_VAL HUGE_VAL +#endif + +// For the limited API it often makes sense to use Py_LIMITED_API rather than PY_VERSION_HEX +// when doing version checks. +#define __PYX_LIMITED_VERSION_HEX PY_VERSION_HEX + +#if defined(GRAALVM_PYTHON) + /* For very preliminary testing purposes. Most variables are set the same as PyPy. + The existence of this section does not imply that anything works or is even tested */ + // GRAALVM_PYTHON test comes before PyPy test because GraalPython unhelpfully defines PYPY_VERSION + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 1 + + #define CYTHON_COMPILING_IN_CPYTHON_FREETHREADING 0 + + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 0 + #undef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 0 + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #undef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 0 + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #undef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 1 + #undef CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS + #define CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS 1 + #undef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 0 + #undef CYTHON_ASSUME_SAFE_SIZE + #define CYTHON_ASSUME_SAFE_SIZE 0 + #undef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 0 + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #undef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL 0 + #undef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 0 + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS 1 + #endif + #undef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 1 + #undef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 + #undef CYTHON_USE_SYS_MONITORING + #define CYTHON_USE_SYS_MONITORING 0 + #undef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 0 + #undef CYTHON_USE_AM_SEND + #define CYTHON_USE_AM_SEND 0 + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #undef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 1 + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 + #endif + #undef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 0 + +#elif defined(PYPY_VERSION) + #define CYTHON_COMPILING_IN_PYPY 1 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 0 + + #define CYTHON_COMPILING_IN_CPYTHON_FREETHREADING 0 + + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 1 + #ifndef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 0 + #endif + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #undef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 0 + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #undef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 1 + #undef CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS + #define CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS 1 + #undef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 0 + #ifndef CYTHON_ASSUME_SAFE_SIZE + #define CYTHON_ASSUME_SAFE_SIZE 1 + #endif + #undef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 0 + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #undef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL 0 + #undef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 0 + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS 1 + #endif + #if PY_VERSION_HEX < 0x03090000 + #undef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 0 + #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT) + #define CYTHON_PEP489_MULTI_PHASE_INIT 1 + #endif + #undef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 + #undef CYTHON_USE_SYS_MONITORING + #define CYTHON_USE_SYS_MONITORING 0 + #ifndef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE (PYPY_VERSION_NUM >= 0x07030C00) + #endif + #undef CYTHON_USE_AM_SEND + #define CYTHON_USE_AM_SEND 0 + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #undef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 0 + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC (PYPY_VERSION_NUM >= 0x07031100) + #endif + #undef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 0 + +#elif defined(CYTHON_LIMITED_API) + // EXPERIMENTAL !! + #ifdef Py_LIMITED_API + #undef __PYX_LIMITED_VERSION_HEX + #define __PYX_LIMITED_VERSION_HEX Py_LIMITED_API + #endif + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_LIMITED_API 1 + #define CYTHON_COMPILING_IN_GRAAL 0 + + #define CYTHON_COMPILING_IN_CPYTHON_FREETHREADING 0 + + // CYTHON_CLINE_IN_TRACEBACK is currently disabled for the Limited API + #undef CYTHON_CLINE_IN_TRACEBACK + #define CYTHON_CLINE_IN_TRACEBACK 0 + + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 0 + #undef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 1 + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #undef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 0 + #ifndef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #endif + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #ifndef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 0 + #endif + #ifndef CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS + #define CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS 0 + #endif + #undef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 0 + #undef CYTHON_ASSUME_SAFE_SIZE + #define CYTHON_ASSUME_SAFE_SIZE 0 + #undef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 0 + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #undef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL (__PYX_LIMITED_VERSION_HEX >= 0x030C0000) + #undef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 0 + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS 1 + #endif + #ifndef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 1 + #endif + #ifndef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 + #endif + #undef CYTHON_USE_SYS_MONITORING + #define CYTHON_USE_SYS_MONITORING 0 + #ifndef CYTHON_USE_TP_FINALIZE + // PyObject_CallFinalizerFromDealloc is missing and not easily replaced + #define CYTHON_USE_TP_FINALIZE 0 + #endif + #ifndef CYTHON_USE_AM_SEND + #define CYTHON_USE_AM_SEND (__PYX_LIMITED_VERSION_HEX >= 0x030A0000) + #endif + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #undef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 0 + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 + #endif + #undef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 0 + +#else + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_CPYTHON 1 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 0 + + #ifdef Py_GIL_DISABLED + #define CYTHON_COMPILING_IN_CPYTHON_FREETHREADING 1 + #else + #define CYTHON_COMPILING_IN_CPYTHON_FREETHREADING 0 + #endif + + #if PY_VERSION_HEX < 0x030A0000 + // Before Py3.10, PyObject_GetSlot() rejects static (non-heap) types. + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 1 + #elif !defined(CYTHON_USE_TYPE_SLOTS) + #define CYTHON_USE_TYPE_SLOTS 1 + #endif + #ifndef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 0 + #endif + #ifndef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 1 + #endif + #ifndef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 1 + #endif + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + #undef CYTHON_USE_PYLIST_INTERNALS + // Use thread-safe CPython C API calls to manipulate list contents + #define CYTHON_USE_PYLIST_INTERNALS 0 + #elif !defined(CYTHON_USE_PYLIST_INTERNALS) + #define CYTHON_USE_PYLIST_INTERNALS 1 + #endif + #ifndef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 1 + #endif + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING || PY_VERSION_HEX >= 0x030B00A2 + // Python 3.11a2 hid _PyLong_FormatAdvancedWriter and _PyFloat_FormatAdvancedWriter + // therefore disable unicode writer until a better alternative appears + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #elif !defined(CYTHON_USE_UNICODE_WRITER) + #define CYTHON_USE_UNICODE_WRITER 1 + #endif + // CYTHON_AVOID_BORROWED_REFS - Avoid borrowed references and always request owned references directly instead. + #ifndef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 0 + #endif + // CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS - Avoid borrowed references that are not thread-safe in the free-threaded build of CPython. + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + #undef CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS + #define CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS 1 + #elif !defined(CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS) + #define CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS 0 + #endif + // CYTHON_ASSUME_SAFE_MACROS - Assume that macro calls do not fail and do not raise exceptions. + #ifndef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 1 + #endif + // CYTHON_ASSUME_SAFE_SIZE - Assume that Py*_GET_SIZE() calls do not fail and do not raise exceptions. + #ifndef CYTHON_ASSUME_SAFE_SIZE + #define CYTHON_ASSUME_SAFE_SIZE 1 + #endif + #ifndef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 1 + #endif + #ifndef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 1 + #endif + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #elif !defined(CYTHON_FAST_GIL) + // FIXME: FastGIL can probably be supported also in CPython 3.12 but needs to be adapted. + // The gain is unclear, however, since the GIL handling itself became faster in recent CPython versions. + #define CYTHON_FAST_GIL (PY_VERSION_HEX < 0x030C00A6) + #endif + #ifndef CYTHON_METH_FASTCALL + // CPython 3.6 introduced METH_FASTCALL but with slightly different + // semantics. It became stable starting from CPython 3.7. + #define CYTHON_METH_FASTCALL 1 + #endif + #ifndef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 1 + #endif + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS 1 + #endif + #ifndef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 1 + #endif + // CYTHON_USE_MODULE_STATE - Use a module state/globals struct tied to the module object. + #ifndef CYTHON_USE_MODULE_STATE + // EXPERIMENTAL !! + #define CYTHON_USE_MODULE_STATE 0 + #endif + #ifndef CYTHON_USE_SYS_MONITORING + #define CYTHON_USE_SYS_MONITORING (PY_VERSION_HEX >= 0x030d00B1) + #endif + #ifndef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 1 + #endif + #ifndef CYTHON_USE_AM_SEND + #define CYTHON_USE_AM_SEND 1 + #endif + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #elif !defined(CYTHON_USE_DICT_VERSIONS) + // Python 3.12a5 deprecated "ma_version_tag" + // and we use static variables with dict versions so it's incompatible with module state + #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX < 0x030C00A5 && !CYTHON_USE_MODULE_STATE) + #endif + #ifndef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 1 + #endif + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC 1 + #endif + #ifndef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS (!CYTHON_COMPILING_IN_CPYTHON_FREETHREADING) + #endif +#endif + +#ifndef CYTHON_FAST_PYCCALL +#define CYTHON_FAST_PYCCALL CYTHON_FAST_PYCALL +#endif + +#ifndef CYTHON_VECTORCALL +#if CYTHON_COMPILING_IN_LIMITED_API +// Possibly needs a bit of clearing up, however: +// the limited API doesn't define CYTHON_FAST_PYCCALL (because that involves +// a lot of access to internals) but does define CYTHON_VECTORCALL because +// that's available cleanly from Python 3.12. Note that only VectorcallDict isn't +// available though. +#define CYTHON_VECTORCALL (__PYX_LIMITED_VERSION_HEX >= 0x030C0000) +#else +#define CYTHON_VECTORCALL (CYTHON_FAST_PYCCALL && PY_VERSION_HEX >= 0x030800B1) +#endif +#endif + +/* Whether to use METH_FASTCALL with a fake backported implementation of vectorcall */ +#define CYTHON_BACKPORT_VECTORCALL (CYTHON_METH_FASTCALL && PY_VERSION_HEX < 0x030800B1) + +#if CYTHON_USE_PYLONG_INTERNALS + /* These short defines from the PyLong header can easily conflict with other code */ + #undef SHIFT + #undef BASE + #undef MASK + /* Compile-time sanity check that these are indeed equal. Github issue #2670. */ + #ifdef SIZEOF_VOID_P + enum { __pyx_check_sizeof_voidp = 1 / (int)(SIZEOF_VOID_P == sizeof(void*)) }; + #endif +#endif + +#ifndef CYTHON_LOCK_AND_GIL_DEADLOCK_AVOIDANCE_TIME + #define CYTHON_LOCK_AND_GIL_DEADLOCK_AVOIDANCE_TIME 100 /* ms */ +#endif + +#ifndef __has_attribute + #define __has_attribute(x) 0 +#endif + +#ifndef __has_cpp_attribute + #define __has_cpp_attribute(x) 0 +#endif + +// restrict +#ifndef CYTHON_RESTRICT + #if defined(__GNUC__) + #define CYTHON_RESTRICT __restrict__ + #elif defined(_MSC_VER) && _MSC_VER >= 1400 + #define CYTHON_RESTRICT __restrict + #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define CYTHON_RESTRICT restrict + #else + #define CYTHON_RESTRICT + #endif +#endif + +// unused attribute +#ifndef CYTHON_UNUSED + #if defined(__cplusplus) + /* for clang __has_cpp_attribute(maybe_unused) is true even before C++17 + * but leads to warnings with -pedantic, since it is a C++17 feature */ + #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L) + #if __has_cpp_attribute(maybe_unused) + #define CYTHON_UNUSED [[maybe_unused]] + #endif + #endif + #endif +#endif +#ifndef CYTHON_UNUSED +# if defined(__GNUC__) +# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) +# define CYTHON_UNUSED __attribute__ ((__unused__)) +# else +# define CYTHON_UNUSED +# endif +# elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER)) +# define CYTHON_UNUSED __attribute__ ((__unused__)) +# else +# define CYTHON_UNUSED +# endif +#endif + +#ifndef CYTHON_UNUSED_VAR +# if defined(__cplusplus) + template void CYTHON_UNUSED_VAR( const T& ) { } +# else +# define CYTHON_UNUSED_VAR(x) (void)(x) +# endif +#endif + +#ifndef CYTHON_MAYBE_UNUSED_VAR + #define CYTHON_MAYBE_UNUSED_VAR(x) CYTHON_UNUSED_VAR(x) +#endif + +#ifndef CYTHON_NCP_UNUSED +# if CYTHON_COMPILING_IN_CPYTHON && !CYTHON_COMPILING_IN_CPYTHON_FREETHREADING +# define CYTHON_NCP_UNUSED +# else +# define CYTHON_NCP_UNUSED CYTHON_UNUSED +# endif +#endif + +#ifndef CYTHON_USE_CPP_STD_MOVE + // msvc doesn't set __cplusplus to a useful value + #if defined(__cplusplus) && ( \ + __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1600)) + #define CYTHON_USE_CPP_STD_MOVE 1 + #else + #define CYTHON_USE_CPP_STD_MOVE 0 + #endif +#endif + +#define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None) + +#ifdef _MSC_VER + #ifndef _MSC_STDINT_H_ + #if _MSC_VER < 1300 + typedef unsigned char uint8_t; + typedef unsigned short uint16_t; + typedef unsigned int uint32_t; + #else + typedef unsigned __int8 uint8_t; + typedef unsigned __int16 uint16_t; + typedef unsigned __int32 uint32_t; + #endif + #endif + #if _MSC_VER < 1300 + #ifdef _WIN64 + typedef unsigned long long __pyx_uintptr_t; + #else + typedef unsigned int __pyx_uintptr_t; + #endif + #else + #ifdef _WIN64 + typedef unsigned __int64 __pyx_uintptr_t; + #else + typedef unsigned __int32 __pyx_uintptr_t; + #endif + #endif +#else + #include + typedef uintptr_t __pyx_uintptr_t; +#endif + + +#ifndef CYTHON_FALLTHROUGH + #if defined(__cplusplus) + /* for clang __has_cpp_attribute(fallthrough) is true even before C++17 + * but leads to warnings with -pedantic, since it is a C++17 feature */ + #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L) + #if __has_cpp_attribute(fallthrough) + #define CYTHON_FALLTHROUGH [[fallthrough]] + #endif + #endif + + #ifndef CYTHON_FALLTHROUGH + #if __has_cpp_attribute(clang::fallthrough) + #define CYTHON_FALLTHROUGH [[clang::fallthrough]] + #elif __has_cpp_attribute(gnu::fallthrough) + #define CYTHON_FALLTHROUGH [[gnu::fallthrough]] + #endif + #endif + #endif + + #ifndef CYTHON_FALLTHROUGH + #if __has_attribute(fallthrough) + #define CYTHON_FALLTHROUGH __attribute__((fallthrough)) + #else + #define CYTHON_FALLTHROUGH + #endif + #endif + + #if defined(__clang__) && defined(__apple_build_version__) + #if __apple_build_version__ < 7000000 /* Xcode < 7.0 */ + #undef CYTHON_FALLTHROUGH + #define CYTHON_FALLTHROUGH + #endif + #endif +#endif + +#ifndef Py_UNREACHABLE + #define Py_UNREACHABLE() assert(0); abort() +#endif + +#ifdef __cplusplus + template + struct __PYX_IS_UNSIGNED_IMPL {static const bool value = T(0) < T(-1);}; + #define __PYX_IS_UNSIGNED(type) (__PYX_IS_UNSIGNED_IMPL::value) +#else + #define __PYX_IS_UNSIGNED(type) (((type)-1) > 0) +#endif + +#if CYTHON_COMPILING_IN_PYPY == 1 + #define __PYX_NEED_TP_PRINT_SLOT (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x030A0000) +#else + #define __PYX_NEED_TP_PRINT_SLOT (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000) +#endif +// reinterpret + +// TODO: refactor existing code to use those macros +#define __PYX_REINTERPRET_FUNCION(func_pointer, other_pointer) ((func_pointer)(void(*)(void))(other_pointer)) +// #define __PYX_REINTERPRET_POINTER(pointer_type, pointer) ((pointer_type)(void *)(pointer)) +// #define __PYX_RUNTIME_REINTERPRET(type, var) (*(type *)(&var)) + + +/////////////// CInitCode /////////////// + +// inline attribute +#ifndef CYTHON_INLINE + #if defined(__clang__) + #define CYTHON_INLINE __inline__ __attribute__ ((__unused__)) + #elif defined(__GNUC__) + #define CYTHON_INLINE __inline__ + #elif defined(_MSC_VER) + #define CYTHON_INLINE __inline + #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define CYTHON_INLINE inline + #else + #define CYTHON_INLINE + #endif +#endif + + +/////////////// CppInitCode /////////////// + +#ifndef __cplusplus + #error "Cython files generated with the C++ option must be compiled with a C++ compiler." +#endif + +// inline attribute +#ifndef CYTHON_INLINE + #if defined(__clang__) + #define CYTHON_INLINE __inline__ __attribute__ ((__unused__)) + #else + #define CYTHON_INLINE inline + #endif +#endif + +// Work around clang bug https://stackoverflow.com/questions/21847816/c-invoke-nested-template-class-destructor +// (even without the clang bug, the need not to know the typename is generally a benefit) +template +void __Pyx_call_destructor(T& x) { + x.~T(); +} + +// Used for temporary variables of "reference" type. +template +class __Pyx_FakeReference { + public: + __Pyx_FakeReference() : ptr(NULL) { } + // __Pyx_FakeReference(T& ref) : ptr(&ref) { } + // Const version needed as Cython doesn't know about const overloads (e.g. for stl containers). + __Pyx_FakeReference(const T& ref) : ptr(const_cast(&ref)) { } + T *operator->() { return ptr; } + T *operator&() { return ptr; } + operator T&() { return *ptr; } + // TODO(robertwb): Delegate all operators (or auto-generate unwrapping code where needed). + template bool operator ==(const U& other) const { return *ptr == other; } + template bool operator !=(const U& other) const { return *ptr != other; } + template bool operator==(const __Pyx_FakeReference& other) const { return *ptr == *other.ptr; } + template bool operator!=(const __Pyx_FakeReference& other) const { return *ptr != *other.ptr; } + private: + T *ptr; +}; + + +/////////////// PythonCompatibility /////////////// +//@substitute: naming + +#define __PYX_BUILD_PY_SSIZE_T "n" +#define CYTHON_FORMAT_SSIZE_T "z" + +// TODO: remove this block +#define __Pyx_BUILTIN_MODULE_NAME "builtins" +#define __Pyx_DefaultClassType PyType_Type + +#if CYTHON_COMPILING_IN_LIMITED_API + // Cython uses these constants but they are not available in the limited API. + // Therefore define them as static variables and look them up at module init. + #ifndef CO_OPTIMIZED + static int CO_OPTIMIZED; + #endif + #ifndef CO_NEWLOCALS + static int CO_NEWLOCALS; + #endif + #ifndef CO_VARARGS + static int CO_VARARGS; + #endif + #ifndef CO_VARKEYWORDS + static int CO_VARKEYWORDS; + #endif + #ifndef CO_ASYNC_GENERATOR + static int CO_ASYNC_GENERATOR; + #endif + #ifndef CO_GENERATOR + static int CO_GENERATOR; + #endif + #ifndef CO_COROUTINE + static int CO_COROUTINE; + #endif +#else + #ifndef CO_COROUTINE + #define CO_COROUTINE 0x80 + #endif + #ifndef CO_ASYNC_GENERATOR + #define CO_ASYNC_GENERATOR 0x200 + #endif +#endif +static int __Pyx_init_co_variables(void); /* proto */ + +#if PY_VERSION_HEX >= 0x030900A4 || defined(Py_IS_TYPE) + #define __Pyx_IS_TYPE(ob, type) Py_IS_TYPE(ob, type) +#else + #define __Pyx_IS_TYPE(ob, type) (((const PyObject*)ob)->ob_type == (type)) +#endif + +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_Is) + #define __Pyx_Py_Is(x, y) Py_Is(x, y) +#else + #define __Pyx_Py_Is(x, y) ((x) == (y)) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsNone) + #define __Pyx_Py_IsNone(ob) Py_IsNone(ob) +#else + #define __Pyx_Py_IsNone(ob) __Pyx_Py_Is((ob), Py_None) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsTrue) + #define __Pyx_Py_IsTrue(ob) Py_IsTrue(ob) +#else + #define __Pyx_Py_IsTrue(ob) __Pyx_Py_Is((ob), Py_True) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsFalse) + #define __Pyx_Py_IsFalse(ob) Py_IsFalse(ob) +#else + #define __Pyx_Py_IsFalse(ob) __Pyx_Py_Is((ob), Py_False) +#endif +#define __Pyx_NoneAsNull(obj) (__Pyx_Py_IsNone(obj) ? NULL : (obj)) + +#if PY_VERSION_HEX >= 0x030900F0 && !CYTHON_COMPILING_IN_PYPY + #define __Pyx_PyObject_GC_IsFinalized(o) PyObject_GC_IsFinalized(o) +#else + #define __Pyx_PyObject_GC_IsFinalized(o) _PyGC_FINALIZED(o) +#endif + +#ifndef Py_TPFLAGS_CHECKTYPES + #define Py_TPFLAGS_CHECKTYPES 0 +#endif +#ifndef Py_TPFLAGS_HAVE_INDEX + #define Py_TPFLAGS_HAVE_INDEX 0 +#endif +#ifndef Py_TPFLAGS_HAVE_NEWBUFFER + #define Py_TPFLAGS_HAVE_NEWBUFFER 0 +#endif +#ifndef Py_TPFLAGS_HAVE_FINALIZE + #define Py_TPFLAGS_HAVE_FINALIZE 0 +#endif +#ifndef Py_TPFLAGS_SEQUENCE + #define Py_TPFLAGS_SEQUENCE 0 +#endif +#ifndef Py_TPFLAGS_MAPPING + #define Py_TPFLAGS_MAPPING 0 +#endif + +#ifndef METH_STACKLESS + // already defined for Stackless Python (all versions) and C-Python >= 3.7 + // value if defined: Stackless Python < 3.6: 0x80 else 0x100 + #define METH_STACKLESS 0 +#endif +#ifndef METH_FASTCALL + // new in CPython 3.6, but changed in 3.7 - see + // positional-only parameters: + // https://bugs.python.org/issue29464 + // const args: + // https://bugs.python.org/issue32240 + #ifndef METH_FASTCALL + #define METH_FASTCALL 0x80 + #endif + typedef PyObject *(*__Pyx_PyCFunctionFast) (PyObject *self, PyObject *const *args, Py_ssize_t nargs); + // new in CPython 3.7, used to be old signature of _PyCFunctionFast() in 3.6 + typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args, + Py_ssize_t nargs, PyObject *kwnames); +#else + #if PY_VERSION_HEX >= 0x030d00A4 + # define __Pyx_PyCFunctionFast PyCFunctionFast + # define __Pyx_PyCFunctionFastWithKeywords PyCFunctionFastWithKeywords + #else + # define __Pyx_PyCFunctionFast _PyCFunctionFast + # define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords + #endif +#endif + +#if CYTHON_METH_FASTCALL + #define __Pyx_METH_FASTCALL METH_FASTCALL + #define __Pyx_PyCFunction_FastCall __Pyx_PyCFunctionFast + #define __Pyx_PyCFunction_FastCallWithKeywords __Pyx_PyCFunctionFastWithKeywords +#else + #define __Pyx_METH_FASTCALL METH_VARARGS + #define __Pyx_PyCFunction_FastCall PyCFunction + #define __Pyx_PyCFunction_FastCallWithKeywords PyCFunctionWithKeywords +#endif + +#if CYTHON_VECTORCALL + #define __pyx_vectorcallfunc vectorcallfunc + #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET PY_VECTORCALL_ARGUMENTS_OFFSET + #define __Pyx_PyVectorcall_NARGS(n) PyVectorcall_NARGS((size_t)(n)) +#elif CYTHON_BACKPORT_VECTORCALL + typedef PyObject *(*__pyx_vectorcallfunc)(PyObject *callable, PyObject *const *args, + size_t nargsf, PyObject *kwnames); + #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET ((size_t)1 << (8 * sizeof(size_t) - 1)) + #define __Pyx_PyVectorcall_NARGS(n) ((Py_ssize_t)(((size_t)(n)) & ~__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)) +#else + #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET 0 + #define __Pyx_PyVectorcall_NARGS(n) ((Py_ssize_t)(n)) +#endif + +// These PyCFunction related macros get redefined in CythonFunction.c. +// We need our own copies because the inline functions in CPython have a type-check assert +// that breaks with a CyFunction in debug mode. +#if PY_VERSION_HEX >= 0x030900B1 +#define __Pyx_PyCFunction_CheckExact(func) PyCFunction_CheckExact(func) +#else +#define __Pyx_PyCFunction_CheckExact(func) PyCFunction_Check(func) +#endif +#define __Pyx_CyOrPyCFunction_Check(func) PyCFunction_Check(func) + +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func) (((PyCFunctionObject*)(func))->m_ml->ml_meth) +#elif !CYTHON_COMPILING_IN_LIMITED_API +// It's probably easier for non-CPythons to support PyCFunction_GET_FUNCTION() than the object struct layout. +#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func) PyCFunction_GET_FUNCTION(func) +// Unused in CYTHON_COMPILING_IN_LIMITED_API. +#endif +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_CyOrPyCFunction_GET_FLAGS(func) (((PyCFunctionObject*)(func))->m_ml->ml_flags) +static CYTHON_INLINE PyObject* __Pyx_CyOrPyCFunction_GET_SELF(PyObject *func) { + return (__Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_STATIC) ? NULL : ((PyCFunctionObject*)func)->m_self; +} +// Only used if CYTHON_COMPILING_IN_CPYTHON. +#endif +static CYTHON_INLINE int __Pyx__IsSameCFunction(PyObject *func, void (*cfunc)(void)) { +#if CYTHON_COMPILING_IN_LIMITED_API + return PyCFunction_Check(func) && PyCFunction_GetFunction(func) == (PyCFunction) cfunc; +#else + return PyCFunction_Check(func) && PyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc; +#endif +} +#define __Pyx_IsSameCFunction(func, cfunc) __Pyx__IsSameCFunction(func, cfunc) + +// PEP-573: PyCFunction holds reference to defining class (PyCMethodObject) +#if __PYX_LIMITED_VERSION_HEX < 0x03090000 + #define __Pyx_PyType_FromModuleAndSpec(m, s, b) ((void)m, PyType_FromSpecWithBases(s, b)) + typedef PyObject *(*__Pyx_PyCMethod)(PyObject *, PyTypeObject *, PyObject *const *, size_t, PyObject *); +#else + #define __Pyx_PyType_FromModuleAndSpec(m, s, b) PyType_FromModuleAndSpec(m, s, b) + #define __Pyx_PyCMethod PyCMethod +#endif +#ifndef METH_METHOD + #define METH_METHOD 0x200 +#endif + +#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc) + #define PyObject_Malloc(s) PyMem_Malloc(s) + #define PyObject_Free(p) PyMem_Free(p) + #define PyObject_Realloc(p) PyMem_Realloc(p) +#endif + +#if CYTHON_COMPILING_IN_LIMITED_API + // __Pyx_PyCode_HasFreeVars isn't easily emulated in the limited API (but isn't really necessary) + #define __Pyx_PyFrame_SetLineNumber(frame, lineno) +#elif CYTHON_COMPILING_IN_GRAAL + #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) + #define __Pyx_PyFrame_SetLineNumber(frame, lineno) _PyFrame_SetLineNumber((frame), (lineno)) +#else + #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) + #define __Pyx_PyFrame_SetLineNumber(frame, lineno) (frame)->f_lineno = (lineno) +#endif + +#if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_PyThreadState_Current PyThreadState_Get() +#elif !CYTHON_FAST_THREAD_STATE + #define __Pyx_PyThreadState_Current PyThreadState_GET() +#elif PY_VERSION_HEX >= 0x030d00A1 + #define __Pyx_PyThreadState_Current PyThreadState_GetUnchecked() +#else + #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet() +#endif + +#if CYTHON_USE_MODULE_STATE +static CYTHON_INLINE void *__Pyx__PyModule_GetState(PyObject *op) +{ + void *result; + + result = PyModule_GetState(op); + if (!result) + Py_FatalError("Couldn't find the module state"); + return result; +} +// Define a macro with a cast because the modulestate type isn't known yet and +// is a typedef struct so impossible to forward declare +#define __Pyx_PyModule_GetState(o) ($modulestatetype_cname *)__Pyx__PyModule_GetState(o) +#else +#define __Pyx_PyModule_GetState(op) ((void)op,$modulestateglobal_cname) +#endif + +// The "Try" variants may return NULL on static types with the Limited API on earlier versions +// so should be used for optimization rather than where a result is required. +#define __Pyx_PyObject_GetSlot(obj, name, func_ctype) __Pyx_PyType_GetSlot(Py_TYPE((PyObject *) obj), name, func_ctype) +#define __Pyx_PyObject_TryGetSlot(obj, name, func_ctype) __Pyx_PyType_TryGetSlot(Py_TYPE(obj), name, func_ctype) +#define __Pyx_PyObject_GetSubSlot(obj, sub, name, func_ctype) __Pyx_PyType_GetSubSlot(Py_TYPE(obj), sub, name, func_ctype) +#define __Pyx_PyObject_TryGetSubSlot(obj, sub, name, func_ctype) __Pyx_PyType_TryGetSubSlot(Py_TYPE(obj), sub, name, func_ctype) +#if CYTHON_USE_TYPE_SLOTS + #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((type)->name) + #define __Pyx_PyType_TryGetSlot(type, name, func_ctype) __Pyx_PyType_GetSlot(type, name, func_ctype) + #define __Pyx_PyType_GetSubSlot(type, sub, name, func_ctype) (((type)->sub) ? ((type)->sub->name) : NULL) + #define __Pyx_PyType_TryGetSubSlot(type, sub, name, func_ctype) __Pyx_PyType_GetSubSlot(type, sub, name, func_ctype) +#else + #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((func_ctype) PyType_GetSlot((type), Py_##name)) + #define __Pyx_PyType_TryGetSlot(type, name, func_ctype) \ + ((__PYX_LIMITED_VERSION_HEX >= 0x030A0000 || \ + (PyType_GetFlags(type) & Py_TPFLAGS_HEAPTYPE) || __Pyx_get_runtime_version() >= 0x030A0000) ? \ + __Pyx_PyType_GetSlot(type, name, func_ctype) : NULL) + #define __Pyx_PyType_GetSubSlot(obj, sub, name, func_ctype) __Pyx_PyType_GetSlot(obj, name, func_ctype) + #define __Pyx_PyType_TryGetSubSlot(obj, sub, name, func_ctype) __Pyx_PyType_TryGetSlot(obj, name, func_ctype) +#endif + +#if CYTHON_COMPILING_IN_CPYTHON || defined(_PyDict_NewPresized) +#define __Pyx_PyDict_NewPresized(n) ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n)) +#else +#define __Pyx_PyDict_NewPresized(n) PyDict_New() +#endif + +#define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y) +#define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y) + +#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_UNICODE_INTERNALS +// _PyDict_GetItem_KnownHash() existed from CPython 3.5 to 3.12, but it was +// dropping exceptions in 3.5. Since 3.6, exceptions are kept. +#define __Pyx_PyDict_GetItemStrWithError(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash) +static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStr(PyObject *dict, PyObject *name) { + PyObject *res = __Pyx_PyDict_GetItemStrWithError(dict, name); + if (res == NULL) PyErr_Clear(); + return res; +} +#elif !CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07020000 +#define __Pyx_PyDict_GetItemStrWithError PyDict_GetItemWithError +#define __Pyx_PyDict_GetItemStr PyDict_GetItem +#else +static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStrWithError(PyObject *dict, PyObject *name) { + // This is tricky - we should return a borrowed reference but not swallow non-KeyError exceptions. 8-| + // But: this function is only used in Py2 and older PyPys, + // and currently only for argument parsing and other non-correctness-critical lookups + // and we know that 'name' is an interned 'str' with pre-calculated hash value (only comparisons can fail), + // thus, performance matters more than correctness here, especially in the "not found" case. +#if CYTHON_COMPILING_IN_PYPY + // So we ignore any exceptions in old PyPys ... + return PyDict_GetItem(dict, name); +#else + // and hack together a stripped-down and modified PyDict_GetItem() in CPython 2. + PyDictEntry *ep; + PyDictObject *mp = (PyDictObject*) dict; + long hash = ((PyStringObject *) name)->ob_shash; + assert(hash != -1); /* hash values of interned strings are always initialised */ + ep = (mp->ma_lookup)(mp, name, hash); + if (ep == NULL) { + // error occurred + return NULL; + } + // found or not found + return ep->me_value; +#endif +} +#define __Pyx_PyDict_GetItemStr PyDict_GetItem +#endif + +/* Type slots */ + +#if CYTHON_USE_TYPE_SLOTS + #define __Pyx_PyType_GetFlags(tp) (((PyTypeObject *)tp)->tp_flags) + #define __Pyx_PyType_HasFeature(type, feature) ((__Pyx_PyType_GetFlags(type) & (feature)) != 0) +#else + #define __Pyx_PyType_GetFlags(tp) (PyType_GetFlags((PyTypeObject *)tp)) + #define __Pyx_PyType_HasFeature(type, feature) PyType_HasFeature(type, feature) +#endif + +// There is no replacement for "Py_TYPE(obj)->iternext" in the C-API. +// PyIter_Next() discards the StopIteration, unlike Python's "next()". +#define __Pyx_PyObject_GetIterNextFunc(iterator) __Pyx_PyObject_GetSlot(iterator, tp_iternext, iternextfunc) + +#if CYTHON_USE_TYPE_SPECS && PY_VERSION_HEX >= 0x03080000 +// In Py3.8+, instances of heap types need to decref their type on deallocation. +// https://bugs.python.org/issue35810 +#define __Pyx_PyHeapTypeObject_GC_Del(obj) { \ + PyTypeObject *type = Py_TYPE((PyObject*)obj); \ + assert(__Pyx_PyType_HasFeature(type, Py_TPFLAGS_HEAPTYPE)); \ + PyObject_GC_Del(obj); \ + Py_DECREF(type); \ +} +#else +#define __Pyx_PyHeapTypeObject_GC_Del(obj) PyObject_GC_Del(obj) +#endif + +#if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_PyUnicode_READY(op) (0) + #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_ReadChar(u, i) + #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((void)u, 1114111U) + #define __Pyx_PyUnicode_KIND(u) ((void)u, (0)) + // __Pyx_PyUnicode_DATA() and __Pyx_PyUnicode_READ() must go together, e.g. for iteration. + #define __Pyx_PyUnicode_DATA(u) ((void*)u) + #define __Pyx_PyUnicode_READ(k, d, i) ((void)k, PyUnicode_ReadChar((PyObject*)(d), i)) + //#define __Pyx_PyUnicode_WRITE(k, d, i, ch) /* not available */ + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GetLength(u)) +#else + #if PY_VERSION_HEX >= 0x030C0000 + // Py3.12 / PEP-623 removed wstr type unicode strings and all of the PyUnicode_READY() machinery. + #define __Pyx_PyUnicode_READY(op) (0) + #else + #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ? \ + 0 : _PyUnicode_Ready((PyObject *)(op))) + #endif + + #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) + #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) PyUnicode_MAX_CHAR_VALUE(u) + #define __Pyx_PyUnicode_KIND(u) ((int)PyUnicode_KIND(u)) + #define __Pyx_PyUnicode_DATA(u) PyUnicode_DATA(u) + #define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i) + #define __Pyx_PyUnicode_WRITE(k, d, i, ch) PyUnicode_WRITE(k, d, i, (Py_UCS4) ch) + #if PY_VERSION_HEX >= 0x030C0000 + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_LENGTH(u)) + #else + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000 + // Avoid calling deprecated C-API functions in Py3.9+ that PEP-623 schedules for removal in Py3.12. + // https://www.python.org/dev/peps/pep-0623/ + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length)) + #else + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) + #endif + #endif +#endif + +#if CYTHON_COMPILING_IN_PYPY + #define __Pyx_PyUnicode_Concat(a, b) PyNumber_Add(a, b) + #define __Pyx_PyUnicode_ConcatSafe(a, b) PyNumber_Add(a, b) +#else + #define __Pyx_PyUnicode_Concat(a, b) PyUnicode_Concat(a, b) + #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ? \ + PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b)) +#endif + +#if CYTHON_COMPILING_IN_PYPY + #if !defined(PyUnicode_DecodeUnicodeEscape) + #define PyUnicode_DecodeUnicodeEscape(s, size, errors) PyUnicode_Decode(s, size, "unicode_escape", errors) + #endif + #if !defined(PyUnicode_Contains) + #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) + #endif + #if !defined(PyByteArray_Check) + #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type) + #endif + #if !defined(PyObject_Format) + #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt) + #endif +#endif + +// ("..." % x) must call PyNumber_Remainder() if x is a string subclass that implements "__rmod__()". +#define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) + +#if CYTHON_COMPILING_IN_CPYTHON + #define __Pyx_PySequence_ListKeepNew(obj) \ + (likely(PyList_CheckExact(obj) && Py_REFCNT(obj) == 1) ? __Pyx_NewRef(obj) : PySequence_List(obj)) +#else + #define __Pyx_PySequence_ListKeepNew(obj) PySequence_List(obj) +#endif + +#ifndef PySet_CheckExact + #define PySet_CheckExact(obj) __Pyx_IS_TYPE(obj, &PySet_Type) +#endif + +#if PY_VERSION_HEX >= 0x030900A4 + #define __Pyx_SET_REFCNT(obj, refcnt) Py_SET_REFCNT(obj, refcnt) + #define __Pyx_SET_SIZE(obj, size) Py_SET_SIZE(obj, size) +#else + #define __Pyx_SET_REFCNT(obj, refcnt) Py_REFCNT(obj) = (refcnt) + #define __Pyx_SET_SIZE(obj, size) Py_SIZE(obj) = (size) +#endif + +#if CYTHON_AVOID_BORROWED_REFS || CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS + #if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 + #define __Pyx_PyList_GetItemRef(o, i) PyList_GetItemRef(o, i) + #elif CYTHON_COMPILING_IN_LIMITED_API || !CYTHON_ASSUME_SAFE_MACROS + #define __Pyx_PyList_GetItemRef(o, i) (likely((i) >= 0) ? PySequence_GetItem(o, i) : (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL)) + #else + #define __Pyx_PyList_GetItemRef(o, i) PySequence_ITEM(o, i) + #endif +#elif CYTHON_COMPILING_IN_LIMITED_API || !CYTHON_ASSUME_SAFE_MACROS + #if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 + #define __Pyx_PyList_GetItemRef(o, i) PyList_GetItemRef(o, i) + #else + #define __Pyx_PyList_GetItemRef(o, i) __Pyx_XNewRef(PyList_GetItem(o, i)) + #endif +#else + #define __Pyx_PyList_GetItemRef(o, i) __Pyx_NewRef(PyList_GET_ITEM(o, i)) +#endif + +#if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 +#define __Pyx_PyDict_GetItemRef(dict, key, result) PyDict_GetItemRef(dict, key, result) +#elif CYTHON_AVOID_BORROWED_REFS || CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS +static CYTHON_INLINE int __Pyx_PyDict_GetItemRef(PyObject *dict, PyObject *key, PyObject **result) { + *result = PyObject_GetItem(dict, key); + if (*result == NULL) { + if (PyErr_ExceptionMatches(PyExc_KeyError)) { + PyErr_Clear(); + return 0; + } + return -1; + } + return 1; +} +#else +static CYTHON_INLINE int __Pyx_PyDict_GetItemRef(PyObject *dict, PyObject *key, PyObject **result) { + *result = PyDict_GetItemWithError(dict, key); + if (*result == NULL) { + return PyErr_Occurred() ? -1 : 0; + } + Py_INCREF(*result); + return 1; +} +#endif + +// No-op macro for calling Py_VISIT() on known constants that can never participate in reference cycles. +// Users can define "CYTHON_DEBUG_VISIT_CONST=1" to help in debugging reference issues. +#if defined(CYTHON_DEBUG_VISIT_CONST) && CYTHON_DEBUG_VISIT_CONST + #define __Pyx_VISIT_CONST(obj) Py_VISIT(obj) +#else + #define __Pyx_VISIT_CONST(obj) +#endif + +#if CYTHON_ASSUME_SAFE_MACROS + #define __Pyx_PySequence_ITEM(o, i) PySequence_ITEM(o, i) + #define __Pyx_PySequence_SIZE(seq) Py_SIZE(seq) + #define __Pyx_PyTuple_SET_ITEM(o, i, v) (PyTuple_SET_ITEM(o, i, v), (0)) + #define __Pyx_PyTuple_GET_ITEM(o, i) PyTuple_GET_ITEM(o, i) + #define __Pyx_PyList_SET_ITEM(o, i, v) (PyList_SET_ITEM(o, i, v), (0)) + #define __Pyx_PyList_GET_ITEM(o, i) PyList_GET_ITEM(o, i) +#else + #define __Pyx_PySequence_ITEM(o, i) PySequence_GetItem(o, i) + // NOTE: might fail with exception => check for -1 + #define __Pyx_PySequence_SIZE(seq) PySequence_Size(seq) + // NOTE: this doesn't leak a reference to whatever is at o[i] + #define __Pyx_PyTuple_SET_ITEM(o, i, v) PyTuple_SetItem(o, i, v) + #define __Pyx_PyTuple_GET_ITEM(o, i) PyTuple_GetItem(o, i) + #define __Pyx_PyList_SET_ITEM(o, i, v) PyList_SetItem(o, i, v) + #define __Pyx_PyList_GET_ITEM(o, i) PyList_GetItem(o, i) +#endif + +#if CYTHON_ASSUME_SAFE_SIZE + #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_GET_SIZE(o) + #define __Pyx_PyList_GET_SIZE(o) PyList_GET_SIZE(o) + #define __Pyx_PySet_GET_SIZE(o) PySet_GET_SIZE(o) + #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_GET_SIZE(o) + #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_GET_SIZE(o) + #define __Pyx_PyUnicode_GET_LENGTH(o) PyUnicode_GET_LENGTH(o) +#else + // These all need exception checks for -1. + #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_Size(o) + #define __Pyx_PyList_GET_SIZE(o) PyList_Size(o) + #define __Pyx_PySet_GET_SIZE(o) PySet_Size(o) + #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_Size(o) + #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_Size(o) + #define __Pyx_PyUnicode_GET_LENGTH(o) PyUnicode_GetLength(o) +#endif + +#if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 + #define __Pyx_PyImport_AddModuleRef(name) PyImport_AddModuleRef(name) +#else + static CYTHON_INLINE PyObject *__Pyx_PyImport_AddModuleRef(const char *name) { + PyObject *module = PyImport_AddModule(name); + Py_XINCREF(module); + return module; + } +#endif + +#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_InternFromString) + #define PyUnicode_InternFromString(s) PyUnicode_FromString(s) +#endif + +#define __Pyx_PyLong_FromHash_t PyLong_FromSsize_t +#define __Pyx_PyLong_AsHash_t __Pyx_PyIndex_AsSsize_t + + +// backport of PyAsyncMethods from Py3.10 to older Py3.x versions +#if __PYX_LIMITED_VERSION_HEX >= 0x030A0000 + #define __Pyx_PySendResult PySendResult +#else + typedef enum { + PYGEN_RETURN = 0, + PYGEN_ERROR = -1, + PYGEN_NEXT = 1, + } __Pyx_PySendResult; +#endif + +#if CYTHON_COMPILING_IN_LIMITED_API || PY_VERSION_HEX < 0x030A00A3 + typedef __Pyx_PySendResult (*__Pyx_pyiter_sendfunc)(PyObject *iter, PyObject *value, PyObject **result); +#else + #define __Pyx_pyiter_sendfunc sendfunc +#endif + +// "Py_am_send" requires Py3.10 when using type specs (which utility code types do). +#if !CYTHON_USE_AM_SEND +#define __PYX_HAS_PY_AM_SEND 0 +#elif __PYX_LIMITED_VERSION_HEX >= 0x030A0000 +#define __PYX_HAS_PY_AM_SEND 1 +#else +#define __PYX_HAS_PY_AM_SEND 2 // our own backported implementation +#endif + +#if __PYX_HAS_PY_AM_SEND < 2 + #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods +#else + // PyAsyncMethods in Py<3.10 lacks "am_send" + typedef struct { + unaryfunc am_await; + unaryfunc am_aiter; + unaryfunc am_anext; + __Pyx_pyiter_sendfunc am_send; + } __Pyx_PyAsyncMethodsStruct; + + #define __Pyx_SlotTpAsAsync(s) ((PyAsyncMethods*)(s)) +#endif + +// Use a flag in Py < 3.10 to mark coroutines that have the "am_send" field. +#if CYTHON_USE_AM_SEND && PY_VERSION_HEX < 0x030A00F0 + #define __Pyx_TPFLAGS_HAVE_AM_SEND (1UL << 21) +#else + #define __Pyx_TPFLAGS_HAVE_AM_SEND (0) +#endif + +#if PY_VERSION_HEX >= 0x03090000 +#define __Pyx_PyInterpreterState_Get() PyInterpreterState_Get() +#else +#define __Pyx_PyInterpreterState_Get() PyThreadState_Get()->interp +#endif + +#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030A0000 +// PyMem_Calloc *is* in the Stable ABI in all the Limited API versions we care about. +// However, it is omitted from the Python headers which means that C incorrectly +// assumes it returns an int (and generates dubious code on based on that assumption). +// Therefore, copy the prototype. +#ifdef __cplusplus +extern "C" +#endif +PyAPI_FUNC(void *) PyMem_Calloc(size_t nelem, size_t elsize); /* proto */ +#endif + +#if CYTHON_COMPILING_IN_LIMITED_API +// returns 1 for success and 0 for failure to enable it to be chained in an && +static int __Pyx_init_co_variable(PyObject *inspect, const char* name, int *write_to) { + int value; + PyObject *py_value = PyObject_GetAttrString(inspect, name); + if (!py_value) return 0; + // There's a small chance of overflow here, but it'd only happen if inspect was set up wrongly. + value = (int) PyLong_AsLong(py_value); + Py_DECREF(py_value); + *write_to = value; + return value != -1 || !PyErr_Occurred(); +} + +// Returns 0 on success and -1 on failure for normal error handling +static int __Pyx_init_co_variables(void) { + PyObject *inspect; + int result; + inspect = PyImport_ImportModule("inspect"); + + result = +#if !defined(CO_OPTIMIZED) + __Pyx_init_co_variable(inspect, "CO_OPTIMIZED", &CO_OPTIMIZED) && +#endif +#if !defined(CO_NEWLOCALS) + __Pyx_init_co_variable(inspect, "CO_NEWLOCALS", &CO_NEWLOCALS) && +#endif +#if !defined(CO_VARARGS) + __Pyx_init_co_variable(inspect, "CO_VARARGS", &CO_VARARGS) && +#endif +#if !defined(CO_VARKEYWORDS) + __Pyx_init_co_variable(inspect, "CO_VARKEYWORDS", &CO_VARKEYWORDS) && +#endif +#if !defined(CO_ASYNC_GENERATOR) + __Pyx_init_co_variable(inspect, "CO_ASYNC_GENERATOR", &CO_ASYNC_GENERATOR) && +#endif +#if !defined(CO_GENERATOR) + __Pyx_init_co_variable(inspect, "CO_GENERATOR", &CO_GENERATOR) && +#endif +#if !defined(CO_COROUTINE) + __Pyx_init_co_variable(inspect, "CO_COROUTINE", &CO_COROUTINE) && +#endif + 1; + + Py_DECREF(inspect); + return result ? 0 : -1; +} +#else +static int __Pyx_init_co_variables(void) { + return 0; // It's a limited API-only feature +} +#endif + +/////////////// CythonABIVersion.proto /////////////// +//@proto_block: module_declarations +// This needs to go after the utility code 'proto' section but before user code and utility impl. + +#if CYTHON_COMPILING_IN_LIMITED_API + // The limited API makes some significant changes to data structures, so we don't + // want to share the implementations compiled with and without the limited API. + #if CYTHON_METH_FASTCALL + #define __PYX_FASTCALL_ABI_SUFFIX "_fastcall" + #else + #define __PYX_FASTCALL_ABI_SUFFIX + #endif + + #define __PYX_LIMITED_ABI_SUFFIX "limited" __PYX_FASTCALL_ABI_SUFFIX __PYX_AM_SEND_ABI_SUFFIX +#else + #define __PYX_LIMITED_ABI_SUFFIX +#endif + +#if __PYX_HAS_PY_AM_SEND == 1 + #define __PYX_AM_SEND_ABI_SUFFIX +#elif __PYX_HAS_PY_AM_SEND == 2 + #define __PYX_AM_SEND_ABI_SUFFIX "amsendbackport" +#else + #define __PYX_AM_SEND_ABI_SUFFIX "noamsend" +#endif + +#ifndef __PYX_MONITORING_ABI_SUFFIX + #define __PYX_MONITORING_ABI_SUFFIX +#endif + +#if CYTHON_USE_TP_FINALIZE + #define __PYX_TP_FINALIZE_ABI_SUFFIX +#else + // affects destruction of async generator/coroutines + #define __PYX_TP_FINALIZE_ABI_SUFFIX "nofinalize" +#endif + +#if CYTHON_USE_FREELISTS || !defined(__Pyx_AsyncGen_USED) + #define __PYX_FREELISTS_ABI_SUFFIX +#else + // affects allocation/deallocation of async generator objects. + #define __PYX_FREELISTS_ABI_SUFFIX "nofreelists" +#endif + +#define CYTHON_ABI __PYX_ABI_VERSION __PYX_LIMITED_ABI_SUFFIX __PYX_MONITORING_ABI_SUFFIX __PYX_TP_FINALIZE_ABI_SUFFIX __PYX_FREELISTS_ABI_SUFFIX __PYX_AM_SEND_ABI_SUFFIX + +#define __PYX_ABI_MODULE_NAME "_cython_" CYTHON_ABI +#define __PYX_TYPE_MODULE_PREFIX __PYX_ABI_MODULE_NAME "." + +/////////////// PythonCompatibility.init /////////////// + +if (likely(__Pyx_init_co_variables() == 0)); else + + +/////////////// IncludeStructmemberH.proto /////////////// +//@proto_block: utility_code_proto_before_types + +#include + + +/////////////// SmallCodeConfig /////////////// + +#ifndef CYTHON_SMALL_CODE +#if defined(__clang__) + #define CYTHON_SMALL_CODE +#elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) + #define CYTHON_SMALL_CODE __attribute__((cold)) +#else + #define CYTHON_SMALL_CODE +#endif +#endif + + +/////////////// PyModInitFuncType /////////////// + +#ifndef CYTHON_NO_PYINIT_EXPORT + #define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC +#else + // define this to PyObject * manually because PyMODINIT_FUNC adds __declspec(dllexport) to it's definition. + #ifdef __cplusplus + #define __Pyx_PyMODINIT_FUNC extern "C" PyObject * + #else + #define __Pyx_PyMODINIT_FUNC PyObject * + #endif +#endif + + +/////////////// FastTypeChecks.proto /////////////// + +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type) +#define __Pyx_TypeCheck2(obj, type1, type2) __Pyx_IsAnySubtype2(Py_TYPE(obj), (PyTypeObject *)type1, (PyTypeObject *)type2) +static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b);/*proto*/ +static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b);/*proto*/ +static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type);/*proto*/ +static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2);/*proto*/ +#else +#define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) +#define __Pyx_TypeCheck2(obj, type1, type2) (PyObject_TypeCheck(obj, (PyTypeObject *)type1) || PyObject_TypeCheck(obj, (PyTypeObject *)type2)) +#define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type) +static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2) { + return PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2); +} +#endif +#define __Pyx_PyErr_ExceptionMatches2(err1, err2) __Pyx_PyErr_GivenExceptionMatches2(__Pyx_PyErr_CurrentExceptionType(), err1, err2) + +#define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception) +#ifdef PyExceptionInstance_Check + #define __Pyx_PyBaseException_Check(obj) PyExceptionInstance_Check(obj) +#else + #define __Pyx_PyBaseException_Check(obj) __Pyx_TypeCheck(obj, PyExc_BaseException) +#endif + + +/////////////// FastTypeChecks /////////////// +//@requires: Exceptions.c::PyThreadStateGet +//@requires: Exceptions.c::PyErrFetchRestore + +#if CYTHON_COMPILING_IN_CPYTHON +static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) { + while (a) { + a = __Pyx_PyType_GetSlot(a, tp_base, PyTypeObject*); + if (a == b) + return 1; + } + return b == &PyBaseObject_Type; +} + +static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) { + PyObject *mro; + if (a == b) return 1; + mro = a->tp_mro; + if (likely(mro)) { + Py_ssize_t i, n; + n = PyTuple_GET_SIZE(mro); + for (i = 0; i < n; i++) { + if (PyTuple_GET_ITEM(mro, i) == (PyObject *)b) + return 1; + } + return 0; + } + // should only get here for incompletely initialised types, i.e. never under normal usage patterns + return __Pyx_InBases(a, b); +} + +static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b) { + PyObject *mro; + if (cls == a || cls == b) return 1; + mro = cls->tp_mro; + if (likely(mro)) { + Py_ssize_t i, n; + n = PyTuple_GET_SIZE(mro); + for (i = 0; i < n; i++) { + PyObject *base = PyTuple_GET_ITEM(mro, i); + if (base == (PyObject *)a || base == (PyObject *)b) + return 1; + } + return 0; + } + // should only get here for incompletely initialised types, i.e. never under normal usage patterns + return __Pyx_InBases(cls, a) || __Pyx_InBases(cls, b); +} + + +static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) { + if (exc_type1) { + return __Pyx_IsAnySubtype2((PyTypeObject*)err, (PyTypeObject*)exc_type1, (PyTypeObject*)exc_type2); + } else { + return __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2); + } +} + +// so far, we only call PyErr_GivenExceptionMatches() with an exception type (not instance) as first argument +// => optimise for that case + +static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { + Py_ssize_t i, n; + assert(PyExceptionClass_Check(exc_type)); + n = PyTuple_GET_SIZE(tuple); + // the tight subtype checking in Py3 allows faster out-of-order comparison + for (i=0; i pure safety check assertions. + assert(PyExceptionClass_Check(exc_type1)); + assert(PyExceptionClass_Check(exc_type2)); + if (likely(err == exc_type1 || err == exc_type2)) return 1; + if (likely(PyExceptionClass_Check(err))) { + return __Pyx_inner_PyErr_GivenExceptionMatches2(err, exc_type1, exc_type2); + } + return (PyErr_GivenExceptionMatches(err, exc_type1) || PyErr_GivenExceptionMatches(err, exc_type2)); +} + +#endif + + +/////////////// MathInitCode /////////////// + +#if defined(_WIN32) || defined(WIN32) || defined(MS_WINDOWS) + #ifndef _USE_MATH_DEFINES + #define _USE_MATH_DEFINES + #endif +#endif +#include + +#ifdef NAN +#define __PYX_NAN() ((float) NAN) +#else +static CYTHON_INLINE float __PYX_NAN() { + // Initialize NaN. The sign is irrelevant, an exponent with all bits 1 and + // a nonzero mantissa means NaN. If the first bit in the mantissa is 1, it is + // a quiet NaN. + float value; + memset(&value, 0xFF, sizeof(value)); + return value; +} +#endif + +#if defined(__CYGWIN__) && defined(_LDBL_EQ_DBL) +#define __Pyx_truncl trunc +#else +#define __Pyx_truncl truncl +#endif + +/////////////// ForceInitThreads.proto /////////////// +//@proto_block: utility_code_proto_before_types + +#ifndef __PYX_FORCE_INIT_THREADS + #define __PYX_FORCE_INIT_THREADS 0 +#endif + + +/////////////// ModuleCreationPEP489 /////////////// +//@substitute: naming + +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x03090000 +// Probably won't work before 3.8, but we don't use restricted API to find that out. +static PY_INT64_T __Pyx_GetCurrentInterpreterId(void) { + { + PyObject *module = PyImport_ImportModule("_interpreters"); // 3.13+ I think + if (!module) { + PyErr_Clear(); // just try the 3.8-3.12 version + module = PyImport_ImportModule("_xxsubinterpreters"); + if (!module) goto bad; + } + PyObject *current = PyObject_CallMethod(module, "get_current", NULL); + Py_DECREF(module); + if (!current) goto bad; + if (PyTuple_Check(current)) { + // I think 3.13+ returns a tuple of (ID, whence), + // but it's obviously a private module so the API changes a bit. + PyObject *new_current = PySequence_GetItem(current, 0); + Py_DECREF(current); + current = new_current; + if (!new_current) goto bad; + } + long long as_c_int = PyLong_AsLongLong(current); + Py_DECREF(current); + return as_c_int; + } + bad: + PySys_WriteStderr("__Pyx_GetCurrentInterpreterId failed. Try setting the C define CYTHON_PEP489_MULTI_PHASE_INIT=0\n"); + return -1; +} +#endif + +//#if CYTHON_PEP489_MULTI_PHASE_INIT +#if !CYTHON_USE_MODULE_STATE +static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) { + static PY_INT64_T main_interpreter_id = -1; +#if CYTHON_COMPILING_IN_GRAAL + PY_INT64_T current_id = PyInterpreterState_GetIDFromThreadState(PyThreadState_Get()); +#elif CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX >= 0x03090000 + PY_INT64_T current_id = PyInterpreterState_GetID(PyInterpreterState_Get()); +#elif CYTHON_COMPILING_IN_LIMITED_API + PY_INT64_T current_id = __Pyx_GetCurrentInterpreterId(); +#else + PY_INT64_T current_id = PyInterpreterState_GetID(PyThreadState_Get()->interp); +#endif + if (unlikely(current_id == -1)) { + return -1; + } + if (main_interpreter_id == -1) { + main_interpreter_id = current_id; + return 0; + } else if (unlikely(main_interpreter_id != current_id)) { + PyErr_SetString( + PyExc_ImportError, + "Interpreter change detected - this module can only be loaded into one interpreter per process."); + return -1; + } + return 0; +} +#endif + +static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) +{ + PyObject *value = PyObject_GetAttrString(spec, from_name); + int result = 0; + if (likely(value)) { + if (allow_none || value != Py_None) { + result = PyDict_SetItemString(moddict, to_name, value); + } + Py_DECREF(value); + } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) { + PyErr_Clear(); + } else { + result = -1; + } + return result; +} + +static CYTHON_SMALL_CODE PyObject* ${pymodule_create_func_cname}(PyObject *spec, PyModuleDef *def) { + PyObject *module = NULL, *moddict, *modname; + CYTHON_UNUSED_VAR(def); + + #if !CYTHON_USE_MODULE_STATE + // For now, we only have exactly one module instance. + if (__Pyx_check_single_interpreter()) + return NULL; + #endif + if (${module_cname}) + return __Pyx_NewRef(${module_cname}); + + modname = PyObject_GetAttrString(spec, "name"); + if (unlikely(!modname)) goto bad; + + module = PyModule_NewObject(modname); + Py_DECREF(modname); + if (unlikely(!module)) goto bad; + + moddict = PyModule_GetDict(module); + if (unlikely(!moddict)) goto bad; + // moddict is a borrowed reference + + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "submodule_search_locations", "__path__", 0) < 0)) goto bad; + + return module; +bad: + Py_XDECREF(module); + return NULL; +} +//#endif + + +/////////////// CodeObjectCache.proto /////////////// +//@requires: Synchronization.c::Atomics + +#if CYTHON_COMPILING_IN_LIMITED_API +typedef PyObject __Pyx_CachedCodeObjectType; +#else +typedef PyCodeObject __Pyx_CachedCodeObjectType; +#endif + +typedef struct { + __Pyx_CachedCodeObjectType* code_object; + int code_line; +} __Pyx_CodeObjectCacheEntry; + +struct __Pyx_CodeObjectCache { + int count; + int max_count; + __Pyx_CodeObjectCacheEntry* entries; + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + // 0 for none, +ve for readers, -ve for writers. + // + __pyx_atomic_int_type accessor_count; + #endif +}; + +static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line); + +static __Pyx_CachedCodeObjectType *__pyx_find_code_object(int code_line); +static void __pyx_insert_code_object(int code_line, __Pyx_CachedCodeObjectType* code_object); + +/////////////// CodeObjectCache.module_state_decls //////////////// + +struct __Pyx_CodeObjectCache __pyx_code_cache; + +/////////////// CodeObjectCache /////////////// +// Note that errors are simply ignored in the code below. +// This is just a cache, if a lookup or insertion fails - so what? + +static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { + int start = 0, mid = 0, end = count - 1; + if (end >= 0 && code_line > entries[end].code_line) { + return count; + } + while (start < end) { + mid = start + (end - start) / 2; + if (code_line < entries[mid].code_line) { + end = mid; + } else if (code_line > entries[mid].code_line) { + start = mid + 1; + } else { + return mid; + } + } + if (code_line <= entries[mid].code_line) { + return mid; + } else { + return mid + 1; + } +} + +static __Pyx_CachedCodeObjectType *__pyx__find_code_object(struct __Pyx_CodeObjectCache *code_cache, int code_line) { + __Pyx_CachedCodeObjectType* code_object; + int pos; + if (unlikely(!code_line) || unlikely(!code_cache->entries)) { + return NULL; + } + pos = __pyx_bisect_code_objects(code_cache->entries, code_cache->count, code_line); + if (unlikely(pos >= code_cache->count) || unlikely(code_cache->entries[pos].code_line != code_line)) { + return NULL; + } + code_object = code_cache->entries[pos].code_object; + Py_INCREF(code_object); + return code_object; +} + +static __Pyx_CachedCodeObjectType *__pyx_find_code_object(int code_line) { +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING && !CYTHON_ATOMICS + (void)__pyx__find_code_object; + return NULL; // Most implementation should have atomics. But otherwise, don't make it thread-safe, just miss. +#else + struct __Pyx_CodeObjectCache *code_cache = &CGLOBAL(__pyx_code_cache); +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + __pyx_nonatomic_int_type old_count = __pyx_atomic_incr_acq_rel(&code_cache->accessor_count); + if (old_count < 0) { + // It's being written so currently unreadable. + __pyx_atomic_decr_acq_rel(&code_cache->accessor_count); + return NULL; + } +#endif + __Pyx_CachedCodeObjectType *result = __pyx__find_code_object(code_cache, code_line); +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + __pyx_atomic_decr_acq_rel(&code_cache->accessor_count); +#endif + return result; +#endif +} + + +static void __pyx__insert_code_object(struct __Pyx_CodeObjectCache *code_cache, int code_line, __Pyx_CachedCodeObjectType* code_object) +{ + int pos, i; + __Pyx_CodeObjectCacheEntry* entries = code_cache->entries; + if (unlikely(!code_line)) { + return; + } + if (unlikely(!entries)) { + entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry)); + if (likely(entries)) { + code_cache->entries = entries; + code_cache->max_count = 64; + code_cache->count = 1; + entries[0].code_line = code_line; + entries[0].code_object = code_object; + Py_INCREF(code_object); + } + return; + } + pos = __pyx_bisect_code_objects(code_cache->entries, code_cache->count, code_line); + if ((pos < code_cache->count) && unlikely(code_cache->entries[pos].code_line == code_line)) { + __Pyx_CachedCodeObjectType* tmp = entries[pos].code_object; + entries[pos].code_object = code_object; + Py_INCREF(code_object); + Py_DECREF(tmp); + return; + } + if (code_cache->count == code_cache->max_count) { + int new_max = code_cache->max_count + 64; + entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc( + code_cache->entries, ((size_t)new_max) * sizeof(__Pyx_CodeObjectCacheEntry)); + if (unlikely(!entries)) { + return; + } + code_cache->entries = entries; + code_cache->max_count = new_max; + } + for (i=code_cache->count; i>pos; i--) { + entries[i] = entries[i-1]; + } + entries[pos].code_line = code_line; + entries[pos].code_object = code_object; + code_cache->count++; + Py_INCREF(code_object); +} + +static void __pyx_insert_code_object(int code_line, __Pyx_CachedCodeObjectType* code_object) { +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING && !CYTHON_ATOMICS + (void)__pyx__insert_code_object; + return; // Most implementation should have atomics. But otherwise, don't make it thread-safe, just fail. +#else + struct __Pyx_CodeObjectCache *code_cache = &CGLOBAL(__pyx_code_cache); +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + __pyx_nonatomic_int_type expected = 0; + if (!__pyx_atomic_int_cmp_exchange(&code_cache->accessor_count, &expected, INT_MIN)) { + // it's being written or read, Either way we can't do anything + return; + } +#endif + __pyx__insert_code_object(code_cache, code_line, code_object); +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + __pyx_atomic_sub(&code_cache->accessor_count, INT_MIN); +#endif +#endif +} + +/////////////// CodeObjectCache.cleanup /////////////// + +{ + struct __Pyx_CodeObjectCache *code_cache = &CGLOBAL(__pyx_code_cache); + if (code_cache->entries) { + __Pyx_CodeObjectCacheEntry* entries = code_cache->entries; + int i, count = code_cache->count; + code_cache->count = 0; + code_cache->max_count = 0; + code_cache->entries = NULL; + for (i=0; i= 0x030b0000 + return Py_Version & ~0xFFUL; +#else + static unsigned long __Pyx_cached_runtime_version = 0; + if (__Pyx_cached_runtime_version == 0) { + const char* rt_version = Py_GetVersion(); + unsigned long version = 0; + unsigned long factor = 0x01000000UL; + unsigned int digit = 0; + int i = 0; + while (factor) { + while ('0' <= rt_version[i] && rt_version[i] <= '9') { + digit = digit * 10 + (unsigned int) (rt_version[i] - '0'); + ++i; + } + version += factor * digit; + if (rt_version[i] != '.') + break; + digit = 0; + factor >>= 8; + ++i; + } + __Pyx_cached_runtime_version = version; + } + return __Pyx_cached_runtime_version; +#endif +} + +/////////////// CheckBinaryVersion.proto /////////////// + +static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer); + +/////////////// CheckBinaryVersion /////////////// + +static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer) { + // runtime version is: -1 => older, 0 => equal, 1 => newer + const unsigned long MAJOR_MINOR = 0xFFFF0000UL; + if ((rt_version & MAJOR_MINOR) == (ct_version & MAJOR_MINOR)) + return 0; + if (likely(allow_newer && (rt_version & MAJOR_MINOR) > (ct_version & MAJOR_MINOR))) + return 1; + + { + char message[200]; + PyOS_snprintf(message, sizeof(message), + "compile time Python version %d.%d " + "of module '%.100s' " + "%s " + "runtime version %d.%d", + (int) (ct_version >> 24), (int) ((ct_version >> 16) & 0xFF), + __Pyx_MODULE_NAME, + (allow_newer) ? "was newer than" : "does not match", + (int) (rt_version >> 24), (int) ((rt_version >> 16) & 0xFF) + ); + // returns 0 or -1 + return PyErr_WarnEx(NULL, message, 1); + } +} + +/////////////// IsLittleEndian.proto /////////////// + +static CYTHON_INLINE int __Pyx_Is_Little_Endian(void); + +/////////////// IsLittleEndian /////////////// + +static CYTHON_INLINE int __Pyx_Is_Little_Endian(void) +{ + union { + uint32_t u32; + uint8_t u8[4]; + } S; + S.u32 = 0x01020304; + return S.u8[0] == 4; +} + +/////////////// Refnanny.proto /////////////// + +#ifndef CYTHON_REFNANNY + #define CYTHON_REFNANNY 0 +#endif + +#if CYTHON_REFNANNY + typedef struct { + void (*INCREF)(void*, PyObject*, Py_ssize_t); + void (*DECREF)(void*, PyObject*, Py_ssize_t); + void (*GOTREF)(void*, PyObject*, Py_ssize_t); + void (*GIVEREF)(void*, PyObject*, Py_ssize_t); + void* (*SetupContext)(const char*, Py_ssize_t, const char*); + void (*FinishContext)(void**); + } __Pyx_RefNannyAPIStruct; + static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL; + static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname); /*proto*/ + #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL; + #define __Pyx_RefNannySetupContext(name, acquire_gil) \ + if (acquire_gil) { \ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); \ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__)); \ + PyGILState_Release(__pyx_gilstate_save); \ + } else { \ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__)); \ + } + #define __Pyx_RefNannyFinishContextNogil() { \ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); \ + __Pyx_RefNannyFinishContext(); \ + PyGILState_Release(__pyx_gilstate_save); \ + } + #define __Pyx_RefNannyFinishContextNogil() { \ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); \ + __Pyx_RefNannyFinishContext(); \ + PyGILState_Release(__pyx_gilstate_save); \ + } + #define __Pyx_RefNannyFinishContext() \ + __Pyx_RefNanny->FinishContext(&__pyx_refnanny) + #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) + #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) + #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) + #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) + #define __Pyx_XINCREF(r) do { if((r) == NULL); else {__Pyx_INCREF(r); }} while(0) + #define __Pyx_XDECREF(r) do { if((r) == NULL); else {__Pyx_DECREF(r); }} while(0) + #define __Pyx_XGOTREF(r) do { if((r) == NULL); else {__Pyx_GOTREF(r); }} while(0) + #define __Pyx_XGIVEREF(r) do { if((r) == NULL); else {__Pyx_GIVEREF(r);}} while(0) +#else + #define __Pyx_RefNannyDeclarations + #define __Pyx_RefNannySetupContext(name, acquire_gil) + #define __Pyx_RefNannyFinishContextNogil() + #define __Pyx_RefNannyFinishContext() + #define __Pyx_INCREF(r) Py_INCREF(r) + #define __Pyx_DECREF(r) Py_DECREF(r) + #define __Pyx_GOTREF(r) + #define __Pyx_GIVEREF(r) + #define __Pyx_XINCREF(r) Py_XINCREF(r) + #define __Pyx_XDECREF(r) Py_XDECREF(r) + #define __Pyx_XGOTREF(r) + #define __Pyx_XGIVEREF(r) +#endif /* CYTHON_REFNANNY */ + +#define __Pyx_Py_XDECREF_SET(r, v) do { \ + PyObject *tmp = (PyObject *) r; \ + r = v; Py_XDECREF(tmp); \ + } while (0) +#define __Pyx_XDECREF_SET(r, v) do { \ + PyObject *tmp = (PyObject *) r; \ + r = v; __Pyx_XDECREF(tmp); \ + } while (0) +#define __Pyx_DECREF_SET(r, v) do { \ + PyObject *tmp = (PyObject *) r; \ + r = v; __Pyx_DECREF(tmp); \ + } while (0) + +#define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0) +#define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0) + +/////////////// Refnanny /////////////// + +#if CYTHON_REFNANNY +static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { + PyObject *m = NULL, *p = NULL; + void *r = NULL; + m = PyImport_ImportModule(modname); + if (!m) goto end; + p = PyObject_GetAttrString(m, "RefNannyAPI"); + if (!p) goto end; + r = PyLong_AsVoidPtr(p); +end: + Py_XDECREF(p); + Py_XDECREF(m); + return (__Pyx_RefNannyAPIStruct *)r; +} +#endif /* CYTHON_REFNANNY */ + + +/////////////// ImportRefnannyAPI /////////////// + +#if CYTHON_REFNANNY +__Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); +if (!__Pyx_RefNanny) { + PyErr_Clear(); + __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny"); + if (!__Pyx_RefNanny) + Py_FatalError("failed to import 'refnanny' module"); +} +#endif + + +/////////////// RegisterModuleCleanup.proto /////////////// +//@substitute: naming + +static void ${cleanup_cname}(PyObject *self); /*proto*/ + +#if CYTHON_COMPILING_IN_PYPY +static int __Pyx_RegisterCleanup(void); /*proto*/ +#else +#define __Pyx_RegisterCleanup() (0) +#endif + +/////////////// RegisterModuleCleanup /////////////// +//@substitute: naming + +#if CYTHON_COMPILING_IN_PYPY +static PyObject* ${cleanup_cname}_atexit(PyObject *module, PyObject *unused) { + CYTHON_UNUSED_VAR(unused); + ${cleanup_cname}(module); + Py_INCREF(Py_None); return Py_None; +} + +static int __Pyx_RegisterCleanup(void) { + // Don't use Py_AtExit because that has a 32-call limit and is called + // after python finalization. + // Also, we try to prepend the cleanup function to "atexit._exithandlers" + // in Py2 because CPython runs them last-to-first. Being run last allows + // user exit code to run before us that may depend on the globals + // and cached objects that we are about to clean up. + + static PyMethodDef cleanup_def = { + "__cleanup", (PyCFunction)${cleanup_cname}_atexit, METH_NOARGS, 0}; + + PyObject *cleanup_func = 0; + PyObject *atexit = 0; + PyObject *reg = 0; + PyObject *args = 0; + PyObject *res = 0; + int ret = -1; + + cleanup_func = PyCFunction_New(&cleanup_def, 0); + if (!cleanup_func) + goto bad; + + atexit = PyImport_ImportModule("atexit"); + if (!atexit) + goto bad; + reg = PyObject_GetAttrString(atexit, "_exithandlers"); + if (reg && PyList_Check(reg)) { + PyObject *a, *kw; + a = PyTuple_New(0); + kw = PyDict_New(); + if (!a || !kw) { + Py_XDECREF(a); + Py_XDECREF(kw); + goto bad; + } + args = PyTuple_Pack(3, cleanup_func, a, kw); + Py_DECREF(a); + Py_DECREF(kw); + if (!args) + goto bad; + ret = PyList_Insert(reg, 0, args); + } else { + if (!reg) + PyErr_Clear(); + Py_XDECREF(reg); + reg = PyObject_GetAttrString(atexit, "register"); + if (!reg) + goto bad; + args = PyTuple_Pack(1, cleanup_func); + if (!args) + goto bad; + res = PyObject_CallObject(reg, args); + if (!res) + goto bad; + ret = 0; + } +bad: + Py_XDECREF(cleanup_func); + Py_XDECREF(atexit); + Py_XDECREF(reg); + Py_XDECREF(args); + Py_XDECREF(res); + return ret; +} +#endif + +/////////////// FastGil.init /////////////// +__Pyx_FastGilFuncInit(); + +/////////////// NoFastGil.proto /////////////// +//@proto_block: utility_code_proto_before_types + +#define __Pyx_PyGILState_Ensure PyGILState_Ensure +#define __Pyx_PyGILState_Release PyGILState_Release +#define __Pyx_FastGIL_Remember() +#define __Pyx_FastGIL_Forget() +#define __Pyx_FastGilFuncInit() + +/////////////// FastGil.proto /////////////// +//@proto_block: utility_code_proto_before_types + +#if CYTHON_FAST_GIL + +struct __Pyx_FastGilVtab { + PyGILState_STATE (*Fast_PyGILState_Ensure)(void); + void (*Fast_PyGILState_Release)(PyGILState_STATE oldstate); + void (*FastGIL_Remember)(void); + void (*FastGIL_Forget)(void); +}; + +static void __Pyx_FastGIL_Noop(void) {} +static struct __Pyx_FastGilVtab __Pyx_FastGilFuncs = { + PyGILState_Ensure, + PyGILState_Release, + __Pyx_FastGIL_Noop, + __Pyx_FastGIL_Noop +}; + +static void __Pyx_FastGilFuncInit(void); + +#define __Pyx_PyGILState_Ensure __Pyx_FastGilFuncs.Fast_PyGILState_Ensure +#define __Pyx_PyGILState_Release __Pyx_FastGilFuncs.Fast_PyGILState_Release +#define __Pyx_FastGIL_Remember __Pyx_FastGilFuncs.FastGIL_Remember +#define __Pyx_FastGIL_Forget __Pyx_FastGilFuncs.FastGIL_Forget + +#ifndef CYTHON_THREAD_LOCAL + #if defined(__cplusplus) && __cplusplus >= 201103L + #define CYTHON_THREAD_LOCAL thread_local + #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112 + #define CYTHON_THREAD_LOCAL _Thread_local + #elif defined(__GNUC__) + #define CYTHON_THREAD_LOCAL __thread + #elif defined(_MSC_VER) + #define CYTHON_THREAD_LOCAL __declspec(thread) + #endif +#endif + +#else +#define __Pyx_PyGILState_Ensure PyGILState_Ensure +#define __Pyx_PyGILState_Release PyGILState_Release +#define __Pyx_FastGIL_Remember() +#define __Pyx_FastGIL_Forget() +#define __Pyx_FastGilFuncInit() +#endif + +/////////////// FastGil /////////////// +// The implementations of PyGILState_Ensure/Release calls PyThread_get_key_value +// several times which is turns out to be quite slow (slower in fact than +// acquiring the GIL itself). Simply storing it in a thread local for the +// common case is much faster. +// To make optimal use of this thread local, we attempt to share it between +// modules. + +#if CYTHON_FAST_GIL + +#define __Pyx_FastGIL_ABI_module __PYX_ABI_MODULE_NAME +#define __Pyx_FastGIL_PyCapsuleName "FastGilFuncs" +#define __Pyx_FastGIL_PyCapsule \ + __Pyx_FastGIL_ABI_module "." __Pyx_FastGIL_PyCapsuleName + +#ifdef CYTHON_THREAD_LOCAL + +#include "pythread.h" +#include "pystate.h" + +static CYTHON_THREAD_LOCAL PyThreadState *__Pyx_FastGil_tcur = NULL; +static CYTHON_THREAD_LOCAL int __Pyx_FastGil_tcur_depth = 0; +static int __Pyx_FastGil_autoTLSkey = -1; + +static CYTHON_INLINE void __Pyx_FastGIL_Remember0(void) { + ++__Pyx_FastGil_tcur_depth; +} + +static CYTHON_INLINE void __Pyx_FastGIL_Forget0(void) { + if (--__Pyx_FastGil_tcur_depth == 0) { + __Pyx_FastGil_tcur = NULL; + } +} + +static CYTHON_INLINE PyThreadState *__Pyx_FastGil_get_tcur(void) { + PyThreadState *tcur = __Pyx_FastGil_tcur; + if (tcur == NULL) { + tcur = __Pyx_FastGil_tcur = (PyThreadState*)PyThread_get_key_value(__Pyx_FastGil_autoTLSkey); + } + return tcur; +} + +static PyGILState_STATE __Pyx_FastGil_PyGILState_Ensure(void) { + int current; + PyThreadState *tcur; + __Pyx_FastGIL_Remember0(); + tcur = __Pyx_FastGil_get_tcur(); + if (tcur == NULL) { + // Uninitialized, need to initialize now. + return PyGILState_Ensure(); + } + current = tcur == __Pyx_PyThreadState_Current; + if (current == 0) { + PyEval_RestoreThread(tcur); + } + ++tcur->gilstate_counter; + return current ? PyGILState_LOCKED : PyGILState_UNLOCKED; +} + +static void __Pyx_FastGil_PyGILState_Release(PyGILState_STATE oldstate) { + PyThreadState *tcur = __Pyx_FastGil_get_tcur(); + __Pyx_FastGIL_Forget0(); + if (tcur->gilstate_counter == 1) { + // This is the last lock, do all the cleanup as well. + PyGILState_Release(oldstate); + } else { + --tcur->gilstate_counter; + if (oldstate == PyGILState_UNLOCKED) { + PyEval_SaveThread(); + } + } +} + +static void __Pyx_FastGilFuncInit0(void) { + /* Try to detect autoTLSkey. */ + int key; + void* this_thread_state = (void*) PyGILState_GetThisThreadState(); + for (key = 0; key < 100; key++) { + if (PyThread_get_key_value(key) == this_thread_state) { + __Pyx_FastGil_autoTLSkey = key; + break; + } + } + if (__Pyx_FastGil_autoTLSkey != -1) { + PyObject* capsule = NULL; + PyObject* abi_module = NULL; + __Pyx_PyGILState_Ensure = __Pyx_FastGil_PyGILState_Ensure; + __Pyx_PyGILState_Release = __Pyx_FastGil_PyGILState_Release; + __Pyx_FastGIL_Remember = __Pyx_FastGIL_Remember0; + __Pyx_FastGIL_Forget = __Pyx_FastGIL_Forget0; + capsule = PyCapsule_New(&__Pyx_FastGilFuncs, __Pyx_FastGIL_PyCapsule, NULL); + if (capsule) { + abi_module = __Pyx_PyImport_AddModuleRef(__Pyx_FastGIL_ABI_module); + if (abi_module) { + PyObject_SetAttrString(abi_module, __Pyx_FastGIL_PyCapsuleName, capsule); + Py_DECREF(abi_module); + } + } + Py_XDECREF(capsule); + } +} + +#else + +static void __Pyx_FastGilFuncInit0(void) { +} + +#endif + +static void __Pyx_FastGilFuncInit(void) { + struct __Pyx_FastGilVtab* shared = (struct __Pyx_FastGilVtab*)PyCapsule_Import(__Pyx_FastGIL_PyCapsule, 1); + if (shared) { + __Pyx_FastGilFuncs = *shared; + } else { + PyErr_Clear(); + __Pyx_FastGilFuncInit0(); + } +} + +#endif + +///////////////////// PretendToInitialize //////////////////////// + +#ifdef __cplusplus +// In C++ a variable must actually be initialized to make returning +// it defined behaviour, and there doesn't seem to be a viable compiler trick to +// avoid that. +#if __cplusplus > 201103L +#include +#endif + +template +static void __Pyx_pretend_to_initialize(T* ptr) { + // In C++11 we have enough introspection to work out which types it's actually + // necessary to apply this to (non-trivial types will have been initialized by + // the definition). Below C++11 just initialize everything. +#if __cplusplus > 201103L + if ((std::is_trivially_default_constructible::value)) +#endif + *ptr = T(); + (void)ptr; +} +#else +// For C, taking an address of a variable is enough to make returning it +// defined behaviour. +static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; } +#endif + +///////////////////// UtilityCodePragmas ///////////////////////// + +#ifdef _MSC_VER +#pragma warning( push ) +/* Warning 4127: conditional expression is constant + * Cython uses constant conditional expressions to allow in inline functions to be optimized at + * compile-time, so this warning is not useful + */ +#pragma warning( disable : 4127 ) +#endif + +///////////////////// UtilityCodePragmasEnd ////////////////////// + +#ifdef _MSC_VER +#pragma warning( pop ) /* undo whatever Cython has done to warnings */ +#endif + + +//////////////////// NewCodeObj.proto //////////////////////// +//@proto_block: init_codeobjects + +static PyObject* __Pyx_PyCode_New( + //int argcount, + //int num_posonly_args, + //int num_kwonly_args, + //int nlocals, + // int s, + //int flags, + //int first_line, + const __Pyx_PyCode_New_function_description descr, + // PyObject *code, + // PyObject *consts, + // PyObject* n, + // PyObject *varnames_tuple, + PyObject * const *varnames, + // PyObject *freevars, + // PyObject *cellvars, + PyObject *filename, + PyObject *funcname, + const char *line_table, + PyObject *tuple_dedup_map +);/*proto*/ + +//////////////////// NewCodeObj //////////////////////// + +#if CYTHON_COMPILING_IN_LIMITED_API + // Note that the limited API doesn't know about PyCodeObject, so the type of this + // is PyObject (unlike for the main API) + static PyObject* __Pyx__PyCode_New(int a, int p, int k, int l, int s, int f, + PyObject *code, PyObject *c, PyObject* n, PyObject *v, + PyObject *fv, PyObject *cell, PyObject* fn, + PyObject *name, int fline, PyObject *lnos) { + // Backup option for generating a code object. + // PyCode_NewEmpty isn't in the limited API. Therefore the two options are + // 1. Python call of the code type with a long list of positional args. + // 2. Generate a code object by compiling some trivial code, and customize. + // We use the first option here. + PyObject *exception_table = NULL; + PyObject *types_module=NULL, *code_type=NULL, *result=NULL; + #if __PYX_LIMITED_VERSION_HEX < 0x030b0000 + PyObject *version_info; /* borrowed */ + PyObject *py_minor_version = NULL; + #endif + long minor_version = 0; + PyObject *type, *value, *traceback; + + // we must be able to call this while an exception is happening - thus clear then restore the state + PyErr_Fetch(&type, &value, &traceback); + + #if __PYX_LIMITED_VERSION_HEX >= 0x030b0000 + minor_version = 11; + // we don't yet need to distinguish between versions > 11 + // Note that from 3.13, when we do, we can use Py_Version + #else + if (!(version_info = PySys_GetObject("version_info"))) goto end; + if (!(py_minor_version = PySequence_GetItem(version_info, 1))) goto end; + minor_version = PyLong_AsLong(py_minor_version); + Py_DECREF(py_minor_version); + if (minor_version == -1 && PyErr_Occurred()) goto end; + #endif + + if (!(types_module = PyImport_ImportModule("types"))) goto end; + if (!(code_type = PyObject_GetAttrString(types_module, "CodeType"))) goto end; + + if (minor_version <= 7) { + // 3.7: + // code(argcount, kwonlyargcount, nlocals, stacksize, flags, codestring, + // constants, names, varnames, filename, name, firstlineno, + // lnotab[, freevars[, cellvars]]) + (void)p; + result = PyObject_CallFunction(code_type, "iiiiiOOOOOOiOOO", a, k, l, s, f, code, + c, n, v, fn, name, fline, lnos, fv, cell); + } else if (minor_version <= 10) { + // 3.8, 3.9, 3.10 + // code(argcount, posonlyargcount, kwonlyargcount, nlocals, stacksize, + // flags, codestring, constants, names, varnames, filename, name, + // firstlineno, lnotab[, freevars[, cellvars]]) + // 3.10 switches lnotab for linetable, but is otherwise the same + result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOiOOO", a,p, k, l, s, f, code, + c, n, v, fn, name, fline, lnos, fv, cell); + } else { + // 3.11, 3.12 + // code(argcount, posonlyargcount, kwonlyargcount, nlocals, stacksize, + // flags, codestring, constants, names, varnames, filename, name, + // qualname, firstlineno, linetable, exceptiontable, freevars=(), cellvars=(), /) + // We use name and qualname for simplicity + if (!(exception_table = PyBytes_FromStringAndSize(NULL, 0))) goto end; + result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOOiOOOO", a,p, k, l, s, f, code, + c, n, v, fn, name, name, fline, lnos, exception_table, fv, cell); + } + + end: + Py_XDECREF(code_type); + Py_XDECREF(exception_table); + Py_XDECREF(types_module); + if (type) { + PyErr_Restore(type, value, traceback); + } + return result; + } + +#elif PY_VERSION_HEX >= 0x030B0000 + static PyCodeObject* __Pyx__PyCode_New(int a, int p, int k, int l, int s, int f, + PyObject *code, PyObject *c, PyObject* n, PyObject *v, + PyObject *fv, PyObject *cell, PyObject* fn, + PyObject *name, int fline, PyObject *lnos) { + // As earlier versions, but + // 1. pass an empty bytes string as exception_table + // 2. pass name as qualname (TODO this might implementing properly in future) + PyCodeObject *result; + result = + #if PY_VERSION_HEX >= 0x030C0000 + PyUnstable_Code_NewWithPosOnlyArgs + #else + PyCode_NewWithPosOnlyArgs + #endif + (a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, name, fline, lnos, EMPTY(bytes)); + + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030c00A1 + if (likely(result)) + result->_co_firsttraceable = 0; + #endif + return result; + } +#elif PY_VERSION_HEX >= 0x030800B2 && !CYTHON_COMPILING_IN_PYPY + #define __Pyx__PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) \ + PyCode_NewWithPosOnlyArgs(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) +#else + #define __Pyx__PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) \ + PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) +#endif + +// This is a specialised helper function for creating Cython's function code objects. +// It only receives the arguments that differ between the Cython functions of the module. +// This minimises the calling code in the module init function. +static PyObject* __Pyx_PyCode_New( + //int argcount, + //int num_posonly_args, + //int num_kwonly_args, + //int nlocals, + // int s, + //int flags, + //int first_line, + const __Pyx_PyCode_New_function_description descr, + // PyObject *code, + // PyObject *consts, + // PyObject* n, + // PyObject *varnames_tuple, + PyObject * const *varnames, + // PyObject *freevars, + // PyObject *cellvars, + PyObject *filename, + PyObject *funcname, + // line table replaced lnotab in Py3.11 (PEP-626) + const char *line_table, + PyObject *tuple_dedup_map +) { + + PyObject *code_obj = NULL, *varnames_tuple_dedup = NULL, *code_bytes = NULL, *line_table_bytes = NULL; + Py_ssize_t var_count = (Py_ssize_t) descr.nlocals; + + PyObject *varnames_tuple = PyTuple_New(var_count); + if (unlikely(!varnames_tuple)) return NULL; + for (Py_ssize_t i=0; i < var_count; i++) { + Py_INCREF(varnames[i]); + if (__Pyx_PyTuple_SET_ITEM(varnames_tuple, i, varnames[i]) != (0)) goto done; + } + + #if CYTHON_COMPILING_IN_LIMITED_API + varnames_tuple_dedup = PyDict_GetItem(tuple_dedup_map, varnames_tuple); + if (!varnames_tuple_dedup) { + if (unlikely(PyDict_SetItem(tuple_dedup_map, varnames_tuple, varnames_tuple) < 0)) goto done; + varnames_tuple_dedup = varnames_tuple; + } + #else + varnames_tuple_dedup = PyDict_SetDefault(tuple_dedup_map, varnames_tuple, varnames_tuple); + if (unlikely(!varnames_tuple_dedup)) goto done; + #endif + + #if CYTHON_AVOID_BORROWED_REFS + Py_INCREF(varnames_tuple_dedup); + #endif + + if (__PYX_LIMITED_VERSION_HEX >= (0x030b0000) && line_table != NULL + && !CYTHON_COMPILING_IN_GRAAL) { + line_table_bytes = PyBytes_FromStringAndSize(line_table, descr.line_table_length); + if (unlikely(!line_table_bytes)) goto done; + + // Allocate a "byte code" array (oversized) to match the addresses in the line table. + // Length and alignment must be a multiple of sizeof(_Py_CODEUNIT), which is CPython specific but currently 2. + // CPython makes a copy of the code array internally, so make sure it's somewhat short (but not too short). + Py_ssize_t code_len = (descr.line_table_length * 2 + 4) & ~3; + code_bytes = PyBytes_FromStringAndSize(NULL, code_len); + if (unlikely(!code_bytes)) goto done; + char* c_code_bytes = PyBytes_AsString(code_bytes); + if (unlikely(!c_code_bytes)) goto done; + // We initialise the code array to '\0' even though a NOP would be more accurate, + // but NOP changes its byte code ID across Python versions/implementations. + memset(c_code_bytes, 0, (size_t) code_len); + } + + code_obj = (PyObject*) __Pyx__PyCode_New( + (int) descr.argcount, + (int) descr.num_posonly_args, + (int) descr.num_kwonly_args, + (int) descr.nlocals, + 0, + (int) descr.flags, + code_bytes ? code_bytes : EMPTY(bytes), + EMPTY(tuple), + EMPTY(tuple), + varnames_tuple_dedup, + EMPTY(tuple), + EMPTY(tuple), + filename, + funcname, + (int) descr.first_line, + (__PYX_LIMITED_VERSION_HEX >= (0x030b0000) && line_table_bytes) ? line_table_bytes : EMPTY(bytes) + ); + +done: + Py_XDECREF(code_bytes); + Py_XDECREF(line_table_bytes); + #if CYTHON_AVOID_BORROWED_REFS + Py_XDECREF(varnames_tuple_dedup); + #endif + Py_DECREF(varnames_tuple); + return code_obj; +} + + +////////////////////////// MultiPhaseInitModuleState.proto ///////////// + +#if CYTHON_PEP489_MULTI_PHASE_INIT && CYTHON_USE_MODULE_STATE +// This defines an ad-hoc, single module version of PyState_FindModule that +// works for multi-phase init modules. It's intended to be the last option +// when all the other official ways of getting the module are unavailable. +static PyObject *__Pyx_State_FindModule(void*); /* proto */ +static int __Pyx_State_AddModule(PyObject* module, void*); /* proto */ +static int __Pyx_State_RemoveModule(void*); /* proto */ + +#elif CYTHON_USE_MODULE_STATE +#define __Pyx_State_FindModule PyState_FindModule +#define __Pyx_State_AddModule PyState_AddModule +#define __Pyx_State_RemoveModule PyState_RemoveModule +#endif + +////////////////////////// MultiPhaseInitModuleState ///////////// +//@requires: Synchronization.c::Atomics + + +// Code to maintain a mapping between (sub)interpreters and the module instance that they imported. +// This is used to find the correct module state for the current interpreter. + +#if CYTHON_PEP489_MULTI_PHASE_INIT && CYTHON_USE_MODULE_STATE + +#ifndef CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE +// If you're using multiple interpreters but a single GIL then +// this can be undefined for a bit of speed. +// Isolated subinterpreters were added in 3.12, and nogil in 3.13, so before that +// we can safely assume that we're protected by the GIL. +// TODO - turn this off as appropriate when the user is able to set +// Py_MOD_PER_INTERPRETER_GIL_SUPPORTED explicitly. +#if (CYTHON_COMPILING_IN_LIMITED_API || PY_VERSION_HEX >= 0x030C0000) + #define CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE 1 +#else + #define CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE 0 +#endif +#endif + +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE && !CYTHON_ATOMICS +#error "Module state with PEP489 requires atomics. Currently that's one of\ + C11, C++11, gcc atomic intrinsics or MSVC atomic intrinsics" +#endif + +// We also need a lock. In order of preference: +// - PyMutex +// - a language standard library +// - pthreads +// - msvc +// - PyThread_lock isn't acceptable since we can't initialize it in a thread safe way +#if !CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE + +#define __Pyx_ModuleStateLookup_Lock() +#define __Pyx_ModuleStateLookup_Unlock() + +#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d0000 + +static PyMutex __Pyx_ModuleStateLookup_mutex = {0}; +#define __Pyx_ModuleStateLookup_Lock() PyMutex_Lock(&__Pyx_ModuleStateLookup_mutex) +#define __Pyx_ModuleStateLookup_Unlock() PyMutex_Unlock(&__Pyx_ModuleStateLookup_mutex) + +#elif defined(__cplusplus) && __cplusplus >= 201103L + +#include +static std::mutex __Pyx_ModuleStateLookup_mutex; +#define __Pyx_ModuleStateLookup_Lock() __Pyx_ModuleStateLookup_mutex.lock() +#define __Pyx_ModuleStateLookup_Unlock() __Pyx_ModuleStateLookup_mutex.unlock() + +#elif defined(__STDC_VERSION__) && (__STDC_VERSION__ > 201112L) && !defined(__STDC_NO_THREADS__) +#include +static mtx_t __Pyx_ModuleStateLookup_mutex; +static once_flag __Pyx_ModuleStateLookup_mutex_once_flag = ONCE_FLAG_INIT; +static void __Pyx_ModuleStateLookup_initialize_mutex(void) { + mtx_init(&__Pyx_ModuleStateLookup_mutex, mtx_plain); +} +#define __Pyx_ModuleStateLookup_Lock() \ + call_once(&__Pyx_ModuleStateLookup_mutex_once_flag, __Pyx_ModuleStateLookup_initialize_mutex); \ + mtx_lock(&__Pyx_ModuleStateLookup_mutex) +#define __Pyx_ModuleStateLookup_Unlock() mtx_unlock(&__Pyx_ModuleStateLookup_mutex) + +// HAVE_PTHREAD_H comes from pyconfig.h +#elif defined(HAVE_PTHREAD_H) + +#include +static pthread_mutex_t __Pyx_ModuleStateLookup_mutex = PTHREAD_MUTEX_INITIALIZER; +#define __Pyx_ModuleStateLookup_Lock() pthread_mutex_lock(&__Pyx_ModuleStateLookup_mutex) +#define __Pyx_ModuleStateLookup_Unlock() pthread_mutex_unlock(&__Pyx_ModuleStateLookup_mutex) + +#elif defined(_WIN32) + +#include // synchapi.h on its own doesn't work + +// Using a slim-read-write lock (instead of a mutex/critical section) +// because it can be statically initialized. +static SRWLOCK __Pyx_ModuleStateLookup_mutex = SRWLOCK_INIT; +#define __Pyx_ModuleStateLookup_Lock() AcquireSRWLockExclusive(&__Pyx_ModuleStateLookup_mutex) +#define __Pyx_ModuleStateLookup_Unlock() ReleaseSRWLockExclusive(&__Pyx_ModuleStateLookup_mutex) + +#else +#error "No suitable lock available for CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE.\ + Requires C standard >= C11, or C++ standard >= C++11,\ + or pthreads, or the Windows 32 API, or Python >= 3.13." +#endif + + +typedef struct { + int64_t id; + PyObject *module; +} __Pyx_InterpreterIdAndModule; + +typedef struct { + char interpreter_id_as_index; + Py_ssize_t count; + Py_ssize_t allocated; + __Pyx_InterpreterIdAndModule table[1]; +} __Pyx_ModuleStateLookupData; + +#define __PYX_MODULE_STATE_LOOKUP_SMALL_SIZE 32 +// "interpreter_id_as_index" above means "the maximum interpreter ID ever seen is smaller than +// __PYX_MODULE_STATE_LOOKUP_SMALL_SIZE and thus they're stored in an array +// where the index corresponds to interpreter ID, and __Pyx_ModuleStateLookup_count +// is the size of the array. + +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE +static __pyx_atomic_int_type __Pyx_ModuleStateLookup_read_counter = 0; +#endif + +// A sorted list of (sub)interpreter IDs and the module that was imported into that interpreter. +// For now look this up via binary search. +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE +static __pyx_atomic_ptr_type __Pyx_ModuleStateLookup_data = 0; +#else +static __Pyx_ModuleStateLookupData* __Pyx_ModuleStateLookup_data = NULL; +#endif + + +static __Pyx_InterpreterIdAndModule* __Pyx_State_FindModuleStateLookupTableLowerBound( + __Pyx_InterpreterIdAndModule* table, + Py_ssize_t count, + int64_t interpreterId) { + __Pyx_InterpreterIdAndModule* begin = table; + __Pyx_InterpreterIdAndModule* end = begin + count; + + // fairly likely - e.g. single interpreter + if (begin->id == interpreterId) { + return begin; + } + + while ((end - begin) > __PYX_MODULE_STATE_LOOKUP_SMALL_SIZE) { + __Pyx_InterpreterIdAndModule* halfway = begin + (end - begin)/2; + if (halfway->id == interpreterId) { + return halfway; + } + if (halfway->id < interpreterId) { + begin = halfway; + } else { + end = halfway; + } + } + + // Assume that for small ranges, it's quicker to do a linear search + for (; begin < end; ++begin) { + if (begin->id >= interpreterId) return begin; + } + return begin; +} + +static PyObject *__Pyx_State_FindModule(CYTHON_UNUSED void* dummy) { + int64_t interpreter_id = PyInterpreterState_GetID(__Pyx_PyInterpreterState_Get()); + if (interpreter_id == -1) return NULL; + +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE + __Pyx_ModuleStateLookupData* data = (__Pyx_ModuleStateLookupData*)__pyx_atomic_pointer_load_relaxed(&__Pyx_ModuleStateLookup_data); + { + // Thread sanitizer says that this is OK relaxed, but I think it needs to be acquire-release + __pyx_atomic_incr_acq_rel(&__Pyx_ModuleStateLookup_read_counter); + // data == NULL can either mean we're writing, or it's uninitialized. + // Uninitialized only happens infrequently on the first few calls, so it's fine + // to be on the slow path. + if (likely(data)) { + __Pyx_ModuleStateLookupData* new_data = (__Pyx_ModuleStateLookupData*)__pyx_atomic_pointer_load_acquire(&__Pyx_ModuleStateLookup_data); + if (likely(data == new_data)) { + // Nothing has written the data between incrementing the read counter and loading the pointer. + goto read_finished; + } + } + // In principle DW believes this could be "relaxed", but it's on the unlikely slow path anyway + // so let's not add more macros. + // Undo our addition to the read counter. + __pyx_atomic_decr_acq_rel(&__Pyx_ModuleStateLookup_read_counter); + // Wait for the write to finish and try again + __Pyx_ModuleStateLookup_Lock(); + __pyx_atomic_incr_relaxed(&__Pyx_ModuleStateLookup_read_counter); + data = (__Pyx_ModuleStateLookupData*)__pyx_atomic_pointer_load_relaxed(&__Pyx_ModuleStateLookup_data); + __Pyx_ModuleStateLookup_Unlock(); + } + read_finished:; + +#else + __Pyx_ModuleStateLookupData* data = __Pyx_ModuleStateLookup_data; +#endif + + __Pyx_InterpreterIdAndModule* found = NULL; + + // There's one "already imported" check that'll hit this + if (unlikely(!data)) goto end; + + if (data->interpreter_id_as_index) { + if (interpreter_id < data->count) { + found = data->table+interpreter_id; + } + } else { + found = __Pyx_State_FindModuleStateLookupTableLowerBound( + data->table, data->count, interpreter_id); + } + + end: + { + PyObject *result=NULL; + + if (found && found->id == interpreter_id) { + result = found->module; + } +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE + __pyx_atomic_decr_acq_rel(&__Pyx_ModuleStateLookup_read_counter); +#endif + return result; + } +} + +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE +static void __Pyx_ModuleStateLookup_wait_until_no_readers(void) { + // Wait for any readers still working on the old data. Spin-lock is + // fine because readers should be much faster than memory allocation. + while (__pyx_atomic_load(&__Pyx_ModuleStateLookup_read_counter) != 0); +} +#else +#define __Pyx_ModuleStateLookup_wait_until_no_readers() +#endif + +static int __Pyx_State_AddModuleInterpIdAsIndex(__Pyx_ModuleStateLookupData **old_data, PyObject* module, int64_t interpreter_id) { + Py_ssize_t to_allocate = (*old_data)->allocated; + while (to_allocate <= interpreter_id) { + if (to_allocate == 0) to_allocate = 1; + else to_allocate *= 2; + } + __Pyx_ModuleStateLookupData *new_data = *old_data; + if (to_allocate != (*old_data)->allocated) { + new_data = (__Pyx_ModuleStateLookupData *)realloc( + *old_data, + sizeof(__Pyx_ModuleStateLookupData)+(to_allocate-1)*sizeof(__Pyx_InterpreterIdAndModule)); + if (!new_data) { + PyErr_NoMemory(); + return -1; + } + for (Py_ssize_t i = new_data->allocated; i < to_allocate; ++i) { + new_data->table[i].id = i; + new_data->table[i].module = NULL; + } + new_data->allocated = to_allocate; + } + new_data->table[interpreter_id].module = module; + if (new_data->count < interpreter_id+1) { + new_data->count = interpreter_id+1; + } + *old_data = new_data; + return 0; +} + +static void __Pyx_State_ConvertFromInterpIdAsIndex(__Pyx_ModuleStateLookupData *data) { + __Pyx_InterpreterIdAndModule *read = data->table; + __Pyx_InterpreterIdAndModule *write = data->table; + __Pyx_InterpreterIdAndModule *end = read + data->count; + + for (; readmodule) { + write->id = read->id; + write->module = read->module; + ++write; + } + // Otherwise empty; don't copy + } + data->count = write - data->table; + for (; writeid = 0; + write->module = NULL; + } + data->interpreter_id_as_index = 0; +} + +static int __Pyx_State_AddModule(PyObject* module, CYTHON_UNUSED void* dummy) { + int64_t interpreter_id = PyInterpreterState_GetID(__Pyx_PyInterpreterState_Get()); + if (interpreter_id == -1) return -1; + + int result = 0; + + __Pyx_ModuleStateLookup_Lock(); + + // Adding modules is the slow path so I've not thought about memory ordering much and + // just made it strict. +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE + // we're working and maybe modifying it, swap for 0 + __Pyx_ModuleStateLookupData *old_data = (__Pyx_ModuleStateLookupData *) + __pyx_atomic_pointer_exchange(&__Pyx_ModuleStateLookup_data, 0); +#else + __Pyx_ModuleStateLookupData *old_data = __Pyx_ModuleStateLookup_data; +#endif + __Pyx_ModuleStateLookupData *new_data = old_data; + + if (!new_data) { + // If we don't yet have anything, initialize + new_data = (__Pyx_ModuleStateLookupData *)calloc(1, sizeof(__Pyx_ModuleStateLookupData)); + if (!new_data) { + result = -1; + PyErr_NoMemory(); + goto end; + } + new_data->allocated = 1; + new_data->interpreter_id_as_index = 1; + } + + // Pretty much everything from here modifies the data, and so requires us to wait + // until all existing readers have finished in order to be thread-safe. + __Pyx_ModuleStateLookup_wait_until_no_readers(); + if (new_data->interpreter_id_as_index) { + if (interpreter_id < __PYX_MODULE_STATE_LOOKUP_SMALL_SIZE) { + result = __Pyx_State_AddModuleInterpIdAsIndex(&new_data, module, interpreter_id); + goto end; + } + // otherwise we have to convert then proceed with a normal insertion + __Pyx_State_ConvertFromInterpIdAsIndex(new_data); + } + { + Py_ssize_t insert_at = 0; + { + __Pyx_InterpreterIdAndModule* lower_bound = __Pyx_State_FindModuleStateLookupTableLowerBound( + new_data->table, new_data->count, interpreter_id); + + assert(lower_bound); + + insert_at = lower_bound - new_data->table; + + if (unlikely(insert_at < new_data->count && lower_bound->id == interpreter_id)) { + lower_bound->module = module; + goto end; // already in table, nothing more to do + } + + } + + if (new_data->count+1 >= new_data->allocated) { + // Use C realloc. PyMem_RawMalloc is added to the limited API fairly late (3.13) + // and we want allocation independent of the interpreter which I think excludes PyMem_Malloc. + Py_ssize_t to_allocate = (new_data->count+1)*2; + new_data = + (__Pyx_ModuleStateLookupData*)realloc( + new_data, + sizeof(__Pyx_ModuleStateLookupData) + + (to_allocate-1)*sizeof(__Pyx_InterpreterIdAndModule)); + if (!new_data) { + result = -1; + new_data = old_data; + PyErr_NoMemory(); + goto end; + } + new_data->allocated = to_allocate; + } + + ++new_data->count; + + int64_t last_id = interpreter_id; + PyObject *last_module = module; + for (Py_ssize_t i=insert_at; icount; ++i) { + int64_t current_id = new_data->table[i].id; + new_data->table[i].id = last_id; + last_id = current_id; + PyObject *current_module = new_data->table[i].module; + new_data->table[i].module = last_module; + last_module = current_module; + } + } + + end: +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE + __pyx_atomic_pointer_exchange(&__Pyx_ModuleStateLookup_data, new_data); +#else + __Pyx_ModuleStateLookup_data = new_data; +#endif + + __Pyx_ModuleStateLookup_Unlock(); + return result; +} + +static int __Pyx_State_RemoveModule(CYTHON_UNUSED void* dummy) { + int64_t interpreter_id = PyInterpreterState_GetID(__Pyx_PyInterpreterState_Get()); + if (interpreter_id == -1) return -1; + + __Pyx_ModuleStateLookup_Lock(); + +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE + __Pyx_ModuleStateLookupData *data = (__Pyx_ModuleStateLookupData *) + __pyx_atomic_pointer_exchange(&__Pyx_ModuleStateLookup_data, 0); +#else + __Pyx_ModuleStateLookupData *data = __Pyx_ModuleStateLookup_data; +#endif + + if (data->interpreter_id_as_index) { + if (interpreter_id < data->count) { + data->table[interpreter_id].module = NULL; + } + goto done; + } + { + __Pyx_ModuleStateLookup_wait_until_no_readers(); + + __Pyx_InterpreterIdAndModule* lower_bound = __Pyx_State_FindModuleStateLookupTableLowerBound( + data->table, data->count, interpreter_id); + + // TODO Errors here? + if (!lower_bound) goto done; + if (lower_bound->id != interpreter_id) goto done; + + __Pyx_InterpreterIdAndModule *end = data->table+data->count; + for (;lower_boundid = (lower_bound+1)->id; + lower_bound->module = (lower_bound+1)->module; + } + } + --data->count; + if (data->count == 0) { + free(data); + data = NULL; + } + // For now, never shrink the allocated table. + done: +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE + __pyx_atomic_pointer_exchange(&__Pyx_ModuleStateLookup_data, data); +#else + __Pyx_ModuleStateLookup_data = data; +#endif + __Pyx_ModuleStateLookup_Unlock(); + return 0; +} + +#endif + +////////////////////// IncludeStdlibH.proto ////////////////////// + +#include diff --git a/venv/lib/python3.10/site-packages/Cython/Utility/NumpyImportArray.c b/venv/lib/python3.10/site-packages/Cython/Utility/NumpyImportArray.c new file mode 100644 index 0000000000000000000000000000000000000000..37f74da794ea1af0884756289ca51e3188deeccf --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Utility/NumpyImportArray.c @@ -0,0 +1,46 @@ +///////////////////////// NumpyImportArray.init //////////////////// + +// comment below is deliberately kept in the generated C file to +// help users debug where this came from: +/* + * Cython has automatically inserted a call to _import_array since + * you didn't include one when you cimported numpy. To disable this + * add the line + * numpy._import_array + */ +#ifdef NPY_FEATURE_VERSION /* This is a public define that makes us reasonably confident it's "real" Numpy */ +// NO_IMPORT_ARRAY is Numpy's mechanism for indicating that import_array is handled elsewhere +#ifndef NO_IMPORT_ARRAY /* https://numpy.org/doc/stable/reference/c-api/array.html#c.NO_IMPORT_ARRAY */ +if (unlikely(_import_array() == -1)) { + PyErr_SetString(PyExc_ImportError, "numpy.core.multiarray failed to import " + "(auto-generated because you didn't call 'numpy.import_array()' after cimporting numpy; " + "use 'numpy._import_array' to disable if you are certain you don't need it)."); +} +#endif +#endif + +///////////////////////// NumpyImportUFunc.init //////////////////// + +// Unlike import_array, this is generated by the @cython.ufunc decorator +// so we're confident the right headers are present and don't need to override them + +{ + // NO_IMPORT_UFUNC is Numpy's mechanism for indicating that import_umath is handled elsewhere +#ifndef NO_IMPORT_UFUNC /* https://numpy.org/doc/stable/reference/c-api/ufunc.html#c.NO_IMPORT_UFUNC */ + if (unlikely(_import_umath() == -1)) { + PyErr_SetString(PyExc_ImportError, "numpy.core.umath failed to import " + "(auto-generated by @cython.ufunc)."); + } +#else + if ((0)) {} +#endif + // NO_IMPORT_ARRAY is Numpy's mechanism for indicating that import_array is handled elsewhere +#ifndef NO_IMPORT_ARRAY /* https://numpy.org/doc/stable/reference/c-api/array.html#c.NO_IMPORT_ARRAY */ + else if (unlikely(_import_array() == -1)) { + PyErr_SetString(PyExc_ImportError, "numpy.core.multiarray failed to import " + "(auto-generated by @cython.ufunc)."); + } +#endif +} + + diff --git a/venv/lib/python3.10/site-packages/Cython/Utility/ObjectHandling.c b/venv/lib/python3.10/site-packages/Cython/Utility/ObjectHandling.c new file mode 100644 index 0000000000000000000000000000000000000000..4b3d65a3e3fc986ef037f783ea8176ac6b8378d1 --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Utility/ObjectHandling.c @@ -0,0 +1,3367 @@ +/* + * General object operations and protocol implementations, + * including their specialisations for certain builtins. + * + * Optional optimisations for builtins are in Optimize.c. + * + * Required replacements of builtins are in Builtins.c. + */ + +/////////////// RaiseNoneIterError.proto /////////////// + +static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void); + +/////////////// RaiseNoneIterError /////////////// + +static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); +} + +/////////////// RaiseTooManyValuesToUnpack.proto /////////////// + +static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected); + +/////////////// RaiseTooManyValuesToUnpack /////////////// + +static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) { + PyErr_Format(PyExc_ValueError, + "too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected); +} + +/////////////// RaiseNeedMoreValuesToUnpack.proto /////////////// + +static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index); + +/////////////// RaiseNeedMoreValuesToUnpack /////////////// + +static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) { + PyErr_Format(PyExc_ValueError, + "need more than %" CYTHON_FORMAT_SSIZE_T "d value%.1s to unpack", + index, (index == 1) ? "" : "s"); +} + +/////////////// UnpackTupleError.proto /////////////// + +static void __Pyx_UnpackTupleError(PyObject *, Py_ssize_t index); /*proto*/ + +/////////////// UnpackTupleError /////////////// +//@requires: RaiseNoneIterError +//@requires: RaiseNeedMoreValuesToUnpack +//@requires: RaiseTooManyValuesToUnpack + +static void __Pyx_UnpackTupleError(PyObject *t, Py_ssize_t index) { + if (t == Py_None) { + __Pyx_RaiseNoneNotIterableError(); + } else { + Py_ssize_t size = __Pyx_PyTuple_GET_SIZE(t); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(size < 0)) return; + #endif + if (size < index) { + __Pyx_RaiseNeedMoreValuesError(size); + } else { + __Pyx_RaiseTooManyValuesError(index); + } + } +} + +/////////////// UnpackItemEndCheck.proto /////////////// + +static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected); /*proto*/ + +/////////////// UnpackItemEndCheck /////////////// +//@requires: RaiseTooManyValuesToUnpack +//@requires: IterFinish + +static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected) { + if (unlikely(retval)) { + Py_DECREF(retval); + __Pyx_RaiseTooManyValuesError(expected); + return -1; + } + + return __Pyx_IterFinish(); +} + +/////////////// UnpackTuple2.proto /////////////// + +static CYTHON_INLINE int __Pyx_unpack_tuple2( + PyObject* tuple, PyObject** value1, PyObject** value2, int is_tuple, int has_known_size, int decref_tuple); + +static CYTHON_INLINE int __Pyx_unpack_tuple2_exact( + PyObject* tuple, PyObject** value1, PyObject** value2, int decref_tuple); +static int __Pyx_unpack_tuple2_generic( + PyObject* tuple, PyObject** value1, PyObject** value2, int has_known_size, int decref_tuple); + +/////////////// UnpackTuple2 /////////////// +//@requires: UnpackItemEndCheck +//@requires: UnpackTupleError +//@requires: RaiseNeedMoreValuesToUnpack + +static CYTHON_INLINE int __Pyx_unpack_tuple2( + PyObject* tuple, PyObject** value1, PyObject** value2, int is_tuple, int has_known_size, int decref_tuple) { + if (likely(is_tuple || PyTuple_Check(tuple))) { + Py_ssize_t size; + if (has_known_size) { + return __Pyx_unpack_tuple2_exact(tuple, value1, value2, decref_tuple); + } + size = __Pyx_PyTuple_GET_SIZE(tuple); + if (likely(size == 2)) { + return __Pyx_unpack_tuple2_exact(tuple, value1, value2, decref_tuple); + } + if (size >= 0) { + // "size == -1" indicates an error already. + __Pyx_UnpackTupleError(tuple, 2); + } + return -1; + } else { + return __Pyx_unpack_tuple2_generic(tuple, value1, value2, has_known_size, decref_tuple); + } +} + +static CYTHON_INLINE int __Pyx_unpack_tuple2_exact( + PyObject* tuple, PyObject** pvalue1, PyObject** pvalue2, int decref_tuple) { + PyObject *value1 = NULL, *value2 = NULL; +#if CYTHON_AVOID_BORROWED_REFS || !CYTHON_ASSUME_SAFE_MACROS + value1 = __Pyx_PySequence_ITEM(tuple, 0); if (unlikely(!value1)) goto bad; + value2 = __Pyx_PySequence_ITEM(tuple, 1); if (unlikely(!value2)) goto bad; +#else + value1 = PyTuple_GET_ITEM(tuple, 0); Py_INCREF(value1); + value2 = PyTuple_GET_ITEM(tuple, 1); Py_INCREF(value2); +#endif + if (decref_tuple) { + Py_DECREF(tuple); + } + + *pvalue1 = value1; + *pvalue2 = value2; + return 0; +#if CYTHON_AVOID_BORROWED_REFS || !CYTHON_ASSUME_SAFE_MACROS +bad: + Py_XDECREF(value1); + Py_XDECREF(value2); + if (decref_tuple) { Py_XDECREF(tuple); } + return -1; +#endif +} + +static int __Pyx_unpack_tuple2_generic(PyObject* tuple, PyObject** pvalue1, PyObject** pvalue2, + int has_known_size, int decref_tuple) { + Py_ssize_t index; + PyObject *value1 = NULL, *value2 = NULL, *iter = NULL; + iternextfunc iternext; + + iter = PyObject_GetIter(tuple); + if (unlikely(!iter)) goto bad; + if (decref_tuple) { Py_DECREF(tuple); tuple = NULL; } + + iternext = __Pyx_PyObject_GetIterNextFunc(iter); + value1 = iternext(iter); if (unlikely(!value1)) { index = 0; goto unpacking_failed; } + value2 = iternext(iter); if (unlikely(!value2)) { index = 1; goto unpacking_failed; } + if (!has_known_size && unlikely(__Pyx_IternextUnpackEndCheck(iternext(iter), 2))) goto bad; + + Py_DECREF(iter); + *pvalue1 = value1; + *pvalue2 = value2; + return 0; + +unpacking_failed: + if (!has_known_size && __Pyx_IterFinish() == 0) + __Pyx_RaiseNeedMoreValuesError(index); +bad: + Py_XDECREF(iter); + Py_XDECREF(value1); + Py_XDECREF(value2); + if (decref_tuple) { Py_XDECREF(tuple); } + return -1; +} + + +/////////////// IterNextPlain.proto /////////////// + +static CYTHON_INLINE PyObject *__Pyx_PyIter_Next_Plain(PyObject *iterator); +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 +static PyObject *__Pyx_GetBuiltinNext_LimitedAPI(void); +#endif + +/////////////// IterNextPlain.module_state_decls /////////////// + +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 +PyObject *__Pyx_GetBuiltinNext_LimitedAPI_cache; +#endif + +/////////////// IterNextPlain /////////////// +//@requires: GetBuiltinName + +// There is no replacement for "Py_TYPE(obj)->iternext" in the C-API. +// PyIter_Next() discards the StopIteration, unlike Python's "next()". +// PyObject_GetSlot() rejects non-heap types in CPython < 3.10 (and PyPy). + +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 +static PyObject *__Pyx_GetBuiltinNext_LimitedAPI(void) { + if (unlikely(!CGLOBAL(__Pyx_GetBuiltinNext_LimitedAPI_cache))) + CGLOBAL(__Pyx_GetBuiltinNext_LimitedAPI_cache) = __Pyx_GetBuiltinName(PYIDENT("next")); + // Returns the globally owned reference, not a new reference! + return CGLOBAL(__Pyx_GetBuiltinNext_LimitedAPI_cache); +} +#endif + +static CYTHON_INLINE PyObject *__Pyx_PyIter_Next_Plain(PyObject *iterator) { +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 + PyObject *result; + PyObject *next = __Pyx_GetBuiltinNext_LimitedAPI(); + if (unlikely(!next)) return NULL; + result = PyObject_CallFunctionObjArgs(next, iterator, NULL); + return result; +#else + (void)__Pyx_GetBuiltinName; // only for early limited API + iternextfunc iternext = __Pyx_PyObject_GetIterNextFunc(iterator); + assert(iternext); + return iternext(iterator); +#endif +} + + +/////////////// IterNext.proto /////////////// + +#define __Pyx_PyIter_Next(obj) __Pyx_PyIter_Next2(obj, NULL) +static CYTHON_INLINE PyObject *__Pyx_PyIter_Next2(PyObject *, PyObject *); /*proto*/ + +/////////////// IterNext /////////////// +//@requires: Exceptions.c::PyThreadStateGet +//@requires: Exceptions.c::PyErrFetchRestore +//@requires: GetBuiltinName +//@requires: IterNextPlain + +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x03080000 +// In the Limited API for Py 3.7, PyIter_Check is defined but as a macro that uses +// non-limited API features and thus is unusable. Therefore, just call builtin next. +static PyObject *__Pyx_PyIter_Next2(PyObject *o, PyObject *defval) { + PyObject *result; + PyObject *next = __Pyx_GetBuiltinNext_LimitedAPI(); + if (unlikely(!next)) return NULL; + // This works if defval is NULL or not + result = PyObject_CallFunctionObjArgs(next, o, defval, NULL); + return result; +} +#else +static PyObject *__Pyx_PyIter_Next2Default(PyObject* defval) { + PyObject* exc_type; + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + exc_type = __Pyx_PyErr_CurrentExceptionType(); + if (unlikely(exc_type)) { + if (!defval || unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) + return NULL; + __Pyx_PyErr_Clear(); + Py_INCREF(defval); + return defval; + } + if (defval) { + Py_INCREF(defval); + return defval; + } + __Pyx_PyErr_SetNone(PyExc_StopIteration); + return NULL; +} + +static void __Pyx_PyIter_Next_ErrorNoIterator(PyObject *iterator) { + __Pyx_TypeName iterator_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(iterator)); + PyErr_Format(PyExc_TypeError, + __Pyx_FMT_TYPENAME " object is not an iterator", iterator_type_name); + __Pyx_DECREF_TypeName(iterator_type_name); +} + +// originally copied from Py3's builtin_next() +static CYTHON_INLINE PyObject *__Pyx_PyIter_Next2(PyObject* iterator, PyObject* defval) { + PyObject* next; +#if !CYTHON_COMPILING_IN_LIMITED_API + // We always do a quick slot check because calling PyIter_Check() is so wasteful. + iternextfunc iternext = __Pyx_PyObject_TryGetSlot(iterator, tp_iternext, iternextfunc); + if (likely(iternext)) { + next = iternext(iterator); + if (likely(next)) + return next; + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030d0000 + // If the reason for failure was "not implemented", we're done raising the appropriate exception. + if (unlikely(iternext == &_PyObject_NextNotImplemented)) + return NULL; + #endif + } else if (CYTHON_USE_TYPE_SLOTS) { + // If CYTHON_USE_TYPE_SLOTS, then the slot was really not set and we don't have an iterable. + __Pyx_PyIter_Next_ErrorNoIterator(iterator); + return NULL; + } else + // Without CYTHON_USE_TYPE_SLOTS, don't trust "tp_iternext" and rely on PyIter_Check(). +#endif + if (unlikely(!PyIter_Check(iterator))) { + __Pyx_PyIter_Next_ErrorNoIterator(iterator); + return NULL; + } else { + // We'll probably only end up here in the Limited API, where we'd call Python's "next()" now. + // If we have a default value, we don't need the StopIteration and can use PyIter_Next(). + next = defval ? PyIter_Next(iterator) : __Pyx_PyIter_Next_Plain(iterator); + if (likely(next)) + return next; + } + return __Pyx_PyIter_Next2Default(defval); +} +#endif + +/////////////// IterFinish.proto /////////////// + +static CYTHON_INLINE int __Pyx_IterFinish(void); /*proto*/ + +/////////////// IterFinish /////////////// +//@requires: Exceptions.c::PyThreadStateGet +//@requires: Exceptions.c::PyErrFetchRestore + +// When PyIter_Next(iter) has returned NULL in order to signal termination, +// this function does the right cleanup and returns 0 on success. If it +// detects an error that occurred in the iterator, it returns -1. + +static CYTHON_INLINE int __Pyx_IterFinish(void) { + PyObject* exc_type; + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + exc_type = __Pyx_PyErr_CurrentExceptionType(); + if (unlikely(exc_type)) { + if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) + return -1; + __Pyx_PyErr_Clear(); + return 0; + } + return 0; +} + + +/////////////// ObjectGetItem.proto /////////////// + +#if CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject *key);/*proto*/ +#else +#define __Pyx_PyObject_GetItem(obj, key) PyObject_GetItem(obj, key) +#endif + +/////////////// ObjectGetItem /////////////// +// //@requires: GetItemInt - added in IndexNode as it uses templating. +//@requires: PyObjectGetAttrStrNoError +//@requires: PyObjectCallOneArg + +#if CYTHON_USE_TYPE_SLOTS +static PyObject *__Pyx_PyObject_GetIndex(PyObject *obj, PyObject *index) { + // Get element from sequence object `obj` at index `index`. + PyObject *runerr = NULL; + Py_ssize_t key_value; + key_value = __Pyx_PyIndex_AsSsize_t(index); + if (likely(key_value != -1 || !(runerr = PyErr_Occurred()))) { + return __Pyx_GetItemInt_Fast(obj, key_value, 0, 1, 1); + } + + // Error handling code -- only manage OverflowError differently. + if (PyErr_GivenExceptionMatches(runerr, PyExc_OverflowError)) { + __Pyx_TypeName index_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(index)); + PyErr_Clear(); + PyErr_Format(PyExc_IndexError, + "cannot fit '" __Pyx_FMT_TYPENAME "' into an index-sized integer", index_type_name); + __Pyx_DECREF_TypeName(index_type_name); + } + return NULL; +} + +static PyObject *__Pyx_PyObject_GetItem_Slow(PyObject *obj, PyObject *key) { + __Pyx_TypeName obj_type_name; + // Handles less common slow-path checks for GetItem + if (likely(PyType_Check(obj))) { + PyObject *meth = __Pyx_PyObject_GetAttrStrNoError(obj, PYIDENT("__class_getitem__")); + if (!meth) { + PyErr_Clear(); + } else { + PyObject *result = __Pyx_PyObject_CallOneArg(meth, key); + Py_DECREF(meth); + return result; + } + } + + obj_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(obj)); + PyErr_Format(PyExc_TypeError, + "'" __Pyx_FMT_TYPENAME "' object is not subscriptable", obj_type_name); + __Pyx_DECREF_TypeName(obj_type_name); + return NULL; +} + +static PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject *key) { + PyTypeObject *tp = Py_TYPE(obj); + PyMappingMethods *mm = tp->tp_as_mapping; + PySequenceMethods *sm = tp->tp_as_sequence; + + if (likely(mm && mm->mp_subscript)) { + return mm->mp_subscript(obj, key); + } + if (likely(sm && sm->sq_item)) { + return __Pyx_PyObject_GetIndex(obj, key); + } + return __Pyx_PyObject_GetItem_Slow(obj, key); +} +#endif + + +/////////////// DictGetItem.proto /////////////// + +#if !CYTHON_COMPILING_IN_PYPY +static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key);/*proto*/ + +#define __Pyx_PyObject_Dict_GetItem(obj, name) \ + (likely(PyDict_CheckExact(obj)) ? \ + __Pyx_PyDict_GetItem(obj, name) : PyObject_GetItem(obj, name)) + +#else +#define __Pyx_PyDict_GetItem(d, key) PyObject_GetItem(d, key) +#define __Pyx_PyObject_Dict_GetItem(obj, name) PyObject_GetItem(obj, name) +#endif + +/////////////// DictGetItem /////////////// + +#if !CYTHON_COMPILING_IN_PYPY +static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) { + PyObject *value; + if (unlikely(__Pyx_PyDict_GetItemRef(d, key, &value) == 0)) { // no value, no error + if (unlikely(PyTuple_Check(key))) { + // CPython interprets tuples as separate arguments => must wrap them in another tuple. + PyObject* args = PyTuple_Pack(1, key); + if (likely(args)) { + PyErr_SetObject(PyExc_KeyError, args); + Py_DECREF(args); + } + } else { + // Avoid tuple packing if possible. + PyErr_SetObject(PyExc_KeyError, key); + } + } + return value; +} +#endif + +/////////////// GetItemInt.proto /////////////// +//@substitute: tempita + +#define __Pyx_GetItemInt(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck, has_gil) \ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ? \ + __Pyx_GetItemInt_Fast(o, (Py_ssize_t)i, is_list, wraparound, boundscheck) : \ + (is_list ? (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL) : \ + __Pyx_GetItemInt_Generic(o, to_py_func(i)))) + +{{for type in ['List', 'Tuple']}} +#define __Pyx_GetItemInt_{{type}}(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck, has_gil) \ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ? \ + __Pyx_GetItemInt_{{type}}_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) : \ + (PyErr_SetString(PyExc_IndexError, "{{ type.lower() }} index out of range"), (PyObject*)NULL)) + +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_{{type}}_Fast(PyObject *o, Py_ssize_t i, + int wraparound, int boundscheck); +{{endfor}} + +static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j); +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, + int is_list, int wraparound, int boundscheck); + +/////////////// GetItemInt /////////////// +//@substitute: tempita + +static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) { + PyObject *r; + if (unlikely(!j)) return NULL; + r = PyObject_GetItem(o, j); + Py_DECREF(j); + return r; +} + +{{for type in ['List', 'Tuple']}} +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_{{type}}_Fast(PyObject *o, Py_ssize_t i, + CYTHON_NCP_UNUSED int wraparound, + CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_ASSUME_SAFE_MACROS && CYTHON_ASSUME_SAFE_SIZE && !CYTHON_AVOID_BORROWED_REFS{{if type == 'List'}} && !CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS{{endif}} + Py_ssize_t wrapped_i = i; + if (wraparound & unlikely(i < 0)) { + wrapped_i += Py{{type}}_GET_SIZE(o); + } + if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, Py{{type}}_GET_SIZE(o)))) { + PyObject *r = Py{{type}}_GET_ITEM(o, wrapped_i); + Py_INCREF(r); + return r; + } + return __Pyx_GetItemInt_Generic(o, PyLong_FromSsize_t(i)); +#else + return PySequence_GetItem(o, i); +#endif +} +{{endfor}} + +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list, + CYTHON_NCP_UNUSED int wraparound, + CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_ASSUME_SAFE_MACROS && CYTHON_ASSUME_SAFE_SIZE && !CYTHON_AVOID_BORROWED_REFS && CYTHON_USE_TYPE_SLOTS + if (is_list || PyList_CheckExact(o)) { + Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyList_GET_SIZE(o); + if ((!boundscheck) || (likely(__Pyx_is_valid_index(n, PyList_GET_SIZE(o))))) { + return __Pyx_PyList_GetItemRef(o, n); + } + } + else if (PyTuple_CheckExact(o)) { + Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyTuple_GET_SIZE(o); + if ((!boundscheck) || likely(__Pyx_is_valid_index(n, PyTuple_GET_SIZE(o)))) { + PyObject *r = PyTuple_GET_ITEM(o, n); + Py_INCREF(r); + return r; + } + } else { + // inlined PySequence_GetItem() + special cased length overflow + PyMappingMethods *mm = Py_TYPE(o)->tp_as_mapping; + PySequenceMethods *sm = Py_TYPE(o)->tp_as_sequence; + if (mm && mm->mp_subscript) { + PyObject *r, *key = PyLong_FromSsize_t(i); + if (unlikely(!key)) return NULL; + r = mm->mp_subscript(o, key); + Py_DECREF(key); + return r; + } + if (likely(sm && sm->sq_item)) { + if (wraparound && unlikely(i < 0) && likely(sm->sq_length)) { + Py_ssize_t l = sm->sq_length(o); + if (likely(l >= 0)) { + i += l; + } else { + // if length > max(Py_ssize_t), maybe the object can wrap around itself? + if (!PyErr_ExceptionMatches(PyExc_OverflowError)) + return NULL; + PyErr_Clear(); + } + } + return sm->sq_item(o, i); + } + } +#else + // PySequence_GetItem behaves differently to PyObject_GetItem for i<0 + // and possibly some other cases so can't generally be substituted + if (is_list || !PyMapping_Check(o)) { + return PySequence_GetItem(o, i); + } +#endif + return __Pyx_GetItemInt_Generic(o, PyLong_FromSsize_t(i)); +} + +/////////////// SetItemInt.proto /////////////// + +#define __Pyx_SetItemInt(o, i, v, type, is_signed, to_py_func, is_list, wraparound, boundscheck, has_gil) \ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ? \ + __Pyx_SetItemInt_Fast(o, (Py_ssize_t)i, v, is_list, wraparound, boundscheck) : \ + (is_list ? (PyErr_SetString(PyExc_IndexError, "list assignment index out of range"), -1) : \ + __Pyx_SetItemInt_Generic(o, to_py_func(i), v))) + +static int __Pyx_SetItemInt_Generic(PyObject *o, PyObject *j, PyObject *v); +static CYTHON_INLINE int __Pyx_SetItemInt_Fast(PyObject *o, Py_ssize_t i, PyObject *v, + int is_list, int wraparound, int boundscheck); + +/////////////// SetItemInt /////////////// + +static int __Pyx_SetItemInt_Generic(PyObject *o, PyObject *j, PyObject *v) { + int r; + if (unlikely(!j)) return -1; + r = PyObject_SetItem(o, j, v); + Py_DECREF(j); + return r; +} + +static CYTHON_INLINE int __Pyx_SetItemInt_Fast(PyObject *o, Py_ssize_t i, PyObject *v, int is_list, + CYTHON_NCP_UNUSED int wraparound, CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_ASSUME_SAFE_MACROS && CYTHON_ASSUME_SAFE_SIZE && !CYTHON_AVOID_BORROWED_REFS && CYTHON_USE_TYPE_SLOTS + if (is_list || PyList_CheckExact(o)) { + Py_ssize_t n = (!wraparound) ? i : ((likely(i >= 0)) ? i : i + PyList_GET_SIZE(o)); + if ((!boundscheck) || likely(__Pyx_is_valid_index(n, PyList_GET_SIZE(o)))) { + Py_INCREF(v); +#if CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS + PyList_SetItem(o, n, v); +#else + PyObject* old = PyList_GET_ITEM(o, n); + PyList_SET_ITEM(o, n, v); + Py_DECREF(old); +#endif + return 1; + } + } else { + // inlined PySequence_SetItem() + special cased length overflow + PyMappingMethods *mm = Py_TYPE(o)->tp_as_mapping; + PySequenceMethods *sm = Py_TYPE(o)->tp_as_sequence; + if (mm && mm->mp_ass_subscript) { + int r; + PyObject *key = PyLong_FromSsize_t(i); + if (unlikely(!key)) return -1; + r = mm->mp_ass_subscript(o, key, v); + Py_DECREF(key); + return r; + } + if (likely(sm && sm->sq_ass_item)) { + if (wraparound && unlikely(i < 0) && likely(sm->sq_length)) { + Py_ssize_t l = sm->sq_length(o); + if (likely(l >= 0)) { + i += l; + } else { + // if length > max(Py_ssize_t), maybe the object can wrap around itself? + if (!PyErr_ExceptionMatches(PyExc_OverflowError)) + return -1; + PyErr_Clear(); + } + } + return sm->sq_ass_item(o, i, v); + } + } +#else + // PySequence_SetItem behaves differently to PyObject_SetItem for i<0 + // and possibly some other cases so can't generally be substituted + if (is_list || !PyMapping_Check(o)) + { + return PySequence_SetItem(o, i, v); + } +#endif + return __Pyx_SetItemInt_Generic(o, PyLong_FromSsize_t(i), v); +} + + +/////////////// DelItemInt.proto /////////////// + +#define __Pyx_DelItemInt(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck, has_gil) \ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ? \ + __Pyx_DelItemInt_Fast(o, (Py_ssize_t)i, is_list, wraparound) : \ + (is_list ? (PyErr_SetString(PyExc_IndexError, "list assignment index out of range"), -1) : \ + __Pyx_DelItem_Generic(o, to_py_func(i)))) + +static int __Pyx_DelItem_Generic(PyObject *o, PyObject *j); +static CYTHON_INLINE int __Pyx_DelItemInt_Fast(PyObject *o, Py_ssize_t i, + int is_list, int wraparound); + +/////////////// DelItemInt /////////////// + +static int __Pyx_DelItem_Generic(PyObject *o, PyObject *j) { + int r; + if (unlikely(!j)) return -1; + r = PyObject_DelItem(o, j); + Py_DECREF(j); + return r; +} + +static CYTHON_INLINE int __Pyx_DelItemInt_Fast(PyObject *o, Py_ssize_t i, + int is_list, CYTHON_NCP_UNUSED int wraparound) { +#if !CYTHON_USE_TYPE_SLOTS + // PySequence_DelItem behaves differently to PyObject_DelItem for i<0 + // and possibly some other cases so can't generally be substituted + if (is_list || !PyMapping_Check(o)) { + return PySequence_DelItem(o, i); + } +#else + // inlined PySequence_DelItem() + special cased length overflow + PyMappingMethods *mm = Py_TYPE(o)->tp_as_mapping; + PySequenceMethods *sm = Py_TYPE(o)->tp_as_sequence; + if ((!is_list) && mm && mm->mp_ass_subscript) { + PyObject *key = PyLong_FromSsize_t(i); + return likely(key) ? mm->mp_ass_subscript(o, key, (PyObject *)NULL) : -1; + } + if (likely(sm && sm->sq_ass_item)) { + if (wraparound && unlikely(i < 0) && likely(sm->sq_length)) { + Py_ssize_t l = sm->sq_length(o); + if (likely(l >= 0)) { + i += l; + } else { + // if length > max(Py_ssize_t), maybe the object can wrap around itself? + if (!PyErr_ExceptionMatches(PyExc_OverflowError)) + return -1; + PyErr_Clear(); + } + } + return sm->sq_ass_item(o, i, (PyObject *)NULL); + } +#endif + return __Pyx_DelItem_Generic(o, PyLong_FromSsize_t(i)); +} + + +/////////////// SliceObject.proto /////////////// + +// we pass pointer addresses to show the C compiler what is NULL and what isn't +{{if access == 'Get'}} +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetSlice( + PyObject* obj, Py_ssize_t cstart, Py_ssize_t cstop, + PyObject** py_start, PyObject** py_stop, PyObject** py_slice, + int has_cstart, int has_cstop, int wraparound); +{{else}} +#define __Pyx_PyObject_DelSlice(obj, cstart, cstop, py_start, py_stop, py_slice, has_cstart, has_cstop, wraparound) \ + __Pyx_PyObject_SetSlice(obj, (PyObject*)NULL, cstart, cstop, py_start, py_stop, py_slice, has_cstart, has_cstop, wraparound) + +// we pass pointer addresses to show the C compiler what is NULL and what isn't +static CYTHON_INLINE int __Pyx_PyObject_SetSlice( + PyObject* obj, PyObject* value, Py_ssize_t cstart, Py_ssize_t cstop, + PyObject** py_start, PyObject** py_stop, PyObject** py_slice, + int has_cstart, int has_cstop, int wraparound); +{{endif}} + +/////////////// SliceObject /////////////// + +{{if access == 'Get'}} +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetSlice(PyObject* obj, +{{else}} +static CYTHON_INLINE int __Pyx_PyObject_SetSlice(PyObject* obj, PyObject* value, +{{endif}} + Py_ssize_t cstart, Py_ssize_t cstop, + PyObject** _py_start, PyObject** _py_stop, PyObject** _py_slice, + int has_cstart, int has_cstop, CYTHON_UNUSED int wraparound) { + __Pyx_TypeName obj_type_name; +#if CYTHON_USE_TYPE_SLOTS + PyMappingMethods* mp = Py_TYPE(obj)->tp_as_mapping; +{{if access == 'Get'}} + if (likely(mp && mp->mp_subscript)) +{{else}} + if (likely(mp && mp->mp_ass_subscript)) +{{endif}} +#endif + { + {{if access == 'Get'}}PyObject*{{else}}int{{endif}} result; + PyObject *py_slice, *py_start, *py_stop; + if (_py_slice) { + py_slice = *_py_slice; + } else { + PyObject* owned_start = NULL; + PyObject* owned_stop = NULL; + if (_py_start) { + py_start = *_py_start; + } else { + if (has_cstart) { + owned_start = py_start = PyLong_FromSsize_t(cstart); + if (unlikely(!py_start)) goto bad; + } else + py_start = Py_None; + } + if (_py_stop) { + py_stop = *_py_stop; + } else { + if (has_cstop) { + owned_stop = py_stop = PyLong_FromSsize_t(cstop); + if (unlikely(!py_stop)) { + Py_XDECREF(owned_start); + goto bad; + } + } else + py_stop = Py_None; + } + py_slice = PySlice_New(py_start, py_stop, Py_None); + Py_XDECREF(owned_start); + Py_XDECREF(owned_stop); + if (unlikely(!py_slice)) goto bad; + } +#if CYTHON_USE_TYPE_SLOTS +{{if access == 'Get'}} + result = mp->mp_subscript(obj, py_slice); +#else + result = PyObject_GetItem(obj, py_slice); +{{else}} + result = mp->mp_ass_subscript(obj, py_slice, value); +#else + result = value ? PyObject_SetItem(obj, py_slice, value) : PyObject_DelItem(obj, py_slice); +{{endif}} +#endif + if (!_py_slice) { + Py_DECREF(py_slice); + } + return result; + } + obj_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(obj)); + PyErr_Format(PyExc_TypeError, +{{if access == 'Get'}} + "'" __Pyx_FMT_TYPENAME "' object is unsliceable", obj_type_name); +{{else}} + "'" __Pyx_FMT_TYPENAME "' object does not support slice %.10s", + obj_type_name, value ? "assignment" : "deletion"); +{{endif}} + __Pyx_DECREF_TypeName(obj_type_name); + +bad: + return {{if access == 'Get'}}NULL{{else}}-1{{endif}}; +} + + +/////////////// TupleAndListFromArray.proto /////////////// + +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n); +#endif +#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_METH_FASTCALL +static CYTHON_INLINE PyObject* __Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n); +#endif + + +/////////////// TupleAndListFromArray /////////////// + +#if !CYTHON_COMPILING_IN_CPYTHON && CYTHON_METH_FASTCALL +static CYTHON_INLINE PyObject * +__Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n) +{ + PyObject *res; + Py_ssize_t i; + if (n <= 0) { + return __Pyx_NewRef(EMPTY(tuple)); + } + res = PyTuple_New(n); + if (unlikely(res == NULL)) return NULL; + for (i = 0; i < n; i++) { + if (unlikely(__Pyx_PyTuple_SET_ITEM(res, i, src[i]) < (0))) { + Py_DECREF(res); + return NULL; + } + Py_INCREF(src[i]); + } + return res; +} +#elif CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE void __Pyx_copy_object_array(PyObject *const *CYTHON_RESTRICT src, PyObject** CYTHON_RESTRICT dest, Py_ssize_t length) { + PyObject *v; + Py_ssize_t i; + for (i = 0; i < length; i++) { + v = dest[i] = src[i]; + Py_INCREF(v); + } +} + +static CYTHON_INLINE PyObject * +__Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n) +{ + PyObject *res; + if (n <= 0) { + return __Pyx_NewRef(EMPTY(tuple)); + } + res = PyTuple_New(n); + if (unlikely(res == NULL)) return NULL; + __Pyx_copy_object_array(src, ((PyTupleObject*)res)->ob_item, n); + return res; +} + +static CYTHON_INLINE PyObject * +__Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n) +{ + PyObject *res; + if (n <= 0) { + return PyList_New(0); + } + res = PyList_New(n); + if (unlikely(res == NULL)) return NULL; + __Pyx_copy_object_array(src, ((PyListObject*)res)->ob_item, n); + return res; +} +#endif + + +/////////////// SliceTupleAndList.proto /////////////// + +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyList_GetSlice(PyObject* src, Py_ssize_t start, Py_ssize_t stop); +static CYTHON_INLINE PyObject* __Pyx_PyTuple_GetSlice(PyObject* src, Py_ssize_t start, Py_ssize_t stop); +#else +#define __Pyx_PyList_GetSlice(seq, start, stop) PySequence_GetSlice(seq, start, stop) +#define __Pyx_PyTuple_GetSlice(seq, start, stop) PySequence_GetSlice(seq, start, stop) +#endif + +/////////////// SliceTupleAndList /////////////// +//@requires: TupleAndListFromArray +//@requires: Synchronization.c::CriticalSections + +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE void __Pyx_crop_slice(Py_ssize_t* _start, Py_ssize_t* _stop, Py_ssize_t* _length) { + Py_ssize_t start = *_start, stop = *_stop, length = *_length; + if (start < 0) { + start += length; + if (start < 0) + start = 0; + } + + if (stop < 0) + stop += length; + else if (stop > length) + stop = length; + + *_length = stop - start; + *_start = start; + *_stop = stop; +} + +static CYTHON_INLINE PyObject* __Pyx_PyTuple_GetSlice( + PyObject* src, Py_ssize_t start, Py_ssize_t stop) { + Py_ssize_t length = PyTuple_GET_SIZE(src); + __Pyx_crop_slice(&start, &stop, &length); + return __Pyx_PyTuple_FromArray(((PyTupleObject*)src)->ob_item + start, length); +} + +static CYTHON_INLINE PyObject* __Pyx_PyList_GetSlice_locked( + PyObject* src, Py_ssize_t start, Py_ssize_t stop) { + Py_ssize_t length = PyList_GET_SIZE(src); + __Pyx_crop_slice(&start, &stop, &length); + if (length <= 0) { + // Avoid undefined behaviour when accessing `ob_item` of an empty list. + return PyList_New(0); + } + return __Pyx_PyList_FromArray(((PyListObject*)src)->ob_item + start, length); +} + +static CYTHON_INLINE PyObject* __Pyx_PyList_GetSlice( + PyObject* src, Py_ssize_t start, Py_ssize_t stop) { + PyObject *result; + __Pyx_BEGIN_CRITICAL_SECTION(src); + result = __Pyx_PyList_GetSlice_locked(src, start, stop); + __Pyx_END_CRITICAL_SECTION(); + return result; +} +#endif // CYTHON_COMPILING_IN_CPYTHON + + +/////////////// CalculateMetaclass.proto /////////////// + +static PyObject *__Pyx_CalculateMetaclass(PyTypeObject *metaclass, PyObject *bases); + +/////////////// CalculateMetaclass /////////////// + +static PyObject *__Pyx_CalculateMetaclass(PyTypeObject *metaclass, PyObject *bases) { + Py_ssize_t i, nbases; +#if CYTHON_ASSUME_SAFE_SIZE + nbases = PyTuple_GET_SIZE(bases); +#else + nbases = PyTuple_Size(bases); + if (nbases < 0) return NULL; +#endif + for (i=0; i < nbases; i++) { + PyTypeObject *tmptype; +#if CYTHON_ASSUME_SAFE_MACROS + PyObject *tmp = PyTuple_GET_ITEM(bases, i); +#else + PyObject *tmp = PyTuple_GetItem(bases, i); + if (!tmp) return NULL; +#endif + tmptype = Py_TYPE(tmp); + if (!metaclass) { + metaclass = tmptype; + continue; + } + if (PyType_IsSubtype(metaclass, tmptype)) + continue; + if (PyType_IsSubtype(tmptype, metaclass)) { + metaclass = tmptype; + continue; + } + // else: + PyErr_SetString(PyExc_TypeError, + "metaclass conflict: " + "the metaclass of a derived class " + "must be a (non-strict) subclass " + "of the metaclasses of all its bases"); + return NULL; + } + if (!metaclass) { + metaclass = &PyType_Type; + } + // make owned reference + Py_INCREF((PyObject*) metaclass); + return (PyObject*) metaclass; +} + + +/////////////// FindInheritedMetaclass.proto /////////////// + +static PyObject *__Pyx_FindInheritedMetaclass(PyObject *bases); /*proto*/ + +/////////////// FindInheritedMetaclass /////////////// +//@requires: PyObjectGetAttrStr +//@requires: CalculateMetaclass + +static PyObject *__Pyx_FindInheritedMetaclass(PyObject *bases) { + PyObject *metaclass; + #if CYTHON_ASSUME_SAFE_SIZE + if (PyTuple_Check(bases) && PyTuple_GET_SIZE(bases) > 0) + #else + Py_ssize_t tuple_size = PyTuple_Check(bases) ? PyTuple_Size(bases) : 0; + if (unlikely(tuple_size < 0)) return NULL; + if (tuple_size > 0) + #endif + { + PyTypeObject *metatype; +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + PyObject *base = PyTuple_GET_ITEM(bases, 0); +#else + PyObject *base = __Pyx_PySequence_ITEM(bases, 0); +#endif + metatype = Py_TYPE(base); + metaclass = __Pyx_CalculateMetaclass(metatype, bases); +#if !(CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS) + Py_DECREF(base); +#endif + } else { + // no bases => use default metaclass + metaclass = (PyObject *) &PyType_Type; + Py_INCREF(metaclass); + } + return metaclass; +} + +/////////////// Py3MetaclassGet.proto /////////////// + +static PyObject *__Pyx_Py3MetaclassGet(PyObject *bases, PyObject *mkw); /*proto*/ + +/////////////// Py3MetaclassGet /////////////// +//@requires: FindInheritedMetaclass +//@requires: CalculateMetaclass + +static PyObject *__Pyx_Py3MetaclassGet(PyObject *bases, PyObject *mkw) { + PyObject *metaclass = mkw ? __Pyx_PyDict_GetItemStr(mkw, PYIDENT("metaclass")) : NULL; + if (metaclass) { + Py_INCREF(metaclass); + if (PyDict_DelItem(mkw, PYIDENT("metaclass")) < 0) { + Py_DECREF(metaclass); + return NULL; + } + if (PyType_Check(metaclass)) { + PyObject* orig = metaclass; + metaclass = __Pyx_CalculateMetaclass((PyTypeObject*) metaclass, bases); + Py_DECREF(orig); + } + return metaclass; + } + return __Pyx_FindInheritedMetaclass(bases); +} + +/////////////// CreateClass.proto /////////////// + +static PyObject *__Pyx_CreateClass(PyObject *bases, PyObject *dict, PyObject *name, + PyObject *qualname, PyObject *modname); /*proto*/ + +/////////////// CreateClass /////////////// +//@requires: FindInheritedMetaclass +//@requires: CalculateMetaclass + +static PyObject *__Pyx_CreateClass(PyObject *bases, PyObject *dict, PyObject *name, + PyObject *qualname, PyObject *modname) { + PyObject *result; + PyObject *metaclass; + + if (unlikely(PyDict_SetItem(dict, PYIDENT("__module__"), modname) < 0)) + return NULL; + if (unlikely(PyDict_SetItem(dict, PYIDENT("__qualname__"), qualname) < 0)) + return NULL; + + /* Python2 __metaclass__ */ + metaclass = __Pyx_PyDict_GetItemStr(dict, PYIDENT("__metaclass__")); + if (metaclass) { + Py_INCREF(metaclass); + if (PyType_Check(metaclass)) { + PyObject* orig = metaclass; + metaclass = __Pyx_CalculateMetaclass((PyTypeObject*) metaclass, bases); + Py_DECREF(orig); + } + } else { + metaclass = __Pyx_FindInheritedMetaclass(bases); + } + if (unlikely(!metaclass)) + return NULL; + result = PyObject_CallFunctionObjArgs(metaclass, name, bases, dict, NULL); + Py_DECREF(metaclass); + return result; +} + +/////////////// Py3UpdateBases.proto /////////////// + +static PyObject* __Pyx_PEP560_update_bases(PyObject *bases); /* proto */ + +/////////////// Py3UpdateBases ///////////////////// +//@requires: PyObjectCallOneArg +//@requires: PyObjectGetAttrStrNoError + +/* Shamelessly adapted from cpython/bltinmodule.c update_bases */ +static PyObject* +__Pyx_PEP560_update_bases(PyObject *bases) +{ + Py_ssize_t i, j, size_bases; + PyObject *base = NULL, *meth, *new_base, *result, *new_bases = NULL; + /*assert(PyTuple_Check(bases));*/ + +#if CYTHON_ASSUME_SAFE_SIZE + size_bases = PyTuple_GET_SIZE(bases); +#else + size_bases = PyTuple_Size(bases); + if (size_bases < 0) return NULL; +#endif + for (i = 0; i < size_bases; i++) { + // original code in CPython: base = args[i]; +#if CYTHON_AVOID_BORROWED_REFS + Py_CLEAR(base); +#endif +#if CYTHON_ASSUME_SAFE_MACROS + base = PyTuple_GET_ITEM(bases, i); +#else + base = PyTuple_GetItem(bases, i); + if (!base) goto error; +#endif +#if CYTHON_AVOID_BORROWED_REFS + Py_INCREF(base); +#endif + if (PyType_Check(base)) { + if (new_bases) { + // If we already have made a replacement, then we append every normal base, + // otherwise just skip it. + if (PyList_Append(new_bases, base) < 0) { + goto error; + } + } + continue; + } + // original code in CPython: + // if (_PyObject_LookupAttrId(base, &PyId___mro_entries__, &meth) < 0) { + meth = __Pyx_PyObject_GetAttrStrNoError(base, PYIDENT("__mro_entries__")); + if (!meth && PyErr_Occurred()) { + goto error; + } + if (!meth) { + if (new_bases) { + if (PyList_Append(new_bases, base) < 0) { + goto error; + } + } + continue; + } + new_base = __Pyx_PyObject_CallOneArg(meth, bases); + Py_DECREF(meth); + if (!new_base) { + goto error; + } + if (!PyTuple_Check(new_base)) { + PyErr_SetString(PyExc_TypeError, + "__mro_entries__ must return a tuple"); + Py_DECREF(new_base); + goto error; + } + if (!new_bases) { + // If this is a first successful replacement, create new_bases list and + // copy previously encountered bases. + if (!(new_bases = PyList_New(i))) { + goto error; + } + for (j = 0; j < i; j++) { + // original code in CPython: base = args[j]; + // We use a different name here to keep refcounting separate from base + PyObject *base_from_list; +#if CYTHON_ASSUME_SAFE_MACROS + base_from_list = PyTuple_GET_ITEM(bases, j); + PyList_SET_ITEM(new_bases, j, base_from_list); + Py_INCREF(base_from_list); +#else + base_from_list = PyTuple_GetItem(bases, j); + if (!base_from_list) goto error; + Py_INCREF(base_from_list); + if (PyList_SetItem(new_bases, j, base_from_list) < 0) goto error; +#endif + } + } +#if CYTHON_ASSUME_SAFE_SIZE + j = PyList_GET_SIZE(new_bases); +#else + j = PyList_Size(new_bases); + if (j < 0) goto error; +#endif + if (PyList_SetSlice(new_bases, j, j, new_base) < 0) { + goto error; + } + Py_DECREF(new_base); + } + if (!new_bases) { + // unlike the CPython implementation, always return a new reference + Py_INCREF(bases); + return bases; + } + result = PyList_AsTuple(new_bases); + Py_DECREF(new_bases); +#if CYTHON_AVOID_BORROWED_REFS + Py_XDECREF(base); +#endif + return result; + +error: + Py_XDECREF(new_bases); +#if CYTHON_AVOID_BORROWED_REFS + Py_XDECREF(base); +#endif + return NULL; +} + +/////////////// Py3ClassCreate.proto /////////////// + +static PyObject *__Pyx_Py3MetaclassPrepare(PyObject *metaclass, PyObject *bases, PyObject *name, PyObject *qualname, + PyObject *mkw, PyObject *modname, PyObject *doc); /*proto*/ +static PyObject *__Pyx_Py3ClassCreate(PyObject *metaclass, PyObject *name, PyObject *bases, PyObject *dict, + PyObject *mkw, int calculate_metaclass, int allow_py2_metaclass); /*proto*/ + +/////////////// Py3ClassCreate /////////////// +//@requires: PyObjectGetAttrStrNoError +//@requires: CalculateMetaclass +//@requires: PyObjectFastCall +//@requires: PyObjectCall2Args +//@requires: PyObjectLookupSpecial +// only in fallback code: + +static PyObject *__Pyx_Py3MetaclassPrepare(PyObject *metaclass, PyObject *bases, PyObject *name, + PyObject *qualname, PyObject *mkw, PyObject *modname, PyObject *doc) { + PyObject *ns; + if (metaclass) { + PyObject *prep = __Pyx_PyObject_GetAttrStrNoError(metaclass, PYIDENT("__prepare__")); + if (prep) { + PyObject *pargs[3] = {NULL, name, bases}; + ns = __Pyx_PyObject_FastCallDict(prep, pargs+1, 2 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET, mkw); + Py_DECREF(prep); + } else { + if (unlikely(PyErr_Occurred())) + return NULL; + ns = PyDict_New(); + } + } else { + ns = PyDict_New(); + } + + if (unlikely(!ns)) + return NULL; + + /* Required here to emulate assignment order */ + if (unlikely(PyObject_SetItem(ns, PYIDENT("__module__"), modname) < 0)) goto bad; + if (unlikely(PyObject_SetItem(ns, PYIDENT("__qualname__"), qualname) < 0)) goto bad; + if (unlikely(doc && PyObject_SetItem(ns, PYIDENT("__doc__"), doc) < 0)) goto bad; + return ns; +bad: + Py_DECREF(ns); + return NULL; +} + +static PyObject *__Pyx_Py3ClassCreate(PyObject *metaclass, PyObject *name, PyObject *bases, + PyObject *dict, PyObject *mkw, + int calculate_metaclass, int allow_py2_metaclass) { + PyObject *result; + PyObject *owned_metaclass = NULL; + PyObject *margs[4] = {NULL, name, bases, dict}; + if (allow_py2_metaclass) { + /* honour Python2 __metaclass__ for backward compatibility */ + owned_metaclass = PyObject_GetItem(dict, PYIDENT("__metaclass__")); + if (owned_metaclass) { + metaclass = owned_metaclass; + } else if (likely(PyErr_ExceptionMatches(PyExc_KeyError))) { + PyErr_Clear(); + } else { + return NULL; + } + } + if (calculate_metaclass && (!metaclass || PyType_Check(metaclass))) { + metaclass = __Pyx_CalculateMetaclass((PyTypeObject*) metaclass, bases); + Py_XDECREF(owned_metaclass); + if (unlikely(!metaclass)) + return NULL; + owned_metaclass = metaclass; + } + result = __Pyx_PyObject_FastCallDict(metaclass, margs+1, 3 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET, mkw); + Py_XDECREF(owned_metaclass); + return result; +} + +/////////////// ExtTypeTest.proto /////////////// + +static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type); /*proto*/ + +/////////////// ExtTypeTest /////////////// + +static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) { + __Pyx_TypeName obj_type_name; + __Pyx_TypeName type_name; + if (unlikely(!type)) { + PyErr_SetString(PyExc_SystemError, "Missing type object"); + return 0; + } + if (likely(__Pyx_TypeCheck(obj, type))) + return 1; + obj_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(obj)); + type_name = __Pyx_PyType_GetFullyQualifiedName(type); + PyErr_Format(PyExc_TypeError, + "Cannot convert " __Pyx_FMT_TYPENAME " to " __Pyx_FMT_TYPENAME, + obj_type_name, type_name); + __Pyx_DECREF_TypeName(obj_type_name); + __Pyx_DECREF_TypeName(type_name); + return 0; +} + +/////////////// CallableCheck.proto /////////////// + +// PyPy does not set tp_call on classes with metaclass. +// See https://github.com/cython/cython/issues/6892 +#if CYTHON_USE_TYPE_SLOTS && !CYTHON_COMPILING_IN_PYPY +#define __Pyx_PyCallable_Check(obj) (Py_TYPE(obj)->tp_call != NULL) +#else +#define __Pyx_PyCallable_Check(obj) PyCallable_Check(obj) +#endif + +/////////////// PyDictContains.proto /////////////// + +static CYTHON_INLINE int __Pyx_PyDict_ContainsTF(PyObject* item, PyObject* dict, int eq) { + int result = PyDict_Contains(dict, item); + return unlikely(result < 0) ? result : (result == (eq == Py_EQ)); +} + +/////////////// PySetContains.proto /////////////// + +static CYTHON_INLINE int __Pyx_PySet_ContainsTF(PyObject* key, PyObject* set, int eq); /* proto */ + +/////////////// PySetContains /////////////// +//@requires: Builtins.c::pyfrozenset_new + +static int __Pyx_PySet_ContainsUnhashable(PyObject *set, PyObject *key) { + int result = -1; + if (PySet_Check(key) && PyErr_ExceptionMatches(PyExc_TypeError)) { + /* Convert key to frozenset */ + PyObject *tmpkey; + PyErr_Clear(); + tmpkey = __Pyx_PyFrozenSet_New(key); + if (tmpkey != NULL) { + result = PySet_Contains(set, tmpkey); + Py_DECREF(tmpkey); + } + } + return result; +} + +static CYTHON_INLINE int __Pyx_PySet_ContainsTF(PyObject* key, PyObject* set, int eq) { + int result = PySet_Contains(set, key); + + if (unlikely(result < 0)) { + result = __Pyx_PySet_ContainsUnhashable(set, key); + } + return unlikely(result < 0) ? result : (result == (eq == Py_EQ)); +} + +/////////////// PySequenceContains.proto /////////////// + +static CYTHON_INLINE int __Pyx_PySequence_ContainsTF(PyObject* item, PyObject* seq, int eq) { + int result = PySequence_Contains(seq, item); + return unlikely(result < 0) ? result : (result == (eq == Py_EQ)); +} + +/////////////// PyBoolOrNullFromLong.proto /////////////// + +static CYTHON_INLINE PyObject* __Pyx_PyBoolOrNull_FromLong(long b) { + return unlikely(b < 0) ? NULL : __Pyx_PyBool_FromLong(b); +} + +/////////////// GetBuiltinName.proto /////////////// + +static PyObject *__Pyx_GetBuiltinName(PyObject *name); /*proto*/ + +/////////////// GetBuiltinName /////////////// +//@requires: PyObjectGetAttrStrNoError + +static PyObject *__Pyx_GetBuiltinName(PyObject *name) { + PyObject* result = __Pyx_PyObject_GetAttrStrNoError(NAMED_CGLOBAL(builtins_cname), name); + if (unlikely(!result) && !PyErr_Occurred()) { + PyErr_Format(PyExc_NameError, + "name '%U' is not defined", name); + } + return result; +} + +/////////////// GetNameInClass.proto /////////////// + +#define __Pyx_GetNameInClass(var, nmspace, name) (var) = __Pyx__GetNameInClass(nmspace, name) +static PyObject *__Pyx__GetNameInClass(PyObject *nmspace, PyObject *name); /*proto*/ + +/////////////// GetNameInClass /////////////// +//@requires: GetModuleGlobalName + +static PyObject *__Pyx__GetNameInClass(PyObject *nmspace, PyObject *name) { + PyObject *result; + PyObject *dict; + assert(PyType_Check(nmspace)); +#if CYTHON_USE_TYPE_SLOTS + dict = ((PyTypeObject*)nmspace)->tp_dict; + Py_XINCREF(dict); +#else + dict = PyObject_GetAttr(nmspace, PYIDENT("__dict__")); +#endif + if (likely(dict)) { + result = PyObject_GetItem(dict, name); + Py_DECREF(dict); + if (result) { + return result; + } + } + PyErr_Clear(); + __Pyx_GetModuleGlobalNameUncached(result, name); + return result; +} + + +/////////////// SetNameInClass.proto /////////////// + +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030d0000 +// Identifier names are always interned and have a pre-calculated hash value. +#define __Pyx_SetNameInClass(ns, name, value) \ + (likely(PyDict_CheckExact(ns)) ? _PyDict_SetItem_KnownHash(ns, name, value, ((PyASCIIObject *) name)->hash) : PyObject_SetItem(ns, name, value)) +#elif CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_SetNameInClass(ns, name, value) \ + (likely(PyDict_CheckExact(ns)) ? PyDict_SetItem(ns, name, value) : PyObject_SetItem(ns, name, value)) +#else +#define __Pyx_SetNameInClass(ns, name, value) PyObject_SetItem(ns, name, value) +#endif + +/////////////// SetNewInClass.proto /////////////// + +static int __Pyx_SetNewInClass(PyObject *ns, PyObject *name, PyObject *value); + +/////////////// SetNewInClass /////////////// +//@requires: SetNameInClass + +// Special-case setting __new__: if it's a Cython function, wrap it in a +// staticmethod. This is similar to what Python does for a Python function +// called __new__. +static int __Pyx_SetNewInClass(PyObject *ns, PyObject *name, PyObject *value) { +#ifdef __Pyx_CyFunction_USED + int ret; + if (__Pyx_CyFunction_Check(value)) { + PyObject *staticnew; +#if !CYTHON_COMPILING_IN_LIMITED_API + staticnew = PyStaticMethod_New(value); +#else + PyObject *builtins, *staticmethod_str, *staticmethod; + builtins = PyEval_GetBuiltins(); // borrowed + if (!builtins) return -1; + staticmethod_str = PyUnicode_FromStringAndSize("staticmethod", 12); + if (!staticmethod_str) return -1; + staticmethod = PyObject_GetItem(builtins, staticmethod_str); + Py_DECREF(staticmethod_str); + if (!staticmethod) return -1; + staticnew = PyObject_CallFunctionObjArgs(staticmethod, value, NULL); + Py_DECREF(staticmethod); +#endif + if (unlikely(!staticnew)) return -1; + ret = __Pyx_SetNameInClass(ns, name, staticnew); + Py_DECREF(staticnew); + return ret; + } +#endif + return __Pyx_SetNameInClass(ns, name, value); +} + + +/////////////// GetModuleGlobalName.proto /////////////// +//@requires: PyDictVersioning + +#if CYTHON_USE_DICT_VERSIONS +#define __Pyx_GetModuleGlobalName(var, name) do { \ + static PY_UINT64_T __pyx_dict_version = 0; \ + static PyObject *__pyx_dict_cached_value = NULL; \ + (var) = (likely(__pyx_dict_version == __PYX_GET_DICT_VERSION(NAMED_CGLOBAL(moddict_cname)))) ? \ + (likely(__pyx_dict_cached_value) ? __Pyx_NewRef(__pyx_dict_cached_value) : __Pyx_GetBuiltinName(name)) : \ + __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value); \ +} while(0) +#define __Pyx_GetModuleGlobalNameUncached(var, name) do { \ + PY_UINT64_T __pyx_dict_version; \ + PyObject *__pyx_dict_cached_value; \ + (var) = __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value); \ +} while(0) +static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value); /*proto*/ +#else +#define __Pyx_GetModuleGlobalName(var, name) (var) = __Pyx__GetModuleGlobalName(name) +#define __Pyx_GetModuleGlobalNameUncached(var, name) (var) = __Pyx__GetModuleGlobalName(name) +static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name); /*proto*/ +#endif + + +/////////////// GetModuleGlobalName /////////////// +//@requires: GetBuiltinName +//@substitute: naming + +#if CYTHON_USE_DICT_VERSIONS +static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value) +#else +static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name) +#endif +{ + PyObject *result; +#if CYTHON_COMPILING_IN_LIMITED_API + if (unlikely(!$module_cname)) { + if (!PyErr_Occurred()) + PyErr_SetNone(PyExc_NameError); + return NULL; + } + result = PyObject_GetAttr($module_cname, name); + if (likely(result)) { + return result; + } + PyErr_Clear(); +#elif CYTHON_AVOID_BORROWED_REFS || CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS + if (unlikely(__Pyx_PyDict_GetItemRef(NAMED_CGLOBAL(moddict_cname), name, &result) == -1)) PyErr_Clear(); + __PYX_UPDATE_DICT_CACHE(NAMED_CGLOBAL(moddict_cname), result, *dict_cached_value, *dict_version) + if (likely(result)) { + return result; + } +#else + // Identifier names are always interned and have a pre-calculated hash value. + result = _PyDict_GetItem_KnownHash(NAMED_CGLOBAL(moddict_cname), name, ((PyASCIIObject *) name)->hash); + __PYX_UPDATE_DICT_CACHE(NAMED_CGLOBAL(moddict_cname), result, *dict_cached_value, *dict_version) + if (likely(result)) { + return __Pyx_NewRef(result); + } + PyErr_Clear(); +#endif + return __Pyx_GetBuiltinName(name); +} + +//////////////////// GetAttr.proto //////////////////// + +static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *, PyObject *); /*proto*/ + +//////////////////// GetAttr //////////////////// +//@requires: PyObjectGetAttrStr + +static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *o, PyObject *n) { +#if CYTHON_USE_TYPE_SLOTS + if (likely(PyUnicode_Check(n))) + return __Pyx_PyObject_GetAttrStr(o, n); +#endif + return PyObject_GetAttr(o, n); +} + + +/////////////// PyObjectLookupSpecial.proto /////////////// + +#if CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS +#define __Pyx_PyObject_LookupSpecialNoError(obj, attr_name) __Pyx__PyObject_LookupSpecial(obj, attr_name, 0) +#define __Pyx_PyObject_LookupSpecial(obj, attr_name) __Pyx__PyObject_LookupSpecial(obj, attr_name, 1) + +static CYTHON_INLINE PyObject* __Pyx__PyObject_LookupSpecial(PyObject* obj, PyObject* attr_name, int with_error); /*proto*/ + +#else +#define __Pyx_PyObject_LookupSpecialNoError(o,n) __Pyx_PyObject_GetAttrStrNoError(o,n) +#define __Pyx_PyObject_LookupSpecial(o,n) __Pyx_PyObject_GetAttrStr(o,n) +#endif + +/////////////// PyObjectLookupSpecial /////////////// +//@requires: PyObjectGetAttrStr +//@requires: PyObjectGetAttrStrNoError + +#if CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PyObject* __Pyx__PyObject_LookupSpecial(PyObject* obj, PyObject* attr_name, int with_error) { + PyObject *res; + PyTypeObject *tp = Py_TYPE(obj); + // adapted from CPython's special_lookup() in ceval.c + res = _PyType_Lookup(tp, attr_name); + if (likely(res)) { + descrgetfunc f = Py_TYPE(res)->tp_descr_get; + if (!f) { + Py_INCREF(res); + } else { + res = f(res, obj, (PyObject *)tp); + } + } else if (with_error) { + PyErr_SetObject(PyExc_AttributeError, attr_name); + } + return res; +} +#endif + +/////////////// PyObjectGetAttrStrNoError.proto /////////////// + +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name);/*proto*/ + +/////////////// PyObjectGetAttrStrNoError /////////////// +//@requires: PyObjectGetAttrStr +//@requires: Exceptions.c::PyThreadStateGet +//@requires: Exceptions.c::PyErrFetchRestore +//@requires: Exceptions.c::PyErrExceptionMatches + +#if __PYX_LIMITED_VERSION_HEX < 0x030d0000 +static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError))) + __Pyx_PyErr_Clear(); +} +#endif + +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) { + PyObject *result; +#if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 + (void) PyObject_GetOptionalAttr(obj, attr_name, &result); + return result; +#else +#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS + // _PyObject_GenericGetAttrWithDict() in CPython 3.7+ can avoid raising the AttributeError. + // See https://bugs.python.org/issue32544 + PyTypeObject* tp = Py_TYPE(obj); + if (likely(tp->tp_getattro == PyObject_GenericGetAttr)) { + return _PyObject_GenericGetAttrWithDict(obj, attr_name, NULL, 1); + } +#endif + result = __Pyx_PyObject_GetAttrStr(obj, attr_name); + if (unlikely(!result)) { + __Pyx_PyObject_GetAttrStr_ClearAttributeError(); + } + return result; +#endif +} + + +/////////////// PyObjectGetAttrStr.proto /////////////// + +#if CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name);/*proto*/ +#else +#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) +#endif + +/////////////// PyObjectGetAttrStr /////////////// + +#if CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) { + PyTypeObject* tp = Py_TYPE(obj); + if (likely(tp->tp_getattro)) + return tp->tp_getattro(obj, attr_name); + return PyObject_GetAttr(obj, attr_name); +} +#endif + +/////////////// PyObjectDelAttr.proto ////////////////// + +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030d0000 +#define __Pyx_PyObject_DelAttr(o, n) PyObject_SetAttr(o, n, NULL) +#else +#define __Pyx_PyObject_DelAttr(o, n) PyObject_DelAttr(o, n) +#endif + +/////////////// PyObjectSetAttrStr.proto /////////////// +//@requires: PyObjectDelAttr + +#if CYTHON_USE_TYPE_SLOTS +#define __Pyx_PyObject_DelAttrStr(o,n) __Pyx_PyObject_SetAttrStr(o, n, NULL) +static CYTHON_INLINE int __Pyx_PyObject_SetAttrStr(PyObject* obj, PyObject* attr_name, PyObject* value);/*proto*/ +#else +#define __Pyx_PyObject_DelAttrStr(o,n) __Pyx_PyObject_DelAttr(o,n) +#define __Pyx_PyObject_SetAttrStr(o,n,v) PyObject_SetAttr(o,n,v) +#endif + +/////////////// PyObjectSetAttrStr /////////////// + +#if CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE int __Pyx_PyObject_SetAttrStr(PyObject* obj, PyObject* attr_name, PyObject* value) { + PyTypeObject* tp = Py_TYPE(obj); + if (likely(tp->tp_setattro)) + return tp->tp_setattro(obj, attr_name, value); + return PyObject_SetAttr(obj, attr_name, value); +} +#endif + + +/////////////// PyObjectGetMethod.proto /////////////// + +static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method);/*proto*/ + +/////////////// PyObjectGetMethod /////////////// +//@requires: PyObjectGetAttrStr + +static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method) { + PyObject *attr; +#if CYTHON_UNPACK_METHODS && CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_PYTYPE_LOOKUP + __Pyx_TypeName type_name; + // Copied from _PyObject_GetMethod() in CPython 3.7 + PyTypeObject *tp = Py_TYPE(obj); + PyObject *descr; + descrgetfunc f = NULL; + PyObject **dictptr, *dict; + int meth_found = 0; + + assert (*method == NULL); + + if (unlikely(tp->tp_getattro != PyObject_GenericGetAttr)) { + attr = __Pyx_PyObject_GetAttrStr(obj, name); + goto try_unpack; + } + if (unlikely(tp->tp_dict == NULL) && unlikely(PyType_Ready(tp) < 0)) { + return 0; + } + + descr = _PyType_Lookup(tp, name); + if (likely(descr != NULL)) { + Py_INCREF(descr); +#if defined(Py_TPFLAGS_METHOD_DESCRIPTOR) && Py_TPFLAGS_METHOD_DESCRIPTOR + if (__Pyx_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR)) +#else + // Repeating the condition below accommodates for MSVC's inability to test macros inside of macro expansions. + #ifdef __Pyx_CyFunction_USED + if (likely(PyFunction_Check(descr) || __Pyx_IS_TYPE(descr, &PyMethodDescr_Type) || __Pyx_CyFunction_Check(descr))) + #else + if (likely(PyFunction_Check(descr) || __Pyx_IS_TYPE(descr, &PyMethodDescr_Type))) + #endif +#endif + { + meth_found = 1; + } else { + f = Py_TYPE(descr)->tp_descr_get; + if (f != NULL && PyDescr_IsData(descr)) { + attr = f(descr, obj, (PyObject *)Py_TYPE(obj)); + Py_DECREF(descr); + goto try_unpack; + } + } + } + + dictptr = _PyObject_GetDictPtr(obj); + if (dictptr != NULL && (dict = *dictptr) != NULL) { + Py_INCREF(dict); + attr = __Pyx_PyDict_GetItemStr(dict, name); + if (attr != NULL) { + Py_INCREF(attr); + Py_DECREF(dict); + Py_XDECREF(descr); + goto try_unpack; + } + Py_DECREF(dict); + } + + if (meth_found) { + *method = descr; + return 1; + } + + if (f != NULL) { + attr = f(descr, obj, (PyObject *)Py_TYPE(obj)); + Py_DECREF(descr); + goto try_unpack; + } + + if (likely(descr != NULL)) { + *method = descr; + return 0; + } + + type_name = __Pyx_PyType_GetFullyQualifiedName(tp); + PyErr_Format(PyExc_AttributeError, + "'" __Pyx_FMT_TYPENAME "' object has no attribute '%U'", + type_name, name); + __Pyx_DECREF_TypeName(type_name); + return 0; + +// Generic fallback implementation using normal attribute lookup. +#else + attr = __Pyx_PyObject_GetAttrStr(obj, name); + goto try_unpack; +#endif + +try_unpack: +#if CYTHON_UNPACK_METHODS + // Even if we failed to avoid creating a bound method object, it's still worth unpacking it now, if possible. + if (likely(attr) && PyMethod_Check(attr) && likely(PyMethod_GET_SELF(attr) == obj)) { + PyObject *function = PyMethod_GET_FUNCTION(attr); + Py_INCREF(function); + Py_DECREF(attr); + *method = function; + return 1; + } +#endif + *method = attr; + return 0; +} + + +/////////////// UnpackUnboundCMethod.proto /////////////// +//@requires: Synchronization.c::Atomics + +typedef struct { + PyObject *type; + PyObject **method_name; +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING && CYTHON_ATOMICS + // 0 for uninitialized, 1 for initializing, 2 for initialized + __pyx_atomic_int_type initialized; +#endif + // "func" is set on first access (direct C function pointer) + PyCFunction func; + // "method" is set on first access (fallback) + PyObject *method; + int flag; +} __Pyx_CachedCFunction; + +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING +static CYTHON_INLINE int __Pyx_CachedCFunction_GetAndSetInitializing(__Pyx_CachedCFunction *cfunc) { +#if !CYTHON_ATOMICS + // always say "we're initializing". This'll always go an inefficient route, + // but in reality we always expect to have atomics. + return 1; +#else + __pyx_nonatomic_int_type expected = 0; + if (__pyx_atomic_int_cmp_exchange(&cfunc->initialized, &expected, 1)) { + // we were uninitialized + return 0; + } + return expected; +#endif +} + +static CYTHON_INLINE void __Pyx_CachedCFunction_SetFinishedInitializing(__Pyx_CachedCFunction *cfunc) { +#if CYTHON_ATOMICS + __pyx_atomic_store(&cfunc->initialized, 2); +#endif +} +#else +#define __Pyx_CachedCFunction_GetAndSetInitializing(cfunc) 2 +#define __Pyx_CachedCFunction_SetFinishedInitializing(cfunc) +#endif + +/////////////// UnpackUnboundCMethod /////////////// +//@requires: PyObjectGetAttrStr + +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030C0000 +static PyObject *__Pyx_SelflessCall(PyObject *method, PyObject *args, PyObject *kwargs) { + PyObject *result; + PyObject *selfless_args = PyTuple_GetSlice(args, 1, PyTuple_Size(args)); + if (unlikely(!selfless_args)) return NULL; + + result = PyObject_Call(method, selfless_args, kwargs); + Py_DECREF(selfless_args); + return result; +} +#elif CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x03090000 +// PyPy 3.8 does not define 'args' as 'const'. +// See https://github.com/cython/cython/issues/6867 +static PyObject *__Pyx_SelflessCall(PyObject *method, PyObject **args, Py_ssize_t nargs, PyObject *kwnames) { + return _PyObject_Vectorcall + (method, args ? args+1 : NULL, nargs ? nargs-1 : 0, kwnames); +} +#else +static PyObject *__Pyx_SelflessCall(PyObject *method, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames) { + return +#if PY_VERSION_HEX < 0x03090000 + _PyObject_Vectorcall +#else + PyObject_Vectorcall +#endif + (method, args ? args+1 : NULL, nargs ? (size_t) nargs-1 : 0, kwnames); +} +#endif + +static PyMethodDef __Pyx_UnboundCMethod_Def = { + /* .ml_name = */ "CythonUnboundCMethod", + /* .ml_meth = */ __PYX_REINTERPRET_FUNCION(PyCFunction, __Pyx_SelflessCall), +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030C0000 + /* .ml_flags = */ METH_VARARGS | METH_KEYWORDS, +#else + /* .ml_flags = */ METH_FASTCALL | METH_KEYWORDS, +#endif + /* .ml_doc = */ NULL +}; + +static int __Pyx_TryUnpackUnboundCMethod(__Pyx_CachedCFunction* target) { + PyObject *method, *result=NULL; + method = __Pyx_PyObject_GetAttrStr(target->type, *target->method_name); + if (unlikely(!method)) + return -1; + result = method; +// FIXME: use functionality from CythonFunction.c/ClassMethod +#if CYTHON_COMPILING_IN_CPYTHON + if (likely(__Pyx_TypeCheck(method, &PyMethodDescr_Type))) + { + PyMethodDescrObject *descr = (PyMethodDescrObject*) method; + target->func = descr->d_method->ml_meth; + target->flag = descr->d_method->ml_flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_STACKLESS); + } else +#endif + // bound classmethods need special treatment +#if CYTHON_COMPILING_IN_PYPY + // In PyPy, functions are regular methods, so just do the self check. +#else + if (PyCFunction_Check(method)) +#endif + { + PyObject *self; + int self_found; +#if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_PYPY + self = PyObject_GetAttrString(method, "__self__"); + if (!self) { + PyErr_Clear(); + } +#else + self = PyCFunction_GET_SELF(method); +#endif + self_found = (self && self != Py_None); +#if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_PYPY + Py_XDECREF(self); +#endif + if (self_found) { + PyObject *unbound_method = PyCFunction_New(&__Pyx_UnboundCMethod_Def, method); + if (unlikely(!unbound_method)) return -1; + // New PyCFunction will own method reference, thus decref __Pyx_PyObject_GetAttrStr + Py_DECREF(method); + result = unbound_method; + } + } +#if !CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + // Unlikely corner-case where another thread has initialized target->method first. + // Can't happen in free-threading because the whole thing is locked. + if (unlikely(target->method)) { + Py_DECREF(result); + } else +#endif + target->method = result; + return 0; +} + +/////////////// CallCFunction.proto /////////////// +#define __Pyx_CallCFunction(cfunc, self, args) \ + ((PyCFunction)(void(*)(void))(cfunc)->func)(self, args) +#define __Pyx_CallCFunctionWithKeywords(cfunc, self, args, kwargs) \ + ((PyCFunctionWithKeywords)(void(*)(void))(cfunc)->func)(self, args, kwargs) +#define __Pyx_CallCFunctionFast(cfunc, self, args, nargs) \ + ((__Pyx_PyCFunctionFast)(void(*)(void))(PyCFunction)(cfunc)->func)(self, args, nargs) +#define __Pyx_CallCFunctionFastWithKeywords(cfunc, self, args, nargs, kwnames) \ + ((__Pyx_PyCFunctionFastWithKeywords)(void(*)(void))(PyCFunction)(cfunc)->func)(self, args, nargs, kwnames) + +/////////////// CallUnboundCMethod0.proto /////////////// + +CYTHON_UNUSED +static PyObject* __Pyx__CallUnboundCMethod0(__Pyx_CachedCFunction* cfunc, PyObject* self); /*proto*/ + +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_CallUnboundCMethod0(__Pyx_CachedCFunction* cfunc, PyObject* self); /* proto */ +#else +#define __Pyx_CallUnboundCMethod0(cfunc, self) __Pyx__CallUnboundCMethod0(cfunc, self) +#endif + +/////////////// CallUnboundCMethod0 /////////////// +//@requires: CallCFunction +//@requires: UnpackUnboundCMethod +//@requires: PyObjectCallOneArg + +#if CYTHON_COMPILING_IN_CPYTHON +// FASTCALL methods receive "&empty_tuple" as simple "PyObject[0]*" +static CYTHON_INLINE PyObject* __Pyx_CallUnboundCMethod0(__Pyx_CachedCFunction* cfunc, PyObject* self) { + int was_initialized = __Pyx_CachedCFunction_GetAndSetInitializing(cfunc); + + if (likely(was_initialized == 2 && cfunc->func)) { + if (likely(cfunc->flag == METH_NOARGS)) + return __Pyx_CallCFunction(cfunc, self, NULL); + if (likely(cfunc->flag == METH_FASTCALL)) + return __Pyx_CallCFunctionFast(cfunc, self, NULL, 0); + if (cfunc->flag == (METH_FASTCALL | METH_KEYWORDS)) + return __Pyx_CallCFunctionFastWithKeywords(cfunc, self, NULL, 0, NULL); + if (likely(cfunc->flag == (METH_VARARGS | METH_KEYWORDS))) + return __Pyx_CallCFunctionWithKeywords(cfunc, self, EMPTY(tuple), NULL); + if (cfunc->flag == METH_VARARGS) + return __Pyx_CallCFunction(cfunc, self, EMPTY(tuple)); + return __Pyx__CallUnboundCMethod0(cfunc, self); + } +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + else if (unlikely(was_initialized == 1)) { + // If it's being simultaneously initialized, just work on a temp + __Pyx_CachedCFunction tmp_cfunc = { +#ifndef __cplusplus + 0 +#endif + }; + tmp_cfunc.type = cfunc->type; + tmp_cfunc.method_name = cfunc->method_name; + return __Pyx__CallUnboundCMethod0(&tmp_cfunc, self); + } +#endif + PyObject *result = __Pyx__CallUnboundCMethod0(cfunc, self); + __Pyx_CachedCFunction_SetFinishedInitializing(cfunc); + return result; +} +#endif + +static PyObject* __Pyx__CallUnboundCMethod0(__Pyx_CachedCFunction* cfunc, PyObject* self) { + PyObject *result; + if (unlikely(!cfunc->method) && unlikely(__Pyx_TryUnpackUnboundCMethod(cfunc) < 0)) return NULL; + result = __Pyx_PyObject_CallOneArg(cfunc->method, self); + return result; +} + + +/////////////// CallUnboundCMethod1.proto /////////////// + +CYTHON_UNUSED +static PyObject* __Pyx__CallUnboundCMethod1(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg);/*proto*/ + +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_CallUnboundCMethod1(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg);/*proto*/ +#else +#define __Pyx_CallUnboundCMethod1(cfunc, self, arg) __Pyx__CallUnboundCMethod1(cfunc, self, arg) +#endif + +/////////////// CallUnboundCMethod1 /////////////// +//@requires: CallCFunction +//@requires: UnpackUnboundCMethod +//@requires: PyObjectCall2Args + +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_CallUnboundCMethod1(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg) { + int was_initialized = __Pyx_CachedCFunction_GetAndSetInitializing(cfunc); + + if (likely(was_initialized == 2 && cfunc->func)) { + int flag = cfunc->flag; + if (flag == METH_O) { + return __Pyx_CallCFunction(cfunc, self, arg); + } else if (flag == METH_FASTCALL) { + return __Pyx_CallCFunctionFast(cfunc, self, &arg, 1); + } else if (flag == (METH_FASTCALL | METH_KEYWORDS)) { + return __Pyx_CallCFunctionFastWithKeywords(cfunc, self, &arg, 1, NULL); + } + } +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + else if (unlikely(was_initialized == 1)) { + // Race to initialize - use a temp + __Pyx_CachedCFunction tmp_cfunc = { +#ifndef __cplusplus + 0 +#endif + }; + tmp_cfunc.type = cfunc->type; + tmp_cfunc.method_name = cfunc->method_name; + return __Pyx__CallUnboundCMethod1(&tmp_cfunc, self, arg); + } +#endif + PyObject* result = __Pyx__CallUnboundCMethod1(cfunc, self, arg); + __Pyx_CachedCFunction_SetFinishedInitializing(cfunc); + return result; +} +#endif + +static PyObject* __Pyx__CallUnboundCMethod1(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg){ + PyObject *result = NULL; + if (unlikely(!cfunc->func && !cfunc->method) && unlikely(__Pyx_TryUnpackUnboundCMethod(cfunc) < 0)) return NULL; +#if CYTHON_COMPILING_IN_CPYTHON + if (cfunc->func && (cfunc->flag & METH_VARARGS)) { + PyObject *args = PyTuple_New(1); + if (unlikely(!args)) return NULL; + Py_INCREF(arg); + PyTuple_SET_ITEM(args, 0, arg); + if (cfunc->flag & METH_KEYWORDS) + result = __Pyx_CallCFunctionWithKeywords(cfunc, self, args, NULL); + else + result = __Pyx_CallCFunction(cfunc, self, args); + Py_DECREF(args); + } else +#endif + { + result = __Pyx_PyObject_Call2Args(cfunc->method, self, arg); + } + return result; +} + + +/////////////// CallUnboundCMethod2.proto /////////////// + +CYTHON_UNUSED +static PyObject* __Pyx__CallUnboundCMethod2(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg1, PyObject* arg2); /*proto*/ + +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject *__Pyx_CallUnboundCMethod2(__Pyx_CachedCFunction *cfunc, PyObject *self, PyObject *arg1, PyObject *arg2); /*proto*/ +#else +#define __Pyx_CallUnboundCMethod2(cfunc, self, arg1, arg2) __Pyx__CallUnboundCMethod2(cfunc, self, arg1, arg2) +#endif + +/////////////// CallUnboundCMethod2 /////////////// +//@requires: CallCFunction +//@requires: UnpackUnboundCMethod +//@requires: PyObjectFastCall + +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject *__Pyx_CallUnboundCMethod2(__Pyx_CachedCFunction *cfunc, PyObject *self, PyObject *arg1, PyObject *arg2) { + int was_initialized = __Pyx_CachedCFunction_GetAndSetInitializing(cfunc); + + if (likely(was_initialized == 2 && cfunc->func)) { + PyObject *args[2] = {arg1, arg2}; + if (cfunc->flag == METH_FASTCALL) { + return __Pyx_CallCFunctionFast(cfunc, self, args, 2); + } + if (cfunc->flag == (METH_FASTCALL | METH_KEYWORDS)) + return __Pyx_CallCFunctionFastWithKeywords(cfunc, self, args, 2, NULL); + } +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + else if (unlikely(was_initialized == 1)) { + // Race to initialize - run this on a temp function instead. + __Pyx_CachedCFunction tmp_cfunc = { +#ifndef __cplusplus + 0 +#endif + }; + tmp_cfunc.type = cfunc->type; + tmp_cfunc.method_name = cfunc->method_name; + return __Pyx__CallUnboundCMethod2(&tmp_cfunc, self, arg1, arg2); + } +#endif + PyObject *result = __Pyx__CallUnboundCMethod2(cfunc, self, arg1, arg2); + __Pyx_CachedCFunction_SetFinishedInitializing(cfunc); + return result; +} +#endif + +static PyObject* __Pyx__CallUnboundCMethod2(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg1, PyObject* arg2){ + if (unlikely(!cfunc->func && !cfunc->method) && unlikely(__Pyx_TryUnpackUnboundCMethod(cfunc) < 0)) return NULL; +#if CYTHON_COMPILING_IN_CPYTHON + if (cfunc->func && (cfunc->flag & METH_VARARGS)) { + PyObject *result = NULL; + PyObject *args = PyTuple_New(2); + if (unlikely(!args)) return NULL; + Py_INCREF(arg1); + PyTuple_SET_ITEM(args, 0, arg1); + Py_INCREF(arg2); + PyTuple_SET_ITEM(args, 1, arg2); + if (cfunc->flag & METH_KEYWORDS) + result = __Pyx_CallCFunctionWithKeywords(cfunc, self, args, NULL); + else + result = __Pyx_CallCFunction(cfunc, self, args); + Py_DECREF(args); + return result; + } +#endif + { + PyObject *args[4] = {NULL, self, arg1, arg2}; + return __Pyx_PyObject_FastCall(cfunc->method, args+1, 3 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); + } +} + + +/////////////// PyObjectFastCall.proto /////////////// + +#define __Pyx_PyObject_FastCall(func, args, nargs) __Pyx_PyObject_FastCallDict(func, args, (size_t)(nargs), NULL) +static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject * const*args, size_t nargs, PyObject *kwargs); /*proto*/ + +/////////////// PyObjectFastCall /////////////// +//@requires: PyObjectCall +//@requires: PyFunctionFastCall +//@requires: PyObjectCallMethO + +#if PY_VERSION_HEX < 0x03090000 || CYTHON_COMPILING_IN_LIMITED_API +static PyObject* __Pyx_PyObject_FastCall_fallback(PyObject *func, PyObject * const*args, size_t nargs, PyObject *kwargs) { + PyObject *argstuple; + PyObject *result = 0; + size_t i; + + argstuple = PyTuple_New((Py_ssize_t)nargs); + if (unlikely(!argstuple)) return NULL; + for (i = 0; i < nargs; i++) { + Py_INCREF(args[i]); + if (__Pyx_PyTuple_SET_ITEM(argstuple, (Py_ssize_t)i, args[i]) != (0)) goto bad; + } + result = __Pyx_PyObject_Call(func, argstuple, kwargs); + bad: + Py_DECREF(argstuple); + return result; +} +#endif + +#if CYTHON_VECTORCALL && !CYTHON_COMPILING_IN_LIMITED_API + #if PY_VERSION_HEX < 0x03090000 + #define __Pyx_PyVectorcall_Function(callable) _PyVectorcall_Function(callable) + #elif CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE vectorcallfunc __Pyx_PyVectorcall_Function(PyObject *callable) { + PyTypeObject *tp = Py_TYPE(callable); + + #if defined(__Pyx_CyFunction_USED) + if (__Pyx_CyFunction_CheckExact(callable)) { + return __Pyx_CyFunction_func_vectorcall(callable); + } + #endif + + if (!PyType_HasFeature(tp, Py_TPFLAGS_HAVE_VECTORCALL)) { + return NULL; + } + assert(PyCallable_Check(callable)); + + Py_ssize_t offset = tp->tp_vectorcall_offset; + assert(offset > 0); + + vectorcallfunc ptr; + memcpy(&ptr, (char *) callable + offset, sizeof(ptr)); + return ptr; +} + #else + #define __Pyx_PyVectorcall_Function(callable) PyVectorcall_Function(callable) + #endif +#endif + +static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject *const *args, size_t _nargs, PyObject *kwargs) { + // Special fast paths for 0 and 1 arguments + // NOTE: in many cases, this is called with a constant value for nargs + // which is known at compile-time. So the branches below will typically + // be optimized away. + Py_ssize_t nargs = __Pyx_PyVectorcall_NARGS(_nargs); +#if CYTHON_COMPILING_IN_CPYTHON + if (nargs == 0 && kwargs == NULL) { + if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_NOARGS)) + return __Pyx_PyObject_CallMethO(func, NULL); + } + else if (nargs == 1 && kwargs == NULL) { + if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_O)) + return __Pyx_PyObject_CallMethO(func, args[0]); + } +#endif + + #if PY_VERSION_HEX < 0x030800B1 + #if CYTHON_FAST_PYCCALL + if (PyCFunction_Check(func)) { + if (kwargs) { + return _PyCFunction_FastCallDict(func, args, nargs, kwargs); + } else { + return _PyCFunction_FastCallKeywords(func, args, nargs, NULL); + } + } + if (!kwargs && __Pyx_IS_TYPE(func, &PyMethodDescr_Type)) { + return _PyMethodDescr_FastCallKeywords(func, args, nargs, NULL); + } + #endif + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(func)) { + return __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs); + } + #endif + #endif + + if (kwargs == NULL) { + #if CYTHON_VECTORCALL && !CYTHON_COMPILING_IN_LIMITED_API + vectorcallfunc f = __Pyx_PyVectorcall_Function(func); + if (f) { + return f(func, args, _nargs, NULL); + } + #elif defined(__Pyx_CyFunction_USED) && CYTHON_BACKPORT_VECTORCALL + // exclude fused functions for now + if (__Pyx_CyFunction_CheckExact(func)) { + __pyx_vectorcallfunc f = __Pyx_CyFunction_func_vectorcall(func); + if (f) return f(func, args, _nargs, NULL); + } + #elif CYTHON_COMPILING_IN_LIMITED_API && CYTHON_VECTORCALL + return PyObject_Vectorcall(func, args, _nargs, NULL); + #endif + } + + if (nargs == 0) { + return __Pyx_PyObject_Call(func, EMPTY(tuple), kwargs); + } + #if PY_VERSION_HEX >= 0x03090000 && !CYTHON_COMPILING_IN_LIMITED_API + return PyObject_VectorcallDict(func, args, (size_t)nargs, kwargs); + #else + return __Pyx_PyObject_FastCall_fallback(func, args, (size_t)nargs, kwargs); + #endif +} + +/////////////// PyObjectFastCallMethod.proto /////////////// +//@requires PyObjectFastCall + +#if CYTHON_VECTORCALL && PY_VERSION_HEX >= 0x03090000 +#define __Pyx_PyObject_FastCallMethod(name, args, nargsf) PyObject_VectorcallMethod(name, args, nargsf, NULL) +#else +static PyObject *__Pyx_PyObject_FastCallMethod(PyObject *name, PyObject *const *args, size_t nargsf); /* proto */ +#endif + +/////////////// PyObjectFastCallMethod /////////////// + +#if !CYTHON_VECTORCALL || PY_VERSION_HEX < 0x03090000 +static PyObject *__Pyx_PyObject_FastCallMethod(PyObject *name, PyObject *const *args, size_t nargsf) { + PyObject *result; + PyObject *attr = PyObject_GetAttr(args[0], name); + if (unlikely(!attr)) + return NULL; + result = __Pyx_PyObject_FastCall(attr, args+1, nargsf - 1); + Py_DECREF(attr); + return result; +} +#endif + +/////////////// PyObjectVectorCallKwBuilder.proto //////////////// +//@requires: PyObjectFastCall +// For versions that define PyObject_Vectorcall, use PyObject_Vectorcall and define functions to build a kwnames tuple and add arguments to args. +// For versions that don't, use __Pyx_PyObject_FastCallDict and functions to build a keyword dictionary + +CYTHON_UNUSED static int __Pyx_VectorcallBuilder_AddArg_Check(PyObject *key, PyObject *value, PyObject *builder, PyObject **args, int n); /* proto */ + +#if CYTHON_VECTORCALL +#if PY_VERSION_HEX >= 0x03090000 +#define __Pyx_Object_Vectorcall_CallFromBuilder PyObject_Vectorcall +#else +#define __Pyx_Object_Vectorcall_CallFromBuilder _PyObject_Vectorcall +#endif + +#define __Pyx_MakeVectorcallBuilderKwds(n) PyTuple_New(n) + +static int __Pyx_VectorcallBuilder_AddArg(PyObject *key, PyObject *value, PyObject *builder, PyObject **args, int n); /* proto */ +static int __Pyx_VectorcallBuilder_AddArgStr(const char *key, PyObject *value, PyObject *builder, PyObject **args, int n); /* proto */ +#else +#define __Pyx_Object_Vectorcall_CallFromBuilder __Pyx_PyObject_FastCallDict + +#define __Pyx_MakeVectorcallBuilderKwds(n) __Pyx_PyDict_NewPresized(n) + +#define __Pyx_VectorcallBuilder_AddArg(key, value, builder, args, n) PyDict_SetItem(builder, key, value) +#define __Pyx_VectorcallBuilder_AddArgStr(key, value, builder, args, n) PyDict_SetItemString(builder, key, value) +#endif + +/////////////// PyObjectVectorCallKwBuilder //////////////// + +#if CYTHON_VECTORCALL +static int __Pyx_VectorcallBuilder_AddArg(PyObject *key, PyObject *value, PyObject *builder, PyObject **args, int n) { + (void)__Pyx_PyObject_FastCallDict; + + if (__Pyx_PyTuple_SET_ITEM(builder, n, key) != (0)) return -1; + Py_INCREF(key); + args[n] = value; + return 0; +} + +CYTHON_UNUSED static int __Pyx_VectorcallBuilder_AddArg_Check(PyObject *key, PyObject *value, PyObject *builder, PyObject **args, int n) { + (void)__Pyx_VectorcallBuilder_AddArgStr; + if (unlikely(!PyUnicode_Check(key))) { + PyErr_SetString(PyExc_TypeError, "keywords must be strings"); + return -1; + } + return __Pyx_VectorcallBuilder_AddArg(key, value, builder, args, n); +} + +static int __Pyx_VectorcallBuilder_AddArgStr(const char *key, PyObject *value, PyObject *builder, PyObject **args, int n) { + PyObject *pyKey = PyUnicode_FromString(key); + if (!pyKey) return -1; + return __Pyx_VectorcallBuilder_AddArg(pyKey, value, builder, args, n); +} +#else // CYTHON_VECTORCALL +CYTHON_UNUSED static int __Pyx_VectorcallBuilder_AddArg_Check(PyObject *key, PyObject *value, PyObject *builder, CYTHON_UNUSED PyObject **args, CYTHON_UNUSED int n) { + if (unlikely(!PyUnicode_Check(key))) { + PyErr_SetString(PyExc_TypeError, "keywords must be strings"); + return -1; + } + return PyDict_SetItem(builder, key, value); +} +#endif + +/////////////// PyObjectVectorCallMethodKwBuilder.proto //////////////// + +#if CYTHON_VECTORCALL && PY_VERSION_HEX >= 0x03090000 +#define __Pyx_Object_VectorcallMethod_CallFromBuilder PyObject_VectorcallMethod +#else +static PyObject *__Pyx_Object_VectorcallMethod_CallFromBuilder(PyObject *name, PyObject *const *args, size_t nargsf, PyObject *kwnames); /* proto */ +#endif + +/////////////// PyObjectVectorCallMethodKwBuilder //////////////// +//@requires: PyObjectVectorCallKwBuilder + +#if !CYTHON_VECTORCALL || PY_VERSION_HEX < 0x03090000 +static PyObject *__Pyx_Object_VectorcallMethod_CallFromBuilder(PyObject *name, PyObject *const *args, size_t nargsf, PyObject *kwnames) { + PyObject *result; + PyObject *obj = PyObject_GetAttr(args[0], name); + if (unlikely(!obj)) + return NULL; + result = __Pyx_Object_Vectorcall_CallFromBuilder(obj, args+1, nargsf-1, kwnames); + Py_DECREF(obj); + return result; +} +#endif + +/////////////// PyObjectCallMethod0.proto /////////////// + +static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name); /*proto*/ + +/////////////// PyObjectCallMethod0 /////////////// +//@requires: PyObjectGetMethod +//@requires: PyObjectCallOneArg +//@requires: PyObjectCallNoArg + +static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name) { +#if CYTHON_VECTORCALL && (__PYX_LIMITED_VERSION_HEX >= 0x030C0000 || (!CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x03090000)) + PyObject *args[1] = {obj}; + // avoid unused functions + (void) __Pyx_PyObject_GetMethod; + (void) __Pyx_PyObject_CallOneArg; + (void) __Pyx_PyObject_CallNoArg; + return PyObject_VectorcallMethod(method_name, args, 1 | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL); +#else + PyObject *method = NULL, *result = NULL; + int is_method = __Pyx_PyObject_GetMethod(obj, method_name, &method); + if (likely(is_method)) { + result = __Pyx_PyObject_CallOneArg(method, obj); + Py_DECREF(method); + return result; + } + if (unlikely(!method)) goto bad; + result = __Pyx_PyObject_CallNoArg(method); + Py_DECREF(method); +bad: + return result; +#endif +} + + +/////////////// PyObjectCallMethod1.proto /////////////// + +static PyObject* __Pyx_PyObject_CallMethod1(PyObject* obj, PyObject* method_name, PyObject* arg); /*proto*/ + +/////////////// PyObjectCallMethod1 /////////////// +//@requires: PyObjectGetMethod +//@requires: PyObjectCallOneArg +//@requires: PyObjectCall2Args + +#if !(CYTHON_VECTORCALL && (__PYX_LIMITED_VERSION_HEX >= 0x030C0000 || (!CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x03090000))) +static PyObject* __Pyx__PyObject_CallMethod1(PyObject* method, PyObject* arg) { + // Separate function to avoid excessive inlining. + PyObject *result = __Pyx_PyObject_CallOneArg(method, arg); + Py_DECREF(method); + return result; +} +#endif + +static PyObject* __Pyx_PyObject_CallMethod1(PyObject* obj, PyObject* method_name, PyObject* arg) { +#if CYTHON_VECTORCALL && (__PYX_LIMITED_VERSION_HEX >= 0x030C0000 || (!CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x03090000)) + PyObject *args[2] = {obj, arg}; + // avoid unused functions + (void) __Pyx_PyObject_GetMethod; + (void) __Pyx_PyObject_CallOneArg; + (void) __Pyx_PyObject_Call2Args; + return PyObject_VectorcallMethod(method_name, args, 2 | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL); +#else + PyObject *method = NULL, *result; + int is_method = __Pyx_PyObject_GetMethod(obj, method_name, &method); + if (likely(is_method)) { + result = __Pyx_PyObject_Call2Args(method, obj, arg); + Py_DECREF(method); + return result; + } + if (unlikely(!method)) return NULL; + return __Pyx__PyObject_CallMethod1(method, arg); +#endif +} + + +/////////////// tp_new.proto /////////////// + +#define __Pyx_tp_new(type_obj, args) __Pyx_tp_new_kwargs(type_obj, args, NULL) +static CYTHON_INLINE PyObject* __Pyx_tp_new_kwargs(PyObject* type_obj, PyObject* args, PyObject* kwargs); /*proto*/ + +/////////////// tp_new /////////////// + +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 +static PyObject* __Pyx_tp_new_fallback(PyObject* type_obj, PyObject* args, PyObject* kwargs) { + PyObject *new_func = NULL, *new_args = NULL, *obj; + Py_ssize_t i, nargs = PyTuple_Size(args); + + if (unlikely(nargs < 0)) goto bad; + new_args = PyTuple_New(nargs + 1); + if (unlikely(!new_args)) goto bad; + for (i = 0; i < nargs + 1; i++) { + PyObject *item = (i == 0) ? type_obj : PyTuple_GetItem(args, i - 1); + if (unlikely(!item)) goto bad; + Py_INCREF(item); + if (unlikely(PyTuple_SetItem(new_args, i, item)) < 0) goto bad; + } + + new_func = PyObject_GetAttrString(type_obj, "__new__"); + if (unlikely(!new_func)) goto bad; + obj = PyObject_Call(new_func, new_args, kwargs); + Py_DECREF(new_func); + Py_DECREF(new_args); + return obj; + + bad: + Py_XDECREF(new_func); + Py_XDECREF(new_args); + return NULL; +} +#endif + +static PyObject* __Pyx_tp_new_kwargs(PyObject* type_obj, PyObject* args, PyObject* kwargs) { + newfunc tp_new = __Pyx_PyType_TryGetSlot((PyTypeObject*)type_obj, tp_new, newfunc); +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 + if (!tp_new) return __Pyx_tp_new_fallback(type_obj, args, kwargs); +#else + assert(tp_new != NULL); +#endif + return tp_new((PyTypeObject*)type_obj, args, kwargs); +} + + +/////////////// PyObjectCall.proto /////////////// + +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw); /*proto*/ +#else +#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw) +#endif + +/////////////// PyObjectCall /////////////// + +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { + PyObject *result; + ternaryfunc call = Py_TYPE(func)->tp_call; + + if (unlikely(!call)) + return PyObject_Call(func, arg, kw); + if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) + return NULL; + result = (*call)(func, arg, kw); + Py_LeaveRecursiveCall(); + if (unlikely(!result) && unlikely(!PyErr_Occurred())) { + PyErr_SetString( + PyExc_SystemError, + "NULL result without error in PyObject_Call"); + } + return result; +} +#endif + + +/////////////// PyObjectCallMethO.proto /////////////// + +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg); /*proto*/ +#endif + +/////////////// PyObjectCallMethO /////////////// + +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) { + PyObject *self, *result; + PyCFunction cfunc; + cfunc = __Pyx_CyOrPyCFunction_GET_FUNCTION(func); + self = __Pyx_CyOrPyCFunction_GET_SELF(func); + + if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) + return NULL; + result = cfunc(self, arg); + Py_LeaveRecursiveCall(); + if (unlikely(!result) && unlikely(!PyErr_Occurred())) { + PyErr_SetString( + PyExc_SystemError, + "NULL result without error in PyObject_Call"); + } + return result; +} +#endif + + +/////////////// PyFunctionFastCall.proto /////////////// + +#if CYTHON_FAST_PYCALL + +#if !CYTHON_VECTORCALL +#define __Pyx_PyFunction_FastCall(func, args, nargs) \ + __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL) + +static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject *const *args, Py_ssize_t nargs, PyObject *kwargs); +#endif + +// Backport from Python 3 +// Assert a build-time dependency, as an expression. +// Your compile will fail if the condition isn't true, or can't be evaluated +// by the compiler. This can be used in an expression: its value is 0. +// Example: +// #define foo_to_char(foo) \ +// ((char *)(foo) \ +// + Py_BUILD_ASSERT_EXPR(offsetof(struct foo, string) == 0)) +// +// Written by Rusty Russell, public domain, https://ccodearchive.net/ +#define __Pyx_BUILD_ASSERT_EXPR(cond) \ + (sizeof(char [1 - 2*!(cond)]) - 1) + +#ifndef Py_MEMBER_SIZE +// Get the size of a structure member in bytes +#define Py_MEMBER_SIZE(type, member) sizeof(((type *)0)->member) +#endif + +#if !CYTHON_VECTORCALL +#if PY_VERSION_HEX >= 0x03080000 + #include "frameobject.h" + #define __Pxy_PyFrame_Initialize_Offsets() + #define __Pyx_PyFrame_GetLocalsplus(frame) ((frame)->f_localsplus) +#else + // Initialised by module init code. + static size_t __pyx_pyframe_localsplus_offset = 0; + + #include "frameobject.h" + // This is the long runtime version of + // #define __Pyx_PyFrame_GetLocalsplus(frame) ((frame)->f_localsplus) + // offsetof(PyFrameObject, f_localsplus) differs between regular C-Python and Stackless Python < 3.8. + // Therefore the offset is computed at run time from PyFrame_type.tp_basicsize. That is feasible, + // because f_localsplus is the last field of PyFrameObject (checked by Py_BUILD_ASSERT_EXPR below). + #define __Pxy_PyFrame_Initialize_Offsets() \ + ((void)__Pyx_BUILD_ASSERT_EXPR(sizeof(PyFrameObject) == offsetof(PyFrameObject, f_localsplus) + Py_MEMBER_SIZE(PyFrameObject, f_localsplus)), \ + (void)(__pyx_pyframe_localsplus_offset = ((size_t)PyFrame_Type.tp_basicsize) - Py_MEMBER_SIZE(PyFrameObject, f_localsplus))) + #define __Pyx_PyFrame_GetLocalsplus(frame) \ + (assert(__pyx_pyframe_localsplus_offset), (PyObject **)(((char *)(frame)) + __pyx_pyframe_localsplus_offset)) +#endif +#endif /* !CYTHON_VECTORCALL */ + +#endif /* CYTHON_FAST_PYCALL */ + + +/////////////// PyFunctionFastCall /////////////// +// copied from CPython 3.6 ceval.c + +#if CYTHON_FAST_PYCALL && !CYTHON_VECTORCALL +static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject *const *args, Py_ssize_t na, + PyObject *globals) { + PyFrameObject *f; + PyThreadState *tstate = __Pyx_PyThreadState_Current; + PyObject **fastlocals; + Py_ssize_t i; + PyObject *result; + + assert(globals != NULL); + /* XXX Perhaps we should create a specialized + PyFrame_New() that doesn't take locals, but does + take builtins without sanity checking them. + */ + assert(tstate != NULL); + f = PyFrame_New(tstate, co, globals, NULL); + if (f == NULL) { + return NULL; + } + + fastlocals = __Pyx_PyFrame_GetLocalsplus(f); + + for (i = 0; i < na; i++) { + Py_INCREF(*args); + fastlocals[i] = *args++; + } + result = PyEval_EvalFrameEx(f,0); + + ++tstate->recursion_depth; + Py_DECREF(f); + --tstate->recursion_depth; + + return result; +} + + +static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject *const *args, Py_ssize_t nargs, PyObject *kwargs) { + PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func); + PyObject *globals = PyFunction_GET_GLOBALS(func); + PyObject *argdefs = PyFunction_GET_DEFAULTS(func); + PyObject *closure; + PyObject *kwdefs; + //PyObject *name, *qualname; + PyObject *kwtuple, **k; + PyObject **d; + Py_ssize_t nd; + Py_ssize_t nk; + PyObject *result; + + assert(kwargs == NULL || PyDict_Check(kwargs)); + nk = kwargs ? PyDict_Size(kwargs) : 0; + + if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) { + return NULL; + } + + if ( + co->co_kwonlyargcount == 0 && + likely(kwargs == NULL || nk == 0) && + co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) { + /* Fast paths */ + if (argdefs == NULL && co->co_argcount == nargs) { + result = __Pyx_PyFunction_FastCallNoKw(co, args, nargs, globals); + goto done; + } + else if (nargs == 0 && argdefs != NULL + && co->co_argcount == Py_SIZE(argdefs)) { + /* function called with no arguments, but all parameters have + a default value: use default values as arguments .*/ + args = &PyTuple_GET_ITEM(argdefs, 0); + result =__Pyx_PyFunction_FastCallNoKw(co, args, Py_SIZE(argdefs), globals); + goto done; + } + } + + if (kwargs != NULL) { + Py_ssize_t pos, i; + kwtuple = PyTuple_New(2 * nk); + if (kwtuple == NULL) { + result = NULL; + goto done; + } + + k = &PyTuple_GET_ITEM(kwtuple, 0); + pos = i = 0; + while (PyDict_Next(kwargs, &pos, &k[i], &k[i+1])) { + Py_INCREF(k[i]); + Py_INCREF(k[i+1]); + i += 2; + } + nk = i / 2; + } + else { + kwtuple = NULL; + k = NULL; + } + + closure = PyFunction_GET_CLOSURE(func); + kwdefs = PyFunction_GET_KW_DEFAULTS(func); + //name = ((PyFunctionObject *)func) -> func_name; + //qualname = ((PyFunctionObject *)func) -> func_qualname; + + if (argdefs != NULL) { + d = &PyTuple_GET_ITEM(argdefs, 0); + nd = Py_SIZE(argdefs); + } + else { + d = NULL; + nd = 0; + } + + //return _PyEval_EvalCodeWithName((PyObject*)co, globals, (PyObject *)NULL, + // args, nargs, + // NULL, 0, + // d, nd, kwdefs, + // closure, name, qualname); + result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL, + args, (int)nargs, + k, (int)nk, + d, (int)nd, kwdefs, closure); + Py_XDECREF(kwtuple); + +done: + Py_LeaveRecursiveCall(); + return result; +} +#endif /* CYTHON_FAST_PYCALL && !CYTHON_VECTORCALL */ + + +/////////////// PyObjectCall2Args.proto /////////////// + +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2); /*proto*/ + +/////////////// PyObjectCall2Args /////////////// +//@requires: PyObjectFastCall + +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2) { + PyObject *args[3] = {NULL, arg1, arg2}; + return __Pyx_PyObject_FastCall(function, args+1, 2 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); +} + + +/////////////// PyObjectCallOneArg.proto /////////////// + +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); /*proto*/ + +/////////////// PyObjectCallOneArg /////////////// +//@requires: PyObjectFastCall + +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { + PyObject *args[2] = {NULL, arg}; + return __Pyx_PyObject_FastCall(func, args+1, 1 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); +} + + +/////////////// PyObjectCallNoArg.proto /////////////// + +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func); /*proto*/ + +/////////////// PyObjectCallNoArg /////////////// +//@requires: PyObjectFastCall + +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) { + PyObject *arg[2] = {NULL, NULL}; + return __Pyx_PyObject_FastCall(func, arg + 1, 0 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); +} + + +/////////////// PyVectorcallFastCallDict.proto /////////////// + +#if CYTHON_METH_FASTCALL && (CYTHON_VECTORCALL || CYTHON_BACKPORT_VECTORCALL) +static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw); +#endif + +/////////////// PyVectorcallFastCallDict /////////////// + +#if CYTHON_METH_FASTCALL && (CYTHON_VECTORCALL || CYTHON_BACKPORT_VECTORCALL) +// Slow path when kw is non-empty +static PyObject *__Pyx_PyVectorcall_FastCallDict_kw(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw) +{ + // Code based on _PyObject_FastCallDict() and _PyStack_UnpackDict() from CPython + PyObject *res = NULL; + PyObject *kwnames; + PyObject **newargs; + PyObject **kwvalues; + Py_ssize_t i, pos; + size_t j; + PyObject *key, *value; + unsigned long keys_are_strings; + #if !CYTHON_ASSUME_SAFE_SIZE + Py_ssize_t nkw = PyDict_Size(kw); + if (unlikely(nkw == -1)) return NULL; + #else + Py_ssize_t nkw = PyDict_GET_SIZE(kw); + #endif + + // Copy positional arguments + newargs = (PyObject **)PyMem_Malloc((nargs + (size_t)nkw) * sizeof(args[0])); + if (unlikely(newargs == NULL)) { + PyErr_NoMemory(); + return NULL; + } + for (j = 0; j < nargs; j++) newargs[j] = args[j]; + + // Copy keyword arguments + kwnames = PyTuple_New(nkw); + if (unlikely(kwnames == NULL)) { + PyMem_Free(newargs); + return NULL; + } + kwvalues = newargs + nargs; + pos = i = 0; + keys_are_strings = Py_TPFLAGS_UNICODE_SUBCLASS; + while (PyDict_Next(kw, &pos, &key, &value)) { + keys_are_strings &= + #if CYTHON_COMPILING_IN_LIMITED_API + PyType_GetFlags(Py_TYPE(key)); + #else + Py_TYPE(key)->tp_flags; + #endif + Py_INCREF(key); + Py_INCREF(value); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely(PyTuple_SetItem(kwnames, i, key) < 0)) goto cleanup; + #else + PyTuple_SET_ITEM(kwnames, i, key); + #endif + kwvalues[i] = value; + i++; + } + if (unlikely(!keys_are_strings)) { + PyErr_SetString(PyExc_TypeError, "keywords must be strings"); + goto cleanup; + } + + // The actual call + res = vc(func, newargs, nargs, kwnames); + +cleanup: + Py_DECREF(kwnames); + for (i = 0; i < nkw; i++) + Py_DECREF(kwvalues[i]); + PyMem_Free(newargs); + return res; +} + +static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw) +{ + Py_ssize_t kw_size = + likely(kw == NULL) ? + 0 : +#if !CYTHON_ASSUME_SAFE_SIZE + PyDict_Size(kw); +#else + PyDict_GET_SIZE(kw); +#endif + + if (kw_size == 0) { + return vc(func, args, nargs, NULL); + } +#if !CYTHON_ASSUME_SAFE_SIZE + else if (unlikely(kw_size == -1)) { + return NULL; + } +#endif + return __Pyx_PyVectorcall_FastCallDict_kw(func, vc, args, nargs, kw); +} +#endif + + +/////////////// MatrixMultiply.proto /////////////// + +// TODO: remove +#define __Pyx_PyNumber_MatrixMultiply(x,y) PyNumber_MatrixMultiply(x,y) +#define __Pyx_PyNumber_InPlaceMatrixMultiply(x,y) PyNumber_InPlaceMatrixMultiply(x,y) + + +/////////////// PyDictVersioning.proto /////////////// + +#if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS +#define __PYX_DICT_VERSION_INIT ((PY_UINT64_T) -1) +#define __PYX_GET_DICT_VERSION(dict) (((PyDictObject*)(dict))->ma_version_tag) +#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var) \ + (version_var) = __PYX_GET_DICT_VERSION(dict); \ + (cache_var) = (value); + +#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) { \ + static PY_UINT64_T __pyx_dict_version = 0; \ + static PyObject *__pyx_dict_cached_value = NULL; \ + if (likely(__PYX_GET_DICT_VERSION(DICT) == __pyx_dict_version)) { \ + (VAR) = __pyx_dict_cached_value; \ + } else { \ + (VAR) = __pyx_dict_cached_value = (LOOKUP); \ + __pyx_dict_version = __PYX_GET_DICT_VERSION(DICT); \ + } \ +} + +static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj); /*proto*/ +static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj); /*proto*/ +static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version); /*proto*/ + +#else +#define __PYX_GET_DICT_VERSION(dict) (0) +#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var) +#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) (VAR) = (LOOKUP); +#endif + +/////////////// PyDictVersioning /////////////// + +#if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj) { + PyObject *dict = Py_TYPE(obj)->tp_dict; + return likely(dict) ? __PYX_GET_DICT_VERSION(dict) : 0; +} + +static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj) { + PyObject **dictptr = NULL; + Py_ssize_t offset = Py_TYPE(obj)->tp_dictoffset; + if (offset) { +#if CYTHON_COMPILING_IN_CPYTHON + dictptr = (likely(offset > 0)) ? (PyObject **) ((char *)obj + offset) : _PyObject_GetDictPtr(obj); +#else + dictptr = _PyObject_GetDictPtr(obj); +#endif + } + return (dictptr && *dictptr) ? __PYX_GET_DICT_VERSION(*dictptr) : 0; +} + +static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version) { + PyObject *dict = Py_TYPE(obj)->tp_dict; + if (unlikely(!dict) || unlikely(tp_dict_version != __PYX_GET_DICT_VERSION(dict))) + return 0; + return obj_dict_version == __Pyx_get_object_dict_version(obj); +} +#endif + +////////////// CachedMethodType.module_state_decls //////////// + +#if CYTHON_COMPILING_IN_LIMITED_API +PyObject *__Pyx_CachedMethodType; +#endif + +////////////// CachedMethodType.init ////////////// + +#if CYTHON_COMPILING_IN_LIMITED_API +{ + PyObject *typesModule=NULL; + typesModule = PyImport_ImportModule("types"); + if (typesModule) { + CGLOBAL(__Pyx_CachedMethodType) = PyObject_GetAttrString(typesModule, "MethodType"); + Py_DECREF(typesModule); + } +} // error handling follows +#endif + +/////////////// CachedMethodType.cleanup //////////////// + +#if CYTHON_COMPILING_IN_LIMITED_API +Py_CLEAR(CGLOBAL(__Pyx_CachedMethodType)); +#endif + +/////////////// PyMethodNew.proto /////////////// + +static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ); /* proto */ + +/////////////// PyMethodNew /////////////// +//@requires: CachedMethodType + +#if CYTHON_COMPILING_IN_LIMITED_API +static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) { + PyObject *result; + CYTHON_UNUSED_VAR(typ); + if (!self) + return __Pyx_NewRef(func); + #if __PYX_LIMITED_VERSION_HEX >= 0x030C0000 + { + PyObject *args[] = {func, self}; + result = PyObject_Vectorcall(CGLOBAL(__Pyx_CachedMethodType), args, 2, NULL); + } + #else + result = PyObject_CallFunctionObjArgs(CGLOBAL(__Pyx_CachedMethodType), func, self, NULL); + #endif + return result; +} +#else +// This should be an actual function (not a macro), such that we can put it +// directly in a tp_descr_get slot. +static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) { + CYTHON_UNUSED_VAR(typ); + if (!self) + return __Pyx_NewRef(func); + return PyMethod_New(func, self); +} +#endif + +///////////// PyMethodNew2Arg.proto ///////////// +//@requires: CachedMethodType + +// TODO: remove +// Another wrapping of PyMethod_New that matches the Python3 signature +#if CYTHON_COMPILING_IN_LIMITED_API +static PyObject *__Pyx_PyMethod_New2Arg(PyObject *func, PyObject *self); /* proto */ +#else +#define __Pyx_PyMethod_New2Arg PyMethod_New +#endif + +///////////// PyMethodNew2Arg ///////////// +//@requires: CachedMethodType + +#if CYTHON_COMPILING_IN_LIMITED_API +static PyObject *__Pyx_PyMethod_New2Arg(PyObject *func, PyObject *self) { + PyObject *result; + #if __PYX_LIMITED_VERSION_HEX >= 0x030C0000 + { + PyObject *args[] = {func, self}; + result = PyObject_Vectorcall(CGLOBAL(__Pyx_CachedMethodType), args, 2, NULL); + } + #else + result = PyObject_CallFunctionObjArgs(CGLOBAL(__Pyx_CachedMethodType), func, self, NULL); + #endif + return result; +} +#endif + +/////////////// UnicodeConcatInPlace.proto //////////////// + +# if CYTHON_COMPILING_IN_CPYTHON +// __Pyx_PyUnicode_ConcatInPlace may modify the first argument 'left' +// However, unlike `PyUnicode_Append` it will never NULL it. +// It behaves like a regular function - returns a new reference and NULL on error + #if CYTHON_REFNANNY + #define __Pyx_PyUnicode_ConcatInPlace(left, right) __Pyx_PyUnicode_ConcatInPlaceImpl(&left, right, __pyx_refnanny) + #else + #define __Pyx_PyUnicode_ConcatInPlace(left, right) __Pyx_PyUnicode_ConcatInPlaceImpl(&left, right) + #endif + // __Pyx_PyUnicode_ConcatInPlace is slightly odd because it has the potential to modify the input + // argument (but only in cases where no user should notice). Therefore, it needs to keep Cython's + // refnanny informed. + static CYTHON_INLINE PyObject *__Pyx_PyUnicode_ConcatInPlaceImpl(PyObject **p_left, PyObject *right + #if CYTHON_REFNANNY + , void* __pyx_refnanny + #endif + ); /* proto */ +#else +#define __Pyx_PyUnicode_ConcatInPlace __Pyx_PyUnicode_Concat +#endif +#define __Pyx_PyUnicode_ConcatInPlaceSafe(left, right) ((unlikely((left) == Py_None) || unlikely((right) == Py_None)) ? \ + PyNumber_InPlaceAdd(left, right) : __Pyx_PyUnicode_ConcatInPlace(left, right)) + +/////////////// UnicodeConcatInPlace //////////////// + +# if CYTHON_COMPILING_IN_CPYTHON +// copied directly from unicode_object.c "unicode_modifiable +// removing _PyUnicode_HASH since it's a macro we don't have +// - this is OK because trying PyUnicode_Resize on a non-modifyable +// object will still work, it just won't happen in place +static int +__Pyx_unicode_modifiable(PyObject *unicode) +{ + if (Py_REFCNT(unicode) != 1) + return 0; + if (!PyUnicode_CheckExact(unicode)) + return 0; + if (PyUnicode_CHECK_INTERNED(unicode)) + return 0; + return 1; +} + +static CYTHON_INLINE PyObject *__Pyx_PyUnicode_ConcatInPlaceImpl(PyObject **p_left, PyObject *right + #if CYTHON_REFNANNY + , void* __pyx_refnanny + #endif + ) { + // heavily based on PyUnicode_Append + PyObject *left = *p_left; + Py_ssize_t left_len, right_len, new_len; + + if (unlikely(__Pyx_PyUnicode_READY(left) == -1)) + return NULL; + if (unlikely(__Pyx_PyUnicode_READY(right) == -1)) + return NULL; + + // Shortcuts + left_len = PyUnicode_GET_LENGTH(left); + if (left_len == 0) { + Py_INCREF(right); + return right; + } + right_len = PyUnicode_GET_LENGTH(right); + if (right_len == 0) { + Py_INCREF(left); + return left; + } + if (unlikely(left_len > PY_SSIZE_T_MAX - right_len)) { + PyErr_SetString(PyExc_OverflowError, + "strings are too large to concat"); + return NULL; + } + new_len = left_len + right_len; + + if (__Pyx_unicode_modifiable(left) + && PyUnicode_CheckExact(right) + && PyUnicode_KIND(right) <= PyUnicode_KIND(left) + // Don't resize for ascii += latin1. Convert ascii to latin1 requires + // to change the structure size, but characters are stored just after + // the structure, and so it requires to move all characters which is + // not so different than duplicating the string. + && !(PyUnicode_IS_ASCII(left) && !PyUnicode_IS_ASCII(right))) { + + int ret; + // GIVEREF/GOTREF since we expect *p_left to change (although it won't change on failures). + __Pyx_GIVEREF(*p_left); + ret = PyUnicode_Resize(p_left, new_len); + __Pyx_GOTREF(*p_left); + if (unlikely(ret != 0)) + return NULL; + + // copy 'right' into the newly allocated area of 'left' + #if PY_VERSION_HEX >= 0x030d0000 + if (unlikely(PyUnicode_CopyCharacters(*p_left, left_len, right, 0, right_len) < 0)) return NULL; + #else + _PyUnicode_FastCopyCharacters(*p_left, left_len, right, 0, right_len); + #endif + __Pyx_INCREF(*p_left); + __Pyx_GIVEREF(*p_left); + return *p_left; + } else { + return __Pyx_PyUnicode_Concat(left, right); + } + } +#endif + + +/////////////// PySequenceMultiply.proto /////////////// + +#define __Pyx_PySequence_Multiply_Left(mul, seq) __Pyx_PySequence_Multiply(seq, mul) +static CYTHON_INLINE PyObject* __Pyx_PySequence_Multiply(PyObject *seq, Py_ssize_t mul); + +/////////////// PySequenceMultiply /////////////// + +static PyObject* __Pyx_PySequence_Multiply_Generic(PyObject *seq, Py_ssize_t mul) { + PyObject *result, *pymul = PyLong_FromSsize_t(mul); + if (unlikely(!pymul)) + return NULL; + result = PyNumber_Multiply(seq, pymul); + Py_DECREF(pymul); + return result; +} + +static CYTHON_INLINE PyObject* __Pyx_PySequence_Multiply(PyObject *seq, Py_ssize_t mul) { +#if CYTHON_USE_TYPE_SLOTS + PyTypeObject *type = Py_TYPE(seq); + if (likely(type->tp_as_sequence && type->tp_as_sequence->sq_repeat)) { + return type->tp_as_sequence->sq_repeat(seq, mul); + } else +#endif + { + return __Pyx_PySequence_Multiply_Generic(seq, mul); + } +} + + +/////////////// FormatTypeName.proto /////////////// + +#if CYTHON_COMPILING_IN_LIMITED_API +typedef PyObject *__Pyx_TypeName; +#define __Pyx_FMT_TYPENAME "%U" +#define __Pyx_DECREF_TypeName(obj) Py_XDECREF(obj) + +#if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 +#define __Pyx_PyType_GetFullyQualifiedName PyType_GetFullyQualifiedName +#else +static __Pyx_TypeName __Pyx_PyType_GetFullyQualifiedName(PyTypeObject* tp); /*proto*/ +#endif +#else // !LIMITED_API +typedef const char *__Pyx_TypeName; +#define __Pyx_FMT_TYPENAME "%.200s" +#define __Pyx_PyType_GetFullyQualifiedName(tp) ((tp)->tp_name) +#define __Pyx_DECREF_TypeName(obj) +#endif + +/////////////// FormatTypeName /////////////// + +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030d0000 +static __Pyx_TypeName +__Pyx_PyType_GetFullyQualifiedName(PyTypeObject* tp) +{ + PyObject *module = NULL, *name = NULL, *result = NULL; + + #if __PYX_LIMITED_VERSION_HEX < 0x030b0000 + name = __Pyx_PyObject_GetAttrStr((PyObject *)tp, + PYIDENT("__qualname__")); + #else + name = PyType_GetQualName(tp); + #endif + if (unlikely(name == NULL) || unlikely(!PyUnicode_Check(name))) goto bad; + module = __Pyx_PyObject_GetAttrStr((PyObject *)tp, + PYIDENT("__module__")); + if (unlikely(module == NULL) || unlikely(!PyUnicode_Check(module))) goto bad; + + if (PyUnicode_CompareWithASCIIString(module, "builtins") == 0) { + result = name; + name = NULL; + goto done; + } + + result = PyUnicode_FromFormat("%U.%U", module, name); + if (unlikely(result == NULL)) goto bad; + + done: + Py_XDECREF(name); + Py_XDECREF(module); + return result; + + bad: + PyErr_Clear(); + if (name) { + // Use this as second-best fallback + result = name; + name = NULL; + } else { + result = __Pyx_NewRef(PYUNICODE("?")); + } + goto done; +} +#endif + + +/////////////// RaiseUnexpectedTypeError.proto /////////////// + +static int __Pyx_RaiseUnexpectedTypeError(const char *expected, PyObject *obj); /*proto*/ + +/////////////// RaiseUnexpectedTypeError /////////////// + +static int +__Pyx_RaiseUnexpectedTypeError(const char *expected, PyObject *obj) +{ + __Pyx_TypeName obj_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(obj)); + PyErr_Format(PyExc_TypeError, "Expected %s, got " __Pyx_FMT_TYPENAME, + expected, obj_type_name); + __Pyx_DECREF_TypeName(obj_type_name); + return 0; +} + + +/////////////// RaiseUnboundLocalError.proto /////////////// +static void __Pyx_RaiseUnboundLocalError(const char *varname);/*proto*/ + +/////////////// RaiseUnboundLocalError /////////////// +static void __Pyx_RaiseUnboundLocalError(const char *varname) { + PyErr_Format(PyExc_UnboundLocalError, "local variable '%s' referenced before assignment", varname); +} + +/////////////// RaiseUnboundLocalErrorNogil.proto /////////////// +static void __Pyx_RaiseUnboundLocalErrorNogil(const char *varname);/*proto*/ + +/////////////// RaiseUnboundLocalErrorNogil /////////////// +//@requires: RaiseUnboundLocalError + +// Don't inline the function, it should really never be called in production +static void __Pyx_RaiseUnboundLocalErrorNogil(const char *varname) { + PyGILState_STATE gilstate = PyGILState_Ensure(); + __Pyx_RaiseUnboundLocalError(varname); + PyGILState_Release(gilstate); +} + + +/////////////// RaiseClosureNameError.proto /////////////// +static void __Pyx_RaiseClosureNameError(const char *varname);/*proto*/ + +/////////////// RaiseClosureNameError /////////////// +static void __Pyx_RaiseClosureNameError(const char *varname) { + PyErr_Format(PyExc_NameError, "free variable '%s' referenced before assignment in enclosing scope", varname); +} + +/////////////// RaiseClosureNameErrorNogil.proto /////////////// +static void __Pyx_RaiseClosureNameErrorNogil(const char *varname);/*proto*/ + +/////////////// RaiseClosureNameErrorNogil /////////////// +//@requires: RaiseClosureNameError + +static void __Pyx_RaiseClosureNameErrorNogil(const char *varname) { + PyGILState_STATE gilstate = PyGILState_Ensure(); + __Pyx_RaiseClosureNameError(varname); + PyGILState_Release(gilstate); +} + +//////////////// RaiseCppGlobalNameError.proto /////////////////////// +static void __Pyx_RaiseCppGlobalNameError(const char *varname); /*proto*/ + +/////////////// RaiseCppGlobalNameError ////////////////////////////// +static void __Pyx_RaiseCppGlobalNameError(const char *varname) { + PyErr_Format(PyExc_NameError, "C++ global '%s' is not initialized", varname); +} + +//////////////// RaiseCppGlobalNameErrorNogil.proto /////////////////////// +static void __Pyx_RaiseCppGlobalNameErrorNogil(const char *varname); /*proto*/ + +/////////////// RaiseCppGlobalNameErrorNogil ////////////////////////////// +//@requires: RaiseCppGlobalNameError + +static void __Pyx_RaiseCppGlobalNameErrorNogil(const char *varname) { + PyGILState_STATE gilstate = PyGILState_Ensure(); + __Pyx_RaiseCppGlobalNameError(varname); + PyGILState_Release(gilstate); +} + +//////////////// RaiseCppAttributeError.proto /////////////////////// +static void __Pyx_RaiseCppAttributeError(const char *varname); /*proto*/ + +/////////////// RaiseCppAttributeError ////////////////////////////// +static void __Pyx_RaiseCppAttributeError(const char *varname) { + PyErr_Format(PyExc_AttributeError, "C++ attribute '%s' is not initialized", varname); +} + +//////////////// RaiseCppAttributeErrorNogil.proto /////////////////////// +static void __Pyx_RaiseCppAttributeErrorNogil(const char *varname); /*proto*/ + +/////////////// RaiseCppAttributeErrorNogil ////////////////////////////// +//@requires: RaiseCppGlobalNameError + +static void __Pyx_RaiseCppAttributeErrorNogil(const char *varname) { + PyGILState_STATE gilstate = PyGILState_Ensure(); + __Pyx_RaiseCppAttributeError(varname); + PyGILState_Release(gilstate); +} + +/////////////// ListPack.proto ////////////////////////////////////// + +// Equivalent to PyTuple_Pack for sections where we want to reduce the code size +static PyObject *__Pyx_PyList_Pack(Py_ssize_t n, ...); /* proto */ + +/////////////// ListPack ////////////////////////////////////// + +static PyObject *__Pyx_PyList_Pack(Py_ssize_t n, ...) { + va_list va; + PyObject *l = PyList_New(n); + va_start(va, n); + if (unlikely(!l)) goto end; + + for (Py_ssize_t i=0; iallocated > len) & likely(len > (L->allocated >> 1))) { + Py_INCREF(x); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 + // In Py3.13a1, PyList_SET_ITEM() checks that the end index is lower than the current size. + // However, extending the size *before* setting the value would not be correct, + // so we cannot call PyList_SET_ITEM(). + L->ob_item[len] = x; + #else + PyList_SET_ITEM(list, len, x); + #endif + __Pyx_SET_SIZE(list, len + 1); + return 0; + } + return PyList_Append(list, x); +} +#else +#define __Pyx_PyList_Append(L,x) PyList_Append(L,x) +#endif + +/////////////// ListCompAppend.proto /////////////// + +#if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS +static CYTHON_INLINE int __Pyx_ListComp_Append(PyObject* list, PyObject* x) { + PyListObject* L = (PyListObject*) list; + Py_ssize_t len = Py_SIZE(list); + if (likely(L->allocated > len)) { + Py_INCREF(x); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 + // In Py3.13a1, PyList_SET_ITEM() checks that the end index is lower than the current size. + // However, extending the size *before* setting the value would not be correct, + // so we cannot call PyList_SET_ITEM(). + L->ob_item[len] = x; + #else + PyList_SET_ITEM(list, len, x); + #endif + __Pyx_SET_SIZE(list, len + 1); + return 0; + } + return PyList_Append(list, x); +} +#else +#define __Pyx_ListComp_Append(L,x) PyList_Append(L,x) +#endif + +//////////////////// ListExtend.proto //////////////////// + +static CYTHON_INLINE int __Pyx_PyList_Extend(PyObject* L, PyObject* v) { +#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00a2 + return PyList_Extend(L, v); +#elif CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030d0000 + PyObject* none = _PyList_Extend((PyListObject*)L, v); + if (unlikely(!none)) + return -1; + Py_DECREF(none); + return 0; +#else + return PyList_SetSlice(L, PY_SSIZE_T_MAX, PY_SSIZE_T_MAX, v); +#endif +} + +/////////////// pop.proto /////////////// + +static CYTHON_INLINE PyObject* __Pyx__PyObject_Pop(PyObject* L); /*proto*/ + +#if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS && CYTHON_ASSUME_SAFE_SIZE +static CYTHON_INLINE PyObject* __Pyx_PyList_Pop(PyObject* L); /*proto*/ +#define __Pyx_PyObject_Pop(L) (likely(PyList_CheckExact(L)) ? \ + __Pyx_PyList_Pop(L) : __Pyx__PyObject_Pop(L)) + +#else +#define __Pyx_PyList_Pop(L) __Pyx__PyObject_Pop(L) +#define __Pyx_PyObject_Pop(L) __Pyx__PyObject_Pop(L) +#endif + +/////////////// pop /////////////// +//@requires: ObjectHandling.c::PyObjectCallMethod0 + +static CYTHON_INLINE PyObject* __Pyx__PyObject_Pop(PyObject* L) { + if (__Pyx_IS_TYPE(L, &PySet_Type)) { + return PySet_Pop(L); + } + return __Pyx_PyObject_CallMethod0(L, PYIDENT("pop")); +} + +#if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS && CYTHON_ASSUME_SAFE_SIZE +static CYTHON_INLINE PyObject* __Pyx_PyList_Pop(PyObject* L) { + /* Check that both the size is positive and no reallocation shrinking needs to be done. */ + if (likely(PyList_GET_SIZE(L) > (((PyListObject*)L)->allocated >> 1))) { + __Pyx_SET_SIZE(L, Py_SIZE(L) - 1); + return PyList_GET_ITEM(L, PyList_GET_SIZE(L)); + } + return CALL_UNBOUND_METHOD(PyList_Type, "pop", L); +} +#endif + + +/////////////// pop_index.proto /////////////// + +static PyObject* __Pyx__PyObject_PopNewIndex(PyObject* L, PyObject* py_ix); /*proto*/ +static PyObject* __Pyx__PyObject_PopIndex(PyObject* L, PyObject* py_ix); /*proto*/ + +#if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS && CYTHON_ASSUME_SAFE_SIZE +static PyObject* __Pyx__PyList_PopIndex(PyObject* L, PyObject* py_ix, Py_ssize_t ix); /*proto*/ + +#define __Pyx_PyObject_PopIndex(L, py_ix, ix, is_signed, type, to_py_func) ( \ + (likely(PyList_CheckExact(L) && __Pyx_fits_Py_ssize_t(ix, type, is_signed))) ? \ + __Pyx__PyList_PopIndex(L, py_ix, ix) : ( \ + (unlikely((py_ix) == Py_None)) ? __Pyx__PyObject_PopNewIndex(L, to_py_func(ix)) : \ + __Pyx__PyObject_PopIndex(L, py_ix))) + +#define __Pyx_PyList_PopIndex(L, py_ix, ix, is_signed, type, to_py_func) ( \ + __Pyx_fits_Py_ssize_t(ix, type, is_signed) ? \ + __Pyx__PyList_PopIndex(L, py_ix, ix) : ( \ + (unlikely((py_ix) == Py_None)) ? __Pyx__PyObject_PopNewIndex(L, to_py_func(ix)) : \ + __Pyx__PyObject_PopIndex(L, py_ix))) + +#else + +#define __Pyx_PyList_PopIndex(L, py_ix, ix, is_signed, type, to_py_func) \ + __Pyx_PyObject_PopIndex(L, py_ix, ix, is_signed, type, to_py_func) + +#define __Pyx_PyObject_PopIndex(L, py_ix, ix, is_signed, type, to_py_func) ( \ + (unlikely((py_ix) == Py_None)) ? __Pyx__PyObject_PopNewIndex(L, to_py_func(ix)) : \ + __Pyx__PyObject_PopIndex(L, py_ix)) +#endif + +/////////////// pop_index /////////////// +//@requires: ObjectHandling.c::PyObjectCallMethod1 + +static PyObject* __Pyx__PyObject_PopNewIndex(PyObject* L, PyObject* py_ix) { + PyObject *r; + if (unlikely(!py_ix)) return NULL; + r = __Pyx__PyObject_PopIndex(L, py_ix); + Py_DECREF(py_ix); + return r; +} + +static PyObject* __Pyx__PyObject_PopIndex(PyObject* L, PyObject* py_ix) { + return __Pyx_PyObject_CallMethod1(L, PYIDENT("pop"), py_ix); +} + +#if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS && CYTHON_ASSUME_SAFE_SIZE +static PyObject* __Pyx__PyList_PopIndex(PyObject* L, PyObject* py_ix, Py_ssize_t ix) { + Py_ssize_t size = PyList_GET_SIZE(L); + if (likely(size > (((PyListObject*)L)->allocated >> 1))) { + Py_ssize_t cix = ix; + if (cix < 0) { + cix += size; + } + if (likely(__Pyx_is_valid_index(cix, size))) { + PyObject* v = PyList_GET_ITEM(L, cix); + __Pyx_SET_SIZE(L, Py_SIZE(L) - 1); + size -= 1; + memmove(&PyList_GET_ITEM(L, cix), &PyList_GET_ITEM(L, cix+1), (size_t)(size-cix)*sizeof(PyObject*)); + return v; + } + } + if (py_ix == Py_None) { + return __Pyx__PyObject_PopNewIndex(L, PyLong_FromSsize_t(ix)); + } else { + return __Pyx__PyObject_PopIndex(L, py_ix); + } +} +#endif + + +/////////////// dict_getitem_default.proto /////////////// + +static PyObject* __Pyx_PyDict_GetItemDefault(PyObject* d, PyObject* key, PyObject* default_value); /*proto*/ + +/////////////// dict_getitem_default /////////////// + +static PyObject* __Pyx_PyDict_GetItemDefault(PyObject* d, PyObject* key, PyObject* default_value) { + PyObject* value; +#if !CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07020000 + value = PyDict_GetItemWithError(d, key); + if (unlikely(!value)) { + if (unlikely(PyErr_Occurred())) + return NULL; + value = default_value; + } + Py_INCREF(value); + // avoid C compiler warning about unused utility functions + if ((1)); +#else + if (PyBytes_CheckExact(key) || PyUnicode_CheckExact(key) || PyLong_CheckExact(key)) { + /* these presumably have safe hash functions */ + value = PyDict_GetItem(d, key); + if (unlikely(!value)) { + value = default_value; + } + Py_INCREF(value); + } +#endif + else { + if (default_value == Py_None) + value = CALL_UNBOUND_METHOD(PyDict_Type, "get", d, key); + else + value = CALL_UNBOUND_METHOD(PyDict_Type, "get", d, key, default_value); + } + return value; +} + + +/////////////// dict_setdefault.proto /////////////// + +static CYTHON_INLINE PyObject *__Pyx_PyDict_SetDefault(PyObject *d, PyObject *key, PyObject *default_value, int is_safe_type); /*proto*/ + +/////////////// dict_setdefault /////////////// + +static CYTHON_INLINE PyObject *__Pyx_PyDict_SetDefault(PyObject *d, PyObject *key, PyObject *default_value, + int is_safe_type) { + PyObject* value; + CYTHON_MAYBE_UNUSED_VAR(is_safe_type); +#if CYTHON_COMPILING_IN_LIMITED_API + value = PyObject_CallMethod(d, "setdefault", "OO", key, default_value); +#elif PY_VERSION_HEX >= 0x030d0000 + PyDict_SetDefaultRef(d, key, default_value, &value); +#else + value = PyDict_SetDefault(d, key, default_value); + if (unlikely(!value)) return NULL; + Py_INCREF(value); +#endif + return value; +} + + +/////////////// py_dict_clear.proto /////////////// + +#define __Pyx_PyDict_Clear(d) (PyDict_Clear(d), 0) + + +/////////////// py_dict_pop.proto /////////////// + +static CYTHON_INLINE PyObject *__Pyx_PyDict_Pop(PyObject *d, PyObject *key, PyObject *default_value); /*proto*/ + +/////////////// py_dict_pop /////////////// + +static CYTHON_INLINE PyObject *__Pyx_PyDict_Pop(PyObject *d, PyObject *key, PyObject *default_value) { +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d00A2 || defined(PyDict_Pop) + PyObject *value; + if (PyDict_Pop(d, key, &value) == 0) { + if (default_value) { + Py_INCREF(default_value); + } else { + PyErr_SetObject(PyExc_KeyError, key); + } + value = default_value; + } + // On error, PyDict_Pop() returns -1 and sets value to NULL (our own exception return value). + return value; +#elif CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030d0000 + return _PyDict_Pop(d, key, default_value); +#else + if (default_value) { + return CALL_UNBOUND_METHOD(PyDict_Type, "pop", d, key, default_value); + } else { + return CALL_UNBOUND_METHOD(PyDict_Type, "pop", d, key); + } +#endif +} + + +/////////////// py_dict_pop_ignore.proto /////////////// + +static CYTHON_INLINE int __Pyx_PyDict_Pop_ignore(PyObject *d, PyObject *key, PyObject *default_value); /*proto*/ + +/////////////// py_dict_pop_ignore /////////////// + +static CYTHON_INLINE int __Pyx_PyDict_Pop_ignore(PyObject *d, PyObject *key, PyObject *default_value) { + // We take the "default_value" as argument to avoid "unused" warnings, but we ignore it here. +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d00A2 || defined(PyDict_Pop) + int result = PyDict_Pop(d, key, NULL); + CYTHON_UNUSED_VAR(default_value); + return (unlikely(result == -1)) ? -1 : 0; +#else + PyObject *value; + CYTHON_UNUSED_VAR(default_value); + + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030d0000 + value = _PyDict_Pop(d, key, Py_None); + #else + value = CALL_UNBOUND_METHOD(PyDict_Type, "pop", d, key, Py_None); + #endif + + if (unlikely(value == NULL)) + return -1; + Py_DECREF(value); + return 0; +#endif +} + + +/////////////// dict_iter.proto /////////////// + +static CYTHON_INLINE PyObject* __Pyx_dict_iterator(PyObject* dict, int is_dict, PyObject* method_name, + Py_ssize_t* p_orig_length, int* p_is_dict); +static CYTHON_INLINE int __Pyx_dict_iter_next(PyObject* dict_or_iter, Py_ssize_t orig_length, Py_ssize_t* ppos, + PyObject** pkey, PyObject** pvalue, PyObject** pitem, int is_dict); + +/////////////// dict_iter /////////////// +//@requires: ObjectHandling.c::UnpackTuple2 +//@requires: ObjectHandling.c::IterFinish +//@requires: ObjectHandling.c::PyObjectCallMethod0 + +#if CYTHON_COMPILING_IN_PYPY +#include +#endif + +static CYTHON_INLINE PyObject* __Pyx_dict_iterator(PyObject* iterable, int is_dict, PyObject* method_name, + Py_ssize_t* p_orig_length, int* p_source_is_dict) { + is_dict = is_dict || likely(PyDict_CheckExact(iterable)); + *p_source_is_dict = is_dict; + if (is_dict) { +#if !CYTHON_COMPILING_IN_PYPY + *p_orig_length = PyDict_Size(iterable); + Py_INCREF(iterable); + return iterable; +#else + // On PyPy3, we need to translate manually a few method names. + // This logic is not needed on CPython thanks to the fast case above. + static PyObject *py_items = NULL, *py_keys = NULL, *py_values = NULL; + PyObject **pp = NULL; + if (method_name) { + const char *name = PyUnicode_AsUTF8(method_name); + if (strcmp(name, "iteritems") == 0) pp = &py_items; + else if (strcmp(name, "iterkeys") == 0) pp = &py_keys; + else if (strcmp(name, "itervalues") == 0) pp = &py_values; + if (pp) { + if (!*pp) { + *pp = PyUnicode_FromString(name + 4); + if (!*pp) + return NULL; + } + method_name = *pp; + } + } +#endif + } + *p_orig_length = 0; + if (method_name) { + PyObject* iter; + iterable = __Pyx_PyObject_CallMethod0(iterable, method_name); + if (!iterable) + return NULL; +#if !CYTHON_COMPILING_IN_PYPY + if (PyTuple_CheckExact(iterable) || PyList_CheckExact(iterable)) + return iterable; +#endif + iter = PyObject_GetIter(iterable); + Py_DECREF(iterable); + return iter; + } + return PyObject_GetIter(iterable); +} + + +#if !CYTHON_COMPILING_IN_PYPY +static CYTHON_INLINE int __Pyx_dict_iter_next_source_is_dict( + PyObject* iter_obj, CYTHON_NCP_UNUSED Py_ssize_t orig_length, CYTHON_NCP_UNUSED Py_ssize_t* ppos, + PyObject** pkey, PyObject** pvalue, PyObject** pitem) { + PyObject *key, *value; + if (unlikely(orig_length != PyDict_Size(iter_obj))) { + PyErr_SetString(PyExc_RuntimeError, "dictionary changed size during iteration"); + return -1; + } + if (unlikely(!PyDict_Next(iter_obj, ppos, &key, &value))) { + return 0; + } + if (pitem) { + PyObject* tuple = PyTuple_New(2); + if (unlikely(!tuple)) { + return -1; + } + Py_INCREF(key); + Py_INCREF(value); + #if CYTHON_ASSUME_SAFE_MACROS + PyTuple_SET_ITEM(tuple, 0, key); + PyTuple_SET_ITEM(tuple, 1, value); + #else + if (unlikely(PyTuple_SetItem(tuple, 0, key) < 0)) { + // decref value; PyTuple_SetItem decrefs key on failure + Py_DECREF(value); + Py_DECREF(tuple); + return -1; + } + if (unlikely(PyTuple_SetItem(tuple, 1, value) < 0)) { + // PyTuple_SetItem decrefs value on failure + Py_DECREF(tuple); + return -1; + } + #endif + *pitem = tuple; + } else { + if (pkey) { + Py_INCREF(key); + *pkey = key; + } + if (pvalue) { + Py_INCREF(value); + *pvalue = value; + } + } + return 1; +} +#endif + +static CYTHON_INLINE int __Pyx_dict_iter_next( + PyObject* iter_obj, CYTHON_NCP_UNUSED Py_ssize_t orig_length, CYTHON_NCP_UNUSED Py_ssize_t* ppos, + PyObject** pkey, PyObject** pvalue, PyObject** pitem, int source_is_dict) { + PyObject* next_item; +#if !CYTHON_COMPILING_IN_PYPY + if (source_is_dict) { + int result; +#if PY_VERSION_HEX >= 0x030d0000 && !CYTHON_COMPILING_IN_LIMITED_API + Py_BEGIN_CRITICAL_SECTION(iter_obj); +#endif + result = __Pyx_dict_iter_next_source_is_dict(iter_obj, orig_length, ppos, pkey, pvalue, pitem); +#if PY_VERSION_HEX >= 0x030d0000 && !CYTHON_COMPILING_IN_LIMITED_API + Py_END_CRITICAL_SECTION(); +#endif + return result; + } else if (PyTuple_CheckExact(iter_obj)) { + Py_ssize_t pos = *ppos; + Py_ssize_t tuple_size = __Pyx_PyTuple_GET_SIZE(iter_obj); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(tuple_size < 0)) return -1; + #endif + if (unlikely(pos >= tuple_size)) return 0; + *ppos = pos + 1; + #if CYTHON_ASSUME_SAFE_MACROS + next_item = PyTuple_GET_ITEM(iter_obj, pos); + #else + next_item = PyTuple_GetItem(iter_obj, pos); + if (unlikely(!next_item)) return -1; + #endif + Py_INCREF(next_item); + } else if (PyList_CheckExact(iter_obj)) { + Py_ssize_t pos = *ppos; + Py_ssize_t list_size = __Pyx_PyList_GET_SIZE(iter_obj); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(list_size < 0)) return -1; + #endif + if (unlikely(pos >= list_size)) return 0; + *ppos = pos + 1; + #if CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS + next_item = PyList_GetItemRef(iter_obj, pos); + if (unlikely(!next_item)) return -1; + #elif CYTHON_ASSUME_SAFE_MACROS + next_item = PyList_GET_ITEM(iter_obj, pos); + Py_INCREF(next_item); + #else + next_item = PyList_GetItem(iter_obj, pos); + if (unlikely(!next_item)) return -1; + Py_INCREF(next_item); + #endif + } else +#endif + { + next_item = PyIter_Next(iter_obj); + if (unlikely(!next_item)) { + return __Pyx_IterFinish(); + } + } + if (pitem) { + *pitem = next_item; + } else if (pkey && pvalue) { + if (__Pyx_unpack_tuple2(next_item, pkey, pvalue, source_is_dict, source_is_dict, 1)) + return -1; + } else if (pkey) { + *pkey = next_item; + } else { + *pvalue = next_item; + } + return 1; +} + + +/////////////// set_iter.proto /////////////// + +static CYTHON_INLINE PyObject* __Pyx_set_iterator(PyObject* iterable, int is_set, + Py_ssize_t* p_orig_length, int* p_source_is_set); /*proto*/ +static CYTHON_INLINE int __Pyx_set_iter_next( + PyObject* iter_obj, Py_ssize_t orig_length, + Py_ssize_t* ppos, PyObject **value, + int source_is_set); /*proto*/ + +/////////////// set_iter /////////////// +//@requires: ObjectHandling.c::IterFinish + +static CYTHON_INLINE PyObject* __Pyx_set_iterator(PyObject* iterable, int is_set, + Py_ssize_t* p_orig_length, int* p_source_is_set) { +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030d0000 + is_set = is_set || likely(PySet_CheckExact(iterable) || PyFrozenSet_CheckExact(iterable)); + *p_source_is_set = is_set; + if (likely(is_set)) { + *p_orig_length = PySet_Size(iterable); + Py_INCREF(iterable); + return iterable; + } +#else + CYTHON_UNUSED_VAR(is_set); + *p_source_is_set = 0; +#endif + *p_orig_length = 0; + return PyObject_GetIter(iterable); +} + +static CYTHON_INLINE int __Pyx_set_iter_next( + PyObject* iter_obj, Py_ssize_t orig_length, + Py_ssize_t* ppos, PyObject **value, + int source_is_set) { + if (!CYTHON_COMPILING_IN_CPYTHON || PY_VERSION_HEX >= 0x030d0000 || unlikely(!source_is_set)) { + *value = PyIter_Next(iter_obj); + if (unlikely(!*value)) { + return __Pyx_IterFinish(); + } + CYTHON_UNUSED_VAR(orig_length); + CYTHON_UNUSED_VAR(ppos); + return 1; + } +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030d0000 + if (unlikely(PySet_GET_SIZE(iter_obj) != orig_length)) { + PyErr_SetString( + PyExc_RuntimeError, + "set changed size during iteration"); + return -1; + } + { + Py_hash_t hash; + int ret = _PySet_NextEntry(iter_obj, ppos, value, &hash); + // CPython does not raise errors here, only if !isinstance(iter_obj, set/frozenset) + assert (ret != -1); + if (likely(ret)) { + Py_INCREF(*value); + return 1; + } + } +#endif + return 0; +} + +/////////////// py_set_discard_unhashable /////////////// +//@requires: Builtins.c::pyfrozenset_new + +static int __Pyx_PySet_DiscardUnhashable(PyObject *set, PyObject *key) { + PyObject *tmpkey; + int rv; + + if (likely(!PySet_Check(key) || !PyErr_ExceptionMatches(PyExc_TypeError))) + return -1; + PyErr_Clear(); + tmpkey = __Pyx_PyFrozenSet_New(key); + if (tmpkey == NULL) + return -1; + rv = PySet_Discard(set, tmpkey); + Py_DECREF(tmpkey); + return rv; +} + + +/////////////// py_set_discard.proto /////////////// + +static CYTHON_INLINE int __Pyx_PySet_Discard(PyObject *set, PyObject *key); /*proto*/ + +/////////////// py_set_discard /////////////// +//@requires: py_set_discard_unhashable + +static CYTHON_INLINE int __Pyx_PySet_Discard(PyObject *set, PyObject *key) { + int found = PySet_Discard(set, key); + // Convert *key* to frozenset if necessary + if (unlikely(found < 0)) { + found = __Pyx_PySet_DiscardUnhashable(set, key); + } + // note: returns -1 on error, 0 (not found) or 1 (found) otherwise => error check for -1 or < 0 works + return found; +} + + +/////////////// py_set_remove.proto /////////////// + +static CYTHON_INLINE int __Pyx_PySet_Remove(PyObject *set, PyObject *key); /*proto*/ + +/////////////// py_set_remove /////////////// +//@requires: py_set_discard_unhashable + +static int __Pyx_PySet_RemoveNotFound(PyObject *set, PyObject *key, int found) { + // Convert *key* to frozenset if necessary + if (unlikely(found < 0)) { + found = __Pyx_PySet_DiscardUnhashable(set, key); + } + if (likely(found == 0)) { + // Not found + PyObject *tup; + tup = PyTuple_Pack(1, key); + if (!tup) + return -1; + PyErr_SetObject(PyExc_KeyError, tup); + Py_DECREF(tup); + return -1; + } + // note: returns -1 on error, 0 (not found) or 1 (found) otherwise => error check for -1 or < 0 works + return found; +} + +static CYTHON_INLINE int __Pyx_PySet_Remove(PyObject *set, PyObject *key) { + int found = PySet_Discard(set, key); + if (unlikely(found != 1)) { + // note: returns -1 on error, 0 (not found) or 1 (found) otherwise => error check for -1 or < 0 works + return __Pyx_PySet_RemoveNotFound(set, key, found); + } + return 0; +} + + +/////////////// unicode_iter.proto /////////////// + +static CYTHON_INLINE int __Pyx_init_unicode_iteration( + PyObject* ustring, Py_ssize_t *length, void** data, int *kind); /* proto */ + +/////////////// unicode_iter /////////////// + +static CYTHON_INLINE int __Pyx_init_unicode_iteration( + PyObject* ustring, Py_ssize_t *length, void** data, int *kind) { +#if CYTHON_COMPILING_IN_LIMITED_API + // In the limited API we just point data to the unicode object + *kind = 0; + *length = PyUnicode_GetLength(ustring); + *data = (void*)ustring; +#else + if (unlikely(__Pyx_PyUnicode_READY(ustring) < 0)) return -1; + *kind = PyUnicode_KIND(ustring); + *length = PyUnicode_GET_LENGTH(ustring); + *data = PyUnicode_DATA(ustring); +#endif + return 0; +} + +/////////////// pyobject_as_double.proto /////////////// + +static double __Pyx__PyObject_AsDouble(PyObject* obj); /* proto */ + +#if CYTHON_COMPILING_IN_PYPY +#define __Pyx_PyObject_AsDouble(obj) \ +(likely(PyFloat_CheckExact(obj)) ? PyFloat_AS_DOUBLE(obj) : \ + likely(PyLong_CheckExact(obj)) ? \ + PyFloat_AsDouble(obj) : __Pyx__PyObject_AsDouble(obj)) +#else +#define __Pyx_PyObject_AsDouble(obj) \ +((likely(PyFloat_CheckExact(obj))) ? __Pyx_PyFloat_AS_DOUBLE(obj) : \ + likely(PyLong_CheckExact(obj)) ? \ + PyLong_AsDouble(obj) : __Pyx__PyObject_AsDouble(obj)) +#endif + +/////////////// pyobject_as_double /////////////// +//@requires: pybytes_as_double +//@requires: pyunicode_as_double +//@requires: ObjectHandling.c::PyObjectCallOneArg + +static double __Pyx__PyObject_AsDouble(PyObject* obj) { + if (PyUnicode_CheckExact(obj)) { + return __Pyx_PyUnicode_AsDouble(obj); + } else if (PyBytes_CheckExact(obj)) { + return __Pyx_PyBytes_AsDouble(obj); + } else if (PyByteArray_CheckExact(obj)) { + return __Pyx_PyByteArray_AsDouble(obj); + } else { + PyObject* float_value; +#if !CYTHON_USE_TYPE_SLOTS + float_value = PyNumber_Float(obj); if ((0)) goto bad; + // avoid "unused" warnings + (void)__Pyx_PyObject_CallOneArg; +#else + PyNumberMethods *nb = Py_TYPE(obj)->tp_as_number; + if (likely(nb) && likely(nb->nb_float)) { + float_value = nb->nb_float(obj); + if (likely(float_value) && unlikely(!PyFloat_Check(float_value))) { + __Pyx_TypeName float_value_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(float_value)); + PyErr_Format(PyExc_TypeError, + "__float__ returned non-float (type " __Pyx_FMT_TYPENAME ")", + float_value_type_name); + __Pyx_DECREF_TypeName(float_value_type_name); + Py_DECREF(float_value); + goto bad; + } + } else { + float_value = __Pyx_PyObject_CallOneArg((PyObject*)&PyFloat_Type, obj); + } +#endif + if (likely(float_value)) { + double value = __Pyx_PyFloat_AS_DOUBLE(float_value); + Py_DECREF(float_value); + return value; + } + } +bad: + return (double)-1; +} + + +/////////////// pyunicode_as_double.proto /////////////// + +static CYTHON_INLINE double __Pyx_PyUnicode_AsDouble(PyObject *obj);/*proto*/ + +/////////////// pyunicode_as_double.proto /////////////// +//@requires: pybytes_as_double + +#if !CYTHON_COMPILING_IN_PYPY && CYTHON_ASSUME_SAFE_MACROS +static const char* __Pyx__PyUnicode_AsDouble_Copy(const void* data, const int kind, char* buffer, Py_ssize_t start, Py_ssize_t end) { + int last_was_punctuation; + Py_ssize_t i; + // number must not start with punctuation + last_was_punctuation = 1; + for (i=start; i <= end; i++) { + Py_UCS4 chr = PyUnicode_READ(kind, data, i); + int is_punctuation = (chr == '_') | (chr == '.'); + *buffer = (char)chr; + // reject sequences of '_' and '.' + buffer += (chr != '_'); + if (unlikely(chr > 127)) goto parse_failure; + if (unlikely(last_was_punctuation & is_punctuation)) goto parse_failure; + last_was_punctuation = is_punctuation; + } + if (unlikely(last_was_punctuation)) goto parse_failure; + *buffer = '\0'; + return buffer; + +parse_failure: + return NULL; +} + +static double __Pyx__PyUnicode_AsDouble_inf_nan(const void* data, int kind, Py_ssize_t start, Py_ssize_t length) { + int matches = 1; + Py_UCS4 chr; + Py_UCS4 sign = PyUnicode_READ(kind, data, start); + int is_signed = (sign == '-') | (sign == '+'); + start += is_signed; + length -= is_signed; + + switch (PyUnicode_READ(kind, data, start)) { + #ifdef Py_NAN + case 'n': + case 'N': + if (unlikely(length != 3)) goto parse_failure; + chr = PyUnicode_READ(kind, data, start+1); + matches &= (chr == 'a') | (chr == 'A'); + chr = PyUnicode_READ(kind, data, start+2); + matches &= (chr == 'n') | (chr == 'N'); + if (unlikely(!matches)) goto parse_failure; + return (sign == '-') ? -Py_NAN : Py_NAN; + #endif + case 'i': + case 'I': + if (unlikely(length < 3)) goto parse_failure; + chr = PyUnicode_READ(kind, data, start+1); + matches &= (chr == 'n') | (chr == 'N'); + chr = PyUnicode_READ(kind, data, start+2); + matches &= (chr == 'f') | (chr == 'F'); + if (likely(length == 3 && matches)) + return (sign == '-') ? -Py_HUGE_VAL : Py_HUGE_VAL; + if (unlikely(length != 8)) goto parse_failure; + chr = PyUnicode_READ(kind, data, start+3); + matches &= (chr == 'i') | (chr == 'I'); + chr = PyUnicode_READ(kind, data, start+4); + matches &= (chr == 'n') | (chr == 'N'); + chr = PyUnicode_READ(kind, data, start+5); + matches &= (chr == 'i') | (chr == 'I'); + chr = PyUnicode_READ(kind, data, start+6); + matches &= (chr == 't') | (chr == 'T'); + chr = PyUnicode_READ(kind, data, start+7); + matches &= (chr == 'y') | (chr == 'Y'); + if (unlikely(!matches)) goto parse_failure; + return (sign == '-') ? -Py_HUGE_VAL : Py_HUGE_VAL; + case '.': case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': + break; + default: + goto parse_failure; + } + return 0.0; +parse_failure: + return -1.0; +} + +static double __Pyx_PyUnicode_AsDouble_WithSpaces(PyObject *obj) { + double value; + const char *last; + char *end; + Py_ssize_t start, length = PyUnicode_GET_LENGTH(obj); + const int kind = PyUnicode_KIND(obj); + const void* data = PyUnicode_DATA(obj); + + // strip spaces at start and end + start = 0; + while (Py_UNICODE_ISSPACE(PyUnicode_READ(kind, data, start))) + start++; + while (start < length - 1 && Py_UNICODE_ISSPACE(PyUnicode_READ(kind, data, length - 1))) + length--; + length -= start; + if (unlikely(length <= 0)) goto fallback; + + // parse NaN / inf + value = __Pyx__PyUnicode_AsDouble_inf_nan(data, kind, start, length); + if (unlikely(value == -1.0)) goto fallback; + if (value != 0.0) return value; + + if (length < 40) { + char number[40]; + last = __Pyx__PyUnicode_AsDouble_Copy(data, kind, number, start, start + length); + if (unlikely(!last)) goto fallback; + value = PyOS_string_to_double(number, &end, NULL); + } else { + char *number = (char*) PyMem_Malloc((length + 1) * sizeof(char)); + if (unlikely(!number)) goto fallback; + last = __Pyx__PyUnicode_AsDouble_Copy(data, kind, number, start, start + length); + if (unlikely(!last)) { + PyMem_Free(number); + goto fallback; + } + value = PyOS_string_to_double(number, &end, NULL); + PyMem_Free(number); + } + if (likely(end == last) || (value == (double)-1 && PyErr_Occurred())) { + return value; + } +fallback: + return __Pyx_SlowPyString_AsDouble(obj); +} +#endif + +static CYTHON_INLINE double __Pyx_PyUnicode_AsDouble(PyObject *obj) { + // Currently not optimised for Py2.7. +#if !CYTHON_COMPILING_IN_PYPY && CYTHON_ASSUME_SAFE_MACROS + if (unlikely(__Pyx_PyUnicode_READY(obj) == -1)) + return (double)-1; + if (likely(PyUnicode_IS_ASCII(obj))) { + const char *s; + Py_ssize_t length; + s = PyUnicode_AsUTF8AndSize(obj, &length); + return __Pyx__PyBytes_AsDouble(obj, s, length); + } + return __Pyx_PyUnicode_AsDouble_WithSpaces(obj); +#else + return __Pyx_SlowPyString_AsDouble(obj); +#endif +} + + +/////////////// pybytes_as_double.proto /////////////// + +static double __Pyx_SlowPyString_AsDouble(PyObject *obj);/*proto*/ +static double __Pyx__PyBytes_AsDouble(PyObject *obj, const char* start, Py_ssize_t length);/*proto*/ + +static CYTHON_INLINE double __Pyx_PyBytes_AsDouble(PyObject *obj) { + char* as_c_string; + Py_ssize_t size; +#if CYTHON_ASSUME_SAFE_MACROS && CYTHON_ASSUME_SAFE_SIZE + as_c_string = PyBytes_AS_STRING(obj); + size = PyBytes_GET_SIZE(obj); +#else + if (PyBytes_AsStringAndSize(obj, &as_c_string, &size) < 0) { + return (double)-1; + } +#endif + return __Pyx__PyBytes_AsDouble(obj, as_c_string, size); +} +static CYTHON_INLINE double __Pyx_PyByteArray_AsDouble(PyObject *obj) { + char* as_c_string; + Py_ssize_t size; +#if CYTHON_ASSUME_SAFE_MACROS && CYTHON_ASSUME_SAFE_SIZE + as_c_string = PyByteArray_AS_STRING(obj); + size = PyByteArray_GET_SIZE(obj); +#else + as_c_string = PyByteArray_AsString(obj); + if (as_c_string == NULL) { + return (double)-1; + } + size = PyByteArray_Size(obj); +#endif + return __Pyx__PyBytes_AsDouble(obj, as_c_string, size); +} + + +/////////////// pybytes_as_double /////////////// + +static double __Pyx_SlowPyString_AsDouble(PyObject *obj) { + PyObject *float_value = PyFloat_FromString(obj); + if (likely(float_value)) { + double value = __Pyx_PyFloat_AS_DOUBLE(float_value); + Py_DECREF(float_value); + return value; + } + return (double)-1; +} + +static const char* __Pyx__PyBytes_AsDouble_Copy(const char* start, char* buffer, Py_ssize_t length) { + // number must not start with punctuation + int last_was_punctuation = 1; + int parse_error_found = 0; + Py_ssize_t i; + for (i=0; i < length; i++) { + char chr = start[i]; + int is_punctuation = (chr == '_') | (chr == '.') | (chr == 'e') | (chr == 'E'); + *buffer = chr; + buffer += (chr != '_'); + // reject sequences of punctuation, e.g. '_.' + parse_error_found |= last_was_punctuation & is_punctuation; + last_was_punctuation = is_punctuation; + } + // number must not end with punctuation + parse_error_found |= last_was_punctuation; + *buffer = '\0'; + return unlikely(parse_error_found) ? NULL : buffer; +} + +static double __Pyx__PyBytes_AsDouble_inf_nan(const char* start, Py_ssize_t length) { + int matches = 1; + char sign = start[0]; + int is_signed = (sign == '+') | (sign == '-'); + start += is_signed; + length -= is_signed; + + switch (start[0]) { + #ifdef Py_NAN + case 'n': + case 'N': + if (unlikely(length != 3)) goto parse_failure; + matches &= (start[1] == 'a' || start[1] == 'A'); + matches &= (start[2] == 'n' || start[2] == 'N'); + if (unlikely(!matches)) goto parse_failure; + return (sign == '-') ? -Py_NAN : Py_NAN; + #endif + case 'i': + case 'I': + if (unlikely(length < 3)) goto parse_failure; + matches &= (start[1] == 'n' || start[1] == 'N'); + matches &= (start[2] == 'f' || start[2] == 'F'); + if (likely(length == 3 && matches)) + return (sign == '-') ? -Py_HUGE_VAL : Py_HUGE_VAL; + if (unlikely(length != 8)) goto parse_failure; + matches &= (start[3] == 'i' || start[3] == 'I'); + matches &= (start[4] == 'n' || start[4] == 'N'); + matches &= (start[5] == 'i' || start[5] == 'I'); + matches &= (start[6] == 't' || start[6] == 'T'); + matches &= (start[7] == 'y' || start[7] == 'Y'); + if (unlikely(!matches)) goto parse_failure; + return (sign == '-') ? -Py_HUGE_VAL : Py_HUGE_VAL; + case '.': case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': + break; + default: + goto parse_failure; + } + return 0.0; +parse_failure: + return -1.0; +} + +static CYTHON_INLINE int __Pyx__PyBytes_AsDouble_IsSpace(char ch) { + // see Py_ISSPACE() in CPython + // https://github.com/python/cpython/blob/master/Python/pyctype.c + return (ch == 0x20) | !((ch < 0x9) | (ch > 0xd)); +} + +CYTHON_UNUSED static double __Pyx__PyBytes_AsDouble(PyObject *obj, const char* start, Py_ssize_t length) { + double value; + Py_ssize_t i, digits; + const char *last = start + length; + char *end; + + // strip spaces at start and end + while (__Pyx__PyBytes_AsDouble_IsSpace(*start)) + start++; + while (start < last - 1 && __Pyx__PyBytes_AsDouble_IsSpace(last[-1])) + last--; + length = last - start; + if (unlikely(length <= 0)) goto fallback; + + // parse NaN / inf + value = __Pyx__PyBytes_AsDouble_inf_nan(start, length); + if (unlikely(value == -1.0)) goto fallback; + if (value != 0.0) return value; + + // look for underscores + digits = 0; + for (i=0; i < length; digits += start[i++] != '_'); + + if (likely(digits == length)) { + value = PyOS_string_to_double(start, &end, NULL); + } else if (digits < 40) { + char number[40]; + last = __Pyx__PyBytes_AsDouble_Copy(start, number, length); + if (unlikely(!last)) goto fallback; + value = PyOS_string_to_double(number, &end, NULL); + } else { + char *number = (char*) PyMem_Malloc((digits + 1) * sizeof(char)); + if (unlikely(!number)) goto fallback; + last = __Pyx__PyBytes_AsDouble_Copy(start, number, length); + if (unlikely(!last)) { + PyMem_Free(number); + goto fallback; + } + value = PyOS_string_to_double(number, &end, NULL); + PyMem_Free(number); + } + if (likely(end == last) || (value == (double)-1 && PyErr_Occurred())) { + return value; + } +fallback: + return __Pyx_SlowPyString_AsDouble(obj); +} + + +/////////////// PyNumberPow2.proto /////////////// + +#define __Pyx_PyNumber_InPlacePowerOf2(a, b, c) __Pyx__PyNumber_PowerOf2(a, b, c, 1) +#define __Pyx_PyNumber_PowerOf2(a, b, c) __Pyx__PyNumber_PowerOf2(a, b, c, 0) + +static PyObject* __Pyx__PyNumber_PowerOf2(PyObject *two, PyObject *exp, PyObject *none, int inplace); /*proto*/ + +/////////////// PyNumberPow2 /////////////// + +static PyObject* __Pyx__PyNumber_PowerOf2(PyObject *two, PyObject *exp, PyObject *none, int inplace) { +// in CPython, 1<= 0)) { + if ((size_t)shiftby <= sizeof(long) * 8 - 2) { + long value = 1L << shiftby; + return PyLong_FromLong(value); +#ifdef HAVE_LONG_LONG + } else if ((size_t)shiftby <= sizeof(unsigned PY_LONG_LONG) * 8 - 1) { + unsigned PY_LONG_LONG value = ((unsigned PY_LONG_LONG)1) << shiftby; + return PyLong_FromUnsignedLongLong(value); +#endif + } else { + PyObject *result, *one = PyLong_FromLong(1L); + if (unlikely(!one)) return NULL; + result = PyNumber_Lshift(one, exp); + Py_DECREF(one); + return result; + } + } else if (shiftby == -1 && PyErr_Occurred()) { + PyErr_Clear(); + } +fallback: +#endif + return (inplace ? PyNumber_InPlacePower : PyNumber_Power)(two, exp, none); +} + + +/////////////// PyLongCompare.proto /////////////// + +{{py: c_ret_type = 'PyObject*' if ret_type.is_pyobject else 'int'}} +static CYTHON_INLINE {{c_ret_type}} __Pyx_PyLong_{{'' if ret_type.is_pyobject else 'Bool'}}{{op}}{{order}}(PyObject *op1, PyObject *op2, long intval, long inplace); /*proto*/ + +/////////////// PyLongCompare /////////////// + +{{py: pyval, ival = ('op2', 'b') if order == 'CObj' else ('op1', 'a') }} +{{py: c_ret_type = 'PyObject*' if ret_type.is_pyobject else 'int'}} +{{py: return_true = 'Py_RETURN_TRUE' if ret_type.is_pyobject else 'return 1'}} +{{py: return_false = 'Py_RETURN_FALSE' if ret_type.is_pyobject else 'return 0'}} +{{py: slot_name = op.lower() }} +{{py: c_op = {'Eq': '==', 'Ne': '!='}[op] }} +{{py: +return_compare = ( + (lambda a,b,c_op, return_true=return_true, return_false=return_false: "if ({a} {c_op} {b}) {return_true}; else {return_false};".format( + a=a, b=b, c_op=c_op, return_true=return_true, return_false=return_false)) + if ret_type.is_pyobject else + (lambda a,b,c_op: "return ({a} {c_op} {b});".format(a=a, b=b, c_op=c_op)) + ) +}} + +static CYTHON_INLINE {{c_ret_type}} __Pyx_PyLong_{{'' if ret_type.is_pyobject else 'Bool'}}{{op}}{{order}}(PyObject *op1, PyObject *op2, long intval, long inplace) { + CYTHON_MAYBE_UNUSED_VAR(intval); + CYTHON_UNUSED_VAR(inplace); + if (op1 == op2) { + {{return_true if op == 'Eq' else return_false}}; + } + + #if CYTHON_USE_PYLONG_INTERNALS + if (likely(PyLong_CheckExact({{pyval}}))) { + int unequal; + unsigned long uintval; + Py_ssize_t size = __Pyx_PyLong_DigitCount({{pyval}}); + const digit* digits = __Pyx_PyLong_Digits({{pyval}}); + if (intval == 0) { + {{return_compare('__Pyx_PyLong_IsZero(%s)' % pyval, '1', c_op)}} + } else if (intval < 0) { + if (__Pyx_PyLong_IsNonNeg({{pyval}})) + {{return_false if op == 'Eq' else return_true}}; + // both are negative => can use absolute values now. + intval = -intval; + } else { + // > 0 => Py_SIZE(pyval) > 0 + if (__Pyx_PyLong_IsNeg({{pyval}})) + {{return_false if op == 'Eq' else return_true}}; + } + // After checking that the sign is the same (and excluding 0), now compare the absolute values. + // When inlining, the C compiler should select exactly one line from this unrolled loop. + uintval = (unsigned long) intval; + {{for _size in range(4, 0, -1)}} +#if PyLong_SHIFT * {{_size}} < SIZEOF_LONG*8 + if (uintval >> (PyLong_SHIFT * {{_size}})) { + // The C integer value is between (PyLong_BASE ** _size) and MIN(PyLong_BASE ** _size, LONG_MAX). + unequal = (size != {{_size+1}}) || (digits[0] != (uintval & (unsigned long) PyLong_MASK)) + {{for _i in range(1, _size+1)}} | (digits[{{_i}}] != ((uintval >> ({{_i}} * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)){{endfor}}; + } else +#endif + {{endfor}} + unequal = (size != 1) || (((unsigned long) digits[0]) != (uintval & (unsigned long) PyLong_MASK)); + + {{return_compare('unequal', '0', c_op)}} + } + #endif + + if (PyFloat_CheckExact({{pyval}})) { + const long {{'a' if order == 'CObj' else 'b'}} = intval; + double {{ival}} = __Pyx_PyFloat_AS_DOUBLE({{pyval}}); + {{return_compare('(double)a', '(double)b', c_op)}} + } + + return {{'' if ret_type.is_pyobject else '__Pyx_PyObject_IsTrueAndDecref'}}( + PyObject_RichCompare(op1, op2, Py_{{op.upper()}})); +} + + +/////////////// PyLongBinop.proto /////////////// + +{{py: c_ret_type = 'PyObject*' if ret_type.is_pyobject else 'int'}} +#if !CYTHON_COMPILING_IN_PYPY +static CYTHON_INLINE {{c_ret_type}} __Pyx_PyLong_{{'' if ret_type.is_pyobject else 'Bool'}}{{op}}{{order}}(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check); /*proto*/ +#else +#define __Pyx_PyLong_{{'' if ret_type.is_pyobject else 'Bool'}}{{op}}{{order}}(op1, op2, intval, inplace, zerodivision_check) \ + {{if op in ('Eq', 'Ne')}}{{'' if ret_type.is_pyobject else '__Pyx_PyObject_IsTrueAndDecref'}}(PyObject_RichCompare(op1, op2, Py_{{op.upper()}})) + {{else}}(inplace ? PyNumber_InPlace{{op}}(op1, op2) : PyNumber_{{op}}(op1, op2)) + {{endif}} +#endif + +/////////////// PyLongBinop /////////////// + +#if !CYTHON_COMPILING_IN_PYPY +{{py: from Cython.Utility import pylong_join }} +{{py: pyval, ival = ('op2', 'b') if order == 'CObj' else ('op1', 'a') }} +{{py: c_ret_type = 'PyObject*' if ret_type.is_pyobject else 'int'}} +{{py: return_true = 'Py_RETURN_TRUE' if ret_type.is_pyobject else 'return 1'}} +{{py: return_false = 'Py_RETURN_FALSE' if ret_type.is_pyobject else 'return 0'}} +{{py: slot_name = {'TrueDivide': 'true_divide', 'FloorDivide': 'floor_divide'}.get(op, op.lower()) }} +{{py: cfunc_name = f"__Pyx_PyLong_{'' if ret_type.is_pyobject else 'Bool'}{op}{order}" }} +{{py: +c_op = { + 'Add': '+', 'Subtract': '-', 'Multiply': '*', 'Remainder': '%', 'TrueDivide': '/', 'FloorDivide': '/', + 'Or': '|', 'Xor': '^', 'And': '&', 'Rshift': '>>', 'Lshift': '<<', + 'Eq': '==', 'Ne': '!=', + }[op] +}} +{{py: +def zerodiv_check(operand, optype='integer', _is_mod=op == 'Remainder', _needs_check=(order == 'CObj' and c_op in '%/')): + return ((( + 'if (unlikely(zerodivision_check && ((%s) == 0))) {' + ' PyErr_SetString(PyExc_ZeroDivisionError, "%s division%s by zero");' + ' return NULL;' + '}') % (operand, optype, ' or modulo' if _is_mod else '') + ) if _needs_check else '') +}} + +static {{c_ret_type}} __Pyx_Fallback_{{cfunc_name}}(PyObject *op1, PyObject *op2, int inplace) { + {{if op in ('Eq', 'Ne')}} + CYTHON_UNUSED_VAR(inplace); + return {{'' if ret_type.is_pyobject else '__Pyx_PyObject_IsTrueAndDecref'}}( + PyObject_RichCompare(op1, op2, Py_{{op.upper()}})); + {{else}} + return (inplace ? PyNumber_InPlace{{op}} : PyNumber_{{op}})(op1, op2); + {{endif}} +} + +#if CYTHON_USE_PYLONG_INTERNALS +static {{c_ret_type}} __Pyx_Unpacked_{{cfunc_name}}(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check) { + CYTHON_MAYBE_UNUSED_VAR(inplace); + CYTHON_UNUSED_VAR(zerodivision_check); + + const long {{'a' if order == 'CObj' else 'b'}} = intval; + long {{ival}}{{if op not in ('Eq', 'Ne')}}, x{{endif}}; + {{if op not in ('Eq', 'Ne', 'TrueDivide')}} +#ifdef HAVE_LONG_LONG + const PY_LONG_LONG ll{{'a' if order == 'CObj' else 'b'}} = intval; + PY_LONG_LONG ll{{ival}}, llx; +#endif + {{endif}} + {{if op == 'Rshift' or op == 'Lshift'}} +// shifting negative numbers is technically implementation defined on C, and +// C++ before C++20. Most implementation do the right thing though so +// special case ones we know are good. +#if (defined(__cplusplus) && __cplusplus >= 202002L) \ + || (defined(__GNUC__) || (defined(__clang__))) && \ + (defined(__arm__) || defined(__x86_64__) || defined(__i386__)) \ + || (defined(_MSC_VER) && \ + (defined(_M_ARM) || defined(_M_AMD64) || defined(_M_IX86))) + const int negative_shift_works = 1; +#else + const int negative_shift_works = 0; +#endif + {{endif}} + + // special cases for 0: + - * % / // | ^ & >> << + if (unlikely(__Pyx_PyLong_IsZero({{pyval}}))) { + {{if order == 'CObj' and c_op in '%/'}} + // division by zero! + {{zerodiv_check('0')}} + {{elif order == 'CObj' and c_op in '+-|^>><<'}} + // x == x+0 == x-0 == x|0 == x^0 == x>>0 == x<<0 + return __Pyx_NewRef(op1); + {{elif order == 'CObj' and c_op in '*&'}} + // 0 == x*0 == x&0 + return __Pyx_NewRef(op2); + {{elif order == 'ObjC' and c_op in '+|^'}} + // x == 0+x == 0|x == 0^x + return __Pyx_NewRef(op2); + {{elif order == 'ObjC' and c_op == '-'}} + // -x == 0-x + return PyLong_FromLong(-intval); + {{elif order == 'ObjC' and (c_op in '*%&>><<' or op == 'FloorDivide')}} + // 0 == 0*x == 0%x == 0&x == 0>>x == 0< {{_size}} * PyLong_SHIFT{{if c_op == '*'}}+30{{endif}}{{if op == 'TrueDivide'}} && {{_size-1}} * PyLong_SHIFT < 53{{endif}}) { + {{ival}} = {{'-' if _case < 0 else ''}}(long) {{pylong_join(_size, 'digits')}}; + break; + {{if op not in ('Eq', 'Ne', 'TrueDivide')}} + #ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > {{_size}} * PyLong_SHIFT{{if c_op == '*'}}+30{{endif}}) { + ll{{ival}} = {{'-' if _case < 0 else ''}}(PY_LONG_LONG) {{pylong_join(_size, 'digits', 'unsigned PY_LONG_LONG')}}; + goto long_long; + #endif + {{endif}} + } + // if size doesn't fit into a long or PY_LONG_LONG anymore, fall through to default + CYTHON_FALLTHROUGH; + {{endfor}} + {{endfor}} + + {{if op in ('Eq', 'Ne')}} + #if PyLong_SHIFT < 30 && PyLong_SHIFT != 15 + // unusual setup - your fault + default: return {{'' if ret_type.is_pyobject else '__Pyx_PyObject_IsTrueAndDecref'}}( + PyLong_Type.tp_richcompare({{'op1, op2' if order == 'ObjC' else 'op2, op1'}}, Py_{{op.upper()}})); + #else + // too large for the long values we allow => definitely not equal + default: {{return_false if op == 'Eq' else return_true}}; + #endif + {{else}} + default: return PyLong_Type.tp_as_number->nb_{{slot_name}}(op1, op2); + {{endif}} + } + } + + {{if op in ('Eq', 'Ne')}} + if (a {{c_op}} b) { + {{return_true}}; + } else { + {{return_false}}; + } + {{else}} + {{if c_op == '*'}} + CYTHON_UNUSED_VAR(a); + CYTHON_UNUSED_VAR(b); + #ifdef HAVE_LONG_LONG + ll{{ival}} = {{ival}}; + goto long_long; + #else + return PyLong_Type.tp_as_number->nb_{{slot_name}}(op1, op2); + #endif + {{elif c_op == '%'}} + // see CMath.c :: ModInt utility code + x = a % b; + x += ((x != 0) & ((x ^ b) < 0)) * b; + {{elif op == 'TrueDivide'}} + if ((8 * sizeof(long) <= 53 || likely(labs({{ival}}) <= ((PY_LONG_LONG)1 << 53))) + || __Pyx_PyLong_DigitCount({{pyval}}) <= 52 / PyLong_SHIFT) { + return PyFloat_FromDouble((double)a / (double)b); + } + return PyLong_Type.tp_as_number->nb_{{slot_name}}(op1, op2); + {{elif op == 'FloorDivide'}} + { + long q, r; + // see CMath.c :: DivInt utility code + q = a / b; + r = a - q*b; + q -= ((r != 0) & ((r ^ b) < 0)); + x = q; + } + {{else}} + + {{if op == 'Rshift' or op == 'Lshift'}} + if ((!negative_shift_works) && unlikely(a < 0)) goto fallback; + {{endif}} + {{if op == 'Rshift'}} + if (unlikely(b >= (long) (sizeof(long)*8))) { + x = (a < 0) ? -1 : 0; + } else + {{endif}} + x = a {{c_op}} b; + {{if op == 'Lshift'}} +#ifdef HAVE_LONG_LONG + if (unlikely(!(b < (long) (sizeof(long)*8) && a == x >> b)) && a) { + ll{{ival}} = {{ival}}; + goto long_long; + } +#else + if (likely(b < (long) (sizeof(long)*8) && a == x >> b) || !a) /* execute return statement below */ +#endif + {{endif}} + {{endif}} + return PyLong_FromLong(x); + + {{if op != 'TrueDivide'}} +#ifdef HAVE_LONG_LONG + long_long: + {{if c_op == '%'}} + // see CMath.c :: ModInt utility code + llx = lla % llb; + llx += ((llx != 0) & ((llx ^ llb) < 0)) * llb; + {{elif op == 'FloorDivide'}} + { + PY_LONG_LONG q, r; + // see CMath.c :: DivInt utility code + q = lla / llb; + r = lla - q*llb; + q -= ((r != 0) & ((r ^ llb) < 0)); + llx = q; + } + {{else}} + {{if op == 'LShift' or op == 'Rshift'}} + if ((!negative_shift_works) && unlikely(a < 0)) goto fallback; + {{endif}} + {{if op == 'Rshift'}} + if (unlikely(llb >= (long long) (sizeof(long long)*8))) { + llx = (lla < 0) ? -1 : 0; + } else + {{endif}} + llx = lla {{c_op}} llb; + {{if op == 'Lshift'}} + if (likely(lla == llx >> llb)) /* then execute 'return' below */ + {{endif}} + {{endif}} + return PyLong_FromLongLong(llx); +#endif +{{if op == 'Lshift' or op == 'Rshift'}} + fallback: +{{endif}} + + return __Pyx_Fallback_{{cfunc_name}}(op1, op2, inplace); + + {{endif}}{{# if op != 'TrueDivide' #}} + {{endif}}{{# if op in ('Eq', 'Ne') #}} +} +#endif + +{{if c_op in '+-*' or op in ('TrueDivide', 'Eq', 'Ne')}} +static {{c_ret_type}} __Pyx_Float_{{cfunc_name}}(PyObject *float_val, long intval, int zerodivision_check) { + CYTHON_UNUSED_VAR(zerodivision_check); + + const long {{'a' if order == 'CObj' else 'b'}} = intval; + double {{ival}} = __Pyx_PyFloat_AS_DOUBLE(float_val); + {{if op in ('Eq', 'Ne')}} + if ((double)a {{c_op}} (double)b) { + {{return_true}}; + } else { + {{return_false}}; + } + {{else}} + double result; + {{zerodiv_check('b', 'float')}} + result = ((double)a) {{c_op}} (double)b; + return PyFloat_FromDouble(result); + {{endif}} +} +{{endif}} + +static CYTHON_INLINE {{c_ret_type}} {{cfunc_name}}(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check) { + CYTHON_MAYBE_UNUSED_VAR(intval); + CYTHON_UNUSED_VAR(zerodivision_check); + + {{if op in ('Eq', 'Ne')}} + if (op1 == op2) { + {{return_true if op == 'Eq' else return_false}}; + } + {{endif}} + + #if CYTHON_USE_PYLONG_INTERNALS + if (likely(PyLong_CheckExact({{pyval}}))) { + return __Pyx_Unpacked_{{cfunc_name}}(op1, op2, intval, inplace, zerodivision_check); + } + #endif + + {{if c_op in '+-*' or op in ('TrueDivide', 'Eq', 'Ne')}} + if (PyFloat_CheckExact({{pyval}})) { + return __Pyx_Float_{{cfunc_name}}({{pyval}}, intval, zerodivision_check); + } + {{endif}} + + return __Pyx_Fallback_{{cfunc_name}}(op1, op2, inplace); +} +#endif /* !CYTHON_COMPILING_IN_PYPY */ + + +/////////////// PyFloatBinop.proto /////////////// + +{{py: c_ret_type = 'PyObject*' if ret_type.is_pyobject else 'int'}} +#if !CYTHON_COMPILING_IN_PYPY +static {{c_ret_type}} __Pyx_PyFloat_{{'' if ret_type.is_pyobject else 'Bool'}}{{op}}{{order}}(PyObject *op1, PyObject *op2, double floatval, int inplace, int zerodivision_check); /*proto*/ +#else +#define __Pyx_PyFloat_{{'' if ret_type.is_pyobject else 'Bool'}}{{op}}{{order}}(op1, op2, floatval, inplace, zerodivision_check) \ + {{if op in ('Eq', 'Ne')}}{{'' if ret_type.is_pyobject else '__Pyx_PyObject_IsTrueAndDecref'}}(PyObject_RichCompare(op1, op2, Py_{{op.upper()}})) + {{elif op == 'Divide'}}((inplace ? __Pyx_PyNumber_InPlaceDivide(op1, op2) : __Pyx_PyNumber_Divide(op1, op2))) + {{else}}(inplace ? PyNumber_InPlace{{op}}(op1, op2) : PyNumber_{{op}}(op1, op2)) + {{endif}} +#endif + +/////////////// PyFloatBinop /////////////// + +#if !CYTHON_COMPILING_IN_PYPY +{{py: from Cython.Utility import pylong_join }} +{{py: c_ret_type = 'PyObject*' if ret_type.is_pyobject else 'int'}} +{{py: return_true = 'Py_RETURN_TRUE' if ret_type.is_pyobject else 'return 1'}} +{{py: return_false = 'Py_RETURN_FALSE' if ret_type.is_pyobject else 'return 0'}} +{{py: pyval, fval = ('op2', 'b') if order == 'CObj' else ('op1', 'a') }} +{{py: cfunc_name = '__Pyx_PyFloat_%s%s%s' % ('' if ret_type.is_pyobject else 'Bool', op, order) }} +{{py: +c_op = { + 'Add': '+', 'Subtract': '-', 'TrueDivide': '/', 'Divide': '/', 'Remainder': '%', + 'Eq': '==', 'Ne': '!=', + }[op] +}} +{{py: +def zerodiv_check(operand, _is_mod=op == 'Remainder', _needs_check=(order == 'CObj' and c_op in '%/')): + return ((( + 'if (unlikely(zerodivision_check && ((%s) == 0.0))) {' + ' PyErr_SetString(PyExc_ZeroDivisionError, "float division%s by zero");' + ' return NULL;' + '}') % (operand, ' or modulo' if _is_mod else '') + ) if _needs_check else '') +}} + +static {{c_ret_type}} {{cfunc_name}}(PyObject *op1, PyObject *op2, double floatval, int inplace, int zerodivision_check) { + const double {{'a' if order == 'CObj' else 'b'}} = floatval; + double {{fval}}{{if op not in ('Eq', 'Ne')}}, result{{endif}}; + CYTHON_UNUSED_VAR(inplace); + CYTHON_UNUSED_VAR(zerodivision_check); + + {{if op in ('Eq', 'Ne')}} + if (op1 == op2) { + {{return_true if op == 'Eq' else return_false}}; + } + {{endif}} + + if (likely(PyFloat_CheckExact({{pyval}}))) { + {{fval}} = __Pyx_PyFloat_AS_DOUBLE({{pyval}}); + {{zerodiv_check(fval)}} + } else + + if (likely(PyLong_CheckExact({{pyval}}))) { + #if CYTHON_USE_PYLONG_INTERNALS + if (__Pyx_PyLong_IsZero({{pyval}})) { + {{fval}} = 0.0; + {{zerodiv_check(fval)}} + } else if (__Pyx_PyLong_IsCompact({{pyval}})) { + {{fval}} = (double) __Pyx_PyLong_CompactValue({{pyval}}); + } else { + const digit* digits = __Pyx_PyLong_Digits({{pyval}}); + const Py_ssize_t size = __Pyx_PyLong_SignedDigitCount({{pyval}}); + switch (size) { + {{for _size in (2, 3, 4)}} + case -{{_size}}: + case {{_size}}: + if (8 * sizeof(unsigned long) > {{_size}} * PyLong_SHIFT && ((8 * sizeof(unsigned long) < 53) || ({{_size-1}} * PyLong_SHIFT < 53))) { + {{fval}} = (double) {{pylong_join(_size, 'digits')}}; + // let CPython do its own float rounding from 2**53 on (max. consecutive integer in double float) + if ((8 * sizeof(unsigned long) < 53) || ({{_size}} * PyLong_SHIFT < 53) || ({{fval}} < (double) ((PY_LONG_LONG)1 << 53))) { + if (size == {{-_size}}) + {{fval}} = -{{fval}}; + break; + } + } + // Fall through if size doesn't fit safely into a double anymore. + // It may not be obvious that this is a safe fall-through given the "fval < 2**53" + // check above. However, the number of digits that CPython uses for a given PyLong + // value is minimal, and together with the "(size-1) * SHIFT < 53" check above, + // this should make it safe. + CYTHON_FALLTHROUGH; + {{endfor}} + default: + #endif + {{if op in ('Eq', 'Ne')}} + { + PyObject *res = + #if CYTHON_USE_TYPE_SLOTS || __PYX_LIMITED_VERSION_HEX >= 0x030A0000 + // PyType_GetSlot only works on non-heap types from Python 3.10 + __Pyx_PyType_GetSlot((&PyFloat_Type), tp_richcompare, richcmpfunc) + #else + PyObject_RichCompare + #endif + ({{'op1, op2' if order == 'CObj' else 'op2, op1'}}, + Py_{{op.upper()}}); + return {{'' if ret_type.is_pyobject else '__Pyx_PyObject_IsTrueAndDecref'}}( + res); + } + {{else}} + {{fval}} = PyLong_AsDouble({{pyval}}); + if (unlikely({{fval}} == -1.0 && PyErr_Occurred())) return NULL; + {{if zerodiv_check(fval)}} + #if !CYTHON_USE_PYLONG_INTERNALS + {{zerodiv_check(fval)}} + #endif + {{endif}} + {{endif}} + #if CYTHON_USE_PYLONG_INTERNALS + } + } + #endif + } else { + {{if op in ('Eq', 'Ne')}} + return {{'' if ret_type.is_pyobject else '__Pyx_PyObject_IsTrueAndDecref'}}( + PyObject_RichCompare(op1, op2, Py_{{op.upper()}})); + {{elif op == 'Divide'}} + return (inplace ? __Pyx_PyNumber_InPlaceDivide(op1, op2) : __Pyx_PyNumber_Divide(op1, op2)); + {{else}} + return (inplace ? PyNumber_InPlace{{op}} : PyNumber_{{op}})(op1, op2); + {{endif}} + } + + {{if op in ('Eq', 'Ne')}} + if (a {{c_op}} b) { + {{return_true}}; + } else { + {{return_false}}; + } + {{else}} + {{if c_op == '%'}} + result = fmod(a, b); + if (result) + result += ((result < 0) ^ (b < 0)) * b; + else + result = copysign(0.0, b); + {{else}} + result = a {{c_op}} b; + {{endif}} + return PyFloat_FromDouble(result); + {{endif}} +} +#endif diff --git a/venv/lib/python3.10/site-packages/Cython/Utility/Overflow.c b/venv/lib/python3.10/site-packages/Cython/Utility/Overflow.c new file mode 100644 index 0000000000000000000000000000000000000000..42115e602b4505dd3cf0e612dbbc95e32bb107b4 --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Utility/Overflow.c @@ -0,0 +1,412 @@ +/* +These functions provide integer arithmetic with integer checking. They do not +actually raise an exception when an overflow is detected, but rather set a bit +in the overflow parameter. (This parameter may be reused across several +arithmetic operations, so should be or-ed rather than assigned to.) + +The implementation is divided into two parts, the signed and unsigned basecases, +which is where the magic happens, and a generic template matching a specific +type to an implementation based on its (c-compile-time) size and signedness. + +When possible, branching is avoided, and preference is given to speed over +accuracy (a low rate of falsely "detected" overflows are acceptable, +undetected overflows are not). + + +TODO: Hook up checking. +TODO: Conditionally support 128-bit with intmax_t? +*/ + +/////////////// Common.proto /////////////// + +static int __Pyx_check_twos_complement(void) { + if ((-1) != (~0)) { + PyErr_SetString(PyExc_RuntimeError, "Two's complement required for overflow checks."); + return 1; + } else if ((sizeof(short) == sizeof(int))) { + PyErr_SetString(PyExc_RuntimeError, "sizeof(short) < sizeof(int) required for overflow checks."); + return 1; + } else { + return 0; + } +} + +#define __PYX_SIGN_BIT(type) ((((unsigned type) 1) << (sizeof(type) * 8 - 1))) +#define __PYX_HALF_MAX(type) ((((type) 1) << (sizeof(type) * 8 - 2))) +#define __PYX_MIN(type) ((__PYX_IS_UNSIGNED(type) ? (type) 0 : 0 - __PYX_HALF_MAX(type) - __PYX_HALF_MAX(type))) +#define __PYX_MAX(type) ((~__PYX_MIN(type))) + +#define __Pyx_add_no_overflow(a, b, overflow) ((a) + (b)) +#define __Pyx_add_const_no_overflow(a, b, overflow) ((a) + (b)) +#define __Pyx_sub_no_overflow(a, b, overflow) ((a) - (b)) +#define __Pyx_sub_const_no_overflow(a, b, overflow) ((a) - (b)) +#define __Pyx_mul_no_overflow(a, b, overflow) ((a) * (b)) +#define __Pyx_mul_const_no_overflow(a, b, overflow) ((a) * (b)) +#define __Pyx_div_no_overflow(a, b, overflow) ((a) / (b)) +#define __Pyx_div_const_no_overflow(a, b, overflow) ((a) / (b)) + +#if defined(__has_builtin) +# if __has_builtin(__builtin_add_overflow) && !defined(__ibmxl__) +# define __PYX_HAVE_BUILTIN_OVERFLOW +# endif +#elif defined(__GNUC__) && (__GNUC__ >= 5) && (!defined(__INTEL_COMPILER) || (__INTEL_COMPILER >= 1800)) +# define __PYX_HAVE_BUILTIN_OVERFLOW +#endif + +#if defined(__GNUC__) +# define __Pyx_is_constant(x) (__builtin_constant_p(x)) +#elif defined(__has_builtin) +# if __has_builtin(__builtin_constant_p) +# define __Pyx_is_constant(x) (__builtin_constant_p(x)) +# endif +#else +# define __Pyx_is_constant(x) (0) +#endif + +/////////////// Common.init /////////////// + +if (likely(__Pyx_check_twos_complement() == 0)); else +// error propagation code is appended automatically + +/////////////// BaseCaseUnsigned.proto /////////////// + +{{if UINT == "long long"}}#ifdef HAVE_LONG_LONG{{endif}} + +static CYTHON_INLINE {{UINT}} __Pyx_add_{{NAME}}_checking_overflow({{UINT}} a, {{UINT}} b, int *overflow); +static CYTHON_INLINE {{UINT}} __Pyx_sub_{{NAME}}_checking_overflow({{UINT}} a, {{UINT}} b, int *overflow); +static CYTHON_INLINE {{UINT}} __Pyx_mul_{{NAME}}_checking_overflow({{UINT}} a, {{UINT}} b, int *overflow); +static CYTHON_INLINE {{UINT}} __Pyx_div_{{NAME}}_checking_overflow({{UINT}} a, {{UINT}} b, int *overflow); + +// Use these when b is known at compile time. +#define __Pyx_add_const_{{NAME}}_checking_overflow __Pyx_add_{{NAME}}_checking_overflow +#define __Pyx_sub_const_{{NAME}}_checking_overflow __Pyx_sub_{{NAME}}_checking_overflow +#if defined(__PYX_HAVE_BUILTIN_OVERFLOW) +#define __Pyx_mul_const_{{NAME}}_checking_overflow __Pyx_mul_{{NAME}}_checking_overflow +#else +static CYTHON_INLINE {{UINT}} __Pyx_mul_const_{{NAME}}_checking_overflow({{UINT}} a, {{UINT}} constant, int *overflow); +#endif +#define __Pyx_div_const_{{NAME}}_checking_overflow __Pyx_div_{{NAME}}_checking_overflow + +{{if UINT == "long long"}}#endif{{endif}} + +/////////////// BaseCaseUnsigned /////////////// + +{{if UINT == "long long"}}#ifdef HAVE_LONG_LONG{{endif}} + +#if defined(__PYX_HAVE_BUILTIN_OVERFLOW) + +static CYTHON_INLINE {{UINT}} __Pyx_add_{{NAME}}_checking_overflow({{UINT}} a, {{UINT}} b, int *overflow) { + {{UINT}} result; + *overflow |= __builtin_add_overflow(a, b, &result); + return result; +} + +static CYTHON_INLINE {{UINT}} __Pyx_sub_{{NAME}}_checking_overflow({{UINT}} a, {{UINT}} b, int *overflow) { + {{UINT}} result; + *overflow |= __builtin_sub_overflow(a, b, &result); + return result; +} + +static CYTHON_INLINE {{UINT}} __Pyx_mul_{{NAME}}_checking_overflow({{UINT}} a, {{UINT}} b, int *overflow) { + {{UINT}} result; + *overflow |= __builtin_mul_overflow(a, b, &result); + return result; +} + +#else + +static CYTHON_INLINE {{UINT}} __Pyx_add_{{NAME}}_checking_overflow({{UINT}} a, {{UINT}} b, int *overflow) { + {{UINT}} r = a + b; + *overflow |= r < a; + return r; +} + +static CYTHON_INLINE {{UINT}} __Pyx_sub_{{NAME}}_checking_overflow({{UINT}} a, {{UINT}} b, int *overflow) { + {{UINT}} r = a - b; + *overflow |= r > a; + return r; +} + +static CYTHON_INLINE {{UINT}} __Pyx_mul_{{NAME}}_checking_overflow({{UINT}} a, {{UINT}} b, int *overflow) { + // if we have a constant, use the constant version + if (__Pyx_is_constant(b)) { + return __Pyx_mul_const_{{NAME}}_checking_overflow(a, b, overflow); + } else if (__Pyx_is_constant(a)) { + return __Pyx_mul_const_{{NAME}}_checking_overflow(b, a, overflow); + } else if ((sizeof({{UINT}}) < sizeof(unsigned long))) { + unsigned long big_r = ((unsigned long) a) * ((unsigned long) b); + {{UINT}} r = ({{UINT}}) big_r; + *overflow |= big_r != r; + return r; +#ifdef HAVE_LONG_LONG + } else if ((sizeof({{UINT}}) < sizeof(unsigned PY_LONG_LONG))) { + unsigned PY_LONG_LONG big_r = ((unsigned PY_LONG_LONG) a) * ((unsigned PY_LONG_LONG) b); + {{UINT}} r = ({{UINT}}) big_r; + *overflow |= big_r != r; + return r; +#endif + } else { + return __Pyx_mul_const_{{NAME}}_checking_overflow(a, b, overflow); + } +} + +static CYTHON_INLINE {{UINT}} __Pyx_mul_const_{{NAME}}_checking_overflow({{UINT}} a, {{UINT}} b, int *overflow) { + // note that deliberately the overflow check is written such that it divides by b; this + // function is used when b is a constant thus the compiler should be able to eliminate the + // (very slow on most CPUs!) division operation + {{UINT}} prod; + if (__Pyx_is_constant(a) && !__Pyx_is_constant(b)) { + // if a is a compile-time constant and b isn't, swap them + {{UINT}} temp = b; + b = a; + a = temp; + } + prod = a * b; + if (b != 0) + *overflow |= a > (__PYX_MAX({{UINT}}) / b); + return prod; +} +#endif // __PYX_HAVE_BUILTIN_OVERFLOW + + +static CYTHON_INLINE {{UINT}} __Pyx_div_{{NAME}}_checking_overflow({{UINT}} a, {{UINT}} b, int *overflow) { + if (b == 0) { + *overflow |= 1; + return 0; + } + return a / b; +} + +{{if UINT == "long long"}}#endif{{endif}} + + +/////////////// BaseCaseSigned.proto /////////////// + +{{if INT == "long long"}}#ifdef HAVE_LONG_LONG{{endif}} + +static CYTHON_INLINE {{INT}} __Pyx_add_{{NAME}}_checking_overflow({{INT}} a, {{INT}} b, int *overflow); +static CYTHON_INLINE {{INT}} __Pyx_sub_{{NAME}}_checking_overflow({{INT}} a, {{INT}} b, int *overflow); +static CYTHON_INLINE {{INT}} __Pyx_mul_{{NAME}}_checking_overflow({{INT}} a, {{INT}} b, int *overflow); +static CYTHON_INLINE {{INT}} __Pyx_div_{{NAME}}_checking_overflow({{INT}} a, {{INT}} b, int *overflow); + + +// Use when b is known at compile time. +#define __Pyx_add_const_{{NAME}}_checking_overflow __Pyx_add_{{NAME}}_checking_overflow +#define __Pyx_sub_const_{{NAME}}_checking_overflow __Pyx_sub_{{NAME}}_checking_overflow +#if defined(__PYX_HAVE_BUILTIN_OVERFLOW) +#define __Pyx_mul_const_{{NAME}}_checking_overflow __Pyx_mul_{{NAME}}_checking_overflow +#else +static CYTHON_INLINE {{INT}} __Pyx_mul_const_{{NAME}}_checking_overflow({{INT}} a, {{INT}} constant, int *overflow); +#endif +#define __Pyx_div_const_{{NAME}}_checking_overflow __Pyx_div_{{NAME}}_checking_overflow + +{{if INT == "long long"}}#endif{{endif}} + +/////////////// BaseCaseSigned /////////////// + +{{if INT == "long long"}}#ifdef HAVE_LONG_LONG{{endif}} + +#if defined(__PYX_HAVE_BUILTIN_OVERFLOW) + +static CYTHON_INLINE {{INT}} __Pyx_add_{{NAME}}_checking_overflow({{INT}} a, {{INT}} b, int *overflow) { + {{INT}} result; + *overflow |= __builtin_add_overflow(a, b, &result); + return result; +} + +static CYTHON_INLINE {{INT}} __Pyx_sub_{{NAME}}_checking_overflow({{INT}} a, {{INT}} b, int *overflow) { + {{INT}} result; + *overflow |= __builtin_sub_overflow(a, b, &result); + return result; +} + +static CYTHON_INLINE {{INT}} __Pyx_mul_{{NAME}}_checking_overflow({{INT}} a, {{INT}} b, int *overflow) { + {{INT}} result; + *overflow |= __builtin_mul_overflow(a, b, &result); + return result; +} + +#else + +static CYTHON_INLINE {{INT}} __Pyx_add_{{NAME}}_checking_overflow({{INT}} a, {{INT}} b, int *overflow) { + if ((sizeof({{INT}}) < sizeof(long))) { + long big_r = ((long) a) + ((long) b); + {{INT}} r = ({{INT}}) big_r; + *overflow |= big_r != r; + return r; +#ifdef HAVE_LONG_LONG + } else if ((sizeof({{INT}}) < sizeof(PY_LONG_LONG))) { + PY_LONG_LONG big_r = ((PY_LONG_LONG) a) + ((PY_LONG_LONG) b); + {{INT}} r = ({{INT}}) big_r; + *overflow |= big_r != r; + return r; +#endif + } else { + // Signed overflow undefined, but unsigned overflow is well defined. Casting is + // implementation-defined, but we assume two's complement (see __Pyx_check_twos_complement + // above), and arithmetic in two's-complement is the same as unsigned arithmetic. + unsigned {{INT}} r = (unsigned {{INT}}) a + (unsigned {{INT}}) b; + // Overflow happened if the operands have the same sign, but the result + // has opposite sign. + *overflow |= (((unsigned {{INT}})a ^ r) & ((unsigned {{INT}})b ^ r)) >> (8 * sizeof({{INT}}) - 1); + return ({{INT}}) r; + } +} + +static CYTHON_INLINE {{INT}} __Pyx_sub_{{NAME}}_checking_overflow({{INT}} a, {{INT}} b, int *overflow) { + // Compilers don't handle widening as well in the subtraction case, so don't bother + unsigned {{INT}} r = (unsigned {{INT}}) a - (unsigned {{INT}}) b; + // Overflow happened if the operands differing signs, and the result + // has opposite sign to a. + *overflow |= (((unsigned {{INT}})a ^ (unsigned {{INT}})b) & ((unsigned {{INT}})a ^ r)) >> (8 * sizeof({{INT}}) - 1); + return ({{INT}}) r; +} + +static CYTHON_INLINE {{INT}} __Pyx_mul_{{NAME}}_checking_overflow({{INT}} a, {{INT}} b, int *overflow) { + // if we have a constant, use the constant version + if (__Pyx_is_constant(b)) { + return __Pyx_mul_const_{{NAME}}_checking_overflow(a, b, overflow); + } else if (__Pyx_is_constant(a)) { + return __Pyx_mul_const_{{NAME}}_checking_overflow(b, a, overflow); + } else if ((sizeof({{INT}}) < sizeof(long))) { + long big_r = ((long) a) * ((long) b); + {{INT}} r = ({{INT}}) big_r; + *overflow |= big_r != r; + return ({{INT}}) r; +#ifdef HAVE_LONG_LONG + } else if ((sizeof({{INT}}) < sizeof(PY_LONG_LONG))) { + PY_LONG_LONG big_r = ((PY_LONG_LONG) a) * ((PY_LONG_LONG) b); + {{INT}} r = ({{INT}}) big_r; + *overflow |= big_r != r; + return ({{INT}}) r; +#endif + } else { + return __Pyx_mul_const_{{NAME}}_checking_overflow(a, b, overflow); + } +} + +static CYTHON_INLINE {{INT}} __Pyx_mul_const_{{NAME}}_checking_overflow({{INT}} a, {{INT}} b, int *overflow) { + // note that deliberately all these comparisons are written such that they divide by b; this + // function is used when b is a constant thus the compiler should be able to eliminate the + // (very slow on most CPUs!) division operations + if (__Pyx_is_constant(a) && !__Pyx_is_constant(b)) { + // if a is a compile-time constant and b isn't, swap them + {{INT}} temp = b; + b = a; + a = temp; + } + if (b > 1) { + *overflow |= a > __PYX_MAX({{INT}}) / b; + *overflow |= a < __PYX_MIN({{INT}}) / b; + } else if (b == -1) { + *overflow |= a == __PYX_MIN({{INT}}); + } else if (b < -1) { + *overflow |= a > __PYX_MIN({{INT}}) / b; + *overflow |= a < __PYX_MAX({{INT}}) / b; + } + return ({{INT}}) (((unsigned {{INT}})a) * ((unsigned {{INT}}) b)); +} +#endif // defined(__PYX_HAVE_BUILTIN_OVERFLOW) + +static CYTHON_INLINE {{INT}} __Pyx_div_{{NAME}}_checking_overflow({{INT}} a, {{INT}} b, int *overflow) { + if (b == 0) { + *overflow |= 1; + return 0; + } + *overflow |= a == __PYX_MIN({{INT}}) && b == -1; + return ({{INT}}) ((unsigned {{INT}}) a / (unsigned {{INT}}) b); +} + +{{if INT == "long long"}}#endif{{endif}} + + +/////////////// SizeCheck.init /////////////// + +if (likely(__Pyx_check_sane_{{NAME}}() == 0)); else +// error propagation code is appended automatically + +/////////////// SizeCheck.proto /////////////// + +static int __Pyx_check_sane_{{NAME}}(void) { + if (((sizeof({{TYPE}}) <= sizeof(int)) || +#ifdef HAVE_LONG_LONG + (sizeof({{TYPE}}) == sizeof(PY_LONG_LONG)) || +#endif + (sizeof({{TYPE}}) == sizeof(long)))) { + return 0; + } else { + PyErr_Format(PyExc_RuntimeError, \ + "Bad size for int type %.{{max(60, len(TYPE))}}s: %d", "{{TYPE}}", (int) sizeof({{TYPE}})); + return 1; + } +} + + +/////////////// Binop.proto /////////////// + +static CYTHON_INLINE {{TYPE}} __Pyx_{{BINOP}}_{{NAME}}_checking_overflow({{TYPE}} a, {{TYPE}} b, int *overflow); + +/////////////// Binop /////////////// + +static CYTHON_INLINE {{TYPE}} __Pyx_{{BINOP}}_{{NAME}}_checking_overflow({{TYPE}} a, {{TYPE}} b, int *overflow) { + if ((sizeof({{TYPE}}) < sizeof(int))) { + return __Pyx_{{BINOP}}_no_overflow(a, b, overflow); + } else if (__PYX_IS_UNSIGNED({{TYPE}})) { + if ((sizeof({{TYPE}}) == sizeof(unsigned int))) { + return ({{TYPE}}) __Pyx_{{BINOP}}_unsigned_int_checking_overflow(a, b, overflow); + } else if ((sizeof({{TYPE}}) == sizeof(unsigned long))) { + return ({{TYPE}}) __Pyx_{{BINOP}}_unsigned_long_checking_overflow(a, b, overflow); +#ifdef HAVE_LONG_LONG + } else if ((sizeof({{TYPE}}) == sizeof(unsigned PY_LONG_LONG))) { + return ({{TYPE}}) __Pyx_{{BINOP}}_unsigned_long_long_checking_overflow(a, b, overflow); +#endif + } else { + Py_FatalError( + "__Pyx_{{BINOP}}_{{NAME}}_checking_overflow({{TYPE}}) executed an unexpected code path. " + "Please report this as a bug in Cython" + ); + return 0; /* handled elsewhere */ + } + } else { + if ((sizeof({{TYPE}}) == sizeof(int))) { + return ({{TYPE}}) __Pyx_{{BINOP}}_int_checking_overflow(a, b, overflow); + } else if ((sizeof({{TYPE}}) == sizeof(long))) { + return ({{TYPE}}) __Pyx_{{BINOP}}_long_checking_overflow(a, b, overflow); +#ifdef HAVE_LONG_LONG + } else if ((sizeof({{TYPE}}) == sizeof(PY_LONG_LONG))) { + return ({{TYPE}}) __Pyx_{{BINOP}}_long_long_checking_overflow(a, b, overflow); +#endif + } else { + Py_FatalError( + "__Pyx_{{BINOP}}_{{NAME}}_checking_overflow({{TYPE}}) executed an unexpected code path. " + "Please report this as a bug in Cython" + ); + return 0; /* handled elsewhere */ + } + } +} + +/////////////// LeftShift.proto /////////////// + +static CYTHON_INLINE {{TYPE}} __Pyx_lshift_{{NAME}}_checking_overflow({{TYPE}} a, {{TYPE}} b, int *overflow) { + int overflow_check = +#if {{SIGNED}} + (a < 0) || (b < 0) || +#endif + // the following must be a _logical_ OR as the RHS is undefined if the LHS is true + (b >= ({{TYPE}}) (8 * sizeof({{TYPE}}))) || (a > (__PYX_MAX({{TYPE}}) >> b)); + if (overflow_check) { + *overflow |= 1; + return 0; + } else { + return a << b; + } +} +#define __Pyx_lshift_const_{{NAME}}_checking_overflow __Pyx_lshift_{{NAME}}_checking_overflow + + +/////////////// UnaryNegOverflows.proto /////////////// + +// from intobject.c +#define __Pyx_UNARY_NEG_WOULD_OVERFLOW(x) \ + (((x) < 0) & ((unsigned long)(x) == 0-(unsigned long)(x))) diff --git a/venv/lib/python3.10/site-packages/Cython/Utility/Printing.c b/venv/lib/python3.10/site-packages/Cython/Utility/Printing.c new file mode 100644 index 0000000000000000000000000000000000000000..3cc2600e3900a8b89d2990ce887667c756026a75 --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Utility/Printing.c @@ -0,0 +1,86 @@ +////////////////////// Print.proto ////////////////////// + +static int __Pyx_Print(PyObject*, PyObject *, int); /*proto*/ + +////////////////////// Print.module_state_decls ///////////// +//@substitute: naming +PyObject* $print_function; +PyObject* $print_function_kwargs; + +////////////////////// Print.cleanup ////////////////////// + +Py_CLEAR(NAMED_CGLOBAL(print_function)); +Py_CLEAR(NAMED_CGLOBAL(print_function_kwargs)); + +////////////////////// Print ////////////////////// + +static int __Pyx_Print(PyObject* stream, PyObject *arg_tuple, int newline) { + PyObject* kwargs = 0; + PyObject* result = 0; + PyObject* end_string; + if (unlikely(!NAMED_CGLOBAL(print_function))) { + NAMED_CGLOBAL(print_function) = PyObject_GetAttr(NAMED_CGLOBAL(builtins_cname), PYIDENT("print")); + if (!NAMED_CGLOBAL(print_function)) + return -1; + } + if (stream) { + kwargs = PyDict_New(); + if (unlikely(!kwargs)) + return -1; + if (unlikely(PyDict_SetItem(kwargs, PYIDENT("file"), stream) < 0)) + goto bad; + if (!newline) { + end_string = PyUnicode_FromStringAndSize(" ", 1); + if (unlikely(!end_string)) + goto bad; + if (PyDict_SetItem(kwargs, PYIDENT("end"), end_string) < 0) { + Py_DECREF(end_string); + goto bad; + } + Py_DECREF(end_string); + } + } else if (!newline) { + if (unlikely(!NAMED_CGLOBAL(print_function_kwargs))) { + NAMED_CGLOBAL(print_function_kwargs) = PyDict_New(); + if (unlikely(!NAMED_CGLOBAL(print_function_kwargs))) + return -1; + end_string = PyUnicode_FromStringAndSize(" ", 1); + if (unlikely(!end_string)) + return -1; + if (PyDict_SetItem(NAMED_CGLOBAL(print_function_kwargs), PYIDENT("end"), end_string) < 0) { + Py_DECREF(end_string); + return -1; + } + Py_DECREF(end_string); + } + kwargs = NAMED_CGLOBAL(print_function_kwargs); + } + result = PyObject_Call(NAMED_CGLOBAL(print_function), arg_tuple, kwargs); + if (unlikely(kwargs) && (kwargs != NAMED_CGLOBAL(print_function_kwargs))) + Py_DECREF(kwargs); + if (!result) + return -1; + Py_DECREF(result); + return 0; +bad: + if (kwargs != NAMED_CGLOBAL(print_function_kwargs)) + Py_XDECREF(kwargs); + return -1; +} + +////////////////////// PrintOne.proto ////////////////////// +//@requires: Print + +static int __Pyx_PrintOne(PyObject* stream, PyObject *o); /*proto*/ + +////////////////////// PrintOne ////////////////////// + +static int __Pyx_PrintOne(PyObject* stream, PyObject *o) { + int res; + PyObject* arg_tuple = PyTuple_Pack(1, o); + if (unlikely(!arg_tuple)) + return -1; + res = __Pyx_Print(stream, arg_tuple, 1); + Py_DECREF(arg_tuple); + return res; +} diff --git a/venv/lib/python3.10/site-packages/Cython/Utility/Profile.c b/venv/lib/python3.10/site-packages/Cython/Utility/Profile.c new file mode 100644 index 0000000000000000000000000000000000000000..e20aea6ba7ff0340b4815b8c7ce818fe8d0c6269 --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Utility/Profile.c @@ -0,0 +1,732 @@ +/////////////// Profile_config.proto /////////////// +//@proto_block: utility_code_proto_before_types + +#ifndef CYTHON_PROFILE +#if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_PYPY + #define CYTHON_PROFILE 0 +#else + #define CYTHON_PROFILE 1 +#endif +#endif + +#ifndef CYTHON_TRACE_NOGIL + #define CYTHON_TRACE_NOGIL 0 +#else + #if CYTHON_TRACE_NOGIL && !defined(CYTHON_TRACE) + #define CYTHON_TRACE 1 + #endif +#endif + +#ifndef CYTHON_TRACE + #define CYTHON_TRACE 0 +#endif + + +#if CYTHON_PROFILE || CYTHON_TRACE +#if CYTHON_USE_SYS_MONITORING + + // TODO: make list of event types specific to functions. + typedef enum { + __Pyx_Monitoring_PY_START = 0, + __Pyx_Monitoring_PY_RETURN, + __Pyx_Monitoring_PY_UNWIND, + //__Pyx_Monitoring_CALL, + __Pyx_Monitoring_LINE, + __Pyx_Monitoring_RAISE, + __Pyx_Monitoring_RERAISE, + __Pyx_Monitoring_EXCEPTION_HANDLED, + __Pyx_Monitoring_PY_RESUME, + __Pyx_Monitoring_PY_YIELD, + __Pyx_Monitoring_STOP_ITERATION, + } __Pyx_Monitoring_Event_Index; + + // Note: This is used by the generator/coroutine object struct (in its '.proto' section). + static const unsigned char __Pyx_MonitoringEventTypes[] = { + PY_MONITORING_EVENT_PY_START, + PY_MONITORING_EVENT_PY_RETURN, + PY_MONITORING_EVENT_PY_UNWIND, + //PY_MONITORING_EVENT_CALL, + PY_MONITORING_EVENT_LINE, + PY_MONITORING_EVENT_RAISE, + PY_MONITORING_EVENT_RERAISE, + PY_MONITORING_EVENT_EXCEPTION_HANDLED, + // generator specific: + PY_MONITORING_EVENT_PY_RESUME, + PY_MONITORING_EVENT_PY_YIELD, + PY_MONITORING_EVENT_STOP_ITERATION, + }; + + #define __Pyx_MonitoringEventTypes_CyFunc_count (sizeof(__Pyx_MonitoringEventTypes) - 3) + #define __Pyx_MonitoringEventTypes_CyGen_count (sizeof(__Pyx_MonitoringEventTypes)) + +#endif +#endif + + +/////////////// Profile.proto /////////////// +//@requires: Exceptions.c::PyErrFetchRestore +//@requires: Profile_config +//@substitute: naming + +// Note that cPython ignores PyTrace_EXCEPTION, +// but maybe some other profilers don't. + +#if CYTHON_TRACE + #undef CYTHON_PROFILE_REUSE_FRAME +#endif + +#if CYTHON_USE_MODULE_STATE + #undef CYTHON_PROFILE_REUSE_CODEOBJ + #define CYTHON_PROFILE_REUSE_CODEOBJ 0 + #undef CYTHON_PROFILE_REUSE_FRAME +#endif + +#ifndef CYTHON_PROFILE_REUSE_CODEOBJ + #define CYTHON_PROFILE_REUSE_CODEOBJ 1 +#endif + +#ifndef CYTHON_PROFILE_REUSE_FRAME + #define CYTHON_PROFILE_REUSE_FRAME 0 +#endif + +#if CYTHON_USE_SYS_MONITORING && (CYTHON_PROFILE || CYTHON_TRACE) + // Some types are shared across modules with an object struct layout that depends on monitoring support. + // We therefore use a different name for the different types. + #define __PYX_MONITORING_ABI_SUFFIX "_mon" +#else + #define __PYX_MONITORING_ABI_SUFFIX +#endif + +#if CYTHON_PROFILE || CYTHON_TRACE + +#if CYTHON_USE_SYS_MONITORING +// Use the Py3.13 monitoring C-API: https://github.com/python/cpython/issues/111997 + + typedef uint64_t __pyx_monitoring_version_type; + + #define __Pyx_TraceDeclarationsFunc \ + PyObject *$frame_code_cname = NULL; \ + PyMonitoringState $monitoring_states_cname[__Pyx_MonitoringEventTypes_CyFunc_count]; \ + int __pyx_exception_already_reported = 0; \ + const int __pyx_sys_monitoring_disabled_in_parallel = 0; CYTHON_UNUSED_VAR(__pyx_sys_monitoring_disabled_in_parallel); + + #define __Pyx_TraceDeclarationsGen \ + PyObject *$frame_code_cname = Py_NewRef($generator_cname->gi_code); \ + PyMonitoringState* $monitoring_states_cname = $generator_cname->$monitoring_states_cname; \ + __pyx_monitoring_version_type $monitoring_version_cname = $generator_cname->$monitoring_version_cname; \ + int __pyx_exception_already_reported = 0; \ + const int __pyx_sys_monitoring_disabled_in_parallel = 0; CYTHON_UNUSED_VAR(__pyx_sys_monitoring_disabled_in_parallel); + + #define __Pyx_IsTracing(event_id) ((!__pyx_sys_monitoring_disabled_in_parallel) && ($monitoring_states_cname[event_id]).active) + #define __Pyx_TraceFrameInit(codeobj) \ + if (codeobj) $frame_code_cname = codeobj; + + #define __Pyx_TurnOffSysMonitoringInParallel \ + const int __pyx_sys_monitoring_disabled_in_parallel = 1; \ + CYTHON_UNUSED_VAR(__pyx_sys_monitoring_disabled_in_parallel); + + CYTHON_UNUSED static PyCodeObject *__Pyx_createFrameCodeObject(const char *funcname, const char *srcfile, int firstlineno); /*proto*/ + CYTHON_UNUSED static int __Pyx__TraceStartFunc(PyMonitoringState *state_array, PyObject *code_obj, int offset, int skip_event); /*proto*/ + CYTHON_UNUSED static int __Pyx__TraceStartGen(PyMonitoringState *state_array, __pyx_monitoring_version_type *version, PyObject *code_obj, int offset); /*proto*/ + CYTHON_UNUSED static int __Pyx__TraceResumeGen(PyMonitoringState *state_array, __pyx_monitoring_version_type *version, PyObject *code_obj, int offset); /*proto*/ + CYTHON_UNUSED static void __Pyx__TraceException(PyMonitoringState *monitoring_state, PyObject *code_obj, int offset, int reraised); /*proto*/ + + #define __Pyx_PyMonitoring_ExitScope(nogil) \ + if (nogil) { \ + (void) __pyx_exception_already_reported; \ + if (CYTHON_TRACE_NOGIL) { \ + PyGILState_STATE state = PyGILState_Ensure(); \ + PyMonitoring_ExitScope(); \ + Py_XDECREF($frame_code_cname); \ + PyGILState_Release(state); \ + } \ + } else { \ + PyMonitoring_ExitScope(); \ + Py_XDECREF($frame_code_cname); \ + } + + + // We check "tstate->tracing" after clearing the monitoring state to prevent re-entry while a trace function is running. + #define __Pyx_TraceStartFunc(funcname, srcfile, firstlineno, offset, nogil, skip_event, goto_error) \ + if ((0) /* !__Pyx_IsTracing(__Pyx_Monitoring_PY_START) */); else { \ + int ret = 0; \ + memset($monitoring_states_cname, 0, sizeof($monitoring_states_cname)); \ + if (nogil) { \ + if (CYTHON_TRACE_NOGIL) { \ + PyGILState_STATE state = PyGILState_Ensure(); \ + if (!__Pyx_PyThreadState_Current->tracing) { \ + if (likely($frame_code_cname)) Py_INCREF($frame_code_cname); \ + else $frame_code_cname = (PyObject*) __Pyx_createFrameCodeObject(funcname, srcfile, firstlineno); \ + if (unlikely(!$frame_code_cname)) ret = -1; \ + else ret = __Pyx__TraceStartFunc($monitoring_states_cname, $frame_code_cname, offset, skip_event); \ + } else $frame_code_cname = NULL; \ + PyGILState_Release(state); \ + } else $frame_code_cname = NULL; \ + } else { \ + if (!__Pyx_PyThreadState_Current->tracing) { \ + if (likely($frame_code_cname)) Py_INCREF($frame_code_cname); \ + else $frame_code_cname = (PyObject*) __Pyx_createFrameCodeObject(funcname, srcfile, firstlineno); \ + if (unlikely(!$frame_code_cname)) ret = -1; \ + else ret = __Pyx__TraceStartFunc($monitoring_states_cname, $frame_code_cname, offset, skip_event); \ + } else $frame_code_cname = NULL; \ + } \ + if (unlikely(ret == -1)) goto_error; \ + } + + // TODO: We should prevent tracing inside of trace functions (tstate->tracing > 0). + // 'nogil' is obviously unused + #define __Pyx_TraceStartGen(funcname, srcfile, firstlineno, offset, nogil, skip_event, goto_error) \ + if ((0) /* !__Pyx_IsTracing(__Pyx_Monitoring_PY_START) */); else { \ + int ret = __Pyx__TraceStartGen($monitoring_states_cname, &$monitoring_version_cname, $frame_code_cname, offset); \ + if (unlikely(ret == -1)) goto_error; \ + } + + // TODO: We should prevent tracing inside of trace functions (tstate->tracing > 0). + #define __Pyx_TraceResumeGen(funcname, srcfile, firstlineno, offset, goto_error) \ + if ((0) /* !__Pyx_IsTracing(__Pyx_Monitoring_PY_RESUME) */); else { \ + int ret = __Pyx__TraceResumeGen($monitoring_states_cname, &$monitoring_version_cname, $frame_code_cname, offset); \ + if (unlikely(ret == -1)) goto_error; \ + } + + #define __Pyx_TraceYield(result, offset, goto_error) \ + if (!__Pyx_IsTracing(__Pyx_Monitoring_PY_YIELD)); else { \ + int ret = PyMonitoring_FirePyYieldEvent(&$monitoring_states_cname[__Pyx_Monitoring_PY_RETURN], $frame_code_cname, offset, result); \ + PyMonitoring_ExitScope(); \ + if (unlikely(ret == -1)) goto_error; \ + } + +// #if PY_VERSION_HEX >= 0x030d00b2 +// #define __Pyx_TraceStopIteration(value, offset, goto_error) \ +// if (!__Pyx_IsTracing(__Pyx_Monitoring_STOP_ITERATION)); else { \ +// int ret = PyMonitoring_FireStopIterationEvent(&$monitoring_states_cname[__Pyx_Monitoring_STOP_ITERATION], $frame_code_cname, offset, value); \ +// if (unlikely(ret == -1)) goto_error; \ +// } +// #else +// #define __Pyx_TraceStopIteration(value, offset, goto_error) \ +// if (!__Pyx_IsTracing(__Pyx_Monitoring_STOP_ITERATION)); else { \ +// PyErr_SetObject(PyExc_StopIteration, value); \ +// int ret = PyMonitoring_FireStopIterationEvent(&$monitoring_states_cname[__Pyx_Monitoring_STOP_ITERATION], $frame_code_cname, offset, value); \ +// if (unlikely(ret == -1)) goto_error; \ +// PyErr_SetRaisedException(NULL); \ +// } +// #endif + + // No error handling here since the exception path will be taken either way. + #define __Pyx_TraceException(offset, reraised, fresh) \ + if (!__Pyx_IsTracing((reraised) ? __Pyx_Monitoring_RERAISE : __Pyx_Monitoring_RAISE)); else { \ + if (fresh || reraised || !__pyx_exception_already_reported) { \ + __Pyx__TraceException(&$monitoring_states_cname[(reraised) ? __Pyx_Monitoring_RERAISE : __Pyx_Monitoring_RAISE], $frame_code_cname, offset, reraised); \ + } \ + __pyx_exception_already_reported = 1; \ + } + + #define __Pyx_TraceExceptionDone() __pyx_exception_already_reported = 0 + + // No error handling here since the exception path we'll catch the exception next. + #define __Pyx_TraceExceptionHandled(offset) \ + if (!__Pyx_IsTracing(__Pyx_Monitoring_EXCEPTION_HANDLED)); else { \ + (void) PyMonitoring_FireExceptionHandledEvent(&$monitoring_states_cname[__Pyx_Monitoring_EXCEPTION_HANDLED], $frame_code_cname, offset); \ + __pyx_exception_already_reported = 0; \ + } + + // We assume that we own a safe reference to the returned value, usually in `__pyx_r`. + #define __Pyx_TraceReturnValue(result, offset, nogil, goto_error) \ + if (!__Pyx_IsTracing(__Pyx_Monitoring_PY_RETURN)); else { \ + int ret = 0; \ + if (nogil) { \ + if (CYTHON_TRACE_NOGIL) { \ + PyGILState_STATE state = PyGILState_Ensure(); \ + ret = PyMonitoring_FirePyReturnEvent(&$monitoring_states_cname[__Pyx_Monitoring_PY_RETURN], $frame_code_cname, offset, result); \ + PyGILState_Release(state); \ + } \ + } else { \ + ret = PyMonitoring_FirePyReturnEvent(&$monitoring_states_cname[__Pyx_Monitoring_PY_RETURN], $frame_code_cname, offset, result); \ + } \ + if (unlikely(ret == -1)) goto_error; \ + } + + #define __Pyx_TraceReturnCValue(cresult, convert_function, offset, nogil, goto_error) \ + if (!__Pyx_IsTracing(__Pyx_Monitoring_PY_RETURN)); else { \ + int ret = 0; \ + if (nogil) { \ + if (CYTHON_TRACE_NOGIL) { \ + PyGILState_STATE state = PyGILState_Ensure(); \ + PyObject *pyvalue = convert_function(cresult); \ + if (unlikely(!pyvalue)) { \ + PyErr_Clear(); \ + pyvalue = Py_None; Py_INCREF(Py_None); \ + } \ + ret = PyMonitoring_FirePyReturnEvent(&$monitoring_states_cname[__Pyx_Monitoring_PY_RETURN], $frame_code_cname, offset, pyvalue); \ + Py_DECREF(pyvalue); \ + PyGILState_Release(state); \ + } \ + } else { \ + PyObject *pyvalue = convert_function(cresult); \ + if (unlikely(!pyvalue)) { \ + PyErr_Clear(); \ + pyvalue = Py_None; Py_INCREF(Py_None); \ + } \ + ret = PyMonitoring_FirePyReturnEvent(&$monitoring_states_cname[__Pyx_Monitoring_PY_RETURN], $frame_code_cname, offset, pyvalue); \ + Py_DECREF(pyvalue); \ + } \ + if (unlikely(ret == -1)) goto_error; \ + } + + // We don't need an exception goto in __Pyx_TraceExceptionUnwind() because we are propagating an exception either way. + #define __Pyx_TraceExceptionUnwind(offset, nogil) \ + if (!__Pyx_IsTracing(__Pyx_Monitoring_PY_UNWIND)); else { \ + if (nogil) { \ + if (CYTHON_TRACE_NOGIL) { \ + PyGILState_STATE state = PyGILState_Ensure(); \ + (void) PyMonitoring_FirePyUnwindEvent(&$monitoring_states_cname[__Pyx_Monitoring_PY_UNWIND], $frame_code_cname, offset); \ + PyGILState_Release(state); \ + } \ + } else { \ + (void) PyMonitoring_FirePyUnwindEvent(&$monitoring_states_cname[__Pyx_Monitoring_PY_UNWIND], $frame_code_cname, offset); \ + } \ + } + + #if CYTHON_TRACE + + CYTHON_UNUSED static int __Pyx__TraceLine(PyMonitoringState *monitoring_state, PyObject *code_obj, int line, int offset); /*proto*/ + + #define __Pyx_TraceLine(line, offset, nogil, goto_error) \ + if (!__Pyx_IsTracing(__Pyx_Monitoring_LINE)); else { \ + int ret = 0; \ + if (nogil) { \ + if (CYTHON_TRACE_NOGIL) { \ + PyGILState_STATE state = PyGILState_Ensure(); \ + ret = __Pyx__TraceLine(&$monitoring_states_cname[__Pyx_Monitoring_LINE], $frame_code_cname, line, offset); \ + PyGILState_Release(state); \ + } \ + } else { \ + ret = __Pyx__TraceLine(&$monitoring_states_cname[__Pyx_Monitoring_LINE], $frame_code_cname, line, offset); \ + } \ + if (unlikely(ret == -1)) goto_error; \ + } + #endif + +#else +// No PyMonitoring C-API (Py3.13+), use pre-Py3.12 profiling/tracing "C-API". + + #include "compile.h" + #include "frameobject.h" + #include "traceback.h" +#if PY_VERSION_HEX >= 0x030b00a6 && !defined(PYPY_VERSION) + #ifndef Py_BUILD_CORE + #define Py_BUILD_CORE 1 + #endif + #include "internal/pycore_frame.h" +#endif + + #if CYTHON_PROFILE_REUSE_FRAME + #define CYTHON_FRAME_MODIFIER static + #define CYTHON_FRAME_DEL(frame) + #else + #define CYTHON_FRAME_MODIFIER + #define CYTHON_FRAME_DEL(frame) Py_CLEAR(frame) + #endif + + #if CYTHON_PROFILE_REUSE_CODEOBJ + #define CYTHON_CODEOBJ_MODIFIER static + #else + #define CYTHON_CODEOBJ_MODIFIER + #endif + + + #define __Pyx_TraceDeclarationsFunc \ + CYTHON_CODEOBJ_MODIFIER PyCodeObject *$frame_code_cname = NULL; \ + CYTHON_FRAME_MODIFIER PyFrameObject *$frame_cname = NULL; \ + int __Pyx_use_tracing = 0; + + #define __Pyx_TraceDeclarationsGen \ + PyObject *$frame_code_cname = $generator_cname->gi_code; \ + CYTHON_FRAME_MODIFIER PyFrameObject *$frame_cname = NULL; \ + int __Pyx_use_tracing = 0; + + #define __Pyx_TraceFrameInit(codeobj) \ + if (codeobj) $frame_code_cname = (PyCodeObject*) codeobj; + + #define __Pyx_PyMonitoring_ExitScope(nogil) \ + if (!CYTHON_PROFILE_REUSE_FRAME && nogil) { \ + PyGILState_STATE state = PyGILState_Ensure(); \ + CYTHON_FRAME_DEL($frame_cname); \ + PyGILState_Release(state); \ + } else { \ + CYTHON_FRAME_DEL($frame_cname); \ + } + #define __Pyx_TraceException(offset, reraised, fresh) {} + #define __Pyx_TraceExceptionHandled(offset) {} + #define __Pyx_TraceExceptionDone() {} + #define __Pyx_TurnOffSysMonitoringInParallel {} // Only needed for freethreading + +#if PY_VERSION_HEX >= 0x030b00a2 + #if PY_VERSION_HEX >= 0x030C00b1 + #define __Pyx_IsTracing(tstate, check_tracing, check_funcs) \ + ((!(check_tracing) || !(tstate)->tracing) && \ + (!(check_funcs) || (tstate)->c_profilefunc || (CYTHON_TRACE && (tstate)->c_tracefunc))) + #else + #define __Pyx_IsTracing(tstate, check_tracing, check_funcs) \ + (unlikely((tstate)->cframe->use_tracing) && \ + (!(check_tracing) || !(tstate)->tracing) && \ + (!(check_funcs) || (tstate)->c_profilefunc || (CYTHON_TRACE && (tstate)->c_tracefunc))) + #endif + + #define __Pyx_EnterTracing(tstate) PyThreadState_EnterTracing(tstate) + #define __Pyx_LeaveTracing(tstate) PyThreadState_LeaveTracing(tstate) + +#elif PY_VERSION_HEX >= 0x030a00b1 + #define __Pyx_IsTracing(tstate, check_tracing, check_funcs) \ + (unlikely((tstate)->cframe->use_tracing) && \ + (!(check_tracing) || !(tstate)->tracing) && \ + (!(check_funcs) || (tstate)->c_profilefunc || (CYTHON_TRACE && (tstate)->c_tracefunc))) + + #define __Pyx_EnterTracing(tstate) \ + do { tstate->tracing++; tstate->cframe->use_tracing = 0; } while (0) + + #define __Pyx_LeaveTracing(tstate) \ + do { \ + tstate->tracing--; \ + tstate->cframe->use_tracing = ((CYTHON_TRACE && tstate->c_tracefunc != NULL) \ + || tstate->c_profilefunc != NULL); \ + } while (0) + +#else + #define __Pyx_IsTracing(tstate, check_tracing, check_funcs) \ + (unlikely((tstate)->use_tracing) && \ + (!(check_tracing) || !(tstate)->tracing) && \ + (!(check_funcs) || (tstate)->c_profilefunc || (CYTHON_TRACE && (tstate)->c_tracefunc))) + + #define __Pyx_EnterTracing(tstate) \ + do { tstate->tracing++; tstate->use_tracing = 0; } while (0) + + #define __Pyx_LeaveTracing(tstate) \ + do { \ + tstate->tracing--; \ + tstate->use_tracing = ((CYTHON_TRACE && tstate->c_tracefunc != NULL) \ + || tstate->c_profilefunc != NULL); \ + } while (0) + +#endif + + #define __Pyx_TraceStartFunc(funcname, srcfile, firstlineno, offset, nogil, skip_event, goto_error) \ + if (nogil) { \ + if (CYTHON_TRACE_NOGIL) { \ + PyThreadState *tstate; \ + PyGILState_STATE state = PyGILState_Ensure(); \ + tstate = __Pyx_PyThreadState_Current; \ + if (__Pyx_IsTracing(tstate, 1, 1)) { \ + __Pyx_use_tracing = __Pyx_TraceSetupAndCall((PyCodeObject**)&$frame_code_cname, &$frame_cname, tstate, funcname, srcfile, firstlineno, skip_event); \ + } \ + PyGILState_Release(state); \ + if (unlikely(__Pyx_use_tracing < 0)) goto_error; \ + } \ + } else { \ + PyThreadState* tstate = PyThreadState_GET(); \ + if (__Pyx_IsTracing(tstate, 1, 1)) { \ + __Pyx_use_tracing = __Pyx_TraceSetupAndCall((PyCodeObject**)&$frame_code_cname, &$frame_cname, tstate, funcname, srcfile, firstlineno, skip_event); \ + if (unlikely(__Pyx_use_tracing < 0)) goto_error; \ + } \ + } + + #define __Pyx_TraceStartGen __Pyx_TraceStartFunc + + #define __Pyx_TraceYield(result, offset, goto_error) \ + if (likely(!__Pyx_use_tracing)); else { \ + PyThreadState* tstate = __Pyx_PyThreadState_Current; \ + if (__Pyx_IsTracing(tstate, 0, 0)) { \ + __Pyx_call_return_trace_func(tstate, $frame_cname, (PyObject*)result); \ + } \ + if ((1)); else goto_error; \ + } + + #define __Pyx_TraceResumeGen(funcname, srcfile, firstlineno, offset, goto_error) \ + __Pyx_TraceStartFunc(funcname, srcfile, firstlineno, offset, 0, 0, goto_error) + + CYTHON_UNUSED static void __Pyx_call_return_trace_func(PyThreadState *tstate, PyFrameObject *frame, PyObject *result) { + PyObject *type, *value, *traceback; + __Pyx_ErrFetchInState(tstate, &type, &value, &traceback); + __Pyx_EnterTracing(tstate); + if (CYTHON_TRACE && tstate->c_tracefunc) + tstate->c_tracefunc(tstate->c_traceobj, frame, PyTrace_RETURN, result); + if (tstate->c_profilefunc) + tstate->c_profilefunc(tstate->c_profileobj, frame, PyTrace_RETURN, result); + __Pyx_LeaveTracing(tstate); + __Pyx_ErrRestoreInState(tstate, type, value, traceback); + } + + #define __Pyx_TraceReturnValue(result, offset, nogil, goto_error) \ + if (likely(!__Pyx_use_tracing)); else { \ + if (nogil) { \ + if (CYTHON_TRACE_NOGIL) { \ + PyThreadState *tstate; \ + PyGILState_STATE state = PyGILState_Ensure(); \ + tstate = __Pyx_PyThreadState_Current; \ + if (__Pyx_IsTracing(tstate, 0, 0)) { \ + __Pyx_call_return_trace_func(tstate, $frame_cname, (PyObject*)result); \ + } \ + PyGILState_Release(state); \ + } \ + } else { \ + PyThreadState* tstate = __Pyx_PyThreadState_Current; \ + if (__Pyx_IsTracing(tstate, 0, 0)) { \ + __Pyx_call_return_trace_func(tstate, $frame_cname, (PyObject*)result); \ + } \ + } \ + if ((1)); else goto_error; \ + } + + #define __Pyx_TraceReturnCValue(cresult, convert_function, offset, nogil, goto_error) \ + if (likely(!__Pyx_use_tracing)); else { \ + if (nogil) { \ + if (CYTHON_TRACE_NOGIL) { \ + PyThreadState *tstate; \ + PyGILState_STATE state = PyGILState_Ensure(); \ + tstate = __Pyx_PyThreadState_Current; \ + if (__Pyx_IsTracing(tstate, 0, 0)) { \ + PyObject *pyvalue = convert_function(cresult); \ + if (unlikely(!pyvalue)) { \ + PyErr_Clear(); \ + pyvalue = Py_None; Py_INCREF(Py_None); \ + } \ + __Pyx_call_return_trace_func(tstate, $frame_cname, pyvalue); \ + Py_DECREF(pyvalue); \ + } \ + PyGILState_Release(state); \ + } \ + } else { \ + PyThreadState* tstate = __Pyx_PyThreadState_Current; \ + if (__Pyx_IsTracing(tstate, 0, 0)) { \ + PyObject *pyvalue = convert_function(cresult); \ + if (unlikely(!pyvalue)) { \ + PyErr_Clear(); \ + pyvalue = Py_None; Py_INCREF(Py_None); \ + } \ + __Pyx_call_return_trace_func(tstate, $frame_cname, pyvalue); \ + Py_DECREF(pyvalue); \ + } \ + } \ + if ((1)); else goto_error; \ + } + + #define __Pyx_TraceExceptionUnwind(offset, nogil) \ + if (likely(!__Pyx_use_tracing)); else { \ + if (nogil) { \ + if (CYTHON_TRACE_NOGIL) { \ + PyThreadState *tstate; \ + PyGILState_STATE state = PyGILState_Ensure(); \ + tstate = __Pyx_PyThreadState_Current; \ + if (__Pyx_IsTracing(tstate, 0, 0)) { \ + __Pyx_call_return_trace_func(tstate, $frame_cname, Py_None); \ + } \ + PyGILState_Release(state); \ + } \ + } else { \ + PyThreadState* tstate = __Pyx_PyThreadState_Current; \ + if (__Pyx_IsTracing(tstate, 0, 0)) { \ + __Pyx_call_return_trace_func(tstate, $frame_cname, Py_None); \ + } \ + } \ + } + + static int __Pyx_TraceSetupAndCall(PyCodeObject** code, PyFrameObject** frame, PyThreadState* tstate, const char *funcname, const char *srcfile, int firstlineno, int skip_event); /*proto*/ + +#if CYTHON_TRACE + CYTHON_UNUSED static int __Pyx_call_line_trace_func(PyThreadState *tstate, PyFrameObject *frame, int line);/*proto*/ + + #define __Pyx_TraceLine(line, offset, nogil, goto_error) \ + if (likely(!__Pyx_use_tracing)); else { \ + int ret = 0; \ + if (nogil) { \ + if (CYTHON_TRACE_NOGIL) { \ + PyThreadState *tstate; \ + PyGILState_STATE state = __Pyx_PyGILState_Ensure(); \ + tstate = __Pyx_PyThreadState_Current; \ + if (__Pyx_IsTracing(tstate, 0, 0) && tstate->c_tracefunc && $frame_cname->f_trace) { \ + ret = __Pyx_call_line_trace_func(tstate, $frame_cname, line); \ + } \ + __Pyx_PyGILState_Release(state); \ + } \ + } else { \ + PyThreadState* tstate = __Pyx_PyThreadState_Current; \ + if (__Pyx_IsTracing(tstate, 0, 0) && tstate->c_tracefunc && $frame_cname->f_trace) { \ + ret = __Pyx_call_line_trace_func(tstate, $frame_cname, line); \ + } \ + } \ + if (unlikely(ret)) goto_error; \ + } +#endif + +// End of pre-monitoring implementation (Py<3.12) +#endif + +#else +// ! (CYTHON_TRACE || CYTHON_PROFILE) + + #define __Pyx_TraceDeclarationsFunc + #define __Pyx_TraceDeclarationsGen + #define __Pyx_TraceExceptionDone() {} + #define __Pyx_TraceFrameInit(codeobj) {} + #define __Pyx_TurnOffSysMonitoringInParallel {} + #define __Pyx_PyMonitoring_ExitScope(nogil) {} + #define __Pyx_TraceException(offset, reraised, fresh) {} + #define __Pyx_TraceExceptionUnwind(offset, nogil) {} + #define __Pyx_TraceExceptionHandled(offset) {} + // mark error label as used to avoid compiler warnings + #define __Pyx_TraceStartFunc(funcname, srcfile, firstlineno, offset, nogil, skip_event, goto_error) if ((1)); else goto_error; + #define __Pyx_TraceStartGen __Pyx_TraceStartFunc + #define __Pyx_TraceResumeGen(funcname, srcfile, firstlineno, offset, goto_error) if ((1)); else goto_error; + #define __Pyx_TraceYield(result, offset, goto_error) if ((1)); else goto_error; + #define __Pyx_TraceReturnValue(result, offset, nogil, goto_error) \ + if ((1)); else goto_error; + #define __Pyx_TraceReturnCValue(cresult, convert_function, offset, nogil, goto_error) \ + if ((1)); else { (void) convert_function; goto_error } + +#endif /* CYTHON_PROFILE || CYTHON_TRACE */ + +#if !CYTHON_TRACE + // mark error label as used to avoid compiler warnings + #define __Pyx_TraceLine(line, offset, nogil, goto_error) if ((1)); else goto_error; +#endif + +/////////////// Profile /////////////// + +#if CYTHON_PROFILE || CYTHON_TRACE + +#if CYTHON_TRACE && !CYTHON_USE_SYS_MONITORING +static int __Pyx_call_line_trace_func(PyThreadState *tstate, PyFrameObject *frame, int line) { + // see call_trace_protected() in CPython's ceval.c + int ret; + PyObject *type, *value, *traceback; + __Pyx_ErrFetchInState(tstate, &type, &value, &traceback); + __Pyx_PyFrame_SetLineNumber(frame, line); + __Pyx_EnterTracing(tstate); + + ret = tstate->c_tracefunc(tstate->c_traceobj, frame, PyTrace_LINE, NULL); + + __Pyx_LeaveTracing(tstate); + if (likely(!ret)) { + __Pyx_ErrRestoreInState(tstate, type, value, traceback); + } else { + Py_XDECREF(type); + Py_XDECREF(value); + Py_XDECREF(traceback); + } + return ret; +} +#endif + +CYTHON_UNUSED static PyCodeObject *__Pyx_createFrameCodeObject(const char *funcname, const char *srcfile, int firstlineno) { + PyCodeObject *py_code = PyCode_NewEmpty(srcfile, funcname, firstlineno); + // make CPython use a fresh dict for "f_locals" at need (see GH #1836) + if (likely(py_code)) { + py_code->co_flags |= CO_OPTIMIZED | CO_NEWLOCALS; + } + return py_code; +} + +#if CYTHON_USE_SYS_MONITORING + +CYTHON_UNUSED static int __Pyx__TraceStartFunc(PyMonitoringState *state_array, PyObject *code_obj, int offset, int skip_event) { + int ret; + __pyx_monitoring_version_type version = 0; + ret = PyMonitoring_EnterScope(state_array, &version, __Pyx_MonitoringEventTypes, __Pyx_MonitoringEventTypes_CyFunc_count); + if (unlikely(ret == -1)) return -1; + return skip_event ? 0 : PyMonitoring_FirePyStartEvent(&state_array[__Pyx_Monitoring_PY_START], code_obj, offset); +} + +CYTHON_UNUSED static int __Pyx__TraceStartGen(PyMonitoringState *state_array, __pyx_monitoring_version_type *version, PyObject *code_obj, int offset) { + int ret; + ret = PyMonitoring_EnterScope(state_array, version, __Pyx_MonitoringEventTypes, __Pyx_MonitoringEventTypes_CyGen_count); + if (unlikely(ret == -1)) return -1; + return PyMonitoring_FirePyStartEvent(&state_array[__Pyx_Monitoring_PY_START], code_obj, offset); +} + +CYTHON_UNUSED static int __Pyx__TraceResumeGen(PyMonitoringState *state_array, __pyx_monitoring_version_type *version, PyObject *code_obj, int offset) { + int ret; + ret = PyMonitoring_EnterScope(state_array, version, __Pyx_MonitoringEventTypes, __Pyx_MonitoringEventTypes_CyGen_count); + if (unlikely(ret == -1)) return -1; + return PyMonitoring_FirePyResumeEvent(&state_array[__Pyx_Monitoring_PY_RESUME], code_obj, offset); +} + +CYTHON_UNUSED static void __Pyx__TraceException(PyMonitoringState *monitoring_state, PyObject *code_obj, int offset, int reraised) { + if (reraised) { + (void) PyMonitoring_FireReraiseEvent(monitoring_state, code_obj, offset); + } else { + (void) PyMonitoring_FireRaiseEvent(monitoring_state, code_obj, offset); + } +} + +#if CYTHON_TRACE +CYTHON_UNUSED static int __Pyx__TraceLine(PyMonitoringState *monitoring_state, PyObject *code_obj, int line, int offset) { + int ret; + PyObject *exc = PyErr_GetRaisedException(); + ret = PyMonitoring_FireLineEvent(monitoring_state, code_obj, offset, line); + if (exc) PyErr_SetRaisedException(exc); + return ret; +} +#endif + +#else +// pre sys.monitoring + +static int __Pyx_TraceSetupAndCall(PyCodeObject** code, + PyFrameObject** frame, + PyThreadState* tstate, + const char *funcname, + const char *srcfile, + int firstlineno, + int skip_event) { + if (*frame == NULL || !CYTHON_PROFILE_REUSE_FRAME) { + int needs_new_code_obj = (*code == NULL); + if (needs_new_code_obj) { + *code = __Pyx_createFrameCodeObject(funcname, srcfile, firstlineno); + if (*code == NULL) return 0; + } + *frame = PyFrame_New( + tstate, /*PyThreadState *tstate*/ + *code, /*PyCodeObject *code*/ + NAMED_CGLOBAL(moddict_cname), /*PyObject *globals*/ + 0 /*PyObject *locals*/ + ); + if (needs_new_code_obj && !CYTHON_PROFILE_REUSE_CODEOBJ) + Py_CLEAR(*code); // otherwise the reference is owned externally + if (*frame == NULL) return 0; + if (CYTHON_TRACE && (*frame)->f_trace == NULL) { + // this enables "f_lineno" lookup, at least in CPython ... + Py_INCREF(Py_None); + (*frame)->f_trace = Py_None; + } + } + + if (!skip_event) { + PyObject *type, *value, *traceback; + int retval = 1; + __Pyx_PyFrame_SetLineNumber(*frame, firstlineno); + + __Pyx_EnterTracing(tstate); + __Pyx_ErrFetchInState(tstate, &type, &value, &traceback); + + #if CYTHON_TRACE + if (tstate->c_tracefunc) + retval = tstate->c_tracefunc(tstate->c_traceobj, *frame, PyTrace_CALL, NULL) == 0; + if (retval && tstate->c_profilefunc) + #endif + retval = tstate->c_profilefunc(tstate->c_profileobj, *frame, PyTrace_CALL, NULL) == 0; + + __Pyx_LeaveTracing(tstate); + if (unlikely(!retval)) { + Py_XDECREF(type); + Py_XDECREF(value); + Py_XDECREF(traceback); + return -1; + } + + __Pyx_ErrRestoreInState(tstate, type, value, traceback); + } + + return __Pyx_IsTracing(tstate, 0, 0); +} + +#endif +#endif /* CYTHON_PROFILE */ diff --git a/venv/lib/python3.10/site-packages/Cython/Utility/StringTools.c b/venv/lib/python3.10/site-packages/Cython/Utility/StringTools.c new file mode 100644 index 0000000000000000000000000000000000000000..132084a42c8949695883d8f0c6601a7a662d45b9 --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Utility/StringTools.c @@ -0,0 +1,1277 @@ + +//////////////////// IncludeStringH.proto //////////////////// + +#include + +//////////////////// IncludeCppStringH.proto //////////////////// + +#include + +//////////////////// IncludeCppStringViewH.proto //////////////////// + +#include + + +//////////////////// ssize_pyunicode_strlen.proto //////////////////// + +static CYTHON_INLINE Py_ssize_t __Pyx_Py_UNICODE_ssize_strlen(const Py_UNICODE *u);/*proto*/ + +//////////////////// ssize_pyunicode_strlen //////////////////// +//@requires: pyunicode_strlen + +static CYTHON_INLINE Py_ssize_t __Pyx_Py_UNICODE_ssize_strlen(const Py_UNICODE *u) { + size_t len = __Pyx_Py_UNICODE_strlen(u); + if (unlikely(len > PY_SSIZE_T_MAX)) { + PyErr_SetString(PyExc_OverflowError, "Py_UNICODE string is too long"); + return -1; + } + return (Py_ssize_t) len; +} + +//////////////////// pyunicode_strlen.proto /////////////// + +// There used to be a Py_UNICODE_strlen() in CPython 3.x, but it is deprecated since Py3.3. +static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u); /* proto */ + +//////////////////// pyunicode_strlen ///////////////////// + +// Note: will not work in the limited API since Py_UNICODE is not available there. +// May stop working at some point after Python 3.13 (deprecated) +static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) +{ + const Py_UNICODE *u_end = u; + while (*u_end++) ; + return (size_t)(u_end - u - 1); +} + +//////////////////// pyunicode_from_unicode.proto ////////////////////// +//@requires: pyunicode_strlen + +#define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u)) +#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode + + +//////////////////// InitStrings.proto //////////////////// +//@proto_block: pystring_table + +static int __Pyx_InitStrings(__Pyx_StringTabEntry const *t, PyObject **target, const char* const* encoding_names); /*proto*/ + +//////////////////// InitStrings //////////////////// + +static int __Pyx_InitStrings(__Pyx_StringTabEntry const *t, PyObject **target, const char* const* encoding_names) { + while (t->s) { + PyObject *str; + if (t->is_unicode) { + if (t->intern) { + str = PyUnicode_InternFromString(t->s); + } else if (t->encoding) { + str = PyUnicode_Decode(t->s, t->n - 1, encoding_names[t->encoding], NULL); + } else { + str = PyUnicode_FromStringAndSize(t->s, t->n - 1); + } + } else { + str = PyBytes_FromStringAndSize(t->s, t->n - 1); + } + if (!str) + return -1; + *target = str; + // initialise cached hash value + if (PyObject_Hash(str) == -1) + return -1; + ++t; + ++target; + } + return 0; +} + +//////////////////// BytesContains.proto //////////////////// + +static CYTHON_INLINE int __Pyx_BytesContains(PyObject* bytes, char character); /*proto*/ + +//////////////////// BytesContains //////////////////// +//@requires: IncludeStringH + +static CYTHON_INLINE int __Pyx_BytesContains(PyObject* bytes, char character) { + const Py_ssize_t length = __Pyx_PyBytes_GET_SIZE(bytes); +#if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(length == -1)) return -1; +#endif + const char* char_start = __Pyx_PyBytes_AsString(bytes); +#if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely(!char_start)) return -1; +#endif + return memchr(char_start, (unsigned char)character, (size_t)length) != NULL; +} + + +//////////////////// PyUCS4InUnicode.proto //////////////////// + +static CYTHON_INLINE int __Pyx_UnicodeContainsUCS4(PyObject* unicode, Py_UCS4 character); /*proto*/ + +//////////////////// PyUCS4InUnicode //////////////////// + +static CYTHON_INLINE int __Pyx_UnicodeContainsUCS4(PyObject* unicode, Py_UCS4 character) { + // Note that from Python 3.7, the indices of FindChar are adjusted to match the bounds + // so need to check the length + Py_ssize_t idx = PyUnicode_FindChar(unicode, character, 0, PY_SSIZE_T_MAX, 1); + if (unlikely(idx == -2)) return -1; + // >= 0: found the index, == -1: not found + return idx >= 0; +} + + +//////////////////// PyUnicodeContains.proto //////////////////// + +static CYTHON_INLINE int __Pyx_PyUnicode_ContainsTF(PyObject* substring, PyObject* text, int eq) { + int result = PyUnicode_Contains(text, substring); + return unlikely(result < 0) ? result : (result == (eq == Py_EQ)); +} + + +//////////////////// CStringEquals.proto //////////////////// + +static CYTHON_INLINE int __Pyx_StrEq(const char *, const char *); /*proto*/ + +//////////////////// CStringEquals //////////////////// + +static CYTHON_INLINE int __Pyx_StrEq(const char *s1, const char *s2) { + while (*s1 != '\0' && *s1 == *s2) { s1++; s2++; } + return *s1 == *s2; +} + + +//////////////////// UnicodeEquals.proto //////////////////// + +static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals); /*proto*/ + +//////////////////// UnicodeEquals //////////////////// +//@requires: BytesEquals + +static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals) { +#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_GRAAL + return PyObject_RichCompareBool(s1, s2, equals); +#else + int s1_is_unicode, s2_is_unicode; + if (s1 == s2) { + /* as done by PyObject_RichCompareBool(); also catches the (interned) empty string */ + goto return_eq; + } + s1_is_unicode = PyUnicode_CheckExact(s1); + s2_is_unicode = PyUnicode_CheckExact(s2); + if (s1_is_unicode & s2_is_unicode) { + Py_ssize_t length, length2; + int kind; + void *data1, *data2; + #if !CYTHON_COMPILING_IN_LIMITED_API + if (unlikely(__Pyx_PyUnicode_READY(s1) < 0) || unlikely(__Pyx_PyUnicode_READY(s2) < 0)) + return -1; + #endif + length = __Pyx_PyUnicode_GET_LENGTH(s1); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(length < 0)) return -1; + #endif + length2 = __Pyx_PyUnicode_GET_LENGTH(s2); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(length2 < 0)) return -1; + #endif + if (length != length2) { + goto return_ne; + } +#if CYTHON_USE_UNICODE_INTERNALS + { + Py_hash_t hash1, hash2; + hash1 = ((PyASCIIObject*)s1)->hash; + hash2 = ((PyASCIIObject*)s2)->hash; + if (hash1 != hash2 && hash1 != -1 && hash2 != -1) { + goto return_ne; + } + } +#endif + // len(s1) == len(s2) >= 1 (empty string is interned, and "s1 is not s2") + kind = __Pyx_PyUnicode_KIND(s1); + if (kind != __Pyx_PyUnicode_KIND(s2)) { + goto return_ne; + } + data1 = __Pyx_PyUnicode_DATA(s1); + data2 = __Pyx_PyUnicode_DATA(s2); + if (__Pyx_PyUnicode_READ(kind, data1, 0) != __Pyx_PyUnicode_READ(kind, data2, 0)) { + goto return_ne; + } else if (length == 1) { + goto return_eq; + } else { + int result = memcmp(data1, data2, (size_t)(length * kind)); + return (equals == Py_EQ) ? (result == 0) : (result != 0); + } + } else if ((s1 == Py_None) & s2_is_unicode) { + goto return_ne; + } else if ((s2 == Py_None) & s1_is_unicode) { + goto return_ne; + } else { + int result; + PyObject* py_result = PyObject_RichCompare(s1, s2, equals); + if (!py_result) + return -1; + result = __Pyx_PyObject_IsTrue(py_result); + Py_DECREF(py_result); + return result; + } +return_eq: + return (equals == Py_EQ); +return_ne: + return (equals == Py_NE); +#endif +} + + +//////////////////// BytesEquals.proto //////////////////// + +static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals); /*proto*/ + +//////////////////// BytesEquals //////////////////// +//@requires: IncludeStringH + +static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals) { +#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_GRAAL || \ + !(CYTHON_ASSUME_SAFE_SIZE && CYTHON_ASSUME_SAFE_MACROS) + return PyObject_RichCompareBool(s1, s2, equals); +#else + if (s1 == s2) { + /* as done by PyObject_RichCompareBool(); also catches the (interned) empty string */ + return (equals == Py_EQ); + } else if (PyBytes_CheckExact(s1) & PyBytes_CheckExact(s2)) { + const char *ps1, *ps2; + Py_ssize_t length = PyBytes_GET_SIZE(s1); + if (length != PyBytes_GET_SIZE(s2)) + return (equals == Py_NE); + // len(s1) == len(s2) >= 1 (empty string is interned, and "s1 is not s2") + ps1 = PyBytes_AS_STRING(s1); + ps2 = PyBytes_AS_STRING(s2); + if (ps1[0] != ps2[0]) { + return (equals == Py_NE); + } else if (length == 1) { + return (equals == Py_EQ); + } else { + int result; +#if CYTHON_USE_UNICODE_INTERNALS && (PY_VERSION_HEX < 0x030B0000) + Py_hash_t hash1, hash2; + hash1 = ((PyBytesObject*)s1)->ob_shash; + hash2 = ((PyBytesObject*)s2)->ob_shash; + if (hash1 != hash2 && hash1 != -1 && hash2 != -1) { + return (equals == Py_NE); + } +#endif + result = memcmp(ps1, ps2, (size_t)length); + return (equals == Py_EQ) ? (result == 0) : (result != 0); + } + } else if ((s1 == Py_None) & PyBytes_CheckExact(s2)) { + return (equals == Py_NE); + } else if ((s2 == Py_None) & PyBytes_CheckExact(s1)) { + return (equals == Py_NE); + } else { + int result; + PyObject* py_result = PyObject_RichCompare(s1, s2, equals); + if (!py_result) + return -1; + result = __Pyx_PyObject_IsTrue(py_result); + Py_DECREF(py_result); + return result; + } +#endif +} + +//////////////////// SetStringIndexingError.proto ///////////////// + +static void __Pyx_SetStringIndexingError(const char* message, int has_gil); /* proto */ + +//////////////////// SetStringIndexingError ///////////////// + +static void __Pyx_SetStringIndexingError(const char* message, int has_gil) { + if (!has_gil) { + PyGILState_STATE gil_state = PyGILState_Ensure(); + PyErr_SetString(PyExc_IndexError, message); + PyGILState_Release(gil_state); + } else + PyErr_SetString(PyExc_IndexError, message); +} + +//////////////////// GetItemIntByteArray.proto //////////////////// +//@requires: SetStringIndexingError + +#define __Pyx_GetItemInt_ByteArray(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck, has_gil) \ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ? \ + __Pyx_GetItemInt_ByteArray_Fast(o, (Py_ssize_t)i, wraparound, boundscheck, has_gil) : \ + (__Pyx_SetStringIndexingError("bytearray index out of range", has_gil), -1)) + +static CYTHON_INLINE int __Pyx_GetItemInt_ByteArray_Fast(PyObject* string, Py_ssize_t i, + int wraparound, int boundscheck, int has_gil); + +//////////////////// GetItemIntByteArray //////////////////// + +static CYTHON_INLINE int __Pyx_GetItemInt_ByteArray_Fast(PyObject* string, Py_ssize_t i, + int wraparound, int boundscheck, int has_gil) { + Py_ssize_t length; + if (wraparound | boundscheck) { + length = __Pyx_PyByteArray_GET_SIZE(string); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(length < 0)) return -1; + #endif + if (wraparound & unlikely(i < 0)) i += length; + if ((!boundscheck) || likely(__Pyx_is_valid_index(i, length))) { + #if !CYTHON_ASSUME_SAFE_MACROS + char *asString = PyByteArray_AsString(string); + return likely(asString) ? (unsigned char) asString[i] : -1; + #else + return (unsigned char) (PyByteArray_AS_STRING(string)[i]); + #endif + } else { + __Pyx_SetStringIndexingError("bytearray index out of range", has_gil); + return -1; + } + } else { + #if !CYTHON_ASSUME_SAFE_MACROS + char *asString = PyByteArray_AsString(string); + return likely(asString) ? (unsigned char) asString[i] : -1; + #else + return (unsigned char) (PyByteArray_AS_STRING(string)[i]); + #endif + } +} + + +//////////////////// SetItemIntByteArray.proto //////////////////// +//@requires: SetStringIndexingError + +#define __Pyx_SetItemInt_ByteArray(o, i, v, type, is_signed, to_py_func, is_list, wraparound, boundscheck, has_gil) \ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ? \ + __Pyx_SetItemInt_ByteArray_Fast(o, (Py_ssize_t)i, v, wraparound, boundscheck, has_gil) : \ + (__Pyx_SetStringIndexingError("bytearray index out of range", has_gil), -1)) + +static CYTHON_INLINE int __Pyx_SetItemInt_ByteArray_Fast(PyObject* string, Py_ssize_t i, unsigned char v, + int wraparound, int boundscheck, int has_gil); + +//////////////////// SetItemIntByteArray //////////////////// + +static CYTHON_INLINE int __Pyx_SetItemInt_ByteArray_Fast(PyObject* string, Py_ssize_t i, unsigned char v, + int wraparound, int boundscheck, int has_gil) { + Py_ssize_t length; + if (wraparound | boundscheck) { + length = __Pyx_PyByteArray_GET_SIZE(string); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(length < 0)) return -1; + #endif + if (wraparound & unlikely(i < 0)) i += length; + if ((!boundscheck) || likely(__Pyx_is_valid_index(i, length))) { + #if !CYTHON_ASSUME_SAFE_MACROS + char *asString = PyByteArray_AsString(string); + if (unlikely(!asString)) return -1; + asString[i] = (char)v; + #else + PyByteArray_AS_STRING(string)[i] = (char) v; + #endif + return 0; + } else { + __Pyx_SetStringIndexingError("bytearray index out of range", has_gil); + return -1; + } + } else { + #if !CYTHON_ASSUME_SAFE_MACROS + char *asString = PyByteArray_AsString(string); + if (unlikely(!asString)) return -1; + asString[i] = (char)v; + #else + PyByteArray_AS_STRING(string)[i] = (char) v; + #endif + return 0; + } +} + + +//////////////////// GetItemIntUnicode.proto //////////////////// +//@requires: SetStringIndexingError + +#define __Pyx_GetItemInt_Unicode(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck, has_gil) \ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ? \ + __Pyx_GetItemInt_Unicode_Fast(o, (Py_ssize_t)i, wraparound, boundscheck, has_gil) : \ + (__Pyx_SetStringIndexingError("string index out of range", has_gil), (Py_UCS4)-1)) + +static CYTHON_INLINE Py_UCS4 __Pyx_GetItemInt_Unicode_Fast(PyObject* ustring, Py_ssize_t i, + int wraparound, int boundscheck, int has_gil); + +//////////////////// GetItemIntUnicode //////////////////// + +static CYTHON_INLINE Py_UCS4 __Pyx_GetItemInt_Unicode_Fast(PyObject* ustring, Py_ssize_t i, + int wraparound, int boundscheck, int has_gil) { + Py_ssize_t length; + if (unlikely(__Pyx_PyUnicode_READY(ustring) < 0)) return (Py_UCS4)-1; + if (wraparound | boundscheck) { + length = __Pyx_PyUnicode_GET_LENGTH(ustring); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(length < 0)) return (Py_UCS4)-1; + #endif + if (wraparound & unlikely(i < 0)) i += length; + if ((!boundscheck) || likely(__Pyx_is_valid_index(i, length))) { + return __Pyx_PyUnicode_READ_CHAR(ustring, i); + } else { + __Pyx_SetStringIndexingError("string index out of range", has_gil); + return (Py_UCS4)-1; + } + } else { + return __Pyx_PyUnicode_READ_CHAR(ustring, i); + } +} + + +/////////////// decode_c_string_utf16.proto /////////////// + +static CYTHON_INLINE PyObject *__Pyx_PyUnicode_DecodeUTF16(const char *s, Py_ssize_t size, const char *errors) { + int byteorder = 0; + return PyUnicode_DecodeUTF16(s, size, errors, &byteorder); +} +static CYTHON_INLINE PyObject *__Pyx_PyUnicode_DecodeUTF16LE(const char *s, Py_ssize_t size, const char *errors) { + int byteorder = -1; + return PyUnicode_DecodeUTF16(s, size, errors, &byteorder); +} +static CYTHON_INLINE PyObject *__Pyx_PyUnicode_DecodeUTF16BE(const char *s, Py_ssize_t size, const char *errors) { + int byteorder = 1; + return PyUnicode_DecodeUTF16(s, size, errors, &byteorder); +} + +/////////////// decode_cpp_string.proto /////////////// +//@requires: IncludeCppStringH +//@requires: decode_c_bytes + +static CYTHON_INLINE PyObject* __Pyx_decode_cpp_string( + std::string cppstring, Py_ssize_t start, Py_ssize_t stop, + const char* encoding, const char* errors, + PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)) { + return __Pyx_decode_c_bytes( + cppstring.data(), (Py_ssize_t) cppstring.size(), start, stop, encoding, errors, decode_func); +} + +/////////////// decode_cpp_string_view.proto /////////////// +//@requires: IncludeCppStringViewH +//@requires: decode_c_bytes + +static CYTHON_INLINE PyObject* __Pyx_decode_cpp_string_view( + std::string_view cppstring, Py_ssize_t start, Py_ssize_t stop, + const char* encoding, const char* errors, + PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)) { + return __Pyx_decode_c_bytes( + cppstring.data(), (Py_ssize_t) cppstring.size(), start, stop, encoding, errors, decode_func); +} + +/////////////// decode_c_string.proto /////////////// + +static CYTHON_INLINE PyObject* __Pyx_decode_c_string( + const char* cstring, Py_ssize_t start, Py_ssize_t stop, + const char* encoding, const char* errors, + PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)); + +/////////////// decode_c_string /////////////// +//@requires: IncludeStringH +//@requires: decode_c_string_utf16 + +/* duplicate code to avoid calling strlen() if start >= 0 and stop >= 0 */ +static CYTHON_INLINE PyObject* __Pyx_decode_c_string( + const char* cstring, Py_ssize_t start, Py_ssize_t stop, + const char* encoding, const char* errors, + PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)) { + Py_ssize_t length; + if (unlikely((start < 0) | (stop < 0))) { + size_t slen = strlen(cstring); + if (unlikely(slen > (size_t) PY_SSIZE_T_MAX)) { + PyErr_SetString(PyExc_OverflowError, + "c-string too long to convert to Python"); + return NULL; + } + length = (Py_ssize_t) slen; + if (start < 0) { + start += length; + if (start < 0) + start = 0; + } + if (stop < 0) + stop += length; + } + if (unlikely(stop <= start)) + return __Pyx_NewRef(EMPTY(unicode)); + length = stop - start; + cstring += start; + if (decode_func) { + return decode_func(cstring, length, errors); + } else { + return PyUnicode_Decode(cstring, length, encoding, errors); + } +} + +/////////////// decode_c_bytes.proto /////////////// + +static CYTHON_INLINE PyObject* __Pyx_decode_c_bytes( + const char* cstring, Py_ssize_t length, Py_ssize_t start, Py_ssize_t stop, + const char* encoding, const char* errors, + PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)); + +/////////////// decode_c_bytes /////////////// +//@requires: decode_c_string_utf16 + +static CYTHON_INLINE PyObject* __Pyx_decode_c_bytes( + const char* cstring, Py_ssize_t length, Py_ssize_t start, Py_ssize_t stop, + const char* encoding, const char* errors, + PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)) { + if (unlikely((start < 0) | (stop < 0))) { + if (start < 0) { + start += length; + if (start < 0) + start = 0; + } + if (stop < 0) + stop += length; + } + if (stop > length) + stop = length; + if (unlikely(stop <= start)) + return __Pyx_NewRef(EMPTY(unicode)); + length = stop - start; + cstring += start; + if (decode_func) { + return decode_func(cstring, length, errors); + } else { + return PyUnicode_Decode(cstring, length, encoding, errors); + } +} + +/////////////// decode_bytes.proto /////////////// +//@requires: decode_c_bytes + +static CYTHON_INLINE PyObject* __Pyx_decode_bytes( + PyObject* string, Py_ssize_t start, Py_ssize_t stop, + const char* encoding, const char* errors, + PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)) { + char* as_c_string; + Py_ssize_t size; +#if CYTHON_ASSUME_SAFE_MACROS && CYTHON_ASSUME_SAFE_SIZE + as_c_string = PyBytes_AS_STRING(string); + size = PyBytes_GET_SIZE(string); +#else + if (PyBytes_AsStringAndSize(string, &as_c_string, &size) < 0) { + return NULL; + } +#endif + return __Pyx_decode_c_bytes( + as_c_string, size, + start, stop, encoding, errors, decode_func); +} + +/////////////// decode_bytearray.proto /////////////// +//@requires: decode_c_bytes + +static CYTHON_INLINE PyObject* __Pyx_decode_bytearray( + PyObject* string, Py_ssize_t start, Py_ssize_t stop, + const char* encoding, const char* errors, + PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)) { + char* as_c_string; + Py_ssize_t size; +#if CYTHON_ASSUME_SAFE_MACROS && CYTHON_ASSUME_SAFE_SIZE + as_c_string = PyByteArray_AS_STRING(string); + size = PyByteArray_GET_SIZE(string); +#else + if (!(as_c_string = PyByteArray_AsString(string))) return NULL; + if ((size = PyByteArray_Size(string)) < 0) return NULL; +#endif + return __Pyx_decode_c_bytes( + as_c_string, size, + start, stop, encoding, errors, decode_func); +} + +/////////////// PyUnicode_Substring.proto /////////////// + +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_Substring( + PyObject* text, Py_ssize_t start, Py_ssize_t stop); + +/////////////// PyUnicode_Substring /////////////// + +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_Substring( + PyObject* text, Py_ssize_t start, Py_ssize_t stop) { + Py_ssize_t length; + #if !CYTHON_COMPILING_IN_LIMITED_API + if (unlikely(__Pyx_PyUnicode_READY(text) == -1)) return NULL; + #endif + length = __Pyx_PyUnicode_GET_LENGTH(text); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(length < 0)) return NULL; + #endif + if (start < 0) { + start += length; + if (start < 0) + start = 0; + } + if (stop < 0) + stop += length; + else if (stop > length) + stop = length; + if (stop <= start) + return __Pyx_NewRef(EMPTY(unicode)); + if (start == 0 && stop == length) + return __Pyx_NewRef(text); +#if CYTHON_COMPILING_IN_LIMITED_API + // PyUnicode_Substring() does not support negative indexing but is otherwise fine to use. + return PyUnicode_Substring(text, start, stop); +#else + return PyUnicode_FromKindAndData(PyUnicode_KIND(text), + PyUnicode_1BYTE_DATA(text) + start*PyUnicode_KIND(text), stop-start); +#endif +} + +/////////////// py_unicode_predicate.proto /////////////// + +// isprintable() is lacking C-API support in PyPy +#if CYTHON_COMPILING_IN_LIMITED_API{{if method_name == 'isprintable'}} || (CYTHON_COMPILING_IN_PYPY && !defined(Py_UNICODE_ISPRINTABLE)){{endif}} +static int __Pyx_Py_UNICODE_{{method_name.upper()}}(Py_UCS4 uchar);/*proto*/ +#else +{{if method_name == 'istitle'}} +// Py_UNICODE_ISTITLE() doesn't match unicode.istitle() as the latter +// additionally allows character that comply with Py_UNICODE_ISUPPER() +static CYTHON_INLINE int __Pyx_Py_UNICODE_ISTITLE(Py_UCS4 uchar) { + return Py_UNICODE_ISTITLE(uchar) || Py_UNICODE_ISUPPER(uchar); +} +{{else}} +#define __Pyx_Py_UNICODE_{{method_name.upper()}}(u) Py_UNICODE_{{method_name.upper()}}(u) +{{endif}} +#endif + +/////////////// py_unicode_predicate /////////////// + +{{py: +from operator import methodcaller + +char_matches_unicode_type = methodcaller(method_name) + +def first_nonascii_chr(method_name, _matches=char_matches_unicode_type): + from sys import maxunicode + + for code_point in range(128, maxunicode): + if _matches(chr(code_point)): + return code_point + return maxunicode + +def format_chr_for_c(i): + c = chr(i) + if c == "'": + return r"(Py_UCS4)'\''" + if c == '\\': + return r"(Py_UCS4)'\\'" + if c.isprintable(): + return f"(Py_UCS4)'{c}'" + return str(i) +}} + +#if CYTHON_COMPILING_IN_LIMITED_API{{if method_name == 'isprintable'}} || (CYTHON_COMPILING_IN_PYPY && !defined(Py_UNICODE_ISPRINTABLE)){{endif}} +static int __Pyx_Py_UNICODE_{{method_name.upper()}}(Py_UCS4 uchar) { + int result; + PyObject *py_result, *ustring; + // Add a fast path for ascii - the switch statements get prohibitively big if we try to include + // all of unicode. + if (uchar < {{first_nonascii_chr(method_name)}}) { + switch (uchar) { + {{for i in range(128):}} + {{if char_matches_unicode_type(chr(i)) }} + case {{format_chr_for_c(i)}}: + {{endif}} + {{endfor}} + return 1; + } + return 0; + } + ustring = PyUnicode_FromOrdinal(uchar); + if (!ustring) goto bad; + py_result = PyObject_CallMethod(ustring, "{{method_name}}", NULL); + Py_DECREF(ustring); + if (!py_result) goto bad; + result = PyObject_IsTrue(py_result); + Py_DECREF(py_result); + if (result == -1) goto bad; + return result != 0; + +bad: + PyErr_Clear(); + return 0; /* cannot fail */ +} +#endif + + +/////////////// unicode_tailmatch.proto /////////////// + +static int __Pyx_PyUnicode_Tailmatch( + PyObject* s, PyObject* substr, Py_ssize_t start, Py_ssize_t end, int direction); /*proto*/ + +/////////////// unicode_tailmatch /////////////// + +// Python's unicode.startswith() and unicode.endswith() support a +// tuple of prefixes/suffixes, whereas it's much more common to +// test for a single unicode string. + +static int __Pyx_PyUnicode_TailmatchTuple(PyObject* s, PyObject* substrings, + Py_ssize_t start, Py_ssize_t end, int direction) { + Py_ssize_t i, count = __Pyx_PyTuple_GET_SIZE(substrings); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(count < 0)) return -1; + #endif + for (i = 0; i < count; i++) { + Py_ssize_t result; +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + result = PyUnicode_Tailmatch(s, PyTuple_GET_ITEM(substrings, i), + start, end, direction); +#else + PyObject* sub = __Pyx_PySequence_ITEM(substrings, i); + if (unlikely(!sub)) return -1; + result = PyUnicode_Tailmatch(s, sub, start, end, direction); + Py_DECREF(sub); +#endif + if (result) { + return (int) result; + } + } + return 0; +} + +static int __Pyx_PyUnicode_Tailmatch(PyObject* s, PyObject* substr, + Py_ssize_t start, Py_ssize_t end, int direction) { + if (unlikely(PyTuple_Check(substr))) { + return __Pyx_PyUnicode_TailmatchTuple(s, substr, start, end, direction); + } + return (int) PyUnicode_Tailmatch(s, substr, start, end, direction); +} + + +/////////////// bytes_tailmatch.proto /////////////// + +static int __Pyx_PyBytes_SingleTailmatch(PyObject* self, PyObject* arg, + Py_ssize_t start, Py_ssize_t end, int direction); /*proto*/ +static int __Pyx_PyBytes_Tailmatch(PyObject* self, PyObject* substr, + Py_ssize_t start, Py_ssize_t end, int direction); /*proto*/ + +/////////////// bytes_tailmatch /////////////// + +static int __Pyx_PyBytes_SingleTailmatch(PyObject* self, PyObject* arg, + Py_ssize_t start, Py_ssize_t end, int direction) { + char* self_ptr; + Py_ssize_t self_len; + char* sub_ptr; + Py_ssize_t sub_len; + int retval; + + #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030b0000 + PyObject *converted_arg = NULL; + #else + Py_buffer view; + view.obj = NULL; + #endif + + #if !(CYTHON_ASSUME_SAFE_MACROS && CYTHON_ASSUME_SAFE_SIZE) + if (PyBytes_AsStringAndSize(self, &self_ptr, &self_len) == -1) return -1; + #else + self_ptr = PyBytes_AS_STRING(self); + self_len = PyBytes_GET_SIZE(self); + #endif + + if (PyBytes_Check(arg)) { + #if !(CYTHON_ASSUME_SAFE_MACROS && CYTHON_ASSUME_SAFE_SIZE) + if (PyBytes_AsStringAndSize(arg, &sub_ptr, &sub_len) == -1) return -1; + #else + sub_ptr = PyBytes_AS_STRING(arg); + sub_len = PyBytes_GET_SIZE(arg); + #endif + } + #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030b0000 + else if (PyByteArray_Check(arg)) { + // The Limited API fallback is inefficient, + // so special-case bytearray to be a bit faster. Keep this to the Limited + // API only since the buffer protocol code is good enough otherwise. + sub_ptr = PyByteArray_AsString(arg); + if (unlikely(!sub_ptr)) return -1; + sub_len = PyByteArray_Size(arg); + if (unlikely(sub_len < 0)) return -1; + } else { + // Where buffer protocol is unavailable, just convert to bytes + // (which is probably inefficient, but does work) + // First check that the object is a buffer (since PyBytes_FromObject) + // is more flexible than what endswith accepts. + PyObject *as_memoryview = PyMemoryView_FromObject(arg); + if (!as_memoryview) return -1; + Py_DECREF(as_memoryview); + converted_arg = PyBytes_FromObject(arg); + if (!converted_arg) return -1; + if (PyBytes_AsStringAndSize(converted_arg, &sub_ptr, &sub_len) == -1) { + Py_DECREF(converted_arg); + return -1; + } + + } + #else // LIMITED_API >= 030B0000 or !LIMITED_API + else { + if (unlikely(PyObject_GetBuffer(arg, &view, PyBUF_SIMPLE) == -1)) + return -1; + sub_ptr = (char*) view.buf; + sub_len = view.len; + } + #endif + + if (end > self_len) + end = self_len; + else if (end < 0) + end += self_len; + if (end < 0) + end = 0; + if (start < 0) + start += self_len; + if (start < 0) + start = 0; + + if (direction > 0) { + /* endswith */ + if (end-sub_len > start) + start = end - sub_len; + } + + if (start + sub_len <= end) + retval = !memcmp(self_ptr+start, sub_ptr, (size_t)sub_len); + else + retval = 0; + + #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030b0000 + Py_XDECREF(converted_arg); + #else + if (view.obj) + PyBuffer_Release(&view); + #endif + + return retval; +} + +static int __Pyx_PyBytes_TailmatchTuple(PyObject* self, PyObject* substrings, + Py_ssize_t start, Py_ssize_t end, int direction) { + Py_ssize_t i, count = __Pyx_PyTuple_GET_SIZE(substrings); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(count < 0)) return -1; + #endif + for (i = 0; i < count; i++) { + int result; +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + result = __Pyx_PyBytes_SingleTailmatch(self, PyTuple_GET_ITEM(substrings, i), + start, end, direction); +#else + PyObject* sub = __Pyx_PySequence_ITEM(substrings, i); + if (unlikely(!sub)) return -1; + result = __Pyx_PyBytes_SingleTailmatch(self, sub, start, end, direction); + Py_DECREF(sub); +#endif + if (result) { + return result; + } + } + return 0; +} + +static int __Pyx_PyBytes_Tailmatch(PyObject* self, PyObject* substr, + Py_ssize_t start, Py_ssize_t end, int direction) { + if (unlikely(PyTuple_Check(substr))) { + return __Pyx_PyBytes_TailmatchTuple(self, substr, start, end, direction); + } + + return __Pyx_PyBytes_SingleTailmatch(self, substr, start, end, direction); +} + + +/////////////// bytes_index.proto /////////////// + +static CYTHON_INLINE char __Pyx_PyBytes_GetItemInt(PyObject* bytes, Py_ssize_t index, int check_bounds); /*proto*/ + +/////////////// bytes_index /////////////// + +static CYTHON_INLINE char __Pyx_PyBytes_GetItemInt(PyObject* bytes, Py_ssize_t index, int check_bounds) { + const char *asString; + if (index < 0) { + Py_ssize_t size = __Pyx_PyBytes_GET_SIZE(bytes); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(size < 0)) return (char) -1; + #endif + index += size; + } + if (check_bounds) { + Py_ssize_t size = __Pyx_PyBytes_GET_SIZE(bytes); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(size < 0)) return (char) -1; + #endif + if (unlikely(!__Pyx_is_valid_index(index, size))) { + PyErr_SetString(PyExc_IndexError, "string index out of range"); + return (char) -1; + } + } + asString = __Pyx_PyBytes_AsString(bytes); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely(!asString)) return (char)-1; + #endif + return asString[index]; +} + + +//////////////////// StringJoin.proto //////////////////// + +static CYTHON_INLINE PyObject* __Pyx_PyBytes_Join(PyObject* sep, PyObject* values); /*proto*/ + +//////////////////// StringJoin //////////////////// +//@requires: ObjectHandling.c::PyObjectCallMethod1 + +static CYTHON_INLINE PyObject* __Pyx_PyBytes_Join(PyObject* sep, PyObject* values) { + // avoid unused function + (void) __Pyx_PyObject_CallMethod1; +#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030e0000 || defined(PyBytes_Join) + return PyBytes_Join(sep, values); +#elif CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030d0000 || defined(_PyBytes_Join) + return _PyBytes_Join(sep, values); +#else + return __Pyx_PyObject_CallMethod1(sep, PYIDENT("join"), values); +#endif +} + + +/////////////// JoinPyUnicode.proto /////////////// + +static PyObject* __Pyx_PyUnicode_Join(PyObject** values, Py_ssize_t value_count, Py_ssize_t result_ulength, + Py_UCS4 max_char); + +/////////////// JoinPyUnicode /////////////// +//@requires: IncludeStringH + +static PyObject* __Pyx_PyUnicode_Join(PyObject** values, Py_ssize_t value_count, Py_ssize_t result_ulength, + Py_UCS4 max_char) { +#if CYTHON_USE_UNICODE_INTERNALS && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + PyObject *result_uval; + int result_ukind, kind_shift; + Py_ssize_t i, char_pos; + void *result_udata; + + if (max_char > 1114111) max_char = 1114111; + result_uval = PyUnicode_New(result_ulength, max_char); + if (unlikely(!result_uval)) return NULL; + result_ukind = (max_char <= 255) ? PyUnicode_1BYTE_KIND : (max_char <= 65535) ? PyUnicode_2BYTE_KIND : PyUnicode_4BYTE_KIND; + kind_shift = (result_ukind == PyUnicode_4BYTE_KIND) ? 2 : result_ukind - 1; + result_udata = PyUnicode_DATA(result_uval); + assert(kind_shift == 2 || kind_shift == 1 || kind_shift == 0); + + if (unlikely((PY_SSIZE_T_MAX >> kind_shift) - result_ulength < 0)) + goto overflow; + + char_pos = 0; + for (i=0; i < value_count; i++) { + int ukind; + Py_ssize_t ulength; + void *udata; + PyObject *uval = values[i]; + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_PyUnicode_READY(uval) == (-1)) + goto bad; + #endif + ulength = __Pyx_PyUnicode_GET_LENGTH(uval); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(ulength < 0)) goto bad; + #endif + if (unlikely(!ulength)) + continue; + if (unlikely((PY_SSIZE_T_MAX >> kind_shift) - ulength < char_pos)) + goto overflow; + ukind = __Pyx_PyUnicode_KIND(uval); + udata = __Pyx_PyUnicode_DATA(uval); + if (ukind == result_ukind) { + memcpy((char *)result_udata + (char_pos << kind_shift), udata, (size_t) (ulength << kind_shift)); + } else { + #if PY_VERSION_HEX >= 0x030d0000 + if (unlikely(PyUnicode_CopyCharacters(result_uval, char_pos, uval, 0, ulength) < 0)) goto bad; + #elif CYTHON_COMPILING_IN_CPYTHON || defined(_PyUnicode_FastCopyCharacters) + _PyUnicode_FastCopyCharacters(result_uval, char_pos, uval, 0, ulength); + #else + Py_ssize_t j; + for (j=0; j < ulength; j++) { + Py_UCS4 uchar = __Pyx_PyUnicode_READ(ukind, udata, j); + __Pyx_PyUnicode_WRITE(result_ukind, result_udata, char_pos+j, uchar); + } + #endif + } + char_pos += ulength; + } + return result_uval; +overflow: + PyErr_SetString(PyExc_OverflowError, "join() result is too long for a Python string"); +bad: + Py_DECREF(result_uval); + return NULL; +#else + // non-CPython fallback + Py_ssize_t i; + PyObject *result = NULL; + PyObject *value_tuple = PyTuple_New(value_count); + if (unlikely(!value_tuple)) return NULL; + CYTHON_UNUSED_VAR(max_char); + CYTHON_UNUSED_VAR(result_ulength); + + for (i=0; i 0) { + i = 0; + if (prepend_sign) { + __Pyx_PyUnicode_WRITE(PyUnicode_1BYTE_KIND, udata, 0, '-'); + i++; + } + for (; i < uoffset; i++) { + __Pyx_PyUnicode_WRITE(PyUnicode_1BYTE_KIND, udata, i, padding_char); + } + } + for (i=0; i < clength; i++) { + __Pyx_PyUnicode_WRITE(PyUnicode_1BYTE_KIND, udata, uoffset+i, chars[i]); + } + +#else + // non-CPython + { + PyObject *sign = NULL, *padding = NULL; + uval = NULL; + if (uoffset > 0) { + prepend_sign = !!prepend_sign; + if (uoffset > prepend_sign) { + padding = PyUnicode_FromOrdinal(padding_char); + if (likely(padding) && uoffset > prepend_sign + 1) { + PyObject *tmp = PySequence_Repeat(padding, uoffset - prepend_sign); + Py_DECREF(padding); + padding = tmp; + } + if (unlikely(!padding)) goto done_or_error; + } + if (prepend_sign) { + sign = PyUnicode_FromOrdinal('-'); + if (unlikely(!sign)) goto done_or_error; + } + } + + uval = PyUnicode_DecodeASCII(chars, clength, NULL); + if (likely(uval) && padding) { + PyObject *tmp = PyUnicode_Concat(padding, uval); + Py_DECREF(uval); + uval = tmp; + } + if (likely(uval) && sign) { + PyObject *tmp = PyUnicode_Concat(sign, uval); + Py_DECREF(uval); + uval = tmp; + } +done_or_error: + Py_XDECREF(padding); + Py_XDECREF(sign); + } +#endif + + return uval; +} + + +//////////////////// ByteArrayAppendObject.proto //////////////////// + +static CYTHON_INLINE int __Pyx_PyByteArray_AppendObject(PyObject* bytearray, PyObject* value); + +//////////////////// ByteArrayAppendObject //////////////////// +//@requires: ByteArrayAppend + +static CYTHON_INLINE int __Pyx_PyByteArray_AppendObject(PyObject* bytearray, PyObject* value) { + Py_ssize_t ival; +#if CYTHON_USE_PYLONG_INTERNALS + if (likely(PyLong_CheckExact(value)) && likely(__Pyx_PyLong_IsCompact(value))) { + if (__Pyx_PyLong_IsZero(value)) { + ival = 0; + } else { + ival = __Pyx_PyLong_CompactValue(value); + if (unlikely(!__Pyx_is_valid_index(ival, 256))) goto bad_range; + } + } else +#endif + { + // CPython calls PyNumber_Index() internally + ival = __Pyx_PyIndex_AsSsize_t(value); + if (unlikely(!__Pyx_is_valid_index(ival, 256))) { + if (ival == -1 && PyErr_Occurred()) + return -1; + goto bad_range; + } + } + return __Pyx_PyByteArray_Append(bytearray, (int) ival); +bad_range: + PyErr_SetString(PyExc_ValueError, "byte must be in range(0, 256)"); + return -1; +} + +//////////////////// ByteArrayAppend.proto //////////////////// + +static CYTHON_INLINE int __Pyx_PyByteArray_Append(PyObject* bytearray, int value); + +//////////////////// ByteArrayAppend //////////////////// +//@requires: ObjectHandling.c::PyObjectCallMethod1 + +static CYTHON_INLINE int __Pyx_PyByteArray_Append(PyObject* bytearray, int value) { + PyObject *pyval, *retval; +#if CYTHON_COMPILING_IN_CPYTHON + if (likely(__Pyx_is_valid_index(value, 256))) { + Py_ssize_t n = Py_SIZE(bytearray); + if (likely(n != PY_SSIZE_T_MAX)) { + if (unlikely(PyByteArray_Resize(bytearray, n + 1) < 0)) + return -1; + PyByteArray_AS_STRING(bytearray)[n] = (char) (unsigned char) value; + return 0; + } + } else { + PyErr_SetString(PyExc_ValueError, "byte must be in range(0, 256)"); + return -1; + } +#endif + pyval = PyLong_FromLong(value); + if (unlikely(!pyval)) + return -1; + retval = __Pyx_PyObject_CallMethod1(bytearray, PYIDENT("append"), pyval); + Py_DECREF(pyval); + if (unlikely(!retval)) + return -1; + Py_DECREF(retval); + return 0; +} + + +//////////////////// PyObjectFormat.proto //////////////////// + +#if CYTHON_USE_UNICODE_WRITER +static PyObject* __Pyx_PyObject_Format(PyObject* s, PyObject* f); +#else +#define __Pyx_PyObject_Format(s, f) PyObject_Format(s, f) +#endif + +//////////////////// PyObjectFormat //////////////////// + +#if CYTHON_USE_UNICODE_WRITER +static PyObject* __Pyx_PyObject_Format(PyObject* obj, PyObject* format_spec) { + int ret; + _PyUnicodeWriter writer; + + if (likely(PyFloat_CheckExact(obj))) { + // copied from CPython 3.5 "float__format__()" in floatobject.c + _PyUnicodeWriter_Init(&writer); + ret = _PyFloat_FormatAdvancedWriter( + &writer, + obj, + format_spec, 0, PyUnicode_GET_LENGTH(format_spec)); + } else if (likely(PyLong_CheckExact(obj))) { + // copied from CPython 3.5 "long__format__()" in longobject.c + _PyUnicodeWriter_Init(&writer); + ret = _PyLong_FormatAdvancedWriter( + &writer, + obj, + format_spec, 0, PyUnicode_GET_LENGTH(format_spec)); + } else { + return PyObject_Format(obj, format_spec); + } + + if (unlikely(ret == -1)) { + _PyUnicodeWriter_Dealloc(&writer); + return NULL; + } + return _PyUnicodeWriter_Finish(&writer); +} +#endif + + +//////////////////// PyObjectFormatSimple.proto //////////////////// + +#if CYTHON_COMPILING_IN_PYPY + #define __Pyx_PyObject_FormatSimple(s, f) ( \ + likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) : \ + PyObject_Format(s, f)) +#elif CYTHON_USE_TYPE_SLOTS + // Py3 nicely returns unicode strings from str() and repr(), which makes this quite efficient for builtin types. + // In Py3.8+, tp_str() delegates to tp_repr(), so we call tp_repr() directly here. + #define __Pyx_PyObject_FormatSimple(s, f) ( \ + likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) : \ + likely(PyLong_CheckExact(s)) ? PyLong_Type.tp_repr(s) : \ + likely(PyFloat_CheckExact(s)) ? PyFloat_Type.tp_repr(s) : \ + PyObject_Format(s, f)) +#else + #define __Pyx_PyObject_FormatSimple(s, f) ( \ + likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) : \ + PyObject_Format(s, f)) +#endif + + +//////////////////// PyObjectFormatAndDecref.proto //////////////////// + +static CYTHON_INLINE PyObject* __Pyx_PyObject_FormatSimpleAndDecref(PyObject* s, PyObject* f); +static CYTHON_INLINE PyObject* __Pyx_PyObject_FormatAndDecref(PyObject* s, PyObject* f); + +//////////////////// PyObjectFormatAndDecref //////////////////// + +static CYTHON_INLINE PyObject* __Pyx_PyObject_FormatSimpleAndDecref(PyObject* s, PyObject* f) { + if (unlikely(!s)) return NULL; + if (likely(PyUnicode_CheckExact(s))) return s; + return __Pyx_PyObject_FormatAndDecref(s, f); +} + +static CYTHON_INLINE PyObject* __Pyx_PyObject_FormatAndDecref(PyObject* s, PyObject* f) { + PyObject *result; + if (unlikely(!s)) return NULL; + result = PyObject_Format(s, f); + Py_DECREF(s); + return result; +} + + +//////////////////// PyUnicode_Unicode.proto //////////////////// + +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_Unicode(PyObject *obj);/*proto*/ + +//////////////////// PyUnicode_Unicode //////////////////// + +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_Unicode(PyObject *obj) { + if (unlikely(obj == Py_None)) + obj = PYUNICODE("None"); + return __Pyx_NewRef(obj); +} + + +//////////////////// PyObject_Unicode.proto //////////////////// + +#define __Pyx_PyObject_Unicode(obj) \ + (likely(PyUnicode_CheckExact(obj)) ? __Pyx_NewRef(obj) : PyObject_Str(obj)) diff --git a/venv/lib/python3.10/site-packages/Cython/Utility/Synchronization.c b/venv/lib/python3.10/site-packages/Cython/Utility/Synchronization.c new file mode 100644 index 0000000000000000000000000000000000000000..3afb6612d94f85789c18a0f2a6714de6ba103df4 --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Utility/Synchronization.c @@ -0,0 +1,355 @@ +/////////// Atomics.proto ///////////// +//@proto_block: utility_code_proto_before_types + +#include + +#ifndef CYTHON_ATOMICS + #define CYTHON_ATOMICS 1 +#endif +// using CYTHON_ATOMICS as a cdef extern bint in the Cython memoryview code +// interacts badly with "import *". Therefore, define a helper function-like macro +#define __PYX_CYTHON_ATOMICS_ENABLED() CYTHON_ATOMICS +#define __PYX_GET_CYTHON_COMPILING_IN_CPYTHON_FREETHREADING() CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + +#define __pyx_atomic_int_type int +#define __pyx_nonatomic_int_type int + +// For standard C/C++ atomics, get the headers first so we have ATOMIC_INT_LOCK_FREE +// defined when we decide to use them. +#if CYTHON_ATOMICS && (defined(__STDC_VERSION__) && \ + (__STDC_VERSION__ >= 201112L) && \ + !defined(__STDC_NO_ATOMICS__)) + #include +#elif CYTHON_ATOMICS && (defined(__cplusplus) && ( \ + (__cplusplus >= 201103L) || \ + (defined(_MSC_VER) && _MSC_VER >= 1700))) + #include +#endif + +#if CYTHON_ATOMICS && (defined(__STDC_VERSION__) && \ + (__STDC_VERSION__ >= 201112L) && \ + !defined(__STDC_NO_ATOMICS__) && \ + ATOMIC_INT_LOCK_FREE == 2) + // C11 atomics are available and ATOMIC_INT_LOCK_FREE is definitely on + #undef __pyx_atomic_int_type + #define __pyx_atomic_int_type atomic_int + #define __pyx_atomic_ptr_type atomic_uintptr_t + #define __pyx_nonatomic_ptr_type uintptr_t + #define __pyx_atomic_incr_relaxed(value) atomic_fetch_add_explicit(value, 1, memory_order_relaxed) + #define __pyx_atomic_incr_acq_rel(value) atomic_fetch_add_explicit(value, 1, memory_order_acq_rel) + #define __pyx_atomic_decr_acq_rel(value) atomic_fetch_sub_explicit(value, 1, memory_order_acq_rel) + #define __pyx_atomic_sub(value, arg) atomic_fetch_sub(value, arg) + #define __pyx_atomic_int_cmp_exchange(value, expected, desired) atomic_compare_exchange_strong(value, expected, desired) + #define __pyx_atomic_load(value) atomic_load(value) + #define __pyx_atomic_store(value, new_value) atomic_store(value, new_value) + #define __pyx_atomic_pointer_load_relaxed(value) atomic_load_explicit(value, memory_order_relaxed) + #define __pyx_atomic_pointer_load_acquire(value) atomic_load_explicit(value, memory_order_acquire) + #define __pyx_atomic_pointer_exchange(value, new_value) atomic_exchange(value, (__pyx_nonatomic_ptr_type)new_value) + #if defined(__PYX_DEBUG_ATOMICS) && defined(_MSC_VER) + #pragma message ("Using standard C atomics") + #elif defined(__PYX_DEBUG_ATOMICS) + #warning "Using standard C atomics" + #endif +#elif CYTHON_ATOMICS && (defined(__cplusplus) && ( \ + (__cplusplus >= 201103L) || \ + /*_MSC_VER 1700 is Visual Studio 2012 */ \ + (defined(_MSC_VER) && _MSC_VER >= 1700)) && \ + ATOMIC_INT_LOCK_FREE == 2) + // C++11 atomics are available and ATOMIC_INT_LOCK_FREE is definitely on + #undef __pyx_atomic_int_type + #define __pyx_atomic_int_type std::atomic_int + #define __pyx_atomic_ptr_type std::atomic_uintptr_t + #define __pyx_nonatomic_ptr_type uintptr_t + #define __pyx_atomic_incr_relaxed(value) std::atomic_fetch_add_explicit(value, 1, std::memory_order_relaxed) + #define __pyx_atomic_incr_acq_rel(value) std::atomic_fetch_add_explicit(value, 1, std::memory_order_acq_rel) + #define __pyx_atomic_decr_acq_rel(value) std::atomic_fetch_sub_explicit(value, 1, std::memory_order_acq_rel) + #define __pyx_atomic_sub(value, arg) std::atomic_fetch_sub(value, arg) + #define __pyx_atomic_int_cmp_exchange(value, expected, desired) std::atomic_compare_exchange_strong(value, expected, desired) + #define __pyx_atomic_load(value) std::atomic_load(value) + #define __pyx_atomic_store(value, new_value) std::atomic_store(value, new_value) + #define __pyx_atomic_pointer_load_relaxed(value) std::atomic_load_explicit(value, std::memory_order_relaxed) + #define __pyx_atomic_pointer_load_acquire(value) std::atomic_load_explicit(value, std::memory_order_acquire) + #define __pyx_atomic_pointer_exchange(value, new_value) std::atomic_exchange(value, (__pyx_nonatomic_ptr_type)new_value) + + #if defined(__PYX_DEBUG_ATOMICS) && defined(_MSC_VER) + #pragma message ("Using standard C++ atomics") + #elif defined(__PYX_DEBUG_ATOMICS) + #warning "Using standard C++ atomics" + #endif +#elif CYTHON_ATOMICS && (__GNUC__ >= 5 || (__GNUC__ == 4 && \ + (__GNUC_MINOR__ > 1 || \ + (__GNUC_MINOR__ == 1 && __GNUC_PATCHLEVEL__ >= 2)))) + /* gcc >= 4.1.2 */ + #define __pyx_atomic_ptr_type void* + #define __pyx_atomic_incr_relaxed(value) __sync_fetch_and_add(value, 1) + #define __pyx_atomic_incr_acq_rel(value) __sync_fetch_and_add(value, 1) + #define __pyx_atomic_decr_acq_rel(value) __sync_fetch_and_sub(value, 1) + #define __pyx_atomic_sub(value, arg) __sync_fetch_and_sub(value, arg) + static CYTHON_INLINE int __pyx_atomic_int_cmp_exchange(__pyx_atomic_int_type* value, __pyx_nonatomic_int_type* expected, __pyx_nonatomic_int_type desired) { + __pyx_nonatomic_int_type old = __sync_val_compare_and_swap(value, *expected, desired); + int result = old == *expected; + *expected = old; + return result; + } + // the legacy gcc sync builtins don't seem to have plain "load" or "store". + #define __pyx_atomic_load(value) __sync_fetch_and_add(value, 0) + #define __pyx_atomic_store(value, new_value) __sync_lock_test_and_set(value, new_value) + #define __pyx_atomic_pointer_load_relaxed(value) __sync_fetch_and_add(value, 0) + #define __pyx_atomic_pointer_load_acquire(value) __sync_fetch_and_add(value, 0) + #define __pyx_atomic_pointer_exchange(value, new_value) __sync_lock_test_and_set(value, (__pyx_atomic_ptr_type)new_value) + + #ifdef __PYX_DEBUG_ATOMICS + #warning "Using GNU atomics" + #endif +#elif CYTHON_ATOMICS && defined(_MSC_VER) + /* msvc */ + #include + #undef __pyx_atomic_int_type + #define __pyx_atomic_int_type long + #define __pyx_atomic_ptr_type void* + #undef __pyx_nonatomic_int_type + #define __pyx_nonatomic_int_type long + #pragma intrinsic (_InterlockedExchangeAdd, _InterlockedExchange, _InterlockedCompareExchange, _InterlockedCompareExchangePointer, _InterlockedExchangePointer) + #define __pyx_atomic_incr_relaxed(value) _InterlockedExchangeAdd(value, 1) + #define __pyx_atomic_incr_acq_rel(value) _InterlockedExchangeAdd(value, 1) + #define __pyx_atomic_decr_acq_rel(value) _InterlockedExchangeAdd(value, -1) + #define __pyx_atomic_sub(value, arg) _InterlockedExchangeAdd(value, -arg) + static CYTHON_INLINE int __pyx_atomic_int_cmp_exchange(__pyx_atomic_int_type* value, __pyx_nonatomic_int_type* expected, __pyx_nonatomic_int_type desired) { + __pyx_nonatomic_int_type old = _InterlockedCompareExchange(value, desired, *expected); + int result = old == *expected; + *expected = old; + return result; + } + #define __pyx_atomic_load(value) _InterlockedExchangeAdd(value, 0) + #define __pyx_atomic_store(value, new_value) _InterlockedExchange(value, new_value) + // Microsoft says that simple reads are guaranteed to be atomic. + // https://learn.microsoft.com/en-gb/windows/win32/sync/interlocked-variable-access?redirectedfrom=MSDN + // The volatile cast is what CPython does. + #define __pyx_atomic_pointer_load_relaxed(value) *(void * volatile *)value + // compare/exchange is probably overkill nonsense, but plain "load" intrinsics are hard to get. + #define __pyx_atomic_pointer_load_acquire(value) _InterlockedCompareExchangePointer(value, 0, 0) + #define __pyx_atomic_pointer_exchange(value, new_value) _InterlockedExchangePointer(value, (__pyx_atomic_ptr_type)new_value) + + #ifdef __PYX_DEBUG_ATOMICS + #pragma message ("Using MSVC atomics") + #endif +#else + #undef CYTHON_ATOMICS + #define CYTHON_ATOMICS 0 + + #ifdef __PYX_DEBUG_ATOMICS + #warning "Not using atomics" + #endif +#endif + +#if CYTHON_ATOMICS + #define __pyx_add_acquisition_count(memview) \ + __pyx_atomic_incr_relaxed(__pyx_get_slice_count_pointer(memview)) + #define __pyx_sub_acquisition_count(memview) \ + __pyx_atomic_decr_acq_rel(__pyx_get_slice_count_pointer(memview)) +#else + #define __pyx_add_acquisition_count(memview) \ + __pyx_add_acquisition_count_locked(__pyx_get_slice_count_pointer(memview), memview->lock) + #define __pyx_sub_acquisition_count(memview) \ + __pyx_sub_acquisition_count_locked(__pyx_get_slice_count_pointer(memview), memview->lock) +#endif + + +/////////////////////// CriticalSections.proto ///////////////////// +//@proto_block: utility_code_proto_before_types + +#if !CYTHON_COMPILING_IN_CPYTHON_FREETHREADING +#define __Pyx_PyCriticalSection void* +#define __Pyx_PyCriticalSection2 void* +#define __Pyx_PyCriticalSection_Begin1(cs, arg) (void)cs +#define __Pyx_PyCriticalSection_Begin2(cs, arg1, arg2) (void)cs +#define __Pyx_PyCriticalSection_End1(cs) +#define __Pyx_PyCriticalSection_End2(cs) +#else +#define __Pyx_PyCriticalSection PyCriticalSection +#define __Pyx_PyCriticalSection2 PyCriticalSection2 +#define __Pyx_PyCriticalSection_Begin1 PyCriticalSection_Begin +#define __Pyx_PyCriticalSection_Begin2 PyCriticalSection2_Begin +#define __Pyx_PyCriticalSection_End1 PyCriticalSection_End +#define __Pyx_PyCriticalSection_End2 PyCriticalSection2_End +#endif + +#if PY_VERSION_HEX < 0x030d0000 || CYTHON_COMPILING_IN_LIMITED_API +#define __Pyx_BEGIN_CRITICAL_SECTION(o) { +#define __Pyx_END_CRITICAL_SECTION() } +#else +#define __Pyx_BEGIN_CRITICAL_SECTION Py_BEGIN_CRITICAL_SECTION +#define __Pyx_END_CRITICAL_SECTION Py_END_CRITICAL_SECTION +#endif + + +////////////////////// PyThreadTypeLock.proto ////////// +//@proto_block: utility_code_proto_before_types + +// This lock type always uses PyThread_type_lock. The main reason +// to use it is if you are using the Limited API and want to +// share locks between modules. + +#define __Pyx_Locks_PyThreadTypeLock PyThread_type_lock +#define __Pyx_Locks_PyThreadTypeLock_DECL NULL +#define __Pyx_Locks_PyThreadTypeLock_Init(l) l = PyThread_allocate_lock() +#define __Pyx_Locks_PyThreadTypeLock_Delete(l) PyThread_free_lock(l) +#define __Pyx_Locks_PyThreadTypeLock_LockNogil(l) (void)PyThread_acquire_lock(l, WAIT_LOCK) +#define __Pyx_Locks_PyThreadTypeLock_Unlock(l) PyThread_release_lock(l) +static void __Pyx__Locks_PyThreadTypeLock_Lock(__Pyx_Locks_PyThreadTypeLock lock); /* proto */ +static void __Pyx__Locks_PyThreadTypeLock_LockGil(__Pyx_Locks_PyThreadTypeLock lock); /* proto */ +// CYTHON_INLINE because these may be unused +static CYTHON_INLINE void __Pyx_Locks_PyThreadTypeLock_Lock(__Pyx_Locks_PyThreadTypeLock lock) { + __Pyx__Locks_PyThreadTypeLock_Lock(lock); +} +static CYTHON_INLINE void __Pyx_Locks_PyThreadTypeLock_LockGil(__Pyx_Locks_PyThreadTypeLock lock) { + __Pyx__Locks_PyThreadTypeLock_LockGil(lock); +} + + +////////////////////// PyThreadTypeLock //////////////// + +#if CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM < 0x07031400 +#define PY_LOCK_ACQUIRED 1 +#endif + +static void __Pyx__Locks_PyThreadTypeLock_LockGil_spin(__Pyx_Locks_PyThreadTypeLock lock) { + while (1) { + int res; + Py_BEGIN_ALLOW_THREADS +#if !CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07031400 + // Don't block indefinitely. This ensures we don't deadlock (forever) on + // + // with nogil: + // with lock: + // with gil: + // ... + // + // Arguably that's user error, but it seems better to try to help them out. + res = PyThread_acquire_lock_timed(lock, CYTHON_LOCK_AND_GIL_DEADLOCK_AVOIDANCE_TIME, 0); +#else + res = PyThread_acquire_lock(lock, WAIT_LOCK); +#endif + // Wait on the GIL while holding the lock. But importantly we never do the inverse + // and wait on the lock while holding the GIL. + Py_END_ALLOW_THREADS + if (likely(res == PY_LOCK_ACQUIRED)) { + // All good - we got the lock + return; + } + } +} + +static CYTHON_INLINE void __Pyx__Locks_PyThreadTypeLock_LockGil(__Pyx_Locks_PyThreadTypeLock lock) { + #if !CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07031400 + // This is possibly dubious - it makes things faster in the uncontended case, but + // in the heavily-contended case it makes it more likely that one thread will dominate. + if (likely(PyThread_acquire_lock_timed(lock, 0, 0) == PY_LOCK_ACQUIRED)) { + // All good - we got the lock + return; + } + #endif + __Pyx__Locks_PyThreadTypeLock_LockGil_spin(lock); +} + +static void __Pyx__Locks_PyThreadTypeLock_Lock(__Pyx_Locks_PyThreadTypeLock lock) { + int has_gil = 0; +#if CYTHON_COMPILING_IN_LIMITED_API + if (__PYX_LIMITED_VERSION_HEX >= 0x030d0000 || __Pyx_get_runtime_version() >= 0x030d0000) { + // Swap the existing thread state to see if we had the GIL. + // Requires re-acquiring the thread state if we had it, but no-op if we didn't. + PyThreadState *tstate = PyThreadState_Swap(NULL); + has_gil = tstate != NULL; + if (has_gil) + PyThreadState_Swap(tstate); + } else { + // We can't tell if we have the GIL. Therefore make sure we do have it + // and then restore whatever state was there before. + PyGILState_STATE state = PyGILState_Ensure(); + __Pyx_Locks_PyThreadTypeLock_LockNogil(lock); + PyGILState_Release(state); + return; + } +#elif CYTHON_COMPILING_IN_PYPY || PY_VERSION_HEX < 0x030B0000 + has_gil = PyGILState_Check(); +#elif PY_VERSION_HEX < 0x030d0000 + has_gil = _PyThreadState_UncheckedGet() != NULL; +#else + has_gil = PyThreadState_GetUnchecked() != NULL; +#endif + if (has_gil) { + __Pyx_Locks_PyThreadTypeLock_LockGil(lock); + } else { + __Pyx_Locks_PyThreadTypeLock_LockNogil(lock); + } +} + + +////////////////////// PyMutex.proto //////////////////// +//@proto_block: utility_code_proto_before_types +//@requires: PyThreadTypeLock + +// We support two implementations - a Py3.13+ version using PyMutex and +// an older version using PyThread_type_lock. +// In principle it'd be possible to also use things like c++ std::mutex +// (in the absence of PyMutex). I've decided against this for ABI reasons. + +// With the Limited API There is an ABI problem - if a lock is ever +// shared between two modules then they must agree on the definition, +// and so Limited API sharing with regular API will disagree. + +// Therefore I explicitly ban Limited API modules from using +// CythonLockType in a public way. However, they can use +// CythonCompatibleLockType which will always be PyThread_type_lock. + +#if PY_VERSION_HEX > 0x030d0000 && !CYTHON_COMPILING_IN_LIMITED_API +#define __Pyx_Locks_PyMutex PyMutex +#define __Pyx_Locks_PyMutex_DECL {0} +#define __Pyx_Locks_PyMutex_Init(l) (void)(l) +#define __Pyx_Locks_PyMutex_Delete(l) (void)(l) +// Py_Mutex takes care of all GIL handling itself +#define __Pyx_Locks_PyMutex_Lock(l) PyMutex_Lock(&l) +#define __Pyx_Locks_PyMutex_Unlock(l) PyMutex_Unlock(&l) +#define __Pyx_Locks_PyMutex_LockGil(l) PyMutex_Lock(&l) +#define __Pyx_Locks_PyMutex_LockNogil(l) PyMutex_Lock(&l) + +#else + +#define __Pyx_Locks_PyMutex __Pyx_Locks_PyThreadTypeLock +#define __Pyx_Locks_PyMutex_DECL __Pyx_Locks_PyThreadTypeLock_DECL +#define __Pyx_Locks_PyMutex_Init(l) __Pyx_Locks_PyThreadTypeLock_Init(l) +#define __Pyx_Locks_PyMutex_Delete(l) __Pyx_Locks_PyThreadTypeLock_Delete(l) +#define __Pyx_Locks_PyMutex_Lock(l) __Pyx_Locks_PyThreadTypeLock_Lock(l) +#define __Pyx_Locks_PyMutex_Unlock(l) __Pyx_Locks_PyThreadTypeLock_Unlock(l) +#define __Pyx_Locks_PyMutex_LockGil(l) __Pyx_Locks_PyThreadTypeLock_LockGil(l) +#define __Pyx_Locks_PyMutex_LockNogil(l) __Pyx_Locks_PyThreadTypeLock_LockNogil(l) + +#endif + + +//////////////////////////// CythonPyMutexPublicCheck /////////////////////////////////// + +#ifndef CYTHON_UNSAFE_IGNORE_PYMUTEX_ABI_COMPATIBILITY +#define CYTHON_UNSAFE_IGNORE_PYMUTEX_ABI_COMPATIBILITY 0 +#endif + +/* CYTHON_UNSAFE_IGNORE_PYMUTEX_ABI_COMPATIBILITY is left for an advanced user who + * wants to disable this error. However, please don't complain to us when your code + * breaks. Whatever you do, the Limited API version always uses the "compatible" lock + * type anyway, so you're only saving yourself a few extra characters typing. + */ +#if CYTHON_COMPILING_IN_LIMITED_API && !CYTHON_UNSAFE_IGNORE_PYMUTEX_ABI_COMPATIBILITY +#error cython.pymutex is shared between multiple modules in the Limited API.\ + This is intentionally disabled because it is not possible for regular API and Limited API\ + modules to be compatible with each other. Use cython.pythread_type_lock for a safe\ + alternative lock type instead. +#endif + + +////////////////////////// SharedInFreeThreading.proto ////////////////// + +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING +#define __Pyx_shared_in_cpython_freethreading(x) shared(x) +#else +#define __Pyx_shared_in_cpython_freethreading(x) +#endif diff --git a/venv/lib/python3.10/site-packages/Cython/Utility/TestCyUtilityLoader.pyx b/venv/lib/python3.10/site-packages/Cython/Utility/TestCyUtilityLoader.pyx new file mode 100644 index 0000000000000000000000000000000000000000..00e7a7681b8534a71c8de66c517d4ef3e49c7d30 --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Utility/TestCyUtilityLoader.pyx @@ -0,0 +1,8 @@ +########## TestCyUtilityLoader ########## +#@requires: OtherUtility + +test {{cy_loader}} impl + + +########## OtherUtility ########## +req {{cy_loader}} impl diff --git a/venv/lib/python3.10/site-packages/Cython/Utility/TestCythonScope.pyx b/venv/lib/python3.10/site-packages/Cython/Utility/TestCythonScope.pyx new file mode 100644 index 0000000000000000000000000000000000000000..594d5a8798690eae992226f86cec19c71e0a2ff8 --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Utility/TestCythonScope.pyx @@ -0,0 +1,75 @@ +########## TestClass ########## +# These utilities are for testing purposes + +# The "cythonscope" test calls METH_O functions with their (self, arg) signature. +# cython: always_allow_keywords=False + +from __future__ import print_function + +cdef extern from *: + cdef object __pyx_test_dep(object) + ctypedef struct PyObject + +@cname('__pyx_TestClass') +cdef class TestClass(object): + cdef public int value + + def __init__(self, int value): + self.value = value + + def __str__(self): + return f'TestClass({self.value})' + + cdef cdef_method(self, int value): + print('Hello from cdef_method', value) + + cpdef cpdef_method(self, int value): + print('Hello from cpdef_method', value) + + def def_method(self, int value): + print('Hello from def_method', value) + + @cname('cdef_cname') + cdef cdef_cname_method(self, int value): + print("Hello from cdef_cname_method", value) + + @cname('cpdef_cname') + cpdef cpdef_cname_method(self, int value): + print("Hello from cpdef_cname_method", value) + + @cname('def_cname') + def def_cname_method(self, int value): + print("Hello from def_cname_method", value) + +# For now cdef variables are outside the module scope, +# so we can create a global cname that is easily accessible +cdef PyObject* __pyx_TestClass_type = TestClass + +@cname('__pyx_test_call_other_cy_util') +cdef test_call(obj): + print('test_call') + __pyx_test_dep(obj) + +@cname('__pyx_TestClass_New') +cdef _testclass_new(int value): + return TestClass(value) + +########### TestDep ########## + +from __future__ import print_function + +@cname('__pyx_test_dep') +cdef test_dep(obj): + print('test_dep', obj) + +########## TestScope ########## + +@cname('__pyx_testscope') +cdef object _testscope(int value): + return f"hello from cython scope, value={value}" + +########## View.TestScope ########## + +@cname('__pyx_view_testscope') +cdef object _testscope(int value): + return f"hello from cython.view scope, value={value}" diff --git a/venv/lib/python3.10/site-packages/Cython/Utility/TestUtilityLoader.c b/venv/lib/python3.10/site-packages/Cython/Utility/TestUtilityLoader.c new file mode 100644 index 0000000000000000000000000000000000000000..595305f211bd172ec1dfc10c3cf6bab4e92d7fba --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Utility/TestUtilityLoader.c @@ -0,0 +1,12 @@ +////////// TestUtilityLoader.proto ////////// +test {{loader}} prototype + +////////// TestUtilityLoader ////////// +//@requires: OtherUtility +test {{loader}} impl + +////////// OtherUtility.proto ////////// +req {{loader}} proto + +////////// OtherUtility ////////// +req {{loader}} impl diff --git a/venv/lib/python3.10/site-packages/Cython/Utility/TypeConversion.c b/venv/lib/python3.10/site-packages/Cython/Utility/TypeConversion.c new file mode 100644 index 0000000000000000000000000000000000000000..7002a717b546c0f145e0c466b701a4d6a05850cf --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Utility/TypeConversion.c @@ -0,0 +1,1304 @@ +/////////////// TypeConversions.proto /////////////// +//@requires: StringTools.c::IncludeStringH + +/* Type Conversion Predeclarations */ + +#define __Pyx_uchar_cast(c) ((unsigned char)c) +#define __Pyx_long_cast(x) ((long)x) + +#define __Pyx_fits_Py_ssize_t(v, type, is_signed) ( \ + (sizeof(type) < sizeof(Py_ssize_t)) || \ + (sizeof(type) > sizeof(Py_ssize_t) && \ + likely(v < (type)PY_SSIZE_T_MAX || \ + v == (type)PY_SSIZE_T_MAX) && \ + (!is_signed || likely(v > (type)PY_SSIZE_T_MIN || \ + v == (type)PY_SSIZE_T_MIN))) || \ + (sizeof(type) == sizeof(Py_ssize_t) && \ + (is_signed || likely(v < (type)PY_SSIZE_T_MAX || \ + v == (type)PY_SSIZE_T_MAX))) ) + +static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) { + // Optimisation from Section 14.2 "Bounds Checking" in + // https://www.agner.org/optimize/optimizing_cpp.pdf + // See https://bugs.python.org/issue28397 + // The cast to unsigned effectively tests for "0 <= i < limit". + return (size_t) i < (size_t) limit; +} + +// fast and unsafe abs(Py_ssize_t) that ignores the overflow for (-PY_SSIZE_T_MAX-1) +#if defined (__cplusplus) && __cplusplus >= 201103L + #include + #define __Pyx_sst_abs(value) std::abs(value) +#elif SIZEOF_INT >= SIZEOF_SIZE_T + #define __Pyx_sst_abs(value) abs(value) +#elif SIZEOF_LONG >= SIZEOF_SIZE_T + #define __Pyx_sst_abs(value) labs(value) +#elif defined (_MSC_VER) + // abs() is defined for long, but 64-bits type on MSVC is long long. + // Use MS-specific _abs64 instead. + #define __Pyx_sst_abs(value) ((Py_ssize_t)_abs64(value)) +#elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define __Pyx_sst_abs(value) llabs(value) +#elif defined (__GNUC__) + // gcc or clang on 64 bit windows. + #define __Pyx_sst_abs(value) __builtin_llabs(value) +#else + #define __Pyx_sst_abs(value) ((value<0) ? -value : value) +#endif + +static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s); +static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*); +static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length); + +static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char*); +#define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l) +#define __Pyx_PyBytes_FromString PyBytes_FromString +#define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); + +#if CYTHON_ASSUME_SAFE_MACROS + #define __Pyx_PyBytes_AsWritableString(s) ((char*) PyBytes_AS_STRING(s)) + #define __Pyx_PyBytes_AsWritableSString(s) ((signed char*) PyBytes_AS_STRING(s)) + #define __Pyx_PyBytes_AsWritableUString(s) ((unsigned char*) PyBytes_AS_STRING(s)) + #define __Pyx_PyBytes_AsString(s) ((const char*) PyBytes_AS_STRING(s)) + #define __Pyx_PyBytes_AsSString(s) ((const signed char*) PyBytes_AS_STRING(s)) + #define __Pyx_PyBytes_AsUString(s) ((const unsigned char*) PyBytes_AS_STRING(s)) + #define __Pyx_PyByteArray_AsString(s) PyByteArray_AS_STRING(s) +#else + #define __Pyx_PyBytes_AsWritableString(s) ((char*) PyBytes_AsString(s)) + #define __Pyx_PyBytes_AsWritableSString(s) ((signed char*) PyBytes_AsString(s)) + #define __Pyx_PyBytes_AsWritableUString(s) ((unsigned char*) PyBytes_AsString(s)) + #define __Pyx_PyBytes_AsString(s) ((const char*) PyBytes_AsString(s)) + #define __Pyx_PyBytes_AsSString(s) ((const signed char*) PyBytes_AsString(s)) + #define __Pyx_PyBytes_AsUString(s) ((const unsigned char*) PyBytes_AsString(s)) + #define __Pyx_PyByteArray_AsString(s) PyByteArray_AsString(s) +#endif +#define __Pyx_PyObject_AsWritableString(s) ((char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsWritableSString(s) ((signed char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsSString(s) ((const signed char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsUString(s) ((const unsigned char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_FromCString(s) __Pyx_PyObject_FromString((const char*)s) +#define __Pyx_PyBytes_FromCString(s) __Pyx_PyBytes_FromString((const char*)s) +#define __Pyx_PyByteArray_FromCString(s) __Pyx_PyByteArray_FromString((const char*)s) +#define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s) +#define __Pyx_PyUnicode_FromOrdinal(o) PyUnicode_FromOrdinal((int)o) +#define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode + +static CYTHON_INLINE PyObject *__Pyx_NewRef(PyObject *obj) { +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030a0000 || defined(Py_NewRef) + return Py_NewRef(obj); +#else + Py_INCREF(obj); + return obj; +#endif +} + +static CYTHON_INLINE PyObject *__Pyx_XNewRef(PyObject *obj) { +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030a0000 || defined(Py_XNewRef) + return Py_XNewRef(obj); +#else + Py_XINCREF(obj); + return obj; +#endif +} + +static CYTHON_INLINE PyObject *__Pyx_Owned_Py_None(int b); +static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b); +static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*); +static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject*); +static CYTHON_INLINE PyObject* __Pyx_PyNumber_Long(PyObject* x); + +#define __Pyx_PySequence_Tuple(obj) \ + (likely(PyTuple_CheckExact(obj)) ? __Pyx_NewRef(obj) : PySequence_Tuple(obj)) + +static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*); +static CYTHON_INLINE PyObject * __Pyx_PyLong_FromSize_t(size_t); +static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject*); + +#if CYTHON_ASSUME_SAFE_MACROS +#define __Pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x)) +#define __Pyx_PyFloat_AS_DOUBLE(x) PyFloat_AS_DOUBLE(x) +#else +#define __Pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x) +#define __Pyx_PyFloat_AS_DOUBLE(x) PyFloat_AsDouble(x) +#endif +#define __Pyx_PyFloat_AsFloat(x) ((float) __Pyx_PyFloat_AsDouble(x)) + +// We call this __Pyx_PyNumber_Int() since it's the equivalent of the int() function call. +#define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x)) +// __Pyx_PyNumber_Float is now in its own section since it has dependencies (needed to make +// string conversion work the same in all circumstances). + +#if CYTHON_USE_PYLONG_INTERNALS + #if PY_VERSION_HEX >= 0x030C00A7 + #ifndef _PyLong_SIGN_MASK + #define _PyLong_SIGN_MASK 3 + #endif + #ifndef _PyLong_NON_SIZE_BITS + #define _PyLong_NON_SIZE_BITS 3 + #endif + #define __Pyx_PyLong_Sign(x) (((PyLongObject*)x)->long_value.lv_tag & _PyLong_SIGN_MASK) + #define __Pyx_PyLong_IsNeg(x) ((__Pyx_PyLong_Sign(x) & 2) != 0) + #define __Pyx_PyLong_IsNonNeg(x) (!__Pyx_PyLong_IsNeg(x)) + #define __Pyx_PyLong_IsZero(x) (__Pyx_PyLong_Sign(x) & 1) + #define __Pyx_PyLong_IsPos(x) (__Pyx_PyLong_Sign(x) == 0) + #define __Pyx_PyLong_CompactValueUnsigned(x) (__Pyx_PyLong_Digits(x)[0]) + #define __Pyx_PyLong_DigitCount(x) ((Py_ssize_t) (((PyLongObject*)x)->long_value.lv_tag >> _PyLong_NON_SIZE_BITS)) + #define __Pyx_PyLong_SignedDigitCount(x) \ + ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * __Pyx_PyLong_DigitCount(x)) + + #if defined(PyUnstable_Long_IsCompact) && defined(PyUnstable_Long_CompactValue) + #define __Pyx_PyLong_IsCompact(x) PyUnstable_Long_IsCompact((PyLongObject*) x) + #define __Pyx_PyLong_CompactValue(x) PyUnstable_Long_CompactValue((PyLongObject*) x) + #else + #define __Pyx_PyLong_IsCompact(x) (((PyLongObject*)x)->long_value.lv_tag < (2 << _PyLong_NON_SIZE_BITS)) + #define __Pyx_PyLong_CompactValue(x) ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * (Py_ssize_t) __Pyx_PyLong_Digits(x)[0]) + #endif + + // CPython 3.12 requires C99, which defines 'size_t' (but not 'ssize_t') + typedef Py_ssize_t __Pyx_compact_pylong; + typedef size_t __Pyx_compact_upylong; + + #else /* Py < 3.12 */ + #define __Pyx_PyLong_IsNeg(x) (Py_SIZE(x) < 0) + #define __Pyx_PyLong_IsNonNeg(x) (Py_SIZE(x) >= 0) + #define __Pyx_PyLong_IsZero(x) (Py_SIZE(x) == 0) + #define __Pyx_PyLong_IsPos(x) (Py_SIZE(x) > 0) + #define __Pyx_PyLong_CompactValueUnsigned(x) ((Py_SIZE(x) == 0) ? 0 : __Pyx_PyLong_Digits(x)[0]) + #define __Pyx_PyLong_DigitCount(x) __Pyx_sst_abs(Py_SIZE(x)) + #define __Pyx_PyLong_SignedDigitCount(x) Py_SIZE(x) + + #define __Pyx_PyLong_IsCompact(x) (Py_SIZE(x) == 0 || Py_SIZE(x) == 1 || Py_SIZE(x) == -1) + #define __Pyx_PyLong_CompactValue(x) \ + ((Py_SIZE(x) == 0) ? (sdigit) 0 : ((Py_SIZE(x) < 0) ? -(sdigit)__Pyx_PyLong_Digits(x)[0] : (sdigit)__Pyx_PyLong_Digits(x)[0])) + + typedef sdigit __Pyx_compact_pylong; + typedef digit __Pyx_compact_upylong; + #endif + + static CYTHON_INLINE int __Pyx_PyLong_CompactAsLong(PyObject *x, long *return_value); /*proto*/ + + #if PY_VERSION_HEX >= 0x030C00A5 + #define __Pyx_PyLong_Digits(x) (((PyLongObject*)x)->long_value.ob_digit) + #else + #define __Pyx_PyLong_Digits(x) (((PyLongObject*)x)->ob_digit) + #endif +#endif + +#if __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 + #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL) +#elif __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeASCII(c_str, size, NULL) +#else + #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) +#endif + +/////////////// TypeConversions /////////////// + +/* Type Conversion Functions */ + +#include + +static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s) { + size_t len = strlen(s); + if (unlikely(len > (size_t) PY_SSIZE_T_MAX)) { + PyErr_SetString(PyExc_OverflowError, "byte string is too long"); + return -1; + } + return (Py_ssize_t) len; +} + +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) { + Py_ssize_t len = __Pyx_ssize_strlen(c_str); + if (unlikely(len < 0)) return NULL; + return __Pyx_PyUnicode_FromStringAndSize(c_str, len); +} + +static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char* c_str) { + Py_ssize_t len = __Pyx_ssize_strlen(c_str); + if (unlikely(len < 0)) return NULL; + return PyByteArray_FromStringAndSize(c_str, len); +} + +// Py3.7 returns a "const char*" for unicode strings +static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) { + Py_ssize_t ignore; + return __Pyx_PyObject_AsStringAndSize(o, &ignore); +} + +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 +static CYTHON_INLINE const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { + if (unlikely(__Pyx_PyUnicode_READY(o) == -1)) return NULL; +#if CYTHON_COMPILING_IN_LIMITED_API + { + const char* result; + Py_ssize_t unicode_length; + CYTHON_MAYBE_UNUSED_VAR(unicode_length); // only for __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + #if __PYX_LIMITED_VERSION_HEX < 0x030A0000 + if (unlikely(PyArg_Parse(o, "s#", &result, length) < 0)) return NULL; + #else + result = PyUnicode_AsUTF8AndSize(o, length); + #endif + #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + // Pre-checking "isascii" the Limited API involves making Python function calls. + // Therefore we do a post-check instead that the lengths of the encoded and unicode + // strings are the same (which is only true for ascii strings). + // If this isn't true then we've already done the encoding so it's a potential + // performance loss, but it should be better in the successful case. + unicode_length = PyUnicode_GetLength(o); + if (unlikely(unicode_length < 0)) return NULL; + if (unlikely(unicode_length != *length)) { + // raise the error + PyUnicode_AsASCIIString(o); + return NULL; + } + #endif + return result; + } +#else /* CYTHON_COMPILING_IN_LIMITED_API */ +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + if (likely(PyUnicode_IS_ASCII(o))) { + // cached for the lifetime of the object + *length = PyUnicode_GET_LENGTH(o); + return PyUnicode_AsUTF8(o); + } else { + // raise the error + PyUnicode_AsASCIIString(o); + return NULL; + } +#else + return PyUnicode_AsUTF8AndSize(o, length); +#endif /* __PYX_DEFAULT_STRING_ENCODING_IS_ASCII */ +#endif /* !CYTHON_COMPILING_IN_LIMITED_API */ +} +#endif + +// Py3.7 returns a "const char*" for unicode strings +static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) { +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 + if (PyUnicode_Check(o)) { + return __Pyx_PyUnicode_AsStringAndSize(o, length); + } else +#endif + + if (PyByteArray_Check(o)) { +#if (CYTHON_ASSUME_SAFE_SIZE && CYTHON_ASSUME_SAFE_MACROS) || (CYTHON_COMPILING_IN_PYPY && (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE))) + *length = PyByteArray_GET_SIZE(o); + return PyByteArray_AS_STRING(o); +#else + *length = PyByteArray_Size(o); + if (*length == -1) return NULL; + return PyByteArray_AsString(o); +#endif + + } else + { + char* result; + int r = PyBytes_AsStringAndSize(o, &result, length); + if (unlikely(r < 0)) { + return NULL; + } else { + return result; + } + } +} + +/* Note: __Pyx_PyObject_IsTrue is written to minimize branching. */ +static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) { + int is_true = x == Py_True; + if (is_true | (x == Py_False) | (x == Py_None)) return is_true; + else return PyObject_IsTrue(x); +} + +static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) { + int retval; + if (unlikely(!x)) return -1; + retval = __Pyx_PyObject_IsTrue(x); + Py_DECREF(x); + return retval; +} + +static PyObject* __Pyx_PyNumber_LongWrongResultType(PyObject* result) { + __Pyx_TypeName result_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(result)); + if (PyLong_Check(result)) { + // CPython issue #17576: warn if 'result' not of exact type int. + if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1, + "__int__ returned non-int (type " __Pyx_FMT_TYPENAME "). " + "The ability to return an instance of a strict subclass of int is deprecated, " + "and may be removed in a future version of Python.", + result_type_name)) { + __Pyx_DECREF_TypeName(result_type_name); + Py_DECREF(result); + return NULL; + } + __Pyx_DECREF_TypeName(result_type_name); + return result; + } + PyErr_Format(PyExc_TypeError, + "__int__ returned non-int (type " __Pyx_FMT_TYPENAME ")", + result_type_name); + __Pyx_DECREF_TypeName(result_type_name); + Py_DECREF(result); + return NULL; +} + +static CYTHON_INLINE PyObject* __Pyx_PyNumber_Long(PyObject* x) { +#if CYTHON_USE_TYPE_SLOTS + PyNumberMethods *m; +#endif + PyObject *res = NULL; + if (likely(PyLong_Check(x))) + return __Pyx_NewRef(x); +#if CYTHON_USE_TYPE_SLOTS + m = Py_TYPE(x)->tp_as_number; + if (likely(m && m->nb_int)) { + res = m->nb_int(x); + } +#else + if (!PyBytes_CheckExact(x) && !PyUnicode_CheckExact(x)) { + res = PyNumber_Long(x); + } +#endif + if (likely(res)) { + if (unlikely(!PyLong_CheckExact(res))) { + return __Pyx_PyNumber_LongWrongResultType(res); + } + } + else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_TypeError, + "an integer is required"); + } + return res; +} + +{{py: from Cython.Utility import pylong_join }} + +static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { + Py_ssize_t ival; + PyObject *x; + if (likely(PyLong_CheckExact(b))) { + #if CYTHON_USE_PYLONG_INTERNALS + // handle most common case first to avoid indirect branch and optimise branch prediction + if (likely(__Pyx_PyLong_IsCompact(b))) { + return __Pyx_PyLong_CompactValue(b); + } else { + const digit* digits = __Pyx_PyLong_Digits(b); + const Py_ssize_t size = __Pyx_PyLong_SignedDigitCount(b); + switch (size) { + {{for _size in (2, 3, 4)}} + {{for _case in (_size, -_size)}} + case {{_case}}: + if (8 * sizeof(Py_ssize_t) > {{_size}} * PyLong_SHIFT) { + return {{'-' if _case < 0 else ''}}(Py_ssize_t) {{pylong_join(_size, 'digits', 'size_t')}}; + } + break; + {{endfor}} + {{endfor}} + } + } + #endif + return PyLong_AsSsize_t(b); + } + x = PyNumber_Index(b); + if (!x) return -1; + ival = PyLong_AsSsize_t(x); + Py_DECREF(x); + return ival; +} + + +static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject* o) { + if (sizeof(Py_hash_t) == sizeof(Py_ssize_t)) { + return (Py_hash_t) __Pyx_PyIndex_AsSsize_t(o); + } else { + Py_ssize_t ival; + PyObject *x; + x = PyNumber_Index(o); + if (!x) return -1; + ival = PyLong_AsLong(x); + Py_DECREF(x); + return ival; + } +} + +static CYTHON_INLINE PyObject *__Pyx_Owned_Py_None(int b) { + CYTHON_UNUSED_VAR(b); + return __Pyx_NewRef(Py_None); +} + +static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b) { + return b ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False); +} + + +static CYTHON_INLINE PyObject * __Pyx_PyLong_FromSize_t(size_t ival) { + return PyLong_FromSize_t(ival); +} + +#if CYTHON_USE_PYLONG_INTERNALS +static CYTHON_INLINE int __Pyx_PyLong_CompactAsLong(PyObject *x, long *return_value) { + // Safely convert a compact (Py_ssize_t, usually max. 30 bits) PyLong into a C long. + if (unlikely(!__Pyx_PyLong_IsCompact(x))) + return 0; + + Py_ssize_t value = __Pyx_PyLong_CompactValue(x); + if ((sizeof(long) < sizeof(Py_ssize_t)) && unlikely(value != (long) value)) + return 0; + + *return_value = (long) value; + return 1; +} +#endif + + +/////////////// pynumber_float.proto /////////////// + +static CYTHON_INLINE PyObject* __Pyx__PyNumber_Float(PyObject* obj); /* proto */ +#define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : __Pyx__PyNumber_Float(x)) + +/////////////// pynumber_float /////////////// +//@requires: Optimize.c::pybytes_as_double +//@requires: Optimize.c::pyunicode_as_double + +static CYTHON_INLINE PyObject* __Pyx__PyNumber_Float(PyObject* obj) { + // 'obj is PyFloat' is handled in the calling macro + double val; + if (PyLong_CheckExact(obj)) { +#if CYTHON_USE_PYLONG_INTERNALS + if (likely(__Pyx_PyLong_IsCompact(obj))) { + val = (double) __Pyx_PyLong_CompactValue(obj); + goto no_error; + } +#endif + val = PyLong_AsDouble(obj); + } else if (PyUnicode_CheckExact(obj)) { + val = __Pyx_PyUnicode_AsDouble(obj); + } else if (PyBytes_CheckExact(obj)) { + val = __Pyx_PyBytes_AsDouble(obj); + } else if (PyByteArray_CheckExact(obj)) { + val = __Pyx_PyByteArray_AsDouble(obj); + } else { + return PyNumber_Float(obj); + } + + if (unlikely(val == -1 && PyErr_Occurred())) { + return NULL; + } +#if CYTHON_USE_PYLONG_INTERNALS +no_error: +#endif + return PyFloat_FromDouble(val); +} + +/////////////// GCCDiagnostics.proto /////////////// + +// GCC diagnostic pragmas were introduced in GCC 4.6 +// Used to silence conversion warnings that are ok but cannot be avoided. +#if !defined(__INTEL_COMPILER) && defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) +#define __Pyx_HAS_GCC_DIAGNOSTIC +#endif + + +/////////////// ToPyCTupleUtility.proto /////////////// + +static PyObject* {{funcname}}({{struct_type_decl}}); + +/////////////// ToPyCTupleUtility /////////////// + +static PyObject* {{funcname}}({{struct_type_decl}} value) { + PyObject* items[{{size}}] = { {{ ', '.join('0'*size) }} }; + PyObject* result = NULL; + + {{for ix, component in enumerate(components):}} + {{py:attr = f"value.f{ix}" }} + items[{{ix}}] = {{component.to_py_function}}({{attr}}); + if (unlikely(!items[{{ix}}])) goto bad; + {{endfor}} + + result = PyTuple_New({{size}}); + if (unlikely(!result)) goto bad; + + for (Py_ssize_t i=0; i<{{ size }}; ++i) { + PyObject *item = items[i]; + items[i] = NULL; + #if !CYTHON_ASSUME_SAFE_MACROS + // PyTuple_SetItem() always steals a reference. + if (unlikely(PyTuple_SetItem(result, i, item) < 0)) goto bad; + #else + PyTuple_SET_ITEM(result, i, item); + #endif + } + + return result; + +bad: + Py_XDECREF(result); + for (Py_ssize_t i={{ size-1 }}; i >= 0; --i) { + Py_XDECREF(items[i]); + } + return NULL; +} + + +/////////////// FromPyCTupleUtility.proto /////////////// +static CYTHON_INLINE {{struct_type_decl}} {{funcname}}(PyObject *); + +/////////////// FromPyCTupleUtility /////////////// + +#if CYTHON_ASSUME_SAFE_MACROS && CYTHON_ASSUME_SAFE_SIZE && !CYTHON_AVOID_BORROWED_REFS +static void __Pyx_tuple_{{funcname}}(PyObject * o, {{struct_type_decl}} *result) { + {{for ix, component in enumerate(components):}} + {{py:attr = "result->f%s" % ix}} + {{attr}} = {{component.from_py_function}}(PyTuple_GET_ITEM(o, {{ix}})); + if ({{component.error_condition(attr)}}) goto bad; + {{endfor}} + return; +bad: + return; +} + +static void __Pyx_list_{{funcname}}(PyObject * o, {{struct_type_decl}} *result) { + {{for ix, component in enumerate(components):}} + {{py:attr = "result->f%s" % ix}} + {{attr}} = {{component.from_py_function}}(PyList_GET_ITEM(o, {{ix}})); + if ({{component.error_condition(attr)}}) goto bad; + {{endfor}} + return; +bad: + return; +} +#endif + +static void __Pyx_seq_{{funcname}}(PyObject * o, {{struct_type_decl}} *result) { + if (unlikely(!PySequence_Check(o))) { + __Pyx_TypeName o_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(o)); + PyErr_Format(PyExc_TypeError, + "Expected a sequence of size %zd, got " __Pyx_FMT_TYPENAME, (Py_ssize_t) {{size}}, o_type_name); + __Pyx_DECREF_TypeName(o_type_name); + goto bad; + } else if (unlikely(PySequence_Length(o) != {{size}})) { + PyErr_Format(PyExc_TypeError, + "Expected a sequence of size %zd, got size %zd", (Py_ssize_t) {{size}}, PySequence_Length(o)); + goto bad; + } + + { + PyObject *item; + {{for ix, component in enumerate(components):}} + {{py:attr = "result->f%s" % ix}} + item = __Pyx_PySequence_ITEM(o, {{ix}}); if (unlikely(!item)) goto bad; + {{attr}} = {{component.from_py_function}}(item); + Py_DECREF(item); + if ({{component.error_condition(attr)}}) goto bad; + {{endfor}} + } + return; +bad: + return; +} + +static CYTHON_INLINE {{struct_type_decl}} {{funcname}}(PyObject * o) { + {{struct_type_decl}} result; + + #if CYTHON_ASSUME_SAFE_MACROS && CYTHON_ASSUME_SAFE_SIZE && !CYTHON_AVOID_BORROWED_REFS + if (likely(PyTuple_Check(o) && PyTuple_GET_SIZE(o) == {{size}})) { + __Pyx_tuple_{{funcname}}(o, &result); + } else if (likely(PyList_Check(o) && PyList_GET_SIZE(o) == {{size}})) { + __Pyx_list_{{funcname}}(o, &result); + } else + #endif + { + __Pyx_seq_{{funcname}}(o, &result); + } + + return result; +} + + +/////////////// UnicodeAsUCS4.proto /////////////// + +static CYTHON_INLINE Py_UCS4 __Pyx_PyUnicode_AsPy_UCS4(PyObject*); + +/////////////// UnicodeAsUCS4 /////////////// + +static void __Pyx_PyUnicode_AsPy_UCS4_error(Py_ssize_t length) { + if (likely(length >= 0)) { + // "length == -1" indicates an error already. + PyErr_Format(PyExc_ValueError, + "only single character unicode strings can be converted to Py_UCS4, " + "got length %" CYTHON_FORMAT_SSIZE_T "d", length); + } +} + +static CYTHON_INLINE Py_UCS4 __Pyx_PyUnicode_AsPy_UCS4(PyObject* x) { + Py_ssize_t length = __Pyx_PyUnicode_GET_LENGTH(x); + if (unlikely(length != 1)) { + __Pyx_PyUnicode_AsPy_UCS4_error(length); + return (Py_UCS4)-1; + } + return __Pyx_PyUnicode_READ_CHAR(x, 0); +} + + +/////////////// ObjectAsUCS4.proto /////////////// +//@requires: UnicodeAsUCS4 + +static Py_UCS4 __Pyx__PyObject_AsPy_UCS4(PyObject*); + +static CYTHON_INLINE Py_UCS4 __Pyx_PyObject_AsPy_UCS4(PyObject *x) { + return (likely(PyUnicode_Check(x)) ? __Pyx_PyUnicode_AsPy_UCS4(x) : __Pyx__PyObject_AsPy_UCS4(x)); +} + + +/////////////// ObjectAsUCS4 /////////////// + +static void __Pyx__PyObject_AsPy_UCS4_raise_error(long ival) { + if (ival < 0) { + if (!PyErr_Occurred()) + PyErr_SetString(PyExc_OverflowError, + "cannot convert negative value to Py_UCS4"); + } else { + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to Py_UCS4"); + } +} + +static Py_UCS4 __Pyx__PyObject_AsPy_UCS4(PyObject* x) { + long ival; + ival = __Pyx_PyLong_As_long(x); + if (unlikely(!__Pyx_is_valid_index(ival, 1114111 + 1))) { + __Pyx__PyObject_AsPy_UCS4_raise_error(ival); + return (Py_UCS4)-1; + } + return (Py_UCS4)ival; +} + + +/////////////// ObjectAsPyUnicode.proto /////////////// + +static CYTHON_INLINE Py_UNICODE __Pyx_PyObject_AsPy_UNICODE(PyObject*); + +/////////////// ObjectAsPyUnicode /////////////// + +static CYTHON_INLINE Py_UNICODE __Pyx_PyObject_AsPy_UNICODE(PyObject* x) { + long ival; + #if defined(Py_UNICODE_SIZE) && Py_UNICODE_SIZE == 2 + const long maxval = 65535; + #else + const long maxval = 1114111; + #endif + if (PyUnicode_Check(x)) { + Py_ssize_t length = __Pyx_PyUnicode_GET_LENGTH(x); + if (unlikely(length != 1)) { + // -1 indicates an error. + if (length >= 0) { + PyErr_Format(PyExc_ValueError, + "only single character unicode strings can be converted to Py_UNICODE, " + "got length %" CYTHON_FORMAT_SSIZE_T "d", length); + } + return (Py_UNICODE)-1; + } + ival = PyUnicode_READ_CHAR(x, 0); + } else { + ival = __Pyx_PyLong_As_long(x); + } + if (unlikely(!__Pyx_is_valid_index(ival, maxval + 1))) { + if (ival < 0) { + if (!PyErr_Occurred()) + PyErr_SetString(PyExc_OverflowError, + "cannot convert negative value to Py_UNICODE"); + return (Py_UNICODE)-1; + } else { + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to Py_UNICODE"); + } + return (Py_UNICODE)-1; + } + return (Py_UNICODE)ival; +} + + +/////////////// CIntToPy.proto /////////////// + +static CYTHON_INLINE PyObject* {{TO_PY_FUNCTION}}({{TYPE}} value); + +/////////////// CIntToPy /////////////// +//@requires: GCCDiagnostics +//@requires: ObjectHandling.c::PyObjectVectorCallKwBuilder + +static CYTHON_INLINE PyObject* {{TO_PY_FUNCTION}}({{TYPE}} value) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const {{TYPE}} neg_one = ({{TYPE}}) -1, const_zero = ({{TYPE}}) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof({{TYPE}}) < sizeof(long)) { + return PyLong_FromLong((long) value); + } else if (sizeof({{TYPE}}) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#if defined(HAVE_LONG_LONG) && !CYTHON_COMPILING_IN_PYPY + // PyLong_FromUnsignedLongLong() does not necessarily accept ULL arguments in PyPy. + // See https://github.com/cython/cython/issues/6890 + } else if (sizeof({{TYPE}}) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof({{TYPE}}) <= sizeof(long)) { + return PyLong_FromLong((long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof({{TYPE}}) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); +#endif + } + } + { + unsigned char *bytes = (unsigned char *)&value; +#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4 + if (is_unsigned) { + return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1); + } else { + return PyLong_FromNativeBytes(bytes, sizeof(value), -1); + } +#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 + int one = 1; int little = (int)*(unsigned char *)&one; + return _PyLong_FromByteArray(bytes, sizeof({{TYPE}}), + little, !is_unsigned); +#else + // call int.from_bytes() + int one = 1; int little = (int)*(unsigned char *)&one; + PyObject *from_bytes, *result = NULL, *kwds = NULL; + PyObject *py_bytes = NULL, *order_str = NULL; + from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes"); + if (!from_bytes) return NULL; + py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof({{TYPE}})); + if (!py_bytes) goto limited_bad; + // I'm deliberately not using PYIDENT here because this code path is very unlikely + // to ever run so it seems a pessimization mostly. + order_str = PyUnicode_FromString(little ? "little" : "big"); + if (!order_str) goto limited_bad; + { + PyObject *args[3+(CYTHON_VECTORCALL ? 1 : 0)] = { NULL, py_bytes, order_str }; + if (!is_unsigned) { + kwds = __Pyx_MakeVectorcallBuilderKwds(1); + if (!kwds) goto limited_bad; + if (__Pyx_VectorcallBuilder_AddArgStr("signed", __Pyx_NewRef(Py_True), kwds, args+3, 0) < 0) goto limited_bad; + } + result = __Pyx_Object_Vectorcall_CallFromBuilder(from_bytes, args+1, 2 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET, kwds); + } + + limited_bad: + Py_XDECREF(kwds); + Py_XDECREF(order_str); + Py_XDECREF(py_bytes); + Py_XDECREF(from_bytes); + return result; +#endif + } +} + + +/////////////// COrdinalToPyUnicode.proto /////////////// + +static CYTHON_INLINE int __Pyx_CheckUnicodeValue(int value); +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromOrdinal_Padded(int value, Py_ssize_t width, char padding_char); + +/////////////// COrdinalToPyUnicode /////////////// +//@requires: StringTools.c::BuildPyUnicode + +static CYTHON_INLINE int __Pyx_CheckUnicodeValue(int value) { + return value <= 1114111; +} + +static PyObject* __Pyx_PyUnicode_FromOrdinal_Padded(int value, Py_ssize_t ulength, char padding_char) { + if (likely(ulength <= 250)) { + // Encode to UTF-8 / Latin1 buffer, then decode. + char chars[256]; + + if (value <= 255) { + // Simple Latin1 result, fast to decode. + memset(chars, padding_char, (size_t) (ulength - 1)); + chars[ulength-1] = (char) value; + return PyUnicode_DecodeLatin1(chars, ulength, NULL); + } + + char *cpos = chars + sizeof(chars); + if (value < 0x800) { + *--cpos = (char) (0x80 | (value & 0x3f)); + value >>= 6; + *--cpos = (char) (0xc0 | (value & 0x1f)); + } else if (value < 0x10000) { + *--cpos = (char) (0x80 | (value & 0x3f)); + value >>= 6; + *--cpos = (char) (0x80 | (value & 0x3f)); + value >>= 6; + *--cpos = (char) (0xe0 | (value & 0x0f)); + } else { + *--cpos = (char) (0x80 | (value & 0x3f)); + value >>= 6; + *--cpos = (char) (0x80 | (value & 0x3f)); + value >>= 6; + *--cpos = (char) (0x80 | (value & 0x3f)); + value >>= 6; + *--cpos = (char) (0xf0 | (value & 0x07)); + } + cpos -= ulength; + memset(cpos, padding_char, (size_t) (ulength - 1)); + return PyUnicode_DecodeUTF8(cpos, chars + sizeof(chars) - cpos, NULL); + } + + if (value <= 127 && CYTHON_USE_UNICODE_INTERNALS) { + const char chars[1] = {(char) value}; + return __Pyx_PyUnicode_BuildFromAscii(ulength, chars, 1, 0, padding_char); + } + + { + PyObject *uchar, *padding_uchar, *padding, *result; + + padding_uchar = PyUnicode_FromOrdinal(padding_char); + if (unlikely(!padding_uchar)) return NULL; + padding = PySequence_Repeat(padding_uchar, ulength - 1); + Py_DECREF(padding_uchar); + if (unlikely(!padding)) return NULL; + + uchar = PyUnicode_FromOrdinal(value); + if (unlikely(!uchar)) { + Py_DECREF(padding); + return NULL; + } + + result = PyUnicode_Concat(padding, uchar); + Py_DECREF(padding); + Py_DECREF(uchar); + return result; + } +} + + +/////////////// CIntToDigits /////////////// + +static const char DIGIT_PAIRS_10[2*10*10+1] = { + "00010203040506070809" + "10111213141516171819" + "20212223242526272829" + "30313233343536373839" + "40414243444546474849" + "50515253545556575859" + "60616263646566676869" + "70717273747576777879" + "80818283848586878889" + "90919293949596979899" +}; + +static const char DIGIT_PAIRS_8[2*8*8+1] = { + "0001020304050607" + "1011121314151617" + "2021222324252627" + "3031323334353637" + "4041424344454647" + "5051525354555657" + "6061626364656667" + "7071727374757677" +}; + +static const char DIGITS_HEX[2*16+1] = { + "0123456789abcdef" + "0123456789ABCDEF" +}; + + +/////////////// CIntToPyUnicode.proto /////////////// + +static CYTHON_INLINE PyObject* {{TO_PY_FUNCTION}}({{TYPE}} value, Py_ssize_t width, char padding_char, char format_char); + +/////////////// CIntToPyUnicode /////////////// +//@requires: StringTools.c::IncludeStringH +//@requires: StringTools.c::BuildPyUnicode +//@requires: ModuleSetupCode.c::IncludeStdlibH +//@requires: COrdinalToPyUnicode +//@requires: CIntToDigits +//@requires: GCCDiagnostics + +// NOTE: inlining because most arguments are constant, which collapses lots of code below + +static CYTHON_INLINE PyObject* {{TO_PY_FUNCTION}}({{TYPE}} value, Py_ssize_t width, char padding_char, char format_char) { + // simple and conservative C string allocation on the stack: each byte gives at most 3 digits, plus sign + char digits[sizeof({{TYPE}})*3+2]; + // 'dpos' points to end of digits array + 1 initially to allow for pre-decrement looping + char *dpos, *end = digits + sizeof({{TYPE}})*3+2; + const char *hex_digits = DIGITS_HEX; + Py_ssize_t length, ulength; + int prepend_sign, last_one_off; + {{TYPE}} remaining; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const {{TYPE}} neg_one = ({{TYPE}}) -1, const_zero = ({{TYPE}}) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; + + // Format 'c' (unicode character) is really a different thing but included for practical reasons. + if (format_char == 'c') { + // This check is just an awful variation on "(0 <= value <= 1114111)", + // but without C compiler complaints about compile time constant conditions depending on the signed/unsigned TYPE. + if (unlikely(!(is_unsigned || value == 0 || value > 0) || + !(sizeof(value) <= 2 || value & ~ ({{TYPE}}) 0x01fffff || __Pyx_CheckUnicodeValue((int) value)))) { + // PyUnicode_FromOrdinal() and chr() raise ValueError, f-strings raise OverflowError. :-/ + PyErr_SetString(PyExc_OverflowError, "%c arg not in range(0x110000)"); + return NULL; + } + if (width <= 1) { + return PyUnicode_FromOrdinal((int) value); + } + return __Pyx_PyUnicode_FromOrdinal_Padded((int) value, width, padding_char); + } + + if (format_char == 'X') { + hex_digits += 16; + format_char = 'x'; + } + + // surprise: even trivial sprintf() calls don't get optimised in gcc (4.8) + remaining = value; /* not using abs(value) to avoid overflow problems */ + last_one_off = 0; + dpos = end; + do { + int digit_pos; + switch (format_char) { + case 'o': + digit_pos = abs((int)(remaining % (8*8))); + remaining = ({{TYPE}}) (remaining / (8*8)); + dpos -= 2; + memcpy(dpos, DIGIT_PAIRS_8 + digit_pos * 2, 2); /* copy 2 digits at a time, unaligned */ + last_one_off = (digit_pos < 8); + break; + case 'd': + digit_pos = abs((int)(remaining % (10*10))); + remaining = ({{TYPE}}) (remaining / (10*10)); + dpos -= 2; + memcpy(dpos, DIGIT_PAIRS_10 + digit_pos * 2, 2); /* copy 2 digits at a time, unaligned */ + last_one_off = (digit_pos < 10); + break; + case 'x': + *(--dpos) = hex_digits[abs((int)(remaining % 16))]; + remaining = ({{TYPE}}) (remaining / 16); + break; + default: + assert(0); + break; + } + } while (unlikely(remaining != 0)); + + // Correct dpos by 1 if we read an excess digit. + assert(!last_one_off || *dpos == '0'); + dpos += last_one_off; + + length = end - dpos; + ulength = length; + prepend_sign = 0; + if (!is_unsigned && value <= neg_one) { + if (padding_char == ' ' || width <= length + 1) { + *(--dpos) = '-'; + ++length; + } else { + prepend_sign = 1; + } + ++ulength; + } + if (width > ulength) { + ulength = width; + } + // single character unicode strings are cached in CPython => use PyUnicode_FromOrdinal() for them + if (ulength == 1) { + return PyUnicode_FromOrdinal(*dpos); + } + return __Pyx_PyUnicode_BuildFromAscii(ulength, dpos, (int) length, prepend_sign, padding_char); +} + + +/////////////// CBIntToPyUnicode.proto /////////////// + +#define {{TO_PY_FUNCTION}}(value) \ + ((value) ? __Pyx_NewRef({{TRUE_CONST}}) : __Pyx_NewRef({{FALSE_CONST}})) + + +/////////////// CIntFromPyVerify /////////////// + +// see CIntFromPy +#define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value) \ + __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0) + +#define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value) \ + __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1) + +#define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc) \ + { \ + func_type value = func_value; \ + if (sizeof(target_type) < sizeof(func_type)) { \ + if (unlikely(value != (func_type) (target_type) value)) { \ + func_type zero = 0; \ + if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred())) \ + return (target_type) -1; \ + if (is_unsigned && unlikely(value < zero)) \ + goto raise_neg_overflow; \ + else \ + goto raise_overflow; \ + } \ + } \ + return (target_type) value; \ + } + + +/////////////// CIntFromPy.proto /////////////// + +static CYTHON_INLINE {{TYPE}} {{FROM_PY_FUNCTION}}(PyObject *); + +/////////////// CIntFromPy /////////////// +//@requires: CIntFromPyVerify +//@requires: GCCDiagnostics + +{{py: from Cython.Utility import pylong_join }} + +static CYTHON_INLINE {{TYPE}} {{FROM_PY_FUNCTION}}(PyObject *x) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const {{TYPE}} neg_one = ({{TYPE}}) -1, const_zero = ({{TYPE}}) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; + + if (unlikely(!PyLong_Check(x))) { + {{TYPE}} val; + PyObject *tmp = __Pyx_PyNumber_Long(x); + if (!tmp) return ({{TYPE}}) -1; + val = {{FROM_PY_FUNCTION}}(tmp); + Py_DECREF(tmp); + return val; + } + + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + if (unlikely(__Pyx_PyLong_IsNeg(x))) { + goto raise_neg_overflow; + //} else if (__Pyx_PyLong_IsZero(x)) { + // return ({{TYPE}}) 0; + } else if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT({{TYPE}}, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_DigitCount(x)) { + {{for _size in (2, 3, 4)}} + case {{_size}}: + if ((8 * sizeof({{TYPE}}) > {{_size-1}} * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > {{_size}} * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT({{TYPE}}, unsigned long, {{pylong_join(_size, 'digits')}}) + } else if ((8 * sizeof({{TYPE}}) >= {{_size}} * PyLong_SHIFT)) { + return ({{TYPE}}) {{pylong_join(_size, 'digits', TYPE)}}; + } + } + break; + {{endfor}} + } + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + // misuse Py_False as a quick way to compare to a '0' int object in PyPy + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return ({{TYPE}}) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if ((sizeof({{TYPE}}) <= sizeof(unsigned long))) { + __PYX_VERIFY_RETURN_INT_EXC({{TYPE}}, unsigned long, PyLong_AsUnsignedLong(x)) +#ifdef HAVE_LONG_LONG + } else if ((sizeof({{TYPE}}) <= sizeof(unsigned PY_LONG_LONG))) { + __PYX_VERIFY_RETURN_INT_EXC({{TYPE}}, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) +#endif + } + + } else { + // signed +#if CYTHON_USE_PYLONG_INTERNALS + if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT({{TYPE}}, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_SignedDigitCount(x)) { + {{for _size in (2, 3, 4)}} + {{for _case in (-_size, _size)}} + case {{_case}}: + if ((8 * sizeof({{TYPE}}){{' - 1' if _case < 0 else ''}} > {{_size-1}} * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > {{_size}} * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT({{TYPE}}, {{'long' if _case < 0 else 'unsigned long'}}, {{'-(long) ' if _case < 0 else ''}}{{pylong_join(_size, 'digits')}}) + } else if ((8 * sizeof({{TYPE}}) - 1 > {{_size}} * PyLong_SHIFT)) { + return ({{TYPE}}) ({{'((%s)-1)*' % TYPE if _case < 0 else ''}}{{pylong_join(_size, 'digits', TYPE)}}); + } + } + break; + {{endfor}} + {{endfor}} + } + } +#endif + if ((sizeof({{TYPE}}) <= sizeof(long))) { + __PYX_VERIFY_RETURN_INT_EXC({{TYPE}}, long, PyLong_AsLong(x)) +#ifdef HAVE_LONG_LONG + } else if ((sizeof({{TYPE}}) <= sizeof(PY_LONG_LONG))) { + __PYX_VERIFY_RETURN_INT_EXC({{TYPE}}, PY_LONG_LONG, PyLong_AsLongLong(x)) +#endif + } + } + + // large integer type and no access to PyLong internals => allow for a more expensive conversion + { + {{TYPE}} val; + int ret = -1; +#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API + Py_ssize_t bytes_copied = PyLong_AsNativeBytes( + x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0)); + if (unlikely(bytes_copied == -1)) { + // failed + } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) { + goto raise_overflow; + } else { + ret = 0; + } +#elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + ret = _PyLong_AsByteArray((PyLongObject *)x, + bytes, sizeof(val), + is_little, !is_unsigned); +#else +{{if IS_ENUM}} + // The fallback implementation uses math operations like shifting, which do not work well with enums. + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() or PyLong_AsNativeBytes() not available, cannot convert large enums"); + val = ({{TYPE}}) -1; +{{else}} +// Inefficient copy of bit chunks through the C-API. Probably still better than a "cannot do this" exception. +// This is substantially faster in CPython (>30%) than calling "int.to_bytes()" through the C-API. + PyObject *v; + PyObject *stepval = NULL, *mask = NULL, *shift = NULL; + int bits, remaining_bits, is_negative = 0; + int chunk_size = (sizeof(long) < 8) ? 30 : 62; + + // Use exact PyLong to prevent user defined &&/<= (1L << remaining_bits))) + goto raise_overflow; + val |= (({{TYPE}}) idigit) << bits; + } + + // Handle sign and overflow into sign bit. + if (!is_unsigned) { + // gcc warns about unsigned (val < 0) => test sign bit instead + if (unlikely(val & ((({{TYPE}}) 1) << (sizeof({{TYPE}}) * 8 - 1)))) + goto raise_overflow; + // undo the PyNumber_Invert() above + if (is_negative) + val = ~val; + } + ret = 0; + done: + Py_XDECREF(shift); + Py_XDECREF(mask); + Py_XDECREF(stepval); +{{endif}} +#endif + if (unlikely(ret)) + return ({{TYPE}}) -1; + return val; + } + +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to {{TYPE}}"); + return ({{TYPE}}) -1; + +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to {{TYPE}}"); + return ({{TYPE}}) -1; +} diff --git a/venv/lib/python3.10/site-packages/Cython/Utility/UFuncs.pyx b/venv/lib/python3.10/site-packages/Cython/Utility/UFuncs.pyx new file mode 100644 index 0000000000000000000000000000000000000000..778b7bd8ddf1e45e2df242c8f4916eba6ca81f96 --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Utility/UFuncs.pyx @@ -0,0 +1,50 @@ +##################### UFuncDefinition ###################### + +cdef extern from *: + ctypedef int npy_intp + struct PyObject + PyObject* __Pyx_NewRef(object) + +# variable names have to come from tempita to avoid duplication +@cname("{{func_cname}}") +cdef void {{func_cname}}(char **args, const npy_intp *dimensions, const npy_intp* steps, void* data) except * {{"nogil" if will_be_called_without_gil else ""}}: + cdef npy_intp i + cdef npy_intp n = dimensions[0] + {{for idx, tn_tp in enumerate(in_types)}} + cdef char* in_{{idx}} = args[{{idx}}] + cdef {{tn_tp[0]}} cast_in_{{idx}} + {{endfor}} + {{for idx, tn_tp in enumerate(out_types)}} + cdef char* out_{{idx}} = args[{{idx+len(in_types)}}] + cdef {{tn_tp[0]}} cast_out_{{idx}} + {{endfor}} + {{for idx in range(len(out_types)+len(in_types))}} + cdef npy_intp step_{{idx}} = steps[{{idx}}] + {{endfor}} + + {{"with gil" if (not nogil and will_be_called_without_gil) else "if True"}}: + for i in range(n): + {{for idx, tn_tp in enumerate(in_types)}} + {{if tn_tp[1].is_pyobject}} + cast_in_{{idx}} = (<{{tn_tp[0]}}>(in_{{idx}})[0]) + {{else}} + cast_in_{{idx}} = (<{{tn_tp[0]}}*>in_{{idx}})[0] + {{endif}} + {{endfor}} + + {{", ".join("cast_out_{}".format(idx) for idx in range(len(out_types)))}} = \ + {{inline_func_call}}({{", ".join("cast_in_{}".format(idx) for idx in range(len(in_types)))}}) + + {{for idx, tn_tp in enumerate(out_types)}} + {{if tn_tp[1].is_pyobject}} + (out_{{idx}})[0] = __Pyx_NewRef(cast_out_{{idx}}) + {{else}} + (<{{tn_tp[0]}}*>out_{{idx}})[0] = cast_out_{{idx}} + {{endif}} + {{endfor}} + {{for idx in range(len(in_types))}} + in_{{idx}} += step_{{idx}} + {{endfor}} + {{for idx in range(len(out_types))}} + out_{{idx}} += step_{{idx+len(in_types)}} + {{endfor}} diff --git a/venv/lib/python3.10/site-packages/Cython/Utility/UFuncs_C.c b/venv/lib/python3.10/site-packages/Cython/Utility/UFuncs_C.c new file mode 100644 index 0000000000000000000000000000000000000000..2087d8170115e45f17fc908c9d4b8b61159a8ca4 --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Utility/UFuncs_C.c @@ -0,0 +1,89 @@ +///////////////////////// UFuncsInit.proto ///////////////////////// +//@proto_block: utility_code_proto_before_types + +#include +#include + +// account for change in type of arguments to PyUFuncGenericFunction in Numpy 1.19.x +// Unfortunately we can only test against Numpy version 1.20.x since it wasn't marked +// as an API break. Therefore, I'm "solving" the issue by casting function pointer types +// on lower Numpy versions. +#if NPY_API_VERSION >= 0x0000000e // Numpy 1.20.x +#define __PYX_PYUFUNCGENERICFUNCTION_CAST(x) x +#else +#define __PYX_PYUFUNCGENERICFUNCTION_CAST(x) (PyUFuncGenericFunction)x +#endif + +/////////////////////// UFuncTypeHandling.proto ////////////// + +#define __PYX_GET_NPY_COMPLEX_TYPE(tp) \ + sizeof(tp) == sizeof(npy_cfloat) ? NPY_CFLOAT : \ + sizeof(tp) == sizeof(npy_cdouble) ? NPY_CDOUBLE : \ + sizeof(tp) == sizeof(npy_clongdouble) ? NPY_CLONGDOUBLE : NPY_NOTYPE + +#define __PYX_GET_NPY_FLOAT_TYPE(tp) \ + sizeof(tp) == sizeof(npy_float) ? NPY_FLOAT : \ + sizeof(tp) == sizeof(npy_double) ? NPY_DOUBLE : \ + sizeof(tp) == sizeof(npy_longdouble) ? NPY_LONGDOUBLE : NPY_NOTYPE + +#define __PYX_GET_NPY_UINT_TYPE(tp) \ + sizeof(tp) == 1 ? NPY_UINT8 : \ + sizeof(tp) == 2 ? NPY_UINT16 : \ + sizeof(tp) == 4 ? NPY_UINT32 : \ + sizeof(tp) == 8 ? NPY_UINT64 : NPY_NOTYPE + +#define __PYX_GET_NPY_SINT_TYPE(tp) \ + sizeof(tp) == 1 ? NPY_INT8 : \ + sizeof(tp) == 2 ? NPY_INT16 : \ + sizeof(tp) == 4 ? NPY_INT32 : \ + sizeof(tp) == 8 ? NPY_INT64 : NPY_NOTYPE + +#define __PYX_GET_NPY_INT_TYPE(tp) ( \ + (((tp)-1) > (tp)0) ? \ + (__PYX_GET_NPY_UINT_TYPE(tp)) : \ + (__PYX_GET_NPY_SINT_TYPE(tp)) ) + +/////////////////////// UFuncTypedef.proto /////////////////// +//@requires: UFuncTypeHandling + +enum { + /* + Deduce what to tell Numpy about the extern typedef '{{type_cname}}' + */ + __Pyx_typedef_ufunc_{{type_substituted_cname}} = {{macro_name}}({{type_cname}}), + + /* Validation: + If the line below is failing then you are using the extern typedef + '{{type_cname}}' as a parameter in a ufunc and Cython can't work out + how to map the type to a Numpy type. + */ + __Pyx_typedef_ufunc_validation_{{type_substituted_cname}} = + 1 / (int)(__Pyx_typedef_ufunc_{{type_substituted_cname}} - NPY_NOTYPE) +}; + +/////////////////////// UFuncConsts.proto //////////////////// + +// getter functions because we can't forward-declare arrays +static PyUFuncGenericFunction* {{ufunc_funcs_name}}(void); /* proto */ +static char* {{ufunc_types_name}}(void); /* proto */ +static void* {{ufunc_data_name}}[] = {NULL}; /* always null */ + +/////////////////////// UFuncConsts ///////////////////////// + +static PyUFuncGenericFunction* {{ufunc_funcs_name}}(void) { + static PyUFuncGenericFunction arr[] = { + {{for loop, cname in looper(func_cnames)}} + __PYX_PYUFUNCGENERICFUNCTION_CAST(&{{cname}}){{if not loop.last}},{{endif}} + {{endfor}} + }; + return arr; +} + +static char* {{ufunc_types_name}}(void) { + static char arr[] = { + {{for loop, tp in looper(type_constants)}} + {{tp}}{{if not loop.last}},{{endif}} + {{endfor}} + }; + return arr; +} diff --git a/venv/lib/python3.10/site-packages/Cython/Utility/__init__.py b/venv/lib/python3.10/site-packages/Cython/Utility/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..5fd0bb0bfded6c87a68f120258772cdb66718f2d --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Utility/__init__.py @@ -0,0 +1,28 @@ +def pylong_join(count, digits_ptr='digits', join_type='unsigned long'): + """ + Generate an unrolled shift-then-or loop over the first 'count' digits. + Assumes that they fit into 'join_type'. + + (((d[2] << n) | d[1]) << n) | d[0] + """ + return ('(' * (count * 2) + ' | '.join( + "(%s)%s[%d])%s)" % (join_type, digits_ptr, _i, " << PyLong_SHIFT" if _i else '') + for _i in range(count-1, -1, -1))) + + +# although it could potentially make use of data independence, +# this implementation is a bit slower than the simpler one above +def _pylong_join(count, digits_ptr='digits', join_type='unsigned long'): + """ + Generate an or-ed series of shifts for the first 'count' digits. + Assumes that they fit into 'join_type'. + + (d[2] << 2*n) | (d[1] << 1*n) | d[0] + """ + def shift(n): + # avoid compiler warnings for overly large shifts that will be discarded anyway + return " << (%d * PyLong_SHIFT < 8 * sizeof(%s) ? %d * PyLong_SHIFT : 0)" % (n, join_type, n) if n else '' + + return '(%s)' % ' | '.join( + "(((%s)%s[%d])%s)" % (join_type, digits_ptr, i, shift(i)) + for i in range(count-1, -1, -1)) diff --git a/venv/lib/python3.10/site-packages/Cython/Utility/__pycache__/Dataclasses.cpython-310.pyc b/venv/lib/python3.10/site-packages/Cython/Utility/__pycache__/Dataclasses.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..30ce12aefad23440c1cee94a622ef88f499a5ac1 Binary files /dev/null and b/venv/lib/python3.10/site-packages/Cython/Utility/__pycache__/Dataclasses.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/Cython/Utility/__pycache__/__init__.cpython-310.pyc b/venv/lib/python3.10/site-packages/Cython/Utility/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d36c5af7c22d676310fa1bb6e3978bb35e781ba2 Binary files /dev/null and b/venv/lib/python3.10/site-packages/Cython/Utility/__pycache__/__init__.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/Cython/Utility/arrayarray.h b/venv/lib/python3.10/site-packages/Cython/Utility/arrayarray.h new file mode 100644 index 0000000000000000000000000000000000000000..d410e66c8c267870870fe40b777231cc7beacf0b --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Utility/arrayarray.h @@ -0,0 +1,148 @@ +/////////////// ArrayAPI.proto /////////////// + +// arrayarray.h +// +// Artificial C-API for Python's type, +// used by array.pxd +// +// last changes: 2009-05-15 rk +// 2012-05-02 andreasvc +// (see revision control) +// + +#ifndef _ARRAYARRAY_H +#define _ARRAYARRAY_H + +// These two forward declarations are explicitly handled in the type +// declaration code, as including them here is too late for cython-defined +// types to use them. +// struct arrayobject; +// typedef struct arrayobject arrayobject; + +// All possible arraydescr values are defined in the vector "descriptors" +// below. That's defined later because the appropriate get and set +// functions aren't visible yet. +typedef struct arraydescr { + int typecode; + int itemsize; + PyObject * (*getitem)(struct arrayobject *, Py_ssize_t); + int (*setitem)(struct arrayobject *, Py_ssize_t, PyObject *); + char *formats; +} arraydescr; + + +struct arrayobject { + PyObject_HEAD + Py_ssize_t ob_size; + union { + char *ob_item; + float *as_floats; + double *as_doubles; + int *as_ints; + unsigned int *as_uints; + unsigned char *as_uchars; + signed char *as_schars; + char *as_chars; + unsigned long *as_ulongs; + long *as_longs; + unsigned long long *as_ulonglongs; + long long *as_longlongs; + short *as_shorts; + unsigned short *as_ushorts; + // Don't use Py_UNICODE ourselves in the union. This avoids deprecation warnings + // for anyone who uses array.array but doesn't use this field. + #if PY_VERSION_HEX >= 0x030d0000 + Py_DEPRECATED(3.13) + #endif + wchar_t *as_pyunicodes; + void *as_voidptr; + } data; + Py_ssize_t allocated; + struct arraydescr *ob_descr; + PyObject *weakreflist; /* List of weak references */ + int ob_exports; /* Number of exported buffers */ +}; + +#ifndef NO_NEWARRAY_INLINE +// fast creation of a new array +static CYTHON_INLINE PyObject * newarrayobject(PyTypeObject *type, Py_ssize_t size, + struct arraydescr *descr) { + arrayobject *op; + size_t nbytes; + + if (size < 0) { + PyErr_BadInternalCall(); + return NULL; + } + + nbytes = size * descr->itemsize; + // Check for overflow + if (nbytes / descr->itemsize != (size_t)size) { + return PyErr_NoMemory(); + } + op = (arrayobject *) type->tp_alloc(type, 0); + if (op == NULL) { + return NULL; + } + op->ob_descr = descr; + op->allocated = size; + op->weakreflist = NULL; + __Pyx_SET_SIZE(op, size); + if (size <= 0) { + op->data.ob_item = NULL; + } + else { + op->data.ob_item = PyMem_NEW(char, nbytes); + if (op->data.ob_item == NULL) { + Py_DECREF(op); + return PyErr_NoMemory(); + } + } + return (PyObject *) op; +} +#else +PyObject* newarrayobject(PyTypeObject *type, Py_ssize_t size, + struct arraydescr *descr); +#endif /* ifndef NO_NEWARRAY_INLINE */ + +// fast resize (reallocation to the point) +// not designed for filing small increments (but for fast opaque array apps) +static CYTHON_INLINE int resize(arrayobject *self, Py_ssize_t n) { + void *items = (void*) self->data.ob_item; + PyMem_Resize(items, char, (size_t)(n * self->ob_descr->itemsize)); + if (items == NULL) { + PyErr_NoMemory(); + return -1; + } + self->data.ob_item = (char*) items; + __Pyx_SET_SIZE(self, n); + self->allocated = n; + return 0; +} + +// suitable for small increments; over allocation 50% ; +static CYTHON_INLINE int resize_smart(arrayobject *self, Py_ssize_t n) { + void *items = (void*) self->data.ob_item; + Py_ssize_t newsize; + if (n < self->allocated && n*4 > self->allocated) { + __Pyx_SET_SIZE(self, n); + return 0; + } + newsize = n + (n / 2) + 1; + if (newsize <= n) { /* overflow */ + PyErr_NoMemory(); + return -1; + } + PyMem_Resize(items, char, (size_t)(newsize * self->ob_descr->itemsize)); + if (items == NULL) { + PyErr_NoMemory(); + return -1; + } + self->data.ob_item = (char*) items; + __Pyx_SET_SIZE(self, n); + self->allocated = newsize; + return 0; +} + +#endif +/* _ARRAYARRAY_H */ diff --git a/venv/lib/python3.10/site-packages/Cython/Utils.py b/venv/lib/python3.10/site-packages/Cython/Utils.py new file mode 100644 index 0000000000000000000000000000000000000000..ca2222d05f594b8bb1844bc95b84a2241bb93780 --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/Utils.py @@ -0,0 +1,687 @@ +""" +Cython -- Things that don't belong anywhere else in particular +""" + + +import cython + +cython.declare( + os=object, sys=object, re=object, io=object, glob=object, shutil=object, tempfile=object, + update_wrapper=object, partial=object, wraps=object, cython_version=object, + _cache_function=object, _function_caches=list, _parse_file_version=object, _match_file_encoding=object, +) + +import os +import sys +import re +import io +import glob +import shutil +import tempfile + + + +if sys.version_info < (3, 9): + # Work around a limited API bug in these Python versions + # where it isn't possible to make __module__ of CyFunction + # writeable. This means that wraps fails when applied to + # cyfunctions. + # The objective here is just to make limited API builds + # testable. + + from functools import update_wrapper, partial + + def _update_wrapper(wrapper, wrapped): + try: + return update_wrapper(wrapper, wrapped) + except AttributeError: + return wrapper # worse, but it still works + + def wraps(wrapped): + return partial(_update_wrapper, wrapped=wrapped) +else: + from functools import wraps + + +from . import __version__ as cython_version + +PACKAGE_FILES = ("__init__.py", "__init__.pyc", "__init__.pyx", "__init__.pxd") + +_build_cache_name = "__{}_cache".format +_CACHE_NAME_PATTERN = re.compile(r"^__(.+)_cache$") + +modification_time = os.path.getmtime + +GENERATED_BY_MARKER = "/* Generated by Cython %s */" % cython_version +GENERATED_BY_MARKER_BYTES = GENERATED_BY_MARKER.encode('us-ascii') + + +class _TryFinallyGeneratorContextManager: + """ + Fast, bare minimum @contextmanager, only for try-finally, not for exception handling. + """ + def __init__(self, gen): + self._gen = gen + + def __enter__(self): + return next(self._gen) + + def __exit__(self, exc_type, exc_val, exc_tb): + try: + next(self._gen) + except (StopIteration, GeneratorExit): + pass + + +def try_finally_contextmanager(gen_func): + @wraps(gen_func) + def make_gen(*args, **kwargs): + return _TryFinallyGeneratorContextManager(gen_func(*args, **kwargs)) + return make_gen + + +try: + from functools import cache as _cache_function +except ImportError: + from functools import lru_cache + _cache_function = lru_cache(maxsize=None) + + +_function_caches = [] + + +def clear_function_caches(): + for cache in _function_caches: + cache.cache_clear() + + +def cached_function(f): + cf = _cache_function(f) + _function_caches.append(cf) + cf.uncached = f # needed by coverage plugin + return cf + + + +def _find_cache_attributes(obj): + """The function iterates over the attributes of the object and, + if it finds the name of the cache, it returns it and the corresponding method name. + The method may not be present in the object. + """ + for attr_name in dir(obj): + match = _CACHE_NAME_PATTERN.match(attr_name) + if match is not None: + yield attr_name, match.group(1) + + +def clear_method_caches(obj): + """Removes every cache found in the object, + if a corresponding method exists for that cache. + """ + for cache_name, method_name in _find_cache_attributes(obj): + if hasattr(obj, method_name): + delattr(obj, cache_name) + # if there is no corresponding method, then we assume + # that this attribute was not created by our cached method + + +def cached_method(f): + cache_name = _build_cache_name(f.__name__) + + def wrapper(self, *args): + cache = getattr(self, cache_name, None) + if cache is None: + cache = {} + setattr(self, cache_name, cache) + if args in cache: + return cache[args] + res = cache[args] = f(self, *args) + return res + + return wrapper + + +def replace_suffix(path, newsuf): + base, _ = os.path.splitext(path) + return base + newsuf + + +def open_new_file(path): + if os.path.exists(path): + # Make sure to create a new file here so we can + # safely hard link the output files. + os.unlink(path) + + # We only write pure ASCII code strings, but need to write file paths in position comments. + # Those are encoded in UTF-8 so that tools can parse them out again. + return open(path, "w", encoding="UTF-8") + + +def castrate_file(path, st): + # Remove junk contents from an output file after a + # failed compilation. + # Also sets access and modification times back to + # those specified by st (a stat struct). + if not is_cython_generated_file(path, allow_failed=True, if_not_found=False): + return + + try: + f = open_new_file(path) + except OSError: + pass + else: + f.write( + "#error Do not use this file, it is the result of a failed Cython compilation.\n") + f.close() + if st: + os.utime(path, (st.st_atime, st.st_mtime-1)) + + +def is_cython_generated_file(path, allow_failed=False, if_not_found=True): + failure_marker = b"#error Do not use this file, it is the result of a failed Cython compilation." + file_content = None + if os.path.exists(path): + try: + with open(path, "rb") as f: + file_content = f.read(len(failure_marker)) + except OSError: + pass # Probably just doesn't exist any more + + if file_content is None: + # file does not exist (yet) + return if_not_found + + return ( + # Cython C file? + file_content.startswith(b"/* Generated by Cython ") or + # Cython output file after previous failures? + (allow_failed and file_content == failure_marker) or + # Let's allow overwriting empty files as well. They might have resulted from previous failures. + not file_content + ) + + +def file_generated_by_this_cython(path): + file_content = b'' + if os.path.exists(path): + try: + with open(path, "rb") as f: + file_content = f.read(len(GENERATED_BY_MARKER_BYTES)) + except OSError: + pass # Probably just doesn't exist any more + return file_content and file_content.startswith(GENERATED_BY_MARKER_BYTES) + + +def file_newer_than(path, time): + ftime = modification_time(path) + return ftime > time + + +def safe_makedirs(path): + try: + os.makedirs(path) + except OSError: + if not os.path.isdir(path): + raise + + +def copy_file_to_dir_if_newer(sourcefile, destdir): + """ + Copy file sourcefile to directory destdir (creating it if needed), + preserving metadata. If the destination file exists and is not + older than the source file, the copying is skipped. + """ + destfile = os.path.join(destdir, os.path.basename(sourcefile)) + try: + desttime = modification_time(destfile) + except OSError: + # New file does not exist, destdir may or may not exist + safe_makedirs(destdir) + else: + # New file already exists + if not file_newer_than(sourcefile, desttime): + return + shutil.copy2(sourcefile, destfile) + + +@cached_function +def find_root_package_dir(file_path): + dir = os.path.dirname(file_path) + if file_path == dir: + return dir + elif is_package_dir(dir): + return find_root_package_dir(dir) + else: + return dir + + +@cached_function +def check_package_dir(dir_path, package_names): + namespace = True + for dirname in package_names: + dir_path = os.path.join(dir_path, dirname) + has_init = contains_init(dir_path) + if has_init: + namespace = False + return dir_path, namespace + + +@cached_function +def contains_init(dir_path): + for filename in PACKAGE_FILES: + path = os.path.join(dir_path, filename) + if path_exists(path): + return 1 + + +def is_package_dir(dir_path): + if contains_init(dir_path): + return 1 + + +@cached_function +def path_exists(path): + # try on the filesystem first + if os.path.exists(path): + return True + # figure out if a PEP 302 loader is around + try: + loader = __loader__ + # XXX the code below assumes a 'zipimport.zipimporter' instance + # XXX should be easy to generalize, but too lazy right now to write it + archive_path = getattr(loader, 'archive', None) + if archive_path: + normpath = os.path.normpath(path) + if normpath.startswith(archive_path): + arcname = normpath[len(archive_path)+1:] + try: + loader.get_data(arcname) + return True + except OSError: + return False + except NameError: + pass + return False + + +_parse_file_version = re.compile(r".*[.]cython-([0-9]+)[.][^./\\]+$").findall + + +@cached_function +def find_versioned_file(directory, filename, suffix, + _current_version=int(re.sub(r"^([0-9]+)[.]([0-9]+).*", r"\1\2", cython_version))): + """ + Search a directory for versioned pxd files, e.g. "lib.cython-30.pxd" for a Cython 3.0+ version. + + @param directory: the directory to search + @param filename: the filename without suffix + @param suffix: the filename extension including the dot, e.g. ".pxd" + @return: the file path if found, or None + """ + assert not suffix or suffix[:1] == '.' + path_prefix = os.path.join(directory, filename) + + matching_files = glob.glob(glob.escape(path_prefix) + ".cython-*" + suffix) + path = path_prefix + suffix + if not os.path.exists(path): + path = None + best_match = (-1, path) # last resort, if we do not have versioned .pxd files + + for path in matching_files: + versions = _parse_file_version(path) + if versions: + int_version = int(versions[0]) + # Let's assume no duplicates. + if best_match[0] < int_version <= _current_version: + best_match = (int_version, path) + return best_match[1] + + +# file name encodings + +def decode_filename(filename): + if isinstance(filename, bytes): + try: + filename_encoding = sys.getfilesystemencoding() + if filename_encoding is None: + filename_encoding = sys.getdefaultencoding() + filename = filename.decode(filename_encoding) + except UnicodeDecodeError: + pass + return filename + + +# support for source file encoding detection + +_match_file_encoding = re.compile(br"(\w*coding)[:=]\s*([-\w.]+)").search + + +def detect_opened_file_encoding(f, default='UTF-8'): + # PEPs 263 and 3120 + # Most of the time the first two lines fall in the first couple of hundred chars, + # and this bulk read/split is much faster. + lines = () + start = b'' + while len(lines) < 3: + data = f.read(500) + start += data + lines = start.split(b"\n") + if not data: + break + + m = _match_file_encoding(lines[0]) + if m and m.group(1) != b'c_string_encoding': + return m.group(2).decode('iso8859-1') + elif len(lines) > 1: + m = _match_file_encoding(lines[1]) + if m: + return m.group(2).decode('iso8859-1') + return default + + +def skip_bom(f): + """ + Read past a BOM at the beginning of a source file. + This could be added to the scanner, but it's *substantially* easier + to keep it at this level. + """ + if f.read(1) != '\uFEFF': + f.seek(0) + + +def open_source_file(source_filename, encoding=None, error_handling=None): + stream = None + try: + if encoding is None: + # Most of the time the encoding is not specified, so try hard to open the file only once. + f = open(source_filename, 'rb') + encoding = detect_opened_file_encoding(f) + f.seek(0) + stream = io.TextIOWrapper(f, encoding=encoding, errors=error_handling) + else: + stream = open(source_filename, encoding=encoding, errors=error_handling) + + except OSError: + if os.path.exists(source_filename): + raise # File is there, but something went wrong reading from it. + # Allow source files to be in zip files etc. + try: + loader = __loader__ + if source_filename.startswith(loader.archive): + stream = open_source_from_loader( + loader, source_filename, + encoding, error_handling) + except (NameError, AttributeError): + pass + + if stream is None: + raise FileNotFoundError(source_filename) + skip_bom(stream) + return stream + + +def open_source_from_loader(loader, + source_filename, + encoding=None, error_handling=None): + nrmpath = os.path.normpath(source_filename) + arcname = nrmpath[len(loader.archive)+1:] + data = loader.get_data(arcname) + return io.TextIOWrapper(io.BytesIO(data), + encoding=encoding, + errors=error_handling) + + +def str_to_number(value): + # note: this expects a string as input that was accepted by the + # parser already, with an optional "-" sign in front + is_neg = False + if value[:1] == '-': + is_neg = True + value = value[1:] + if len(value) < 2: + value = int(value, 0) + elif value[0] == '0': + literal_type = value[1] # 0'o' - 0'b' - 0'x' + if literal_type in 'xX': + # hex notation ('0x1AF') + value = strip_py2_long_suffix(value) + value = int(value[2:], 16) + elif literal_type in 'oO': + # Py3 octal notation ('0o136') + value = int(value[2:], 8) + elif literal_type in 'bB': + # Py3 binary notation ('0b101') + value = int(value[2:], 2) + else: + # Py2 octal notation ('0136') + value = int(value, 8) + else: + value = int(value, 0) + return -value if is_neg else value + + +def strip_py2_long_suffix(value_str): + """ + Python 2 likes to append 'L' to stringified numbers + which in then can't process when converting them to numbers. + """ + if value_str[-1] in 'lL': + return value_str[:-1] + return value_str + + +def long_literal(value): + if isinstance(value, str): + value = str_to_number(value) + return not -2**31 <= value < 2**31 + + +@try_finally_contextmanager +def captured_fd(stream=2, encoding=None): + orig_stream = os.dup(stream) # keep copy of original stream + try: + with tempfile.TemporaryFile(mode="a+b") as temp_file: + def read_output(_output=[b'']): + if not temp_file.closed: + temp_file.seek(0) + _output[0] = temp_file.read() + return _output[0] + + os.dup2(temp_file.fileno(), stream) # replace stream by copy of pipe + def get_output(): + result = read_output() + return result.decode(encoding) if encoding else result + + yield get_output + # note: @contextlib.contextmanager requires try-finally here + os.dup2(orig_stream, stream) # restore original stream + read_output() # keep the output in case it's used after closing the context manager + finally: + os.close(orig_stream) + + +def get_encoding_candidates(): + candidates = [sys.getdefaultencoding()] + for stream in (sys.stdout, sys.stdin, sys.__stdout__, sys.__stdin__): + encoding = getattr(stream, 'encoding', None) + # encoding might be None (e.g. somebody redirects stdout): + if encoding is not None and encoding not in candidates: + candidates.append(encoding) + return candidates + + +def prepare_captured(captured): + captured_bytes = captured.strip() + if not captured_bytes: + return None + for encoding in get_encoding_candidates(): + try: + return captured_bytes.decode(encoding) + except UnicodeDecodeError: + pass + # last resort: print at least the readable ascii parts correctly. + return captured_bytes.decode('latin-1') + + +def print_captured(captured, output, header_line=None): + captured = prepare_captured(captured) + if captured: + if header_line: + output.write(header_line) + output.write(captured) + + +def print_bytes(s, header_text=None, end=b'\n', file=sys.stdout, flush=True): + if header_text: + file.write(header_text) # note: text! => file.write() instead of out.write() + file.flush() + out = file.buffer + out.write(s) + if end: + out.write(end) + if flush: + out.flush() + + +class OrderedSet: + def __init__(self, elements=()): + self._list = [] + self._set = set() + self.update(elements) + + def __iter__(self): + return iter(self._list) + + def update(self, elements): + for e in elements: + self.add(e) + + def add(self, e): + if e not in self._set: + self._list.append(e) + self._set.add(e) + + def __bool__(self): + return bool(self._set) + + __nonzero__ = __bool__ + + +# Class decorator that adds a metaclass and recreates the class with it. +# Copied from 'six'. +def add_metaclass(metaclass): + """Class decorator for creating a class with a metaclass.""" + def wrapper(cls): + orig_vars = cls.__dict__.copy() + slots = orig_vars.get('__slots__') + if slots is not None: + if isinstance(slots, str): + slots = [slots] + for slots_var in slots: + orig_vars.pop(slots_var) + orig_vars.pop('__dict__', None) + orig_vars.pop('__weakref__', None) + return metaclass(cls.__name__, cls.__bases__, orig_vars) + return wrapper + + +def raise_error_if_module_name_forbidden(full_module_name): + # it is bad idea to call the pyx-file cython.pyx, so fail early + if full_module_name == 'cython' or full_module_name.startswith('cython.'): + raise ValueError('cython is a special module, cannot be used as a module name') + + +def build_hex_version(version_string): + """ + Parse and translate public version identifier like '4.3a1' into the readable hex representation '0x040300A1' (like PY_VERSION_HEX). + + SEE: https://peps.python.org/pep-0440/#public-version-identifiers + """ + # Parse '4.12a1' into [4, 12, 0, 0xA01] + # And ignore .dev, .pre and .post segments + digits = [] + release_status = 0xF0 + for segment in re.split(r'(\D+)', version_string): + if segment in ('a', 'b', 'rc'): + release_status = {'a': 0xA0, 'b': 0xB0, 'rc': 0xC0}[segment] + digits = (digits + [0, 0])[:3] # 1.2a1 -> 1.2.0a1 + elif segment in ('.dev', '.pre', '.post'): + break # break since those are the last segments + elif segment != '.': + digits.append(int(segment)) + + digits = (digits + [0] * 3)[:4] + digits[3] += release_status + + # Then, build a single hex value, two hex digits per version part. + hexversion = 0 + for digit in digits: + hexversion = (hexversion << 8) + digit + + return '0x%08X' % hexversion + + +def write_depfile(target, source, dependencies): + src_base_dir = os.path.dirname(source) + cwd = os.getcwd() + if not src_base_dir.endswith(os.sep): + src_base_dir += os.sep + # paths below the base_dir are relative, otherwise absolute + paths = [] + for fname in dependencies: + try: + newpath = os.path.relpath(fname, cwd) + except ValueError: + # if they are on different Windows drives, absolute is fine + newpath = os.path.abspath(fname) + + paths.append(newpath) + + depline = os.path.relpath(target, cwd) + ": \\\n " + depline += " \\\n ".join(paths) + "\n" + + with open(target+'.dep', 'w') as outfile: + outfile.write(depline) + + +def print_version(): + print("Cython version %s" % cython_version) + # For legacy reasons, we also write the version to stderr. + # New tools should expect it in stdout, but existing ones still pipe from stderr, or from both. + if sys.stderr.isatty() or sys.stdout == sys.stderr: + return + if os.fstat(1) == os.fstat(2): + # This is somewhat unsafe since sys.stdout/err might not really be linked to streams 1/2. + # However, in most *relevant* cases, where Cython is run as an external tool, they are linked. + return + sys.stderr.write("Cython version %s\n" % cython_version) + + +def normalise_float_repr(float_str): + """ + Generate a 'normalised', simple digits string representation of a float value + to allow string comparisons. Examples: '.123', '123.456', '123.' + """ + str_value = float_str.lower().lstrip('0') + + exp = 0 + if 'E' in str_value or 'e' in str_value: + str_value, exp = str_value.split('E' if 'E' in str_value else 'e', 1) + exp = int(exp) + + if '.' in str_value: + num_int_digits = str_value.index('.') + str_value = str_value[:num_int_digits] + str_value[num_int_digits + 1:] + else: + num_int_digits = len(str_value) + exp += num_int_digits + + result = ( + str_value[:exp] + + '0' * (exp - len(str_value)) + + '.' + + '0' * -exp + + str_value[exp:] + ).rstrip('0') + + return result if result != '.' else '.0' diff --git a/venv/lib/python3.10/site-packages/Cython/__init__.py b/venv/lib/python3.10/site-packages/Cython/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..7bd49acce56a4093d36a056671131e11b336e930 --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/__init__.py @@ -0,0 +1,10 @@ +from .Shadow import __version__ + +# Void cython.* directives (for case insensitive operating systems). +from .Shadow import * + + +def load_ipython_extension(ip): + """Load the extension in IPython.""" + from .Build.IpythonMagic import CythonMagics # pylint: disable=cyclic-import + ip.register_magics(CythonMagics) diff --git a/venv/lib/python3.10/site-packages/Cython/__init__.pyi b/venv/lib/python3.10/site-packages/Cython/__init__.pyi new file mode 100644 index 0000000000000000000000000000000000000000..347250e10e85c42cbaa0cbd813775bd166f05cc4 --- /dev/null +++ b/venv/lib/python3.10/site-packages/Cython/__init__.pyi @@ -0,0 +1,7 @@ +from typing import Any + +from .Shadow import * + + +# Internal interface for IPython. Not further typed since it's not meant for end users. +def load_ipython_extension(ip: Any) -> None: ... diff --git a/venv/lib/python3.10/site-packages/Cython/__pycache__/CodeWriter.cpython-310.pyc b/venv/lib/python3.10/site-packages/Cython/__pycache__/CodeWriter.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..cf7299c7860bb7d9f316093dd7ad226bffe07635 Binary files /dev/null and b/venv/lib/python3.10/site-packages/Cython/__pycache__/CodeWriter.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/Cython/__pycache__/Coverage.cpython-310.pyc b/venv/lib/python3.10/site-packages/Cython/__pycache__/Coverage.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..666735e0fa42e4d7f7d4a8c97ee0fc3489b6f52a Binary files /dev/null and b/venv/lib/python3.10/site-packages/Cython/__pycache__/Coverage.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/Cython/__pycache__/Debugging.cpython-310.pyc b/venv/lib/python3.10/site-packages/Cython/__pycache__/Debugging.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..11227013585cf3e5f16fe67ee8507f892ecb0022 Binary files /dev/null and b/venv/lib/python3.10/site-packages/Cython/__pycache__/Debugging.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/Cython/__pycache__/Shadow.cpython-310.pyc b/venv/lib/python3.10/site-packages/Cython/__pycache__/Shadow.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6c5ea28b8248f29a514ed45fb2a137a0b5767057 Binary files /dev/null and b/venv/lib/python3.10/site-packages/Cython/__pycache__/Shadow.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/Cython/__pycache__/StringIOTree.cpython-310.pyc b/venv/lib/python3.10/site-packages/Cython/__pycache__/StringIOTree.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..90168fc39d52bf25f37e4f6143a51709d4ca49a5 Binary files /dev/null and b/venv/lib/python3.10/site-packages/Cython/__pycache__/StringIOTree.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/Cython/__pycache__/TestUtils.cpython-310.pyc b/venv/lib/python3.10/site-packages/Cython/__pycache__/TestUtils.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5b99db7891313c26663d3b490a0c27c14a0102aa Binary files /dev/null and b/venv/lib/python3.10/site-packages/Cython/__pycache__/TestUtils.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/Cython/__pycache__/Utils.cpython-310.pyc b/venv/lib/python3.10/site-packages/Cython/__pycache__/Utils.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..557ebdf3ffb280f46d0e19969739af4439d26f30 Binary files /dev/null and b/venv/lib/python3.10/site-packages/Cython/__pycache__/Utils.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/Cython/__pycache__/__init__.cpython-310.pyc b/venv/lib/python3.10/site-packages/Cython/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..52d64622384a472797bc5fa67ac1e6ecfc1b6935 Binary files /dev/null and b/venv/lib/python3.10/site-packages/Cython/__pycache__/__init__.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/Cython/py.typed b/venv/lib/python3.10/site-packages/Cython/py.typed new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/venv/lib/python3.10/site-packages/bitblas-0.1.0.dist-info/INSTALLER b/venv/lib/python3.10/site-packages/bitblas-0.1.0.dist-info/INSTALLER new file mode 100644 index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68 --- /dev/null +++ b/venv/lib/python3.10/site-packages/bitblas-0.1.0.dist-info/INSTALLER @@ -0,0 +1 @@ +pip diff --git a/venv/lib/python3.10/site-packages/bitblas-0.1.0.dist-info/LICENSE b/venv/lib/python3.10/site-packages/bitblas-0.1.0.dist-info/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..9e841e7a26e4eb057b24511e7b92d42b257a80e5 --- /dev/null +++ b/venv/lib/python3.10/site-packages/bitblas-0.1.0.dist-info/LICENSE @@ -0,0 +1,21 @@ + MIT License + + Copyright (c) Microsoft Corporation. + + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in all + copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + SOFTWARE diff --git a/venv/lib/python3.10/site-packages/bitblas-0.1.0.dist-info/METADATA b/venv/lib/python3.10/site-packages/bitblas-0.1.0.dist-info/METADATA new file mode 100644 index 0000000000000000000000000000000000000000..f1afc7807fd8fa8b55e15886ec0c984c33d1d7af --- /dev/null +++ b/venv/lib/python3.10/site-packages/bitblas-0.1.0.dist-info/METADATA @@ -0,0 +1,263 @@ +Metadata-Version: 2.1 +Name: bitblas +Version: 0.1.0 +Summary: A light weight framework to generate high performance CUDA/HIP code for BLAS operators. +Home-page: https://github.com/microsoft/BitBLAS +Author: Microsoft Research +License: MIT +Keywords: BLAS,CUDA,HIP,Code Generation,TVM +Platform: Environment :: GPU :: NVIDIA CUDA +Platform: Operating System :: POSIX :: Linux +Classifier: Programming Language :: Python :: 3.8 +Classifier: License :: OSI Approved :: MIT License +Classifier: Operating System :: OS Independent +Classifier: Intended Audience :: Developers +Classifier: Intended Audience :: Science/Research +Requires-Python: >=3.8 +Description-Content-Type: text/markdown +License-File: LICENSE +Requires-Dist: cffi +Requires-Dist: cpplint +Requires-Dist: Cython +Requires-Dist: decorator +Requires-Dist: docutils +Requires-Dist: dtlib +Requires-Dist: numpy (>=1.23.5) +Requires-Dist: pytest (>=6.2.4) +Requires-Dist: pytest-xdist (>=2.2.1) +Requires-Dist: packaging (>=21.0) +Requires-Dist: PyYAML +Requires-Dist: tqdm (>=4.62.3) +Requires-Dist: typing-extensions (>=4.10.0) +Requires-Dist: requests +Requires-Dist: attrs +Requires-Dist: cloudpickle +Requires-Dist: ml-dtypes +Requires-Dist: psutil +Requires-Dist: scipy +Requires-Dist: tornado +Requires-Dist: torch +Requires-Dist: thefuzz +Requires-Dist: tabulate + +# BitBLAS + +BitBLAS is a library to support mixed-precision BLAS operations on GPUs, for example, the $W_{wdtype}A_{adtype}$ mixed-precision matrix multiplication where $C_{cdtype}[M, N] = A_{adtype}[M, K] \times W_{wdtype}[N, K]$. +BitBLAS aims to support efficient mixed-precision DNN model deployment, especially the $W_{wdtype}A_{adtype}$ quantization in large language models (LLMs), for example, the $W_{UINT4}A_{FP16}$ in [GPTQ](https://arxiv.org/abs/2210.17323), the $W_{INT2}A_{FP16}$ in [BitDistiller](https://arxiv.org/abs/2402.10631), the $W_{INT2}A_{INT8}$ in [BitNet-b1.58](https://arxiv.org/abs/2402.17764). BitBLAS is based on techniques from our paper ["Ladder: Enabling Efficient Low-Precision Deep Learning Computing through Hardware-aware Tensor Transformation"](https://www.usenix.org/conference/osdi24/presentation/wang-lei) at OSDI'24. + + +Some of the key features of BitBLAS include: + - High performance matrix multiplication for both GEMV (e.g., the single batch auto-regressive decode phase in LLM) and GEMM (e.g., the batched auto-regressive decode phase and the prefill phase in LLM): + - $W_{wdtype}A_{adtype}$ mixed-precision matrix multiplication including FP16xFP8/FP4/INT4/2/1, INT8xINT4/2/1, etc. Please checkout [support matrix](#support-matrix) for detailed data types support. + - Matrix multiplication like FP16xFP16 and INT8xINT8. + - Auto-Tensorization for TensorCore-like hardware instructions. + - Implemented [integration](https://github.com/microsoft/BitBLAS/blob/main/integration/) to [PyTorch](https://pytorch.org/), [GPTQModel](https://github.com/ModelCloud/GPTQModel), [AutoGPTQ](https://github.com/AutoGPTQ/AutoGPTQ), [vLLM](https://github.com/vllm-project/vllm) and [BitNet-b1.58](https://huggingface.co/1bitLLM/bitnet_b1_58-3B) for LLM deployment. Please checkout [benchmark summary](#benchmark-summary) for detailed end2end LLM inference performance. + - BitBLAS first implemented $W_{INT2}A_{INT8}$ GEMV/GEMM in [BitNet-b1.58](https://arxiv.org/abs/2402.17764) with 8x/2x speedup over cuBLAS $W_{FP16}A_{FP16}$ on A100, please checkout [op_benchmark_a100_int2_scaling](https://github.com/microsoft/BitBLAS/blob/main/images/figures/op_benchmark_a100_int2_scaling.png) for detailed benchmark results. Please checkout [BitNet-b1.58 integration](https://github.com/microsoft/BitBLAS/blob/main/integration/BitNet) for the integration with the 3rdparty reproduced BitNet-b1.58 model. + - Support customizing mixed-precision DNN operations for your specific scenarios via the flexible DSL (TIR Script). + +## Latest News +- 11/04/2024 🚀🚀: We've supported high performance A INT4 x W INT4/INT2 Matmul for [BitNet a4.8](https://arxiv.org/pdf/2411.04965). +- 10/02/2024 🚀🚀: We've added initial Flash Attention Ops and its implementation in Tilelang! Please refer to [PythonAPI](https://github.com/microsoft/BitBLAS/blob/main/docs/PythonAPI.md) and [QuickStart](https://github.com/microsoft/BitBLAS/blob/main/docs/QuickStart.md) docs and [PR #202](https://github.com/microsoft/BitBLAS/pull/202). +- 08/12/2024 🚀🚀: We've improved performance for contiguous batching. To enable it, you'll need to set specific flags. For more details, please refer to [PR #133](https://github.com/microsoft/BitBLAS/pull/133). +- 07/11/2024 ✨: Ladder is published and presented in OSDI'24. Please find [Ladder paper and presentation](https://www.usenix.org/conference/osdi24/presentation/wang-lei) if you are interested in the technical details of BitBLAS. +- 06/25/2024 🚀🚀: BitBLAS has been integrated into [GPTQModel](https://github.com/ModelCloud/GPTQModel)! You can now use BitBLAS as a backend in GPTQ. +- 05/04/2024 🚀🚀: We’ve added integration examples for the 1.58-bit model! Check out the files under integration/BitNet. +- 04/30/2024 🚀🚀: BitBLAS now supports FP8 TensorCore ($W_{E5M2/E4M3}A_{E4M3/E5M2}$), providing more combinations beyond the three available in cuBLAS! +- 04/19/2024 ✨: We are excited to announce that BitBLAS, a high-performance library for mixed-precision DNN model deployment, is now open source and available to the public! + + +## Integration Example of FasterTransformer with BitBLAS +![FasterTransformer Integration](images/gif/FasterTransformer.gif) + +## Benchmark Summary + +BitBLAS achieves exceptional performance across a variety of computational patterns. Below are selected results showcasing its capabilities: + +- End2End Integration with Quantize Inference Kernel for AutoGPTQ and vLLM. + +
+ AutoGPTQ end2end performance of llama13b on A100 + AutoGPTQ end2end performance of llama13b on A100 + vLLM end2end performance of llama13b on A100 + vLLM end2end performance of llama13b on A100 +
+ +- Weight Only Matmul performance on A100 + +
+ gemm weight only performance on A100 + gemm weight only performance on A100 +
+ + + +- TensorCore FP16/INT8 GEMM Performance Vs. Vendor Library on A100 and RTX4090 + +
+ gemm fp16 performance on 4090 and a100 + gemm int8 performance on 4090 and a100 +
+ +For more detailed information on benchmark sets with other formats (NF4/FP4) and other devices (RTX 3090), please refer to the [benchmark](./benchmark/README.md). + +## Support Matrix + +| **A_dtype** | **W_dtype** | **Accum_dtype** | **Out_dtype** | **BitBLAS Support** | **Tested Platform** | +|:-----------:|:-----------:|:---------------:|:--------------------:|:-------------------:|:----------------------------------------------------:| +| BF16 | BF16 | FP32 | FP16 | **√** | A100(SM_80)/A6000(SM_86) | +| BF16 | FP4_E2M1 | FP32 | FP16 | **√** | A100(SM_80)/A6000(SM_86) | +| BF16 | FP8_E4M3 | FP32 | FP16 | **√** | A100(SM_80)/A6000(SM_86) | +| BF16 | INT8 | FP32 | FP16 | **√** | A100(SM_80)/A6000(SM_86) | +| BF16 | UINT4/INT4 | FP32 | FP16 | **√** | A100(SM_80)/A6000(SM_86) | +| BF16 | UINT2/INT2 | FP32 | FP16 | **√** | A100(SM_80)/A6000(SM_86) | +| BF16 | UINT1 | FP32 | FP16 | **√** | A100(SM_80)/A6000(SM_86) | +| BF16 | NF4 | FP32 | FP16 | **√** | A100(SM_80)/A6000(SM_86) | +| FP16 | FP16 | FP32/FP16 | FP16 | **√** | V100(SM_70)/A100(SM_80)/A6000(SM_86)/RTX 4090(SM_89) | +| FP16 | FP4_E2M1 | FP32/FP16 | FP16 | **√** | V100(SM_70)/A100(SM_80)/A6000(SM_86)/RTX 4090(SM_89) | +| FP16 | FP8_E4M3 | FP32/FP16 | FP16 | **√** | V100(SM_70)/A100(SM_80)/A6000(SM_86)/RTX 4090(SM_89) | +| FP16 | INT8 | FP32/FP16 | FP16 | **√** | V100(SM_70)/A100(SM_80)/A6000(SM_86)/RTX 4090(SM_89) | +| FP16 | UINT4/INT4 | FP32/FP16 | FP16 | **√** | V100(SM_70)/A100(SM_80)/A6000(SM_86)/RTX 4090(SM_89) | +| FP16 | UINT2/INT2 | FP32/FP16 | FP16 | **√** | V100(SM_70)/A100(SM_80)/A6000(SM_86)/RTX 4090(SM_89) | +| FP16 | UINT1 | FP32/FP16 | FP16 | **√** | V100(SM_70)/A100(SM_80)/A6000(SM_86)/RTX 4090(SM_89) | +| FP16 | NF4 | FP32/FP16 | FP16 | **√** | V100(SM_70)/A100(SM_80)/A6000(SM_86)/RTX 4090(SM_89) | +| INT8 | INT8 | INT32 | FP32/INT32/FP16/INT8 | **√** | V100(SM_70)/A100(SM_80)/A6000(SM_86)/RTX 4090(SM_89) | +| INT8 | UINT4/INT4 | INT32 | FP32/INT32/FP16/INT8 | **√** | V100(SM_70)/A100(SM_80)/A6000(SM_86)/RTX 4090(SM_89) | +| INT8 | UINT2/INT2 | INT32 | FP32/INT32/FP16/INT8 | **√** | V100(SM_70)/A100(SM_80)/A6000(SM_86)/RTX 4090(SM_89) | +| INT8 | UINT1 | INT32 | FP32/INT32/FP16/INT8 | **√** | V100(SM_70)/A100(SM_80)/A6000(SM_86)/RTX 4090(SM_89) | +| FP8_E4M3 | FP8_E4M3 | FP32 | FP32/FP16 | **√** | RTX 4090(SM_89) | +| FP8_E5M2 | FP8_E5M2 | FP32 | FP32/FP16 | **√** | RTX 4090(SM_89) | +| INT4 | INT4 | INT32 | FP32/FP16 | **√** | RTX 4090(SM_89) | +| INT4 | INT4 | INT32 | FP32/FP16 | **√** | RTX 4090(SM_89) | + +We are continuously expanding the support matrix. If you have any specific requirements, please feel free to open an issue or PR. + +## Getting Started with an Example + +### Installing with pip + +**Prerequisites for installation via wheel or PyPI** +- **Operating System**: Ubuntu 20.04 or later +- **Python Version**: >= 3.8 +- **CUDA Version**: >= 11.0 + +The easiest way to install BitBLAS is direcly from the PyPi using pip. To install the latest version, run the following command in your terminal. + +```bash +pip install bitblas +``` + +Alternatively, to install the latest version of BitBLAS from the github repository, you can run the following command: + +```bash +pip install git+https://github.com/microsoft/BitBLAS.git +``` + +After installing BitBLAS, you can verify the installation by running: + +```bash +python -c "import bitblas; print(bitblas.__version__)" +``` + +**Note**: Currently, BitBLAS whl is only supported on Ubuntu 20.04 or later version as we build the whl files on this platform. Currently we only provide whl files for CUDA>=11.0 and with Python>=3.8. **If you are using a different platform or environment, you may need to [build BitBLAS from source](https://github.com/microsoft/BitBLAS/blob/main/docs/Installation.md#building-from-source).** More installation methods can be found in the [installation document](https://github.com/microsoft/BitBLAS/blob/main/docs/Installation.md). + +### Example: $W_{INT4}A_{FP16}$ mixed-precision matrix multiplication + +BitBLAS provides two Python APIs to perform mixed-precision matrix multiplication: + - ```bitblas.Matmul``` implements the $W_{wdtype}A_{adtype}$ mixed-precision matrix multiplication of $C_{cdtype}[M, N] = A_{adtype}[M, K] \times W_{wdtype}[N, K]$ where $W_{wdtype}$ indicates the weight of $wtype$, A_{adtype} indicates the activation of $adtype$, and C_{cdtype} indicates the output of $cdtype$. + - ```bitblas.Linear``` is a PyTorch ```nn.Linear```-like module to support a Linear of mixed-precision. + +Here is an example for a $W_{INT4}A_{FP16}$ mixed-precision matrix multiplication: $out_{FP16}[M, N] = A_{FP16}[M, K] \times W_{INT4}[N, K]$, this example includes the creation of input matrices, quantization of weight matrices, and execution of the matrix multiplication with the ```bitblas.Matmul``` API. The result is then compared against a reference result obtained through conventional methods to ensure accuracy. + +```python +import bitblas +import torch + +# uncomment to enable debug output +# bitblas.set_log_level("Debug") + +matmul_config = bitblas.MatmulConfig( + M=1, # M dimension + N=2048, # N dimension + K=1024, # K dimension + A_dtype="float16", # activation A dtype + W_dtype="int4", # weight W dtype + accum_dtype="float16", # accumulation dtype + out_dtype="float16", # output dtype + layout="nt", # matrix layout, "nt" indicates the layout of A is non-transpose and the layout of W is transpose + with_bias=False, # bias + # configs for weight only quantization + group_size=None, # setting for grouped quantization + with_scaling=False, # setting for scaling factor + with_zeros=False, # setting for zeros + zeros_mode=None, # setting for how to calculating zeros +) + +matmul = bitblas.Matmul(config=matmul_config) + +# Create input matrices +input_tensor = torch.rand((1, 1024), dtype=torch.float16).cuda() +weight_tensor = torch.randint(0, 7, (2048, 1024), dtype=torch.int8).cuda() + +# Transform weight tensor to int4 data type +weight_tensor_int4 = matmul.transform_weight(weight_tensor) + +# Perform mixed-precision matrix multiplication +output_tensor = matmul(input_tensor, weight_tensor_int4) + +# Reference result using PyTorch matmul for comparison +ref_result = torch.matmul(input_tensor, weight_tensor.t().to(torch.float16)) +# Assert that the results are close within a specified tolerance, note that the int4 randint value is a little bigger than the float16 value, so we set the atol to 1.0 +print("Ref output:", ref_result) +print("BitBLAS output:", output_tensor) +torch.testing.assert_close(output_tensor, ref_result, rtol=1e-2, atol=1e-0) +``` + +**Note**: More examples can be found in the [QuickStart document](https://github.com/microsoft/BitBLAS/blob/main/docs/QuickStart.md). + +## Documents + +- [Installation](https://github.com/microsoft/BitBLAS/blob/main/docs/Installation.md): + The installation document of BitBLAS. Make sure you already have the cuda toolkit (version >= 11.0) installed in the system. + - You can easily install from `pip install bitblas` from PyPi. Currently we only provide whl files for CUDA>=11.0 and Ubuntu>=20.04 with Python>=3.8, if you are using a different version of CUDA or OS environment, you may need to build BitBLAS from source. + +- [QuickStart](https://github.com/microsoft/BitBLAS/blob/main/docs/QuickStart.md): This document provides examples to use BitBLAS in your program with ```bitblas.Matmul``` and ```bitblas.Linear```. + +- [Python API](https://github.com/microsoft/BitBLAS/blob/main/docs/PythonAPI.md): The Python API document of BitBLAS. BitBLAS provides two Python APIs to perform mixed-precision matrix multiplication: + - ```bitblas.Matmul``` implements the $W_{wdtype}A_{adtype}$ mixed-precision matrix multiplication of $C_{cdtype}[M, N] = A_{adtype}[M, K] \times W_{wdtype}[N, K]$. + - ```bitblas.Linear``` is a PyTorch ```nn.Linear```-like module to support a Linear of mixed-precision. + +- [Integration](https://github.com/microsoft/BitBLAS/tree/main/integration): Explore how BitBLAS seamlessly integrates with LLM deployment frameworks through our examples. Discover the ease of integrating BitBLAS with PyTorch, AutoGPTQ, and vLLM in the 3rd-party integration examples. + +- [Customization](https://github.com/microsoft/BitBLAS/blob/main/docs/ExtendOperatorsWithDSL.md): BitBLAS supports implementing customized mixed-precision DNN operations (e.g., Conv2D) rather than matrix multiplication with the flexible DSL (TIR Script). + + +## Reference + +Please cite BitBLAS/Ladder in your publications if it helps your research: +```tex +@inproceedings {ladder-osdi24, +author = {Lei Wang and Lingxiao Ma and Shijie Cao and Quanlu Zhang and Jilong Xue and Yining Shi and Ningxin Zheng and Ziming Miao and Fan Yang and Ting Cao and Yuqing Yang and Mao Yang}, +title = {Ladder: Enabling Efficient Low-Precision Deep Learning Computing through Hardware-aware Tensor Transformation}, +booktitle = {18th USENIX Symposium on Operating Systems Design and Implementation (OSDI 24)}, +year = {2024}, +isbn = {978-1-939133-40-3}, +address = {Santa Clara, CA}, +pages = {307--323}, +url = {https://www.usenix.org/conference/osdi24/presentation/wang-lei}, +publisher = {USENIX Association}, +month = jul +} +``` + + +## Contributing + +This project welcomes contributions and suggestions. Most contributions require you to agree to a Contributor License Agreement (CLA) declaring that you have the right to, and actually do, grant us the rights to use your contribution. For details, visit https://cla.opensource.microsoft.com. + +When you submit a pull request, a CLA bot will automatically determine whether you need to provide a CLA and decorate the PR appropriately (e.g., status check, comment). Simply follow the instructions provided by the bot. You will only need to do this once across all repos using our CLA. + +This project has adopted the Microsoft Open Source Code of Conduct. For more information see the Code of Conduct FAQ or contact opencode@microsoft.com with any additional questions or comments. + +## Trademarks + +This project may contain trademarks or logos for projects, products, or services. Authorized use of Microsoft trademarks or logos is subject to and must follow Microsoft's Trademark & Brand Guidelines. Use of Microsoft trademarks or logos in modified versions of this project must not cause confusion or imply Microsoft sponsorship. Any use of third-party trademarks or logos are subject to those third-party's policies. diff --git a/venv/lib/python3.10/site-packages/bitblas-0.1.0.dist-info/RECORD b/venv/lib/python3.10/site-packages/bitblas-0.1.0.dist-info/RECORD new file mode 100644 index 0000000000000000000000000000000000000000..128fd0dd5a0628d4036c3df793b7642be36de5b6 --- /dev/null +++ b/venv/lib/python3.10/site-packages/bitblas-0.1.0.dist-info/RECORD @@ -0,0 +1,11095 @@ +../../../requirements.txt,sha256=b38nR4hyArj9TM_8hR2DOOVrdTw5lWcl8W51pxoDZCk,236 +bitblas-0.1.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +bitblas-0.1.0.dist-info/LICENSE,sha256=ws_MuBL-SCEBqPBFl9_FqZkaaydIJmxHrJG2parhU4M,1141 +bitblas-0.1.0.dist-info/METADATA,sha256=upDQNsQ7lw2NckBfzyzku37Cye5hCWuCZFmxDu8SAP4,19013 +bitblas-0.1.0.dist-info/RECORD,, +bitblas-0.1.0.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +bitblas-0.1.0.dist-info/WHEEL,sha256=CFajK9mVNDQlkA_RnzpTqxOsSo-zOcoxu8F1UFaKdVA,106 +bitblas-0.1.0.dist-info/top_level.txt,sha256=ePtx6E6gSh2jSTa7w3wHh_6wWqLnIDGCjfEvinYZm_U,8 +bitblas/3rdparty/cutlass/.git,sha256=wWFLChR_gJoyO6f5sFuwQqmltqvBiWjTyd6chh7BJUA,44 +bitblas/3rdparty/cutlass/.github/ISSUE_TEMPLATE/bug_report.md,sha256=Nv4zOBfphk4S3RNeSSmnn37jGalXdyiZoaKa3JwUzpQ,753 +bitblas/3rdparty/cutlass/.github/ISSUE_TEMPLATE/documentation_request.md,sha256=FF4D5OY7Sq-XaUpR4HBjxHhG8LGaaf1dOSMiBd35aMU,960 +bitblas/3rdparty/cutlass/.github/ISSUE_TEMPLATE/feature_request.md,sha256=LPRJyDRn_XHI3NXkBkjvjlpVevstZR6aLUMYeBErpEA,677 +bitblas/3rdparty/cutlass/.github/ISSUE_TEMPLATE/submit_question.md,sha256=lAblCfYaFyrHTSvXaEa4tjhPPoRKqRRNBOLoCJPCZZY,169 +bitblas/3rdparty/cutlass/.github/workflows/labeler.yml,sha256=tD6gZMiHPJiPQUZjdspUfiV9PMEnhfsw4TGnpbuIY0Y,205 +bitblas/3rdparty/cutlass/.github/workflows/new-issues-to-triage-projects.yml,sha256=L-UxvGZTpWuT1DZcMFX9KLldSDdyY4JFNJ15fiMgodk,1556 +bitblas/3rdparty/cutlass/.github/workflows/stale.yml,sha256=o363PM944Oinn50um2t5Wii3sj-_q9gxTtHk0ga_HwI,2828 +bitblas/3rdparty/cutlass/.gitignore,sha256=xudYFluo2zg4uSJ9iEpRfvqlCcjViIRWKtJiGD7ye1o,29 +bitblas/3rdparty/cutlass/.gitmodules,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +bitblas/3rdparty/cutlass/CHANGELOG.md,sha256=cXbI1N1kd3imRzki-9vpDTekU-PrnZzDwYJ2XZGWO4g,35090 +bitblas/3rdparty/cutlass/CITATION.cff,sha256=SSyHWgFMyNbN-earXLpfG-ZTPmvMl-xk3ic4dHixxr0,3265 +bitblas/3rdparty/cutlass/CMakeLists.txt,sha256=L2aMRohM_1lj_E8iWc-hujpzjWv5nbZQi1GQVicqxGo,35718 +bitblas/3rdparty/cutlass/CONTRIBUTORS.md,sha256=QkFNPrbh76c5gJpDMRkZ0r1YGpUU9z1j8eNLFcIzLrs,1550 +bitblas/3rdparty/cutlass/CUDA.cmake,sha256=3QlrmVKwtFMgu1m9pkuQImldClX-HywIUlx_25Md95A,10945 +bitblas/3rdparty/cutlass/Doxyfile,sha256=pIH7GnLIqRMN4QH0JmJmQ3NV7swXZgnbWDzB19gUwLU,99551 +bitblas/3rdparty/cutlass/LICENSE.txt,sha256=Xw6gUyMOuSJn6egO1n7AiJnrxV0JPv9KInOns0CkjMo,1547 +bitblas/3rdparty/cutlass/PUBLICATIONS.md,sha256=BZMXshCDXeoWnU3kGvmUylBezeoRK8wspYqWqmoJv4Y,4224 +bitblas/3rdparty/cutlass/README.md,sha256=YlCJUHMwj8NKsV3KEpRVKdsYLaouSqZyrOeQ6mZuTJI,28809 +bitblas/3rdparty/cutlass/bin2hex.cmake,sha256=LpxXHTAXr0c0Sl6_BtDm_Fx4i8WS1HGf20ouUKMWEPU,1029 +bitblas/3rdparty/cutlass/cmake/CTestTestfile.configure.cmake,sha256=JR3qffQYhgTTNW7LM6mia0J5owTRm1_vjbfL3rnF3aA,442 +bitblas/3rdparty/cutlass/cmake/CTestTestfile.test.configure.cmake,sha256=FZpq1hxdam20Vzl-9qKa2LFj2Oni3zYJ1boOAXFkSBw,693 +bitblas/3rdparty/cutlass/cmake/NvidiaCutlassConfig.cmake,sha256=2cg-VB5fc-Xs4_kzggNl34hUeJoPm8nR-bCvKbNrt-Q,334 +bitblas/3rdparty/cutlass/cmake/NvidiaCutlassPackageConfig.cmake,sha256=ho6v7IKCXj9m3xZY9jEmqJP1XN4Sj9ZtRPrMyzFL2KU,783 +bitblas/3rdparty/cutlass/cmake/googletest.cmake,sha256=wwb7p75R30JxfZStMUuP9xJyqkfnBu9dyTTuXVfy-2g,653 +bitblas/3rdparty/cutlass/cmake/nop.cu,sha256=Z8KuXsO8aNmlC8yhShGtUoMEamP2GOcWskh5aGmcEqE,2023 +bitblas/3rdparty/cutlass/cmake/version.h.in,sha256=u_2ITNTpZlJIoPA0hjX__AR-Ig8lyZKHAiNYa7ApE3U,975 +bitblas/3rdparty/cutlass/cuBLAS.cmake,sha256=IfbqkqJMIGRv0DMRyZohV6JtzRxQ1wVHKvOanZL7lLY,4361 +bitblas/3rdparty/cutlass/cuDNN.cmake,sha256=zQbcM1WBsuc6GM7C5z6WP3hcAcQ-7_D6rgzgUiBLaOw,3634 +bitblas/3rdparty/cutlass/docs/_config.yml,sha256=EOyEcuPcjRG3JKxIh1OimXe6e4wACJlgyHTAXAuj6uE,27 +bitblas/3rdparty/cutlass/docs/aligned__buffer_8h.html,sha256=HqIWCWij0Jm5RIkUoMFqTHSPzTA9t7vwzn1dVYlMsdk,6852 +bitblas/3rdparty/cutlass/docs/aligned__buffer_8h__dep__incl.md5,sha256=xekY_y0vDJC5NvN3o9LY40oR0d_UfL9Yc9AI3mnkO_s,32 +bitblas/3rdparty/cutlass/docs/aligned__buffer_8h__incl.md5,sha256=7iSuZZ6ksYFtXFDug1UIfq_BKsV1u4InKxalGlZjXZg,32 +bitblas/3rdparty/cutlass/docs/aligned__buffer_8h_source.html,sha256=SDj9NLK28FHje_zohMQS_AkFZSbyWBehYqQ4MzeC5A4,33928 +bitblas/3rdparty/cutlass/docs/annotated.html,sha256=grm0PBx5cPJSv1LAKf5iMPy7NAHiDtCDSqe-_gdlS9A,332278 +bitblas/3rdparty/cutlass/docs/arch_2mma_8h.html,sha256=UdkGRYVzek4kbdes_7cLtdPTByPii2LqDQEusD3Pra4,8699 +bitblas/3rdparty/cutlass/docs/arch_2mma_8h__dep__incl.md5,sha256=gZ21Hffr4ja9ylFbMeUxWBw-rRTaDf4a2XTvqo3ehp8,32 +bitblas/3rdparty/cutlass/docs/arch_2mma_8h__incl.md5,sha256=d0ssLvJleoKd_nxwttInnnoiFhqDBCGVkmizZ17ZIFQ,32 +bitblas/3rdparty/cutlass/docs/arch_2mma_8h_source.html,sha256=22fPS-5fvocfVF6_IIz73_ASLeUatnsrE4cYfBBCcAk,23669 +bitblas/3rdparty/cutlass/docs/arch_2mma__sm50_8h.html,sha256=q2zJaSiaEkZzOeoLURRm1XALfFdN7Je8vcg4zPrYTpI,14989 +bitblas/3rdparty/cutlass/docs/arch_2mma__sm50_8h__dep__incl.md5,sha256=3TFMPU9gye3PVBvJR-inAKejbkS9g8dI_ZO7XodiKo8,32 +bitblas/3rdparty/cutlass/docs/arch_2mma__sm50_8h__incl.md5,sha256=dxQybHcSYjzGOWvlEj_jBMfeRVJAs3eGjuNla_ULNA8,32 +bitblas/3rdparty/cutlass/docs/arch_2mma__sm50_8h_source.html,sha256=Ndw5VN68P8P1VvVwWnJYrPn1T_tm8YuzcYHaSQq1TmE,66705 +bitblas/3rdparty/cutlass/docs/arch_2mma__sm60_8h.html,sha256=qwlVaLBxq6nebLAOsZAmn5uaj_WCph-vvP1dzXhpPic,9882 +bitblas/3rdparty/cutlass/docs/arch_2mma__sm60_8h__dep__incl.md5,sha256=ycg9pP38CpQf0IUkFMub0HxZPxSkZgX3NmVBUYFsNNw,32 +bitblas/3rdparty/cutlass/docs/arch_2mma__sm60_8h__incl.md5,sha256=spbt4oDGB8VxT9WTIdJvHW5iwiR0bMh0vzZ1qJ2VvWc,32 +bitblas/3rdparty/cutlass/docs/arch_2mma__sm60_8h_source.html,sha256=sDl6DmPEaZPg658fjRX5YkXslSENXMA2OEhWVi0y6YI,45938 +bitblas/3rdparty/cutlass/docs/arch_2mma__sm61_8h.html,sha256=5978JflPhglVW8uJsEmCmuCZO1Yg8kWxfuWRfj0dJ_Q,8078 +bitblas/3rdparty/cutlass/docs/arch_2mma__sm61_8h__dep__incl.md5,sha256=FvvyGPQMXCnLa_6m_EHZzRFy0eICWRrT5JlQ1KbHEoQ,32 +bitblas/3rdparty/cutlass/docs/arch_2mma__sm61_8h__incl.md5,sha256=J9IUXlSeu10gJ0jh8ZsefC-WYPD116xwvs9y40Mozok,32 +bitblas/3rdparty/cutlass/docs/arch_2mma__sm61_8h_source.html,sha256=ohC2JalXa9oqGsZfi1r_WvqS4fzzRRflfqL5SPoMAd4,27865 +bitblas/3rdparty/cutlass/docs/arch_8h.html,sha256=qRhqRBDZ3w7axnWq_XoC7ILlz0MOISNhFTGlbivykxE,7800 +bitblas/3rdparty/cutlass/docs/arch_8h__dep__incl.md5,sha256=148W1BvPKouBgIiZGTbO-q1MTIV0-a-XyIx3jrzcIxg,32 +bitblas/3rdparty/cutlass/docs/arch_8h_source.html,sha256=rjnEdZoWq0IBCghDj3prSLedH_xlVGILIG1LjBJSpqw,16593 +bitblas/3rdparty/cutlass/docs/array_8h.html,sha256=BDv-Vuk4h80oI5asd5UqdEew1EL14SzaehdosftGAHo,12020 +bitblas/3rdparty/cutlass/docs/array_8h__incl.md5,sha256=J2AZWbQPMLKR61ruLFiciwjwQmHEyUE9sZGjE1TRqVI,32 +bitblas/3rdparty/cutlass/docs/array_8h_source.html,sha256=YlkIhRoAaZ-H32BxwYuFMS74XrSHc9tvAheMyoH6nLg,125901 +bitblas/3rdparty/cutlass/docs/array__subbyte_8h.html,sha256=-TzxeF9_-3Ro5_Zi7BwuWhYIe6YYoP8ndrLpzFNTcY4,10636 +bitblas/3rdparty/cutlass/docs/array__subbyte_8h__dep__incl.md5,sha256=WGa7AwgG1pj23RaFDF1Ipp46CIVVEr1fKagtdIU29E8,32 +bitblas/3rdparty/cutlass/docs/array__subbyte_8h__incl.md5,sha256=5TxgiskmhGxzdh40DH40wfE-SdHPLVIrc_olxw_KbGc,32 +bitblas/3rdparty/cutlass/docs/array__subbyte_8h_source.html,sha256=K1tqcaV3-RzXGNXEGleJAOa0txpI7QZc4_JNXe2iSb0,125959 +bitblas/3rdparty/cutlass/docs/batched__reduction_8h.html,sha256=X1r9IimpnuzaEFrIDTrM0R3K5IeuFzuDU53ErwXw7SI,8036 +bitblas/3rdparty/cutlass/docs/batched__reduction_8h__dep__incl.md5,sha256=QTB_5AmnWo0e57uNJtL7VTt01BTlIR49ealFsI80qkQ,32 +bitblas/3rdparty/cutlass/docs/batched__reduction_8h__incl.md5,sha256=OMb3qAOfcH-YCby_YLupNoLdkswdgjw_VWLGJxVVl4w,32 +bitblas/3rdparty/cutlass/docs/batched__reduction_8h_source.html,sha256=pKqRZQIwEuckS3HQwiZAf4zmXk7tjabiKHT3Sk9ludg,39116 +bitblas/3rdparty/cutlass/docs/batched__reduction__traits_8h.html,sha256=pnkri2mnRiyjp0nOGqZT2223OwyJAw0ugcjRq4Svf8c,7811 +bitblas/3rdparty/cutlass/docs/batched__reduction__traits_8h__incl.md5,sha256=JJQeVK-IOzpqIDqUOfRvizb8xybzNGLWUKn_yQORvv4,32 +bitblas/3rdparty/cutlass/docs/batched__reduction__traits_8h_source.html,sha256=OvHH3fk0eqDYX9QBJBtDeUFlZZVFNh_14LXs7bOXDMY,52674 +bitblas/3rdparty/cutlass/docs/bc_s.png,sha256=nBmbLucwLB_CKbt6ElsNswljEIg5hESvYSZCOCfQxGk,675 +bitblas/3rdparty/cutlass/docs/bdwn.png,sha256=7xV80puehRy27DguqeW0dx0sj6CODRq0QNHGyQ1NrHk,147 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1AlignedArray.html,sha256=GymjBX-KPTyViSLLpb9a1sW-YDtg5tWiL1zvyOTupWs,6105 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1AlignedArray__coll__graph.md5,sha256=35WkbImQdkdp7_I0qiwjreloFxx6zjkGU0b87Hpb-7Q,32 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1AlignedArray__inherit__graph.md5,sha256=35WkbImQdkdp7_I0qiwjreloFxx6zjkGU0b87Hpb-7Q,32 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1Array_3_01T_00_01N_00_01false_01_4-members.html,sha256=WPJWdrLTM_Dr6jzL0ldJuYwvBms4L8pIn_7SaO4eOgA,18928 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1Array_3_01T_00_01N_00_01false_01_4.html,sha256=sbwbGtXxZqXVFnAATX8zbU_tdoO_pIC_hgcbZ7vTgM8,63103 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1Array_3_01T_00_01N_00_01false_01_4_1_1const__iterator-members.html,sha256=yAwLenmSzDJwEXwoAcDzUkNxZFrWO58cXalnlVjaHT0,8928 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1Array_3_01T_00_01N_00_01false_01_4_1_1const__iterator.html,sha256=GbTOwIf-oRn2oU8OGX2eFiJGSQ6s0yLJXarw3JVuZkc,18260 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1Array_3_01T_00_01N_00_01false_01_4_1_1const__reference-members.html,sha256=NZbZt7TsA-8Kc2hcFhqMWBrarD_t4K4P1-1e7mhgy3A,7714 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1Array_3_01T_00_01N_00_01false_01_4_1_1const__reference.html,sha256=0KQk2KJm7-lXaXtz6nhnbR1HeEBhnqIeqFdUlEbCs7M,15092 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1Array_3_01T_00_01N_00_01false_01_4_1_1const__reverse__iterator-members.html,sha256=aw7phE8-hIjOfswSGd36giB7Hf6W-YJvlzCw7EZfnm8,6026 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1Array_3_01T_00_01N_00_01false_01_4_1_1const__reverse__iterator.html,sha256=AarloSW6CX5zoYW7rc6e-pAfkzbzZlp6Fhaj9ny0jgw,8888 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1Array_3_01T_00_01N_00_01false_01_4_1_1iterator-members.html,sha256=KOl4AJXfFwRkXjjE1cn50aSrQqUu0UKWEw_6o6oJoA4,8698 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1Array_3_01T_00_01N_00_01false_01_4_1_1iterator.html,sha256=lAMSMQ8yySn3xgoGsGeZWdsxU1y8uw0S0va-Xgj93xU,19578 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1Array_3_01T_00_01N_00_01false_01_4_1_1reference-members.html,sha256=ZmtEovSBWLYsPUFsXLMdE7uE-qITYShrWHobplzkRzM,7954 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1Array_3_01T_00_01N_00_01false_01_4_1_1reference.html,sha256=mBtGfZBZWoIqab04O6IhjZKsiY3EwXEKCCGB-5f7NsA,16749 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1Array_3_01T_00_01N_00_01false_01_4_1_1reverse__iterator-members.html,sha256=uUuMMFCZrcHOI2noGV_KW3N1fOweNqTi_mXM8htSmBk,5936 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1Array_3_01T_00_01N_00_01false_01_4_1_1reverse__iterator.html,sha256=3PGvcQ-LTxS-7IfyFDTu8cmrsTi0M3RSlxrWgWO_Fo8,8785 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1Array_3_01T_00_01N_00_01true_01_4-members.html,sha256=mqjAUdAHejYjOR1oPPKhg95sy8-ZR9CN9tQsPtH9KTI,18386 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1Array_3_01T_00_01N_00_01true_01_4.html,sha256=9ezjQyClTKgsQCtT38ELeeK_JWqmCo6HIgoG3M3lUy8,59859 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1Array_3_01T_00_01N_00_01true_01_4_1_1const__iterator-members.html,sha256=Zdf-oVYM70bIdoLB1HY-43gys6TV6-rswjl9UdZ6SaI,8891 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1Array_3_01T_00_01N_00_01true_01_4_1_1const__iterator.html,sha256=sQXEqC6zeEDqoyXD22xzAL73QY4fV33QKWJc8Sapp8s,19341 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1Array_3_01T_00_01N_00_01true_01_4_1_1const__reverse__iterator-members.html,sha256=xktwwGg15WYPRfF1r1LtniQPjTkxdhKtxtp42rIygmE,9183 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1Array_3_01T_00_01N_00_01true_01_4_1_1const__reverse__iterator.html,sha256=HHx2gNktIlOsw6RJyn-T9QkJCKwzJ7k5FokyD1_3UKk,19172 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1Array_3_01T_00_01N_00_01true_01_4_1_1iterator-members.html,sha256=HUAL_Bw6-swHezbmPJXFwMeENFKyZDXS_Z05U9wDhxs,8649 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1Array_3_01T_00_01N_00_01true_01_4_1_1iterator.html,sha256=wHdsVjxVyt-2cP5Bvg5WZwX9VzeT0F19xG8pcZTHXd4,18979 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1Array_3_01T_00_01N_00_01true_01_4_1_1reverse__iterator-members.html,sha256=_YKynGja5eqB_OayGVju8heZWkiGWkPCEPCtr3xb6fY,8957 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1Array_3_01T_00_01N_00_01true_01_4_1_1reverse__iterator.html,sha256=NfMj4eZxLb4xU54PkhyGpE-kc9Ydfxw501SWMMm-yVM,19410 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1ConstSubbyteReference-members.html,sha256=dF8HeaIRLKrBIpZxYQ5LzWviBYtwCJY8SS3wfbrl7gI,13979 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1ConstSubbyteReference.html,sha256=-hetqbylh8JMrfRb57nr8A9h2G7pl2Z44zQ88EPSVcU,47641 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1HostTensor-members.html,sha256=9io98Ci5utWAIgyDmxZLEvykkDTrVJmmngdgsXdywb4,26798 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1HostTensor.html,sha256=TaPemOATHTlyiwahrk9MVBKlPUt-a2uwz-vL1Q4YZ4E,120537 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1IdentityTensorLayout-members.html,sha256=FczwElHlR7o_dQzyeckF5cBPlrRgn4_WULIpoPa4Ilc,8618 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1IdentityTensorLayout.html,sha256=Xw0GUPFZx7PehNbBTAzQzT2wznvKCEfu7zFi9WEz8BE,24214 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1PredicateVector_1_1ConstIterator-members.html,sha256=f0LqVd3-4xeXfceU1TTKQwxARVhmATxQ7HgjrfF6pIw,11644 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1PredicateVector_1_1ConstIterator.html,sha256=CJt7_ofMB4JPgC_WRp38USo4OVGtdOvZkGAqRbEaffE,34247 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1PredicateVector_1_1Iterator-members.html,sha256=75E98oXpFZkNX8I4XmWB-ikAoAysfq08qcmPB87s5J4,11775 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1PredicateVector_1_1Iterator.html,sha256=4uS41bJMb2nraFoPsn8djStVuxN_FybJDOjl-whUQZU,35548 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1Semaphore-members.html,sha256=-RePklbuMVaVctlmTiYUBSbohExehovv1ZJi_VnQS7U,7053 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1Semaphore.html,sha256=llNKUOIoTeYfrvAMspyVHbroGtA4wSjqKhomYKHMuPU,14351 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1SubbyteReference-members.html,sha256=IP-2Vd4H3KLrUs0Owt-UGf6P_IRKAhti05QJOSUXpQk,15073 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1SubbyteReference.html,sha256=UsKf5GLXq9E80X3i6sIEcpL-RyiHJAAbI9JZgawlRUg,54421 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1TensorRef-members.html,sha256=0cK09WL9mQwVfD5crZxWqgJyMaIuIuxqhSLGJWP7Hdc,16009 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1TensorRef.html,sha256=5VYfqVkN_uA3okTm0_Yk2XNhHiAb5xZqtCUX2Uts-Sg,68315 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1TensorRef__inherit__graph.md5,sha256=WNm250ilYFZLsIUDXaDLyaTnt6ZBMzDOm5jIBf3aMuI,32 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1TensorView-members.html,sha256=KW6op35CMzzd7bDsxEw7mWarcQBFDkuXS-G3EW625lM,21997 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1TensorView.html,sha256=ybR6h6It4eRoCHgYsriKhAz0FvP5IALDR4hpU-w0UdQ,99512 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1TensorView__coll__graph.md5,sha256=Gour0IPRnH8mO2gg7Pd0g77NFZoV4z2igchtHqoXCXU,32 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1TensorView__inherit__graph.md5,sha256=Gour0IPRnH8mO2gg7Pd0g77NFZoV4z2igchtHqoXCXU,32 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1complex-members.html,sha256=86q20DXmChU_rLVDdNnzVxvjz5zv5HrnglVl3Ezt010,12963 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1complex.html,sha256=HmYDJrkcs_xSNzUb80_TExj1wegWgslZPZ11oogGPWg,50644 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1cuda__exception-members.html,sha256=AN29bSn3m7ubHdkLoFcjZeR7cILt8N8-O36Wb-ap_xw,6096 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1cuda__exception.html,sha256=hivmGIvyl-Z7nD8W57xFeBxUoAsHPjGXc1MQF0Yfd9c,11819 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1cuda__exception__coll__graph.md5,sha256=VXFHAGj_qBIPBqRFrMjLASiR6Ou1__usS7o8YnU2e64,32 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1cuda__exception__inherit__graph.md5,sha256=VXFHAGj_qBIPBqRFrMjLASiR6Ou1__usS7o8YnU2e64,32 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1epilogue_1_1EpilogueWorkspace-members.html,sha256=MmDmxC4FXcDgeuKfWJ_HDs3rHztm125LK945fGYSGNg,9846 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1epilogue_1_1EpilogueWorkspace.html,sha256=BWRrC8xs2ngX-mQwNmdCHfm2_nCnDTnM4wHuoD0KxSw,27736 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1epilogue_1_1thread_1_1Convert-members.html,sha256=MMhjKK8hi9yPR4dGK7ZEQuEgBP4AzcXfPaXEUc_wIgk,10120 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1epilogue_1_1thread_1_1Convert.html,sha256=fF92LVvAOCBM7S-zT8sfS6AcaGi92DCXvl9FacxE9Us,28202 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1epilogue_1_1thread_1_1LinearCombination-members.html,sha256=J5U-58mpCwjsqbuqjsa1vxgYBTPMCld6a5ldNk0m624,10729 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1epilogue_1_1thread_1_1LinearCombination.html,sha256=LgeVaoAf3hC-OlaV_jM66I2N34SJDf1Xf7019NRscnw,28991 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1epilogue_1_1thread_1_1LinearCombinationClamp-members.html,sha256=4HXOXKsrRXrhzyDTbsGCagxnR1gwb7vDLuu8wWwqYkY,10981 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1epilogue_1_1thread_1_1LinearCombinationClamp.html,sha256=hquzbp0MSWCWuzBP0iZVtEhVWCevpqpZxzxZewmY_Cs,30255 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1epilogue_1_1thread_1_1LinearCombinationRelu-members.html,sha256=9YVyj1IEde3vnneGCfbCdquFBfrvqkFSvmNk_JucfcA,10939 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1epilogue_1_1thread_1_1LinearCombinationRelu.html,sha256=7WvDREL9WTbELyBbMAysYf4g22R3s0nkCTPebcdX6Ck,30142 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1epilogue_1_1thread_1_1LinearCombinationRelu_3_01ElementOutput___00_01Count_00_014d4e40c4295be6a8d8778d86e94fe14a.html,sha256=W_u-kwZvZaqMDdBkV7l6rWpvStTJOswsDF3lq0pRXVs,12367 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1epilogue_1_1thread_1_1LinearCombinationRelu_3_01ElementOutput___00_01Count_00_01int_00_01float_00_01Round_01_4.html,sha256=_JSk_bablpQiyDlS0OX2rKfnAkt_nSm6dHWZ884j67I,30810 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1epilogue_1_1thread_1_1ReductionOpPlus-members.html,sha256=s0SrOjdFF28GXRrw06C_DyH6BiksJ9ZxrLn3Ts38iyc,7505 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1epilogue_1_1thread_1_1ReductionOpPlus.html,sha256=noS6oeTSj_BSWqZuSsjzZ-dnE_hXnLrxt6KQSs1w1mk,17176 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1epilogue_1_1threadblock_1_1DirectEpilogueTensorOp-members.html,sha256=SDYXb8ay4dOaWTAkjBEULkxi4NX2n-XmjpMe9RlSDl8,10559 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1epilogue_1_1threadblock_1_1DirectEpilogueTensorOp.html,sha256=DcefzoZScFVhEl5NrZYFXfuTwJriQ5atSqIdwY2LtHk,28872 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1epilogue_1_1threadblock_1_1Epilogue-members.html,sha256=uXvzjjQdHAdyJH2KBFx8wZ0cda1tYSefp4IKjL0pgY0,19412 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1epilogue_1_1threadblock_1_1Epilogue.html,sha256=To4Mb1mf0cFT04glhIpHBXUJ2IAKJoTEYMFRf9GO_sY,64790 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1epilogue_1_1threadblock_1_1EpilogueBase-members.html,sha256=HbrqDB6WDpYyw9jyThYD7z8z4Uo_bKaRY2iBAEnKWws,11521 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1epilogue_1_1threadblock_1_1EpilogueBase.html,sha256=0mo4aXbrl6L6i6jgSAgcSETQz60r1CAwt7kMdloGwbQ,30732 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1epilogue_1_1threadblock_1_1EpilogueBase__coll__graph.md5,sha256=O-dPnprYPN6rMS7DI9CEoxM5cKizJ6z1j7OnnRKBCmY,32 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1epilogue_1_1threadblock_1_1EpilogueBase__inherit__graph.md5,sha256=Ys_nWxAib3-Ozm47pqSNwdOC97HB272gICgGL_Zlch4,32 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1epilogue_1_1threadblock_1_1Epilogue__coll__graph.md5,sha256=DNF-rtSxEuR_aSXW2phHP318G6dIjVbflzEM0ENvDEA,32 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1epilogue_1_1threadblock_1_1Epilogue__inherit__graph.md5,sha256=Lo8en_V_E5qag0STYzOQDT3SjzqxJEGIuoF3-SuY4hk,32 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1epilogue_1_1threadblock_1_1InterleavedEpilogue-members.html,sha256=iIDyTGLjWh7Rl80ioOMMZ238Taqr3hTGSW8N-uDiybE,15506 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1epilogue_1_1threadblock_1_1InterleavedEpilogue.html,sha256=QNLjiIybvwIPqsoQlkPEnmewPu7-Q_N6gLIHMsHXwcg,43116 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1epilogue_1_1threadblock_1_1InterleavedPredicatedTileIterator-members.html,sha256=8MH83vcv6-zaUIOb_czIqlr_iK8DPnN_8jKw-QTfIRs,16507 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1epilogue_1_1threadblock_1_1InterleavedPredicatedTileIterator.html,sha256=kBVUfJAC679XlceQchSSTG9vl2H2OIEnlf9xzwrrn7M,47796 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1epilogue_1_1threadblock_1_1PredicatedTileIterator-members.html,sha256=yeYRRwtBwTRgfbONXz2XVLouEjthyfXpaM95aaQ35Ng,15291 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1epilogue_1_1threadblock_1_1PredicatedTileIterator.html,sha256=3Aicfan4uz4ecMTP7xgAUpeSao815lQInsGh1zb48wU,45336 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1epilogue_1_1threadblock_1_1SharedLoadIterator-members.html,sha256=q0OLlC-ytafivpAeyJLvrX-lYdvKD9xZ9PBfMq7FvSM,13941 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1epilogue_1_1threadblock_1_1SharedLoadIterator.html,sha256=hcSYDj_9ramhRqm8dPgyr7Zjy-1hvcMAsR3_RaRO36g,40283 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1epilogue_1_1warp_1_1FragmentIteratorComplexTensorOp.html,sha256=VOlK1G9TLfv05wv21M0DQIS760MU0HQ1ypKd1dEIZ9I,5460 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1epilogue_1_1warp_1_1FragmentIteratorComplexTensorOp_3_01WarpShape___00_01Operato65e8dd1d709c1257fe4e30825dcc5f06.html,sha256=gQxMI2gzNqLyLEgR7XT5xRZ3zQje6HQiCmx4fz8QA64,15535 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1epilogue_1_1warp_1_1FragmentIteratorComplexTensorOp_3_01WarpShape___00_01Operato8cf03c624cf3210c71b7cbd580b080f8.html,sha256=i-IOWEU7czv_5opAYwg2Lgp6qauRj7XwHm9wLfEowzk,39279 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1epilogue_1_1warp_1_1FragmentIteratorSimt.html,sha256=FQ5pHaNZtBg8RyRadtwD4fjdYfWA-oviBHNllB0dAgU,5370 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1epilogue_1_1warp_1_1FragmentIteratorSimt_3_01WarpShape___00_01Operator___00_01la3f2abc523201c1b0228df99119ab88e1.html,sha256=FwDex3ZMCB3P4o275fNh-_sMemaPYFE2fltgN_D_mgE,29776 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1epilogue_1_1warp_1_1FragmentIteratorSimt_3_01WarpShape___00_01Operator___00_01la91754875457d1736401ce8b815f5a9ea.html,sha256=hUIc6PDu4sz3K3Gk2lnANbFF64at6RdcNiRL5_aTjr4,12438 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1epilogue_1_1warp_1_1FragmentIteratorTensorOp.html,sha256=OWlruEKKf4Mo1xQQaD5qV8R92u6lMbw0roCNNzqunPw,5398 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1epilogue_1_1warp_1_1FragmentIteratorTensorOp_3_01WarpShape___00_01OperatorShape_5e78dabe303f20d76b00c600aab61eda.html,sha256=_PdjExZe_mNf9-nlIbpm2opB1r4DVKnN3kuqAIOWjEE,34440 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1epilogue_1_1warp_1_1FragmentIteratorTensorOp_3_01WarpShape___00_01OperatorShape_6b5ec5b2b023c078c305dbf7583b79cf.html,sha256=PtZrpqe3db6j6biBY8jthWCxd0-o-n8NCEQMD50CA-4,14769 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1epilogue_1_1warp_1_1FragmentIteratorTensorOp_3_01WarpShape___00_01OperatorShape_72e1add04bb402b37cf00537c77e94a8.html,sha256=EYh_EGo2X8em1zftVLhY7gVqJBWmO9AkVrtlwJhdqwY,14139 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1epilogue_1_1warp_1_1FragmentIteratorTensorOp_3_01WarpShape___00_01OperatorShape_e459aab140a2ce78336e584f95886726.html,sha256=0G2R1A4nGdDkhJQG_vSpsK6fo4Eo9cP84C5XP0jiCw4,35580 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1epilogue_1_1warp_1_1FragmentIteratorVoltaTensorOp.html,sha256=rGX2G_7UWbAlOEewfZeI1JzhEQX_NvNlXpbwE4lghWs,5404 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1epilogue_1_1warp_1_1FragmentIteratorVoltaTensorOp_3_01WarpShape___00_01gemm_1_1G16e08718cffa0989cce3fe8dbc4b075b.html,sha256=dFFQ55fL9pjFObxKRWhUtIksXUkVgtT3ZECItrZNjY0,35017 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1epilogue_1_1warp_1_1FragmentIteratorVoltaTensorOp_3_01WarpShape___00_01gemm_1_1G78b1ed9e671a468d35013cfbe9935984.html,sha256=nC2heZLT2DvvgrdayHscdo39C6EreBtn9aPtyNp4bNk,14034 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1epilogue_1_1warp_1_1FragmentIteratorVoltaTensorOp_3_01WarpShape___00_01gemm_1_1G8fb159e6b5b40e2838be5f52cfe17062.html,sha256=Lr5y6xiZAMqx1LkSVzCnJTr3vj_9RE-ZaW2sHfOL4yI,13420 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1epilogue_1_1warp_1_1FragmentIteratorVoltaTensorOp_3_01WarpShape___00_01gemm_1_1Gdb805a2dc5571ac3b66e0fe6ffdcede2.html,sha256=YymFF9u6bkkJtIxmJCLjkk7RxLxTxWJVCmEBMBSMKEA,32288 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1epilogue_1_1warp_1_1FragmentIteratorWmmaTensorOp.html,sha256=oywJUDwt4QTlLmXdlHz3xN8VK00aOttF5DeXO2BQ3Zc,5436 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1epilogue_1_1warp_1_1FragmentIteratorWmmaTensorOp_3_01WarpShape___00_01OperatorSh5bf991809805fb3276af51be7cf76c5a.html,sha256=ZUnCpHggnaUL2zXg_NlrKeWh1oRpZY73bTZiLeIfdO0,13587 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1epilogue_1_1warp_1_1FragmentIteratorWmmaTensorOp_3_01WarpShape___00_01OperatorShfdb1f120c6797383663f9fd11d0fc599.html,sha256=W3iadhCsMCQudOIb2iO_bTHbhPg6PW1SkFNZ14W6rbA,32353 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1epilogue_1_1warp_1_1TileIteratorSimt.html,sha256=pKSlAcyKll49jVAKoAiaFxMJEgvZQ1Bpirma58hY9Ok,5376 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1epilogue_1_1warp_1_1TileIteratorSimt_3_01WarpShape___00_01Operator___00_01Elemen511cc12482dd0c67e9fe697263803a4d.html,sha256=OPPOjCEpVONx2hrrL0qpIB9qum-558TeETD6q2yupY0,19189 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1epilogue_1_1warp_1_1TileIteratorSimt_3_01WarpShape___00_01Operator___00_01Elemenf2bd262ed3e202b25d5802d83965bf3b.html,sha256=mQmNrx2EfgXQnqorgdAPrOoNR98sYzIGZvrCJY06H58,54368 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1epilogue_1_1warp_1_1TileIteratorTensorOp.html,sha256=Qh5JRgE4s5mEWAR0DgzaqQUO32y8T9UU5VPrUh20Ykk,5394 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1epilogue_1_1warp_1_1TileIteratorTensorOp_3_01WarpShape___00_01OperatorShape___003a6f54e58875f27c8964f8d800eb0a41.html,sha256=W-3uUk7lMJjA4IBCaq8IjX5VGOZjHKHs4QoN7cCs-Yc,18442 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1epilogue_1_1warp_1_1TileIteratorTensorOp_3_01WarpShape___00_01OperatorShape___003cbb32beb84b4984cb7853662096d289.html,sha256=qDhvns6c-7EfKKX_HZuNHVJ4mUdVQWfbXSfjk9_VoDw,53634 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1epilogue_1_1warp_1_1TileIteratorVoltaTensorOp_3_01WarpShape___00_01gemm_1_1GemmS2fe0c60b727c738c622c18fc3dd76644.html,sha256=LN2XjeuLHguA4El5L7Bh0_ka_HnFmIGX4kQfg_thfbw,59191 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1epilogue_1_1warp_1_1TileIteratorVoltaTensorOp_3_01WarpShape___00_01gemm_1_1GemmSa0ceeeddc22575876eb977da7f5416a8.html,sha256=eUDdZlXYZDGNkrSlvrh6Kknfa4uKWf7pnPdjkWrKndI,60706 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1epilogue_1_1warp_1_1TileIteratorVoltaTensorOp_3_01WarpShape___00_01gemm_1_1GemmSa3f1805da1f79a22c4b13deb8bfd6dbc.html,sha256=HuWOyA9SCOVQDZfhnjui_3WGIIROEdZEVu82OKeJk10,20818 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1epilogue_1_1warp_1_1TileIteratorVoltaTensorOp_3_01WarpShape___00_01gemm_1_1GemmSec8059d5848d8771911d48e44fbab0a1.html,sha256=KS-LnmAA6qMZvkScnOr_BxZuz5zQFxtd5_t0FkGAUy8,20846 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1epilogue_1_1warp_1_1TileIteratorWmmaTensorOp.html,sha256=wueMt3mzAEAKxcwagNVwCoktp7T9ZSQdwbDO2Zrfg4Y,5450 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1epilogue_1_1warp_1_1TileIteratorWmmaTensorOp_3_01WarpShape___00_01OperatorShape_d40dea6fdd53d690220261eb3df00de7.html,sha256=LL7G7kvH_fOQQOV2RI3RTPKzYbz8y4j9ImdZuht4ZTQ,19342 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1epilogue_1_1warp_1_1TileIteratorWmmaTensorOp_3_01WarpShape___00_01OperatorShape_fd6a91cd8bbd07ecd1344326b830e3a4.html,sha256=Wy5COrxLpCC9Tt4Wd4_dI2WWtmsxfCr71vG3qFwSmJk,54907 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1device_1_1Gemm-members.html,sha256=fhX67X6jPkdsVEvIbDBEmoBhorWMGBlmT7_8h4CFvto,26069 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1device_1_1Gemm.html,sha256=oD0_HMjzxPk7NrvBPHADgQ-zU_qQUGh7zpvLMyP7RZc,132130 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1device_1_1GemmBatched-members.html,sha256=4DqU-OfkJtq49l0QdWuRmLcZrniUJ0d8ODlgvqhYyAE,25270 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1device_1_1GemmBatched.html,sha256=7ZLLlczNA5Z7hKKVvBGq3TXW2meuriMALItSG3dXLqc,127972 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1device_1_1GemmBatched_3_01ElementA___00_01LayoutA___00_01ElementB___00_067bcc9899cdd1d09bb72e91a0196124f.html,sha256=Cl1kkW50GpWuZn3kda2Nbblo7u1MxC2U0aEKOiwy2uw,33209 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1device_1_1GemmBatched_3_01ElementA___00_01LayoutA___00_01ElementB___00_0c9bb6f4463ab6085e6008b5d5ad6abfd.html,sha256=cwtADGaxkq1lFWzHvcSvSCaruWfmfPNjJzEY69FfjGU,92210 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1device_1_1GemmComplex-members.html,sha256=w0foAdSOInsUEA7i7_G1A2JgVuVjYn31f8HLzMb0Ghg,24213 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1device_1_1GemmComplex.html,sha256=tW4wkh2hleOYGOw3ncif6yhPO5UByew4_TgjHUvIlEE,109543 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1device_1_1GemmComplex_3_01ElementA___00_01LayoutA___00_01ElementB___00_04d70e4e6a90042308bae3da503c86e09.html,sha256=XXohR2s9kMpgm_n9Ep55sRM9-YR8Qk0LiJTDx_TjB0o,30966 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1device_1_1GemmComplex_3_01ElementA___00_01LayoutA___00_01ElementB___00_07c56401b4df75709ae636675d9980a9a.html,sha256=SK2Y0jMkOkkVMSGI8XRBnNtXzsdzl9HWfR1ww5Ju6-w,86807 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1device_1_1GemmSplitKParallel-members.html,sha256=Eus5y3e24eDEeN9ABTyryO7_K_30eco4LFHx7Yae8Ws,23917 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1device_1_1GemmSplitKParallel.html,sha256=tpn2VVlziY07nM2eQu2EcFmxNYZIf3PgJ2I1K2KmaxY,123598 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1device_1_1GemmSplitKParallel_3_01ElementA___00_01LayoutA___00_01ElementBbe7c1f7154ad5b5bf9d4d28301e2b457.html,sha256=csiSfwdFxVwe1NHV0TYDWZBgjDzF26LLVvX7BGo67Bk,84537 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1device_1_1GemmSplitKParallel_3_01ElementA___00_01LayoutA___00_01ElementBdb459748f0fef7bac42fca5554ff1c33.html,sha256=mVqFIepokvVBCCrl23YWKOQwuPIBoYNY-7ikQhI2iTE,31458 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1device_1_1Gemm_3_01ElementA___00_01LayoutA___00_01ElementB___00_01Layout4d0960ae6b1d1bf19e6239dbd002249c.html,sha256=DZqG2UrK8StklDIojvv-3JJV81XxQwYf3ZTYZFOUkcc,98600 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1device_1_1Gemm_3_01ElementA___00_01LayoutA___00_01ElementB___00_01Layout99997dac0ac0369caba3b97208ce1ff6.html,sha256=4WPUqKwuEZeK-UGK4EZ1HWqXc-nq_UkqyjuoWRRk3qU,35494 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1threadblock_1_1Gemv-members.html,sha256=-mQtMqjWhpQPjKADXQpHRHNjrwurolXK9rUWNVSKJvs,8885 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1threadblock_1_1Gemv.html,sha256=yjvpClBbr3d-X7OHA7HTB-6vhRGBAxht4XoJv-3ZnzI,21917 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1threadblock_1_1MmaBase-members.html,sha256=xgWLgVDp17gzL-Ymh16c4qSVd6ydagQjaE41x68Ht7Q,9757 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1threadblock_1_1MmaBase.html,sha256=HxcSC-WM2JqcKp1J7UYW6eDQWAzBQIILCAz4h3icWTA,25866 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1threadblock_1_1MmaBase_1_1SharedStorage-members.html,sha256=gXvAISnvNkEuAKHbowUAOI-SbdUjU5uLmndYFBy5kjs,8778 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1threadblock_1_1MmaBase_1_1SharedStorage.html,sha256=P-xF9qj_CtK21Vhmxs9EgLn5znRy5H_2tHMSGPLporA,21697 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1threadblock_1_1MmaBase_1_1SharedStorage__coll__graph.md5,sha256=xP9nxQDH0xlePV-MrBdxwr08CrU6yvuAZHz792rfrrs,32 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1threadblock_1_1MmaPipelined-members.html,sha256=DaBNR9z8sShtTB5JltFb56_bGN34aCoP7iG2dNYP-Ig,18260 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1threadblock_1_1MmaPipelined.html,sha256=PUaNwkaRbputVD7JaC4QoVsEizCk5VKff6hU-D2IrR0,62599 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1threadblock_1_1MmaPipelined__coll__graph.md5,sha256=qJNFsJ7iZ0mMQTFsjpfQsE3k_qNcU6LoUIf0jvf2ds0,32 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1threadblock_1_1MmaPipelined__inherit__graph.md5,sha256=qJNFsJ7iZ0mMQTFsjpfQsE3k_qNcU6LoUIf0jvf2ds0,32 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1threadblock_1_1MmaSingleStage-members.html,sha256=5M_pU8vKG1M9IkOWEwbONIvbbtCz8AHOTKf3Qi5UoDY,16847 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1threadblock_1_1MmaSingleStage.html,sha256=jQlMPLh2MVMmWATKmTXIB6KNBKFU4cwVLs9eh00QahY,51561 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1threadblock_1_1MmaSingleStage__coll__graph.md5,sha256=H7GWY56cwjxHSwShDoI8Sg61dwEx_txA-sVBFX_ah4A,32 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1threadblock_1_1MmaSingleStage__inherit__graph.md5,sha256=H7GWY56cwjxHSwShDoI8Sg61dwEx_txA-sVBFX_ah4A,32 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1warp_1_1MmaComplexTensorOp.html,sha256=ph7aOS4vscj5gBw6Ko12OSbFqKIbSuxWaiul2N2LySg,5426 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1warp_1_1MmaComplexTensorOp_3_01Shape___00_01complex_3_01RealElementA_01_0a57cf0ae57b6a111bda06a00be37068.html,sha256=nlx6U9myORKVjOFkYdKxzeA9WceW0aDqVNr-dbKOp4E,20154 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1warp_1_1MmaComplexTensorOp_3_01Shape___00_01complex_3_01RealElementA_01_146441010dad1f40eb51b6dae3ded216.html,sha256=l0z027khexHnyf2aRHhXOEcvs3v2Wbwy7-APAci3eMQ,57254 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1warp_1_1MmaSimt-members.html,sha256=cx_d7M_ZHqP9J9wYUAy4kNL1tQDAj9-ZKVskyLnyJd0,14520 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1warp_1_1MmaSimt.html,sha256=jYWgpsimQeBVonW0zS6QFPlDScF2nZtCiUCi60GOc8I,53387 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1warp_1_1MmaSimtTileIterator.html,sha256=_BnOT8ds8UNKJs1PfgSGNWZxoO96J1innEswpUISSBA,5929 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1warp_1_1MmaSimtTileIterator_3_01Shape___00_01Operand_1_1kA_00_01Element_67ca7e11a38e38f2c51b84767654a90f.html,sha256=OZVoFwTdcnCZixj9P79tKdrBA3GgMqCSSPPta9TmBeE,60233 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1warp_1_1MmaSimtTileIterator_3_01Shape___00_01Operand_1_1kA_00_01Element_a2456a020c69a771b09829baf7b67ebf.html,sha256=V8HOP0hD8zYCsz2M8-I1eXMjg_Id3MxXwXhPmbqwmnI,22403 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1warp_1_1MmaSimtTileIterator_3_01Shape___00_01Operand_1_1kA_00_01Element_e69c7b56575690d8ab3cbb5aeea28451.html,sha256=XBFwcdx5iq44QC-_xftE-Unh4Fu1ucsg_F5O-aRbI9s,19889 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1warp_1_1MmaSimtTileIterator_3_01Shape___00_01Operand_1_1kA_00_01Element_f0ce904a9294556f15e1cc9cf7c99a93.html,sha256=cfxVfcqxlKU2_l0119TElOqrCIBSF_YJPhJQ-Avk4qw,66442 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1warp_1_1MmaSimtTileIterator_3_01Shape___00_01Operand_1_1kB_00_01Element_5010ca7c1b96117113514b8b4ebddfa0.html,sha256=SuiS_c-dyH34ovM42MvYpAw3WUS1jVt1kbiCynxTbQA,22338 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1warp_1_1MmaSimtTileIterator_3_01Shape___00_01Operand_1_1kB_00_01Element_7436805480213675b5259979e1f6a17e.html,sha256=-aX14WVxoXW4-oKmFFwntg7LlwN51GfFuSqFfGCvbak,19833 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1warp_1_1MmaSimtTileIterator_3_01Shape___00_01Operand_1_1kB_00_01Element_ada156b62fcbdce47009c5bf1321c92c.html,sha256=1oaN7eIs31JMht5jdup054RFMDm8gp6nnc-rZP3S1No,67160 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1warp_1_1MmaSimtTileIterator_3_01Shape___00_01Operand_1_1kB_00_01Element_ea0a4e7ce3cd5d25cabf79383efdf4d9.html,sha256=xITpAVucc85paHedvtlQYeR2k7TeWx9B-aIF8dF4CZ0,60751 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1warp_1_1MmaSimtTileIterator_3_01Shape___00_01Operand_1_1kC_00_01Element_2ee3984cc649ece3b024188abfeebdad.html,sha256=n95IcwvxoyoNodAP0FK82lnDs4xit4ze59c2e7F_CLA,18992 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1warp_1_1MmaSimtTileIterator_3_01Shape___00_01Operand_1_1kC_00_01Element_4ccafbc821b3a55cd532602442a74031.html,sha256=Vj9dqDXb1qcFm28RUz1r91rxWO0uXhPfGNj-YJwjBGw,58580 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1warp_1_1MmaSimtTileIterator_3_01Shape___00_01Operand_1_1kC_00_01Element_8f92ea79e85febb67169c4b2d94b1b20.html,sha256=sC6niY80uGNOWXmj6n7fhl4nCeOJZHwql0l6OiSSBME,58415 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1warp_1_1MmaSimtTileIterator_3_01Shape___00_01Operand_1_1kC_00_01Element_a1f4bdda9e7a19223c391e2ec786b91d.html,sha256=vrao3BF20Wzah3VQRrcAZh2BHUnZ8sMmP-q2vk9KPMI,18914 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1warp_1_1MmaTensorOp-members.html,sha256=3Ww3_u1P9kLAXZGUD9NpyymkkYJazVEAcfl7Vsxc87w,15340 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1warp_1_1MmaTensorOp.html,sha256=tMERudE4GYZA23bK-3NWm9Ke_mV6PheIM5G5BanV46o,48197 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1warp_1_1MmaTensorOpAccumulatorTileIterator.html,sha256=puIZtwvV1e9pgh_RqSjcXHAspelU1UKvlm141e8JqNk,5386 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1warp_1_1MmaTensorOpAccumulatorTileIterator_3_01Shape___00_01Element___00027dabdc144edd6276f664ca74088510.html,sha256=7g1GLil1BYNB1UHxFP8FeMGv2TqphsZ0STuZ2Hhjq9g,86908 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1warp_1_1MmaTensorOpAccumulatorTileIterator_3_01Shape___00_01Element___00064bfe771e6b9a641152b220dd6e6550.html,sha256=Z9hopH8LTjkymEZYw6E3YQjzR4v4tDVcqCIlta6ceVI,24726 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1warp_1_1MmaTensorOpAccumulatorTileIterator_3_01Shape___00_01Element___006c39f57875e0aa9d0ad82c8043ed8b98.html,sha256=Ek0o82dCxEc8dYOVuEpIC5qbP6HeUv7txMibjFVFcjE,82644 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1warp_1_1MmaTensorOpAccumulatorTileIterator_3_01Shape___00_01Element___008f607b871a2b3d854eb4def64712c042.html,sha256=UDUGtbcTCuAObaj4TAUO474WUluvKGRyE4n82xkBIQ0,82848 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1warp_1_1MmaTensorOpAccumulatorTileIterator_3_01Shape___00_01Element___009fb4d99d9f854adc12c5f9e63302b4c8.html,sha256=LCQcxisr7VNLVMZmO6bT94GomT4LpsI3MnWVQSdgWUM,24627 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1warp_1_1MmaTensorOpAccumulatorTileIterator_3_01Shape___00_01Element___00aff26d6194ae0e147368350f4cacf994.html,sha256=f2izuqzLo1MkxLnbVnQ5pJ8DmyMN6hTO_HqgCh33fV0,26452 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1warp_1_1MmaTensorOpMultiplicandTileIterator.html,sha256=A9Z4RgchQ7E7noV9jI8xN0zUgnNK1-WncshwMtt-R84,5454 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1warp_1_1MmaTensorOpMultiplicandTileIterator_3_01Shape___00_01Operand___0352e0dcab42bc8360606874e00173556.html,sha256=xj5XiWNzM6PFYH4N9BsTRNise0nnKZEXOS636buJNVU,86240 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1warp_1_1MmaTensorOpMultiplicandTileIterator_3_01Shape___00_01Operand___039819fb3ccd43786d556c2c9669508ef.html,sha256=Q70C5hXAa2zHoO7KOQDBNlO_f3K_M--0sEorCHTw4uA,84211 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1warp_1_1MmaTensorOpMultiplicandTileIterator_3_01Shape___00_01Operand___061061fa051337e681934b994f511ad56.html,sha256=GrUDPub5Mlb3-HZZHKUVa9NFYze273nONwW2eMUwDGw,26323 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1warp_1_1MmaTensorOpMultiplicandTileIterator_3_01Shape___00_01Operand___06c47d82768aa45bab2726e67d577b0d5.html,sha256=eLQjnuLzRaAqfpzieOuTEbw07PyuaJ8IH-IO3lb_-ZY,27219 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1warp_1_1MmaTensorOpMultiplicandTileIterator_3_01Shape___00_01Operand___07bf53239dbcc064f44d6c5d96e4a51bb.html,sha256=F0_BYxvLmTeoVoFGJd-PVyBcEhOK8O2Z4yhNa1hhabg,27592 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1warp_1_1MmaTensorOpMultiplicandTileIterator_3_01Shape___00_01Operand___0b84f53cd44b339eccc12067c9f86e11c.html,sha256=6Up_DDVrFz0RLKQ8NBtlhtpv9HGlO0KkYgSGi_mMIWg,84403 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1warp_1_1MmaTensorOpMultiplicandTileIterator_3_01Shape___00_01Operand___0c430ef744703d5f98604b8ecc88574f9.html,sha256=C8jDz4TnJ38GfUSyc8yJZrf2LyopsmW0vwQBFjgIgNk,27312 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1warp_1_1MmaTensorOpMultiplicandTileIterator_3_01Shape___00_01Operand___0c7d419c589d601ce4eb603be566fea21.html,sha256=NPGEHowbNYTSAf211tmTaWkTxXatUoxC1dNAyJ50sdM,82660 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1warp_1_1MmaTensorOpMultiplicandTileIterator_3_01Shape___00_01Operand___0dadd1ada54e0c66b1fc323db1c2d5f4b.html,sha256=JMJCqNovH8cpR5c_Sd5AR7AfgwedylxBNesCW9kxBHQ,27274 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1warp_1_1MmaTensorOpMultiplicandTileIterator_3_01Shape___00_01Operand___0e406d341fae1780c4b8cd55fe869ef91.html,sha256=bAZpuv0GM_-puHVweSIevT3AbotazjuEpxoq-d6pNh0,27496 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1warp_1_1MmaTensorOpMultiplicandTileIterator_3_01Shape___00_01Operand___0e52ad425e1ee3e68544873f66733237b.html,sha256=CkDLIMyjGRbLEtMX172nF5pNnN29KzJjj5iPza1Aq6A,86411 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1warp_1_1MmaTensorOpMultiplicandTileIterator_3_01Shape___00_01Operand___0ed7daaeba1c095e77f68533d4d2c475c.html,sha256=4xWDvEZkA8yAcQBiFmTVlPuqM8cv7SCMgnDhm9dQXTc,80427 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1warp_1_1MmaVoltaTensorOp-members.html,sha256=f6PqIMPTSHUwRhpp-d6MehvoDOfWDmKIKW8FGeS_k_g,13999 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1warp_1_1MmaVoltaTensorOp.html,sha256=Z9JXswi2NlRMr1e8H3nEgVE_BG5gxlot5IN3yeJ0KLI,44178 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1warp_1_1MmaVoltaTensorOpAccumulatorTileIterator-members.html,sha256=naNQCFuDhb4bOpi8VCpb52LBSYxav3wm7-54_poL2cM,20610 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1warp_1_1MmaVoltaTensorOpAccumulatorTileIterator.html,sha256=TVwDypVP9e686ihUgK8kMAeQbt5ZoDePm0ITMHmv78M,76154 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1warp_1_1MmaVoltaTensorOpMultiplicandTileIterator.html,sha256=sIlgHuR6KfFERDhXcpvxB5z56khHDqTKxMuOWJsl99s,5468 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1warp_1_1MmaVoltaTensorOpMultiplicandTileIterator_3_01Shape___00_01Operan0c2424e93c61db6a6296de234d81956f.html,sha256=afD2ATJN_qqgyRr_GOrUThTxi_9qvY6B4i3POhEsyeo,25497 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1warp_1_1MmaVoltaTensorOpMultiplicandTileIterator_3_01Shape___00_01Operan0d3248553e52cd61ed8a2b3b12a20343.html,sha256=30Csc_t3WU5F1O9E3KgzVhRPgOlyalGa3NSyJdGr6YI,86541 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1warp_1_1MmaVoltaTensorOpMultiplicandTileIterator_3_01Shape___00_01Operan16c56cdc2dda5eeb996af8ec0242d501.html,sha256=FBWEOpJWkmfOczN8CEXis2HZVva6qjsADPfDT35ufK4,81324 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1warp_1_1MmaVoltaTensorOpMultiplicandTileIterator_3_01Shape___00_01Operan26f3c501f953ca28fe4df0c389a6d0f0.html,sha256=_p11hBmeWb2J6NWYbzq0w3H7a9NFGj2Wj_4VE_yFEP8,27279 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1warp_1_1MmaVoltaTensorOpMultiplicandTileIterator_3_01Shape___00_01Operan34be8e21a40af3ebd2dc3dff460dca72.html,sha256=0DtvyNEhI5u58-_VgGQviugAu-41DkI1fgLgn8c0m94,81222 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1warp_1_1MmaVoltaTensorOpMultiplicandTileIterator_3_01Shape___00_01Operan3bcbe1d689d85b2c9dfed34cbb21052a.html,sha256=-vHsj1_18HilOEk531F5w1pOnxjYOxAnE73zmeG9v8Y,26328 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1warp_1_1MmaVoltaTensorOpMultiplicandTileIterator_3_01Shape___00_01Operan40b39855df010de47549257e79292db4.html,sha256=kUI-Nekaqw3PJEZv2EE-05nDQjt9NTA38gpMZveJSho,26485 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1warp_1_1MmaVoltaTensorOpMultiplicandTileIterator_3_01Shape___00_01Operan5808900a4e1f473b3e50b34d97bf937a.html,sha256=Hkb1OkdedhvTymiVIbSPWgkWGdm1qrS54ANL9sMFwAw,25467 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1warp_1_1MmaVoltaTensorOpMultiplicandTileIterator_3_01Shape___00_01Operan5a221944f4a0e16ccab77ba684856942.html,sha256=QDxDFFiTBlhELAnBuBsa7Q54qLW8ioBQiaMTZ7N8mbs,86026 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1warp_1_1MmaVoltaTensorOpMultiplicandTileIterator_3_01Shape___00_01Operan8efc24241724136902518265d02a3d37.html,sha256=nEM8Sr1BkhB_BTr_PuAeOT4URVC9RZOiCFY_Y7_wzmg,26423 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1warp_1_1MmaVoltaTensorOpMultiplicandTileIterator_3_01Shape___00_01Operana2f40b28f0d2286b84d86f7238d67b52.html,sha256=ZvYik6KX3NdEO_TyoBgkXHG8wRCm0_2aTu0jUSj4-ko,80373 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1warp_1_1MmaVoltaTensorOpMultiplicandTileIterator_3_01Shape___00_01Operand734577b7e54a074d143aba59828c2f2.html,sha256=aKXLrDrsTabe7izXhKM4XjOH5roG7Yyrk9_Co_1m1bo,86417 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1warp_1_1MmaVoltaTensorOpMultiplicandTileIterator_3_01Shape___00_01Operandbec6bcbbc4d4add9a9fe66e6de50675.html,sha256=QtdxAkwZQMwv1Y3fV2Ljde5WHZSCMwgolzOBPseCK1s,27375 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1gemm_1_1warp_1_1MmaVoltaTensorOpMultiplicandTileIterator_3_01Shape___00_01Operandcc9821c435540895138bc9af495f321.html,sha256=foZv1tUTUyzbuMlG6V6CtFMIyBR4MBHQ9fMiMCrxDho,85828 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1layout_1_1ColumnMajor-members.html,sha256=DDRD-v7cVZPWlPbAcO2JLrDwjDIpqvD1jkbtwk17stw,10246 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1layout_1_1ColumnMajor.html,sha256=N8s21t_xzRW4Ol30ogDyms1-LvfXWMdBVocpuONlEes,30448 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1layout_1_1PackedVectorLayout-members.html,sha256=7PTCoIwSAN6VeEWWNbfs4HyfG84w6DGrYb66HgbkN2M,8810 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1layout_1_1PackedVectorLayout.html,sha256=iUGgH91TH1uLTyX5Y-llU804l-St8EcFD3o3xfaSNXI,22661 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1layout_1_1PitchLinear-members.html,sha256=nmehr6SB95F1TEHA9Xeso--Z9ITKW4TeT9xOt_L91rc,10248 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1layout_1_1PitchLinear.html,sha256=Kg4XE3MOlIn1Qa9BaTlbYDu_RWpg8eNMfws0J9F2fyk,30732 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1layout_1_1RowMajor-members.html,sha256=dGziMMLyzbAJOMBlSJtICdaGu9WRx3jIMUg4dSG1ho8,10081 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1layout_1_1RowMajor.html,sha256=-vjEUDRa1ZEXeoSK-b4710OSvb3vUylFqASUGObIoyE,30236 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1layout_1_1TensorCxRSKx-members.html,sha256=kErhOa2xXmdlrH7RzgWLTWKPsej7grJirqVAYc1wiSk,9578 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1layout_1_1TensorCxRSKx.html,sha256=vAPJuFc4JOHOE8tbZzkKddBn3RvgORTHTeDw2P67KBs,27378 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1layout_1_1TensorNCHW-members.html,sha256=k9wgEwT5si-0Q8yZFlGszRvMbXfbpztE0-Y-_vYjTkI,8854 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1layout_1_1TensorNCHW.html,sha256=FZN6TcHldEw85FagdtqtvneiYwb9Bw_uVmsz_QpARGo,24006 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1layout_1_1TensorNCxHWx-members.html,sha256=MndvbYki6g9sYIgmFovjwFcFpHwQlRutGhGq83dRr9M,9578 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1layout_1_1TensorNCxHWx.html,sha256=b7VEG4tX3D8EmkFLDZIaVrvShRQaSelO8ABXb9GD_0w,27379 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1layout_1_1TensorNHWC-members.html,sha256=ndanaC2efYbYVdu0dxiLVIE2YxCDGwz2MzUxj2mz8Mg,9987 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1layout_1_1TensorNHWC.html,sha256=bMDirn-T8IRmSBqDPcMLYqGGcPhja1c9KJJzmXtf2O0,30206 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1library_1_1Manifest-members.html,sha256=3XIuwB5kfrZKu7FvLXqbZnTaWGxynqpmm7w2YsvhbjU,6968 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1library_1_1Manifest.html,sha256=CDBoyZ5CuGKzWT0VaWxvJ0YxpaAKF2ftbcd3E0Sz524,13480 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1library_1_1Operation-members.html,sha256=wQmIype__-55mR7qLw1OLF0Ah-SFua3G7IhSMs_tMkA,7639 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1library_1_1Operation.html,sha256=0jzTPOSeI6F0Qxib7ZDQQya9k1gh46hPCYQOgHxnqE8,16191 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1platform_1_1unique__ptr-members.html,sha256=p04983YgVI3iahYADacPwfY_wmIOO6Nb_nQ_3eqaIN0,10709 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1platform_1_1unique__ptr.html,sha256=PUF0oGPPspEEBLEfWgfX3L4Ftgj0Ds5eMCK42hmJ8v4,29401 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1reduction_1_1kernel_1_1ReduceSplitK-members.html,sha256=hyOcTQJ0owymx2FQNo3BDX0AwNAtUUT8YcQ7OltwWs4,11990 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1reduction_1_1kernel_1_1ReduceSplitK.html,sha256=xXyH_jLX72xOQkoVLaJLQplj_-CqgiFqthGywYYMrEY,32085 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1thread_1_1Matrix-members.html,sha256=w7jv7vgShUZuGI6lKisTc-Vwrt2FvsbL9KLSxTfElE4,13918 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1thread_1_1Matrix.html,sha256=42dbVhWx0C_WygIarMZuZtHE4NsG9Y7DeIpxP3i_pWQ,55422 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1thread_1_1Matrix__coll__graph.md5,sha256=JV8E-bcskE47c0DKDYbq0FFK0UKrfcZRz4orgpbhRCw,32 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1thread_1_1Matrix__inherit__graph.md5,sha256=JV8E-bcskE47c0DKDYbq0FFK0UKrfcZRz4orgpbhRCw,32 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1thread_1_1Transpose.html,sha256=iXk7N15fkwLLI994iy3wBWjBZcNugcXxaK0dgsb6YYA,5267 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1PredicatedTileAccessIterator.html,sha256=9Kyphz8LFH1XMCTJIAodtrwEXTYnAzzS0awrnjtoWFg,5979 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1PredicatedTileAccessIterator2dThreadTile.html,sha256=uC5lK-in1POSLW2NEC-65j4zFq2EuQV-LcZfdBNKPbk,6117 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1PredicatedTileAccessIterator2dThreadTile_3_01Shape__0aa7296f39e4779422864a6755ab6070.html,sha256=AWYf7O21XauiUFNWfwgGJKneOa4CAmAwrtuoLga7Mv4,26164 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1PredicatedTileAccessIterator2dThreadTile_3_01Shape__1790abaa54a01f277d75766d5882fec8.html,sha256=9QR6Ee2ztO6oYoyPh5Z5UNt4lVZeP4sOW7jq4cFFAas,76380 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1PredicatedTileAccessIterator2dThreadTile_3_01Shape__18e9cf25bb3b8edfaad595241a6dc2d7.html,sha256=ZdH-4CH2eAco4B3S-DEQ8N7RycR9jDiJjdFTAd8_PHo,11051 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1PredicatedTileAccessIterator2dThreadTile_3_01Shape__41009dfccf282d1422aafb23cf1e3e4a.html,sha256=B8PWubO1f_cz7LZ4b78X7x0hZFDvukAKF34ERr3wR9o,23449 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1PredicatedTileAccessIterator2dThreadTile_3_01Shape__7327fa15996bcb8502cdfcc192350fe1.html,sha256=o4gZwORJbfFB05KjRsOTOKrfYzP5xRTbsO4QCQyJ82g,70541 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1PredicatedTileAccessIterator2dThreadTile_3_01Shape__7edaff7f25fa2f43f21bc45329c1736a.html,sha256=PUhZysRiAVFd_ZcoNtsIQgsTQ_Fw91XaPSepIeDeP3I,7083 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1PredicatedTileAccessIterator2dThreadTile_3_01Shape__8ccc62d47a092afc8bee32ffe9d1e4ba.html,sha256=YuBK736To-_HlG56vlRML3ZD4zSSj3tZHKFnl_LS1L0,12436 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1PredicatedTileAccessIterator2dThreadTile_3_01Shape__8ccd146eec7b82ca7e35a235678df629.html,sha256=7-0w36PA7MYeEmqcUCc9snMJiB9iH4nxPyuKIARqY0o,7735 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1PredicatedTileAccessIterator2dThreadTile_3_01Shape__a56cbccec33ee916292ad9d068474609.html,sha256=SC61SlmYbtbCfJI2KiswEJYBf7J1ZLA6dVG55G0XUAI,11030 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1PredicatedTileAccessIterator2dThreadTile_3_01Shape__ab31a46c81fdcf99dcf3f780d19902e3.html,sha256=741K36JPDsdLDuVjHekfKpfm0Zhe7rDwYKe55gM_lcw,23542 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1PredicatedTileAccessIterator2dThreadTile_3_01Shape__ad17304f9466e09edfd94345da01b287.html,sha256=saBvl-Z-Qx5l8zMArjrv8ErWRbqI7sSbj9DUfEqEuEw,7068 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1PredicatedTileAccessIterator2dThreadTile_3_01Shape__da632779aba661c0f4cfaaa78126b771.html,sha256=pxmAa8qTTtQ2Ex47ym6xoDKPxH95IIf7D9vvZ8li8x0,70751 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1PredicatedTileAccessIterator_3_01Shape___00_01Elemen058417e2cdd86f3cd6ad5458581571c8.html,sha256=WhApLrwFL8d-vQtTv9_IVz6MNkTK-3-l88VsWT_ddM8,10919 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1PredicatedTileAccessIterator_3_01Shape___00_01Elemen2a6b6211aec419b1577007da4b7a8acf.html,sha256=vgER9ApgVPufKVqSSqJz76e-OXyDP4Plb_weSJ-WYEE,23790 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1PredicatedTileAccessIterator_3_01Shape___00_01Elemen339ca2c3f0da474a830c3f9c59a86d53.html,sha256=_chaTq-YMc7N1QGevhBYfpgZJYSCRBhq4q2PNW9nuQI,23694 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1PredicatedTileAccessIterator_3_01Shape___00_01Elemen392f8b4792197075fdff65e10f0aa956.html,sha256=MYFKr-Jw8E2Nq4LX6XD7LTAXshdS569_Ccbw5Cgi6Lo,25406 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1PredicatedTileAccessIterator_3_01Shape___00_01Elemen41e459f664d17473570cf22fb616845f.html,sha256=mF6skEDzPYSGISGFuO8eiMolaqHOtKn35zwa7Qb87fI,12250 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1PredicatedTileAccessIterator_3_01Shape___00_01Elemen44ce348364e78f5a56fa0c2cef6af930.html,sha256=RsYBVkb2WMT7xGaZ65UuS7p9LUEWkVJe5AgFgTibZ2k,10892 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1PredicatedTileAccessIterator_3_01Shape___00_01Elemen48b0145d8f67123c1eb694de377033f3.html,sha256=9aedro2NasntuT9Hw5-h6raT7jgV4O3IuFkwpFAPRIU,7188 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1PredicatedTileAccessIterator_3_01Shape___00_01Elemen5b5c3000a37203d17fda2581511cafe0.html,sha256=ks6vadsryamCqbKYM5YZ2f_xlhmuuM1cL1S2cboVzEM,7173 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1PredicatedTileAccessIterator_3_01Shape___00_01Elemen65295776e4fc034eccbcb4e93de830ba.html,sha256=XiG5lun0M3eUiCDHFzvHeySAjfJF5Spm9gpQIwm51fM,25505 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1PredicatedTileAccessIterator_3_01Shape___00_01Elemen784a0e9da3f55064c47e5613791f51f7.html,sha256=cWTvKu_qMRMs5omVprpDuADm3MfG-D9jKAAoLyIK8iQ,78731 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1PredicatedTileAccessIterator_3_01Shape___00_01Elemen809793e785fb4211888c6b4e5dcfcb39.html,sha256=iCfY1ZCgu4e62qndR2Q54sYDXcQ2Tv4UU-VdYqkU6GI,76004 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1PredicatedTileAccessIterator_3_01Shape___00_01Elemen89c687c583745a73cb485041911a4c4e.html,sha256=8j-r5zgi2Ll13PUaPugUcaV3pTr9bxbb-tRYT-yHr3c,71236 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1PredicatedTileAccessIterator_3_01Shape___00_01Elemen9838736ad62fae54213fbaf722a989ab.html,sha256=aE5c9Z80ogRBFSiDcl03mIf9qGNpqSGHAhWwfjkPq4k,71020 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1PredicatedTileAccessIterator_3_01Shape___00_01Elemena8341a9325c3f49778eaed47c551850e.html,sha256=j7AUEHXcqfbzf4cK_7toO4HnMs3hmUGHqlvM2febv6U,7651 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1PredicatedTileAccessIterator_3_01Shape___00_01Elemena9b06926a275b569ee9f7f142604b997.html,sha256=5cPYg7tqgOOzhr7fW69zTa-uViwzHVKmuQeQH-C9vNY,10940 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1PredicatedTileAccessIterator_3_01Shape___00_01Elemenab63a1e105bf37f6371516cb9e2c5a7a.html,sha256=4xou_QsDZARFZZrlqlfMR0Mb5thC0itiwYwf-WDkfPE,76226 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1PredicatedTileAccessIterator_3_01Shape___00_01Elemenc07b5ec72f83e782121ac629288d61fe.html,sha256=Se9Xs6bMkBqBiiWRSOjQ6CNGJLuokXStKpYsbbL_Tfg,10913 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1PredicatedTileAccessIterator_3_01Shape___00_01Elemend770b8cd1ad441b73d66bc9bda812d63.html,sha256=9Dj3C3HHLjoVEam2pZ6JQ86lIUI7N67M6cexomA3hk0,26992 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1PredicatedTileAccessIterator_3_01Shape___00_01Elemene28e844421b8a8bcfd44613d6581f05b.html,sha256=WDYhKtIrUsYQKaterv1lsaCBptZZG3RVoQypi_ClyJg,7008 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1PredicatedTileAccessIterator_3_01Shape___00_01Elemenf150bf96e27b7d14cb6de66901dd2f4d.html,sha256=rOynTD68X0i-eJzKQYNEaHbvPvGCvIyFr6fiQ2f-qXU,7023 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1PredicatedTileIterator.html,sha256=uFnfPCP4yNJJBw7bmKDSorqBen6JcpAmFtRaHOhvSUQ,7614 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1PredicatedTileIterator2dThreadTile.html,sha256=UzOq3oaaYS5qc8Z_hzNus99jPxRSCGLN-m7uCKw8Ls8,7655 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1PredicatedTileIterator2dThreadTile_3_01Shape___00_0102e766863c6ac9ec2063a02c4803eecb.html,sha256=tpF29fMVeZfQCB2hif8gTXki0_pBJkQGSTVU7tON2rU,10743 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1PredicatedTileIterator2dThreadTile_3_01Shape___00_0133eb0925fe38c979de8394b69685a5df.html,sha256=nWSTK8RlobYN_qDTb1XPnHzp_4kcFR4MakPJg4Wt-gk,24647 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1PredicatedTileIterator2dThreadTile_3_01Shape___00_013671177d6219bfeb0e1b4dc4c1b5bf11.html,sha256=KvLys11FvT1dPsyarA_sMhgpdyDk_kKyQmZ7tHGb09E,75586 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1PredicatedTileIterator2dThreadTile_3_01Shape___00_0145ef045e8f7d57dc718098adcb00cf3d.html,sha256=qTsqSicfDTeQXF4M1aFSW54l3yZ3zm6RL9e7fI6Snyc,12316 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1PredicatedTileIterator2dThreadTile_3_01Shape___00_0165b39a630d10785a3558406f9adb99b9.html,sha256=nsNTKWLxPDjoax7P21RBENxws8jOxn8FFqXCDrf1bx8,75808 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1PredicatedTileIterator2dThreadTile_3_01Shape___00_017a517f3c73efd795ab05059cc9b111e1.html,sha256=VQ_N0xbAHGodt7gjCK13PscGp49tEbJozFNLBlpLqW4,77343 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1PredicatedTileIterator2dThreadTile_3_01Shape___00_0185eef3bfb8e5385c869e25dc77d7e5da.html,sha256=zmc04D21DOJelF9KSRDFBayXIceg-zf3gwHLTnQThBY,7687 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1PredicatedTileIterator2dThreadTile_3_01Shape___00_018ff345579826efbdeed7bbe25bf9565c.html,sha256=YUBqP4aX7cDMiHhOlmDPESon1util3sjxuR1dsgoSww,24548 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1PredicatedTileIterator2dThreadTile_3_01Shape___00_01e11ed7192af5d7ad1bce5641fa13112e.html,sha256=vjbj6-pvGOd7BZaBpxs8v6TYeHA7dWtUpA6hOvC9mUA,10764 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1PredicatedTileIterator2dThreadTile_3_01Shape___00_01f1f7b09761667f6f91a643ded7d0d27c.html,sha256=YC82prVuN3Phnoslm2h472e8pDagWoTM3fbrMXe65qk,7048 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1PredicatedTileIterator2dThreadTile_3_01Shape___00_01f89edd83fe995c8e4757b0706a729e1b.html,sha256=tYk1zZGdGdFXXpFMAsqoaE_6gsjGhpG0EaWnp9r0Nqg,24646 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1PredicatedTileIterator2dThreadTile_3_01Shape___00_01fb185fe950b589f42a59721ab79dc124.html,sha256=gK-KGExXOqMN5dDl_TZA22X_z0hSwNhIdmMubURP7xE,7033 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1PredicatedTileIterator_3_01Shape___00_01Element___00080941085bb0194af8f2f65a15192e0b.html,sha256=kQxOzEVolTAbpiRYDRjjRmcnj0NC0IuYKfxtGN8GOac,23612 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1PredicatedTileIterator_3_01Shape___00_01Element___0010e951973fa9415dd5e9e2e33dbd5289.html,sha256=amFUVoYllHs1Dl79XFA5gMbrzyHlMijKDKVuwxni85E,25320 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1PredicatedTileIterator_3_01Shape___00_01Element___0041ea81994f8af0d4d071fdb9e66b5ff0.html,sha256=WNJuwqmCDwwOoVYhImspdyHkmjv1tDE5ByUvELqQUSQ,72716 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1PredicatedTileIterator_3_01Shape___00_01Element___00498568456c9d689a9759d3d9b23c26c7.html,sha256=Sfx7-ZntmKvWamodSAjdoqYgibIkfP5Y2wUcVbneIBw,23516 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1PredicatedTileIterator_3_01Shape___00_01Element___004d0f9b5e19c29acc17bcdc360dafebbd.html,sha256=C5k2oRWhwRSvkc2KNCpJuyUO83p8WenCwRXFrOJyc0o,10673 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1PredicatedTileIterator_3_01Shape___00_01Element___0068b3e874b5d93d11f0fa902c7f1d11d9.html,sha256=jx9qGfvLqMPqZF44HWrN1KoiN3-88ICOvbURp0IL7J4,72932 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1PredicatedTileIterator_3_01Shape___00_01Element___006a5f2f7a8271031e6cdc5daa5441f2af.html,sha256=EQrzcBav0UHK0i6ZYyHk33xA0t0PEMgwSErM_VYx1Dw,12197 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1PredicatedTileIterator_3_01Shape___00_01Element___006a6d14c98b70ad1baa69b4493734b326.html,sha256=vyEEU9p1sRkNPT3fBugTbQHDp8A7AS3PFBohF9RjuLw,7603 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1PredicatedTileIterator_3_01Shape___00_01Element___0077835ea35054e4d0771d9d6725bb9085.html,sha256=glIvGsFyzBnqqbMCtnluwQZ3ds_gfXjr2AWQ9dEX2W4,24236 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1PredicatedTileIterator_3_01Shape___00_01Element___007f87132882da9ec58c786303b28e9471.html,sha256=ZerFywjphiFmlwvdQioh9lXT8KMALv7AmbNkHqOaIr4,6973 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1PredicatedTileIterator_3_01Shape___00_01Element___009ae162bdb1617beea32983ed0c15dc12.html,sha256=IpSGQHIegu4p7_IIoJvmJadvCe_gv2QiiCDvQVL20G8,7138 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1PredicatedTileIterator_3_01Shape___00_01Element___009fd89f6dad84238fd7d63df0a0c0364f.html,sha256=tq5Np2D_K4WzvCr5tpSR6-Yt3cs9yk-91_4PYhCDMlQ,10898 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1PredicatedTileIterator_3_01Shape___00_01Element___00a6b756b1bcfbb35fe4a3e68ff074e380.html,sha256=xrqfp5HECa-dWEJKOa_eZQwjJOLNeFNBgTi9Hi3o860,10694 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1PredicatedTileIterator_3_01Shape___00_01Element___00d670f969180a8d182dffb356ebcc957e.html,sha256=7zj5ZvuCK899hv3jG4wF9tMMNxNkCHcMUP7Y-cQhFJY,77434 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1PredicatedTileIterator_3_01Shape___00_01Element___00e7c2c404e7aedfe60ad56bb5571306a1.html,sha256=bguhCb65uW-6haQcMp_f72Oj6pdL1dX2IxAbtO7wIpo,76352 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1PredicatedTileIterator_3_01Shape___00_01Element___00ebd1a63351e1085d0b718582ec7b06c8.html,sha256=xs_NBbx3J-oKyZg6lDV4mhZ-AJubUmr7kg3HfnCMND0,10919 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1PredicatedTileIterator_3_01Shape___00_01Element___00ed8b09ab2382d4e8728ddd2a68158934.html,sha256=McUtcAKh-e18CXxlhgAuwXBbc1Lw2Jz2lE4Hg-1i4WI,25221 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1PredicatedTileIterator_3_01Shape___00_01Element___00f5d8ee719cad9052f71bb9bd0fa63021.html,sha256=C0IatvuvDvRRCA0MdnjoZQr40_ORyT6GJoRZK1nN97Y,7153 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1PredicatedTileIterator_3_01Shape___00_01Element___00f6b3a9dfab5e7c72d5233f7e5e6e3b9b.html,sha256=jC_DZLk4Dyz4FW6ytTcU8AUwfNXm05BL98AlOh1Rkyg,77653 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1PredicatedTileIterator_3_01Shape___00_01Element___00f7b2f5e11bc5aeead1e0502a52c45641.html,sha256=S8LehKeyu-a_uPVqOPAnx8o3C4UQ-rShDABc_Ogqui0,6988 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1RegularTileAccessIterator.html,sha256=iJv7pn7IPTOy_fIaUFU4kQKe38q7qq5e-Z6nzDonLdg,5423 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1RegularTileAccessIterator_3_01Shape___00_01Element__0184b7188941788a96624510a4b2f876.html,sha256=f3nKDnVuGZAsCok9EbhZW6AByQxlraVfFeOV-H7eiMU,49284 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1RegularTileAccessIterator_3_01Shape___00_01Element__0855e9d9ab619202d2397180c1e4c4a5.html,sha256=-e6XngeYdHSQsYRhCkeyf6X5Yi7Ls1ST4RArFyvUXbg,41875 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1RegularTileAccessIterator_3_01Shape___00_01Element__213c660dae89d11f257af8ed849b6926.html,sha256=iObWeh4mIc8pHeSsIDF6mkGnhjDSeo7g9DiIjU99I2I,19475 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1RegularTileAccessIterator_3_01Shape___00_01Element__24441807fbf0271dbae4258379c0fad6.html,sha256=G81oqFJMVMpZntdoC58IOvnecv1vrkVRRn6f2UCX4x0,16640 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1RegularTileAccessIterator_3_01Shape___00_01Element__29b83d435ddd06700aca12de5506840e.html,sha256=CZGYl-dSQWQt4i0pZFNpuMm4xSj8jRvFpIqyZ_D4Psw,19079 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1RegularTileAccessIterator_3_01Shape___00_01Element__2c1476eaf582bfe972793e17babfe985.html,sha256=l2flMrtsyZ5_P1aAiF4_B_BJoPf7l_4UdLwSJYF3kV8,49554 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1RegularTileAccessIterator_3_01Shape___00_01Element__402190115c926267caaaf768257c5f78.html,sha256=k9T_asz0QL68ajQCBDE736fQFBQfEuff7-wI6l913Pk,19409 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1RegularTileAccessIterator_3_01Shape___00_01Element__52b6c173ef31c98d1eaa592790f4c1f8.html,sha256=o6niUynNB5fJzXup0BQFo8czuue3dqlRyjL0O3m-q00,17187 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1RegularTileAccessIterator_3_01Shape___00_01Element__6baada077236f1a368c61c5e11b45b72.html,sha256=sacgpreltpjXE8Fd5R5JVER0FNT1HV-wkmYio4ss46w,49395 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1RegularTileAccessIterator_3_01Shape___00_01Element__85e80b4f64dfb53cfbfdd5ac1fb09e87.html,sha256=3OIUDgGT8YIn2oyGq1GM9V9u3GeE1DV7mDFelX7fVJk,17253 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1RegularTileAccessIterator_3_01Shape___00_01Element__a2cfb07ab83f71c364fb627b83ffc1e3.html,sha256=OzaauEerdyma8tmXsxCeufAfB-GK7OpGExAEQZUWBm8,19145 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1RegularTileAccessIterator_3_01Shape___00_01Element__a3c11cf1f00ef7a1efb8389ac6e4c6e0.html,sha256=Umh_Ho6lnKd3lSMu_uwS3vePNG5YgTL-nifO5Jw9oQ0,49443 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1RegularTileAccessIterator_3_01Shape___00_01Element__b29f42e2659fc97d4580ce9251ffcd45.html,sha256=Y2kOj_0WKydH1ih59wicSM_QXZrj1UhMd__IaMaSJoA,18921 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1RegularTileAccessIterator_3_01Shape___00_01Element__d9d6aa4390d5c01350a517455e2fc142.html,sha256=pXXiNaudDCbY6Qw_GWZSO1dNPaBOAw-JL7t694Drl0w,18530 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1RegularTileAccessIterator_3_01Shape___00_01Element__e9a9e0f4286f652f55eb9b863b21effe.html,sha256=HYfVLdCxsg2gjd3vc1B7O0FtfgpkY1BKCmVsxTMVPMA,48288 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1RegularTileAccessIterator_3_01Shape___00_01Element__eb7d20f8b9d69e0ae5e7ef51dc480867.html,sha256=MZVGo-VeQ-V_Z8DhEHZBSrFBFavxYNC_7WBvYjdlML8,44614 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1RegularTileAccessIterator_3_01Shape___00_01Element__ebf4714349612673e8b6609b763eeb6f.html,sha256=3pLLbw-4yrkRLuq0X8SoekT8IRN1rtC2IRPWq65LTy8,46764 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1RegularTileAccessIterator_3_01Shape___00_01Element__f04332958a49a47d6fb2b25201764630.html,sha256=-Eq3S6gFgsuaP3utQMyNxBK_syjRLNHe8JhK1YabDGA,44455 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1RegularTileIterator.html,sha256=0dfp4svyyokK3aZBTWjJmsvo-qeTIUD4UakUt_gjIJI,5369 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1RegularTileIterator2dThreadTile.html,sha256=9l9geUsxrQWogUCuJKGpRMG5FivB60IMSXOVj4pbcaU,5527 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1RegularTileIterator2dThreadTile_3_01Shape___00_01Ele654c8f6161ae5340f040397a4e2e045c.html,sha256=5KP0HMzAxUYE5n-cWQ6H8t9QVB4yawh1UY6UiWUMpaY,60071 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1RegularTileIterator2dThreadTile_3_01Shape___00_01Ele735fe47e284db3d2e21eb1518e7154ee.html,sha256=XgqJ5kWyQTKo606SiLIgyDnVtWu47TaQtqfq9y09s3g,20216 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1RegularTileIterator2dThreadTile_3_01Shape___00_01Ele76ed82829532ae1c17f4c78158f036c7.html,sha256=AonPim5cdZtakPhZZaEEBZLbEtSRSQsb38XANhWGrWQ,55453 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1RegularTileIterator2dThreadTile_3_01Shape___00_01Elead389e8a36933949f1d1980ebbf28757.html,sha256=QvLFPX-hlh6TuyUYmILPW6PKSOkLwuNa7FQKEvQ-Zic,22035 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1RegularTileIterator2dThreadTile_3_01Shape___00_01Eleb60d066756d1c18f05fceee6a27bdb8a.html,sha256=cPi3Z1yy7zv9co62LJNFi-b8JgqZYkqoC-vIIJSUsNc,61968 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1RegularTileIterator2dThreadTile_3_01Shape___00_01Elecdd8cf264ca413a002d04e558552ed0e.html,sha256=LTKbBN2je6jVAu0EtpUmLCA9Ys8jDh-GT-hX7MqPgjU,21311 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1RegularTileIterator_3_01Shape___00_01Element___00_0104ad31bd559a88cc418ae1cab7492ed5.html,sha256=0pg6CSIdI-NUfTAMKo_0qB-26AUvHVBiuSBD_kquFZ4,54011 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1RegularTileIterator_3_01Shape___00_01Element___00_010889a732373c350de9b9a9f6c13cd761.html,sha256=hA0bdFaiO6z5kUMH4rUbLr2GDjJrCyuc4NVx9JjgTo4,56042 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1RegularTileIterator_3_01Shape___00_01Element___00_01187f8574e1fe9d7d5e8fbf09bd834bf0.html,sha256=cHkrE7WjuLZpmci9qIsG3MecuZxUQ1cijhIX-J2dfc8,54176 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1RegularTileIterator_3_01Shape___00_01Element___00_011d3637dbd8bc58bcb020b51bf57fbfc0.html,sha256=S9ME8JvKnKqvpumzjl22yi3VDonuR1KqvjL8e1LpKOg,57890 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1RegularTileIterator_3_01Shape___00_01Element___00_012f9d4bd842629f7d675732247bcc1357.html,sha256=bwwXvaX-7gLppnSqp-fUrIQt8I3HnAC5p_p50LKiSnk,19651 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1RegularTileIterator_3_01Shape___00_01Element___00_01330cb2d847cdbf495059d201f3e0ee3a.html,sha256=24iExoqVPUkvqIpSPHgyhy7oINJ2tQ_pUeVPLwOQhD8,20450 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1RegularTileIterator_3_01Shape___00_01Element___00_01362d1c9ae17630d1c17a1615e68afa80.html,sha256=Oi8mrRcNeDbd56wbRl0FhuIo6oXjFt3o8p-9A-p6n30,20282 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1RegularTileIterator_3_01Shape___00_01Element___00_013a5ea9a174fff627cdcbd801f51281b7.html,sha256=SfAY-8Jt7HCpm6iVjMUwZgjH0I5x7KctRfz8GonNu6o,20642 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1RegularTileIterator_3_01Shape___00_01Element___00_013cae8c66b6ce08eb63e9fb0780f3a8c8.html,sha256=Cea9agOyq55uS2tw-a0PXRKM-oJhIef5IOwbTA0g8z4,20738 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1RegularTileIterator_3_01Shape___00_01Element___00_0149454d361ea5885cf5166a920b5145df.html,sha256=KbvqfE-qJVArHraHM7GBArexzZdJBj7EZukZSN2qUxI,58117 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1RegularTileIterator_3_01Shape___00_01Element___00_01642d01eef37fa16be616cb8f5b8097a3.html,sha256=3rem3yKZqIx9sL-uX6dPE8Co70dmtOTAweiNK5gwgN4,19720 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1RegularTileIterator_3_01Shape___00_01Element___00_016648f777c9d2dbab1ef78c666fcf74b4.html,sha256=D-bCFNfb0oiGCze69OEi3s49inMYbmgxr9-5f5Skqkk,19243 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1RegularTileIterator_3_01Shape___00_01Element___00_01793f74bfd8f116a827948ab01a37349a.html,sha256=-EqJuvho53-nOVwsiHSJayKsj0MRfmNcy_uPSsY6E1c,54040 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1RegularTileIterator_3_01Shape___00_01Element___00_017982f81d4ef592e19c8427de2ea933a3.html,sha256=yIz-GMIPalCsKnht3slUeVmE82hT1Dj6wKYoTbv3xUs,56921 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1RegularTileIterator_3_01Shape___00_01Element___00_0184a89653916f5d51ab59d1b386989a17.html,sha256=p0SEgWUINNyh67Kh4o0S7Wzbuy4dMW_QmVJ0axmI3Cg,54391 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1RegularTileIterator_3_01Shape___00_01Element___00_018b93ffa09fd2e459d73524c0d12a4837.html,sha256=w7w0ofW1JvHb0sg_ooYKgTcXHgVEqUxdIkvJXnmJLy0,20906 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1RegularTileIterator_3_01Shape___00_01Element___00_018d66e3d8188cb0463f1545f89b58769b.html,sha256=iOVn0AoUXnfun3A0PPLeACCax4ScY3xCvBXQxr5JWt4,20546 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1RegularTileIterator_3_01Shape___00_01Element___00_019159d0ec80fd88e0f6c4de44978da1ad.html,sha256=w5Yxq7Yn9oZiesSkswhC1dfKrDLbyByK6jOIZ6Vj1o0,19864 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1RegularTileIterator_3_01Shape___00_01Element___00_0197fef2242a3454a7d1cebe61aee28b43.html,sha256=u5TJUgp6ey_VjeYfQN1637NJAWVTTl7nkNro5gugQUc,56804 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1RegularTileIterator_3_01Shape___00_01Element___00_019ee1429da69883e567d375e27490e28e.html,sha256=MeZGUzzl-n1Wrm23dzQQ1D7nigBKJGG_fUiDG5KSv5U,19628 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1RegularTileIterator_3_01Shape___00_01Element___00_01a31b454d9c930525c1e9ca406a514f40.html,sha256=OPpMIipIU5J9YwATQFns80miQ9IAdxXiHNamlDpv_i0,55871 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1RegularTileIterator_3_01Shape___00_01Element___00_01a75d2cd74e722d6ad6a3b41aabfd432d.html,sha256=oS-2g7G1OSXPfFuacodJsAlU6GQ8eXwASE0I9Ot_IFk,50868 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1RegularTileIterator_3_01Shape___00_01Element___00_01afef766ff169b7e3893ce73e5a54c7d8.html,sha256=ZQ-bkDAGthOkriLE2hFu_in6R9wM8oMKZsm3oqS-1cI,20474 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1RegularTileIterator_3_01Shape___00_01Element___00_01b3fa5720e807697de61b9f937b269cd0.html,sha256=9bWH5SRPmhMS8Jr8t-CfyHQUYNOvQBNBLBjk0QjQomw,56033 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1RegularTileIterator_3_01Shape___00_01Element___00_01ba3cdd330cbe23d59be67495b2e75efb.html,sha256=v8JxpXIOYpNm_ltCDziiG0oI5m0ZudBNu3XukHtgWmA,20834 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1RegularTileIterator_3_01Shape___00_01Element___00_01bc13f671a1c59ed6f2172925532cd35e.html,sha256=FSfVre-lxA9kNH5kviO0Ya53MT4IrwdZCcSwlHJLB6A,19697 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1RegularTileIterator_3_01Shape___00_01Element___00_01bc82bbd3b6983e0c6f0ae466d180afcc.html,sha256=zy9kbJJsGMH0NQ5n2BgB9M130JkhduaXhYdAxsHuo4Q,20369 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1RegularTileIterator_3_01Shape___00_01Element___00_01bd31b3810c1fedf2e7e5959ff92b5d3d.html,sha256=IhrB39T92gD6uWbn5NbOAQSSDjGBr8cideoxBDVse9U,54507 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1RegularTileIterator_3_01Shape___00_01Element___00_01c20d35180520077a5a09b1e33543c1a5.html,sha256=kyDDd3p_fdTCvAQKxWMPuesNaYopP6qaIgSrOG9Uw0Y,56750 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1RegularTileIterator_3_01Shape___00_01Element___00_01d4483ed08587e929d7b0c6a8962d4447.html,sha256=fVoWD_JgvX4ovgPbceHHrCJEGPYXBPQeGSI1td0v5bQ,20019 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1RegularTileIterator_3_01Shape___00_01Element___00_01d997c3a11a0d7dc37d7d50feed0cfc16.html,sha256=EXkFi0cyCwjxkPQ1BnwD6yrKHpjYtTozBGQTLt1fYHk,18781 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1RegularTileIterator_3_01Shape___00_01Element___00_01dbd6b8468d5bd787308d2f615a24d123.html,sha256=3c1-AiIJ8ai01z-Gn5_8oai3dCnMM8KEkr-_vWKQV-8,51543 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1RegularTileIterator_3_01Shape___00_01Element___00_01e0fd04345128a28d88cb94a28a569400.html,sha256=H_QXYB1c9EKZnKxB7WmymrZewrnGCOYNuf0i6QnFDLQ,18803 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1RegularTileIterator_3_01Shape___00_01Element___00_01efd5013a2503d6567e2bf6b40c97360c.html,sha256=k5FMJQtttPvMEk8M4-uTvZEMIVKa0Q4UZdd2usJUAU0,57266 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1RegularTileIterator_3_01Shape___00_01Element___00_01f6f6511b5033cad31083644ac69c54d8.html,sha256=2EJ9iPgLRRBTcMM8e98XPtVcjidKqMmLVcz-h4zdAbo,53953 +bitblas/3rdparty/cutlass/docs/classcutlass_1_1transform_1_1threadblock_1_1RegularTileIterator_3_01Shape___00_01Element___00_01f96bbeb63e6d4ce4a2551279de3a9f0e.html,sha256=eND1PQd-DR9N5uEQJaBk2KerUWVFbh7-zBWO2dxd72Y,50816 +bitblas/3rdparty/cutlass/docs/classes.html,sha256=KAk30FS8EmQIP8rRUTez5dFlNSYi8MHwzdUx8pFjotE,231785 +bitblas/3rdparty/cutlass/docs/closed.png,sha256=KrbE--vctsqRsEARPr5Y8RaU4GD-Dg1clnQ3xdVy4_o,133 +bitblas/3rdparty/cutlass/docs/command__line_8h.html,sha256=9owobJQkTioPP1TfJyJa17HuouMd6eW2cseAQfeF6VI,6586 +bitblas/3rdparty/cutlass/docs/command__line_8h__incl.md5,sha256=24wNI4WYh3qMlpSFz9-cpjKS8SZWp6NBdYZatJgdBaU,32 +bitblas/3rdparty/cutlass/docs/command__line_8h_source.html,sha256=1WMvu6aex9Yw4_2G-18cKvTaEOcXZm4VIXvDmK-QOyk,50269 +bitblas/3rdparty/cutlass/docs/complex_8h.html,sha256=qYTNFQFXIBWrvpTWh_2nhk4oo1Di64jUpJtF35BcQbU,35524 +bitblas/3rdparty/cutlass/docs/complex_8h__dep__incl.md5,sha256=pJUukeRDJ5gmLKcpfmeXrYOG9cSKt7Qh5nWf2FBmPUw,32 +bitblas/3rdparty/cutlass/docs/complex_8h__incl.md5,sha256=A07zl7N1R--QZzqsBHjM3sTuE1lkC399wNU4plVruzg,32 +bitblas/3rdparty/cutlass/docs/complex_8h_source.html,sha256=vK6JgerW1ahDIDswjifgdQ-jhrYSZlNZtujhyNS9mXA,101652 +bitblas/3rdparty/cutlass/docs/conversion__op_8h.html,sha256=gA5sLOp-y3413MCyZLwlDcqAj--4KV6HnbN7Vw4C37I,8473 +bitblas/3rdparty/cutlass/docs/conversion__op_8h__dep__incl.md5,sha256=5tYnJKRhNjpmPyZ3qrKoDsmZYS3nailAbN_F-RP3AhY,32 +bitblas/3rdparty/cutlass/docs/conversion__op_8h__incl.md5,sha256=fai6gtmush__WAnaU-KU562EIYsrvqYNrEefwtUnTDA,32 +bitblas/3rdparty/cutlass/docs/conversion__op_8h_source.html,sha256=Je-xfzjX0VY8KLHy_TwkxXJUUSwaHzQEpGvPpxUzlrU,33822 +bitblas/3rdparty/cutlass/docs/coord_8h.html,sha256=6B4ZhUQ8uws8HtcjbaoY-4KN3JDXQ_9-x-WmlBFwIX4,11613 +bitblas/3rdparty/cutlass/docs/coord_8h__dep__incl.md5,sha256=CVdbYv1P1NodCqmSyqDAJaGDXqyN2wLIr7RePsednA4,32 +bitblas/3rdparty/cutlass/docs/coord_8h__incl.md5,sha256=xj2IGRiWHc3fF4jwj4KvR7zfpMuyBtxobk9WdJnNSP4,32 +bitblas/3rdparty/cutlass/docs/coord_8h_source.html,sha256=hwSUmRqL5tX1SFKocb7cHxz6KfdTA4nwFD6MaHU88zc,85855 +bitblas/3rdparty/cutlass/docs/core__io_8h.html,sha256=a_6KqL4t1csN8nQF7j3W0CpqJN9L4eAteq-wZJ2GiUA,11050 +bitblas/3rdparty/cutlass/docs/core__io_8h__dep__incl.md5,sha256=hRHOL-jVVwC45uQPKDNNCpt1c4W5WC42vsNp5TBZ8SM,32 +bitblas/3rdparty/cutlass/docs/core__io_8h__incl.md5,sha256=NUN2UN4zIRATiG3dVHlfqThEA7cEPanoYUks0UOC40Y,32 +bitblas/3rdparty/cutlass/docs/core__io_8h_source.html,sha256=MgrA54ZlLDLzrzmxefFE6r1vCwKx0nkzhSFeG46vo0Y,21594 +bitblas/3rdparty/cutlass/docs/cutlass-logo-small.png,sha256=MjUthiTOUyUBdC7YA5cgq-_6fD8wHBDfK7nAynmIPTY,1488 +bitblas/3rdparty/cutlass/docs/cutlass_8h.html,sha256=9fWtov-BrHzyQ43xWQwU54uO0EXC8iiB7x-3siBrDIk,11694 +bitblas/3rdparty/cutlass/docs/cutlass_8h_source.html,sha256=fK1GVyTpSVVr8wWznUH9sIqir8h7K6YSnwaCgoXMRfc,28876 +bitblas/3rdparty/cutlass/docs/default__epilogue__complex__tensor__op_8h.html,sha256=XglTakHwBBmwDyY_zyDcjjQX4yAyZdLDtT5d490C2rg,9802 +bitblas/3rdparty/cutlass/docs/default__epilogue__complex__tensor__op_8h__incl.md5,sha256=o-BDmTmz8t8l6pPaqiw18iIg03Hylz3oYL7g5PG2gxs,32 +bitblas/3rdparty/cutlass/docs/default__epilogue__complex__tensor__op_8h_source.html,sha256=ReARWv4ZnHMGQgqavAA9NBVbElz2S1uaAKU23i09YcE,44908 +bitblas/3rdparty/cutlass/docs/default__epilogue__simt_8h.html,sha256=KuzLBjHdPynFhstStjfaSqSP6OWj4hBZoCg9OvxcErU,9958 +bitblas/3rdparty/cutlass/docs/default__epilogue__simt_8h__dep__incl.md5,sha256=_tuJJsDWbdw3XDuudqwJb5C1DbxSUKuy9nqB3ug5Oqk,32 +bitblas/3rdparty/cutlass/docs/default__epilogue__simt_8h__incl.md5,sha256=fQfOmOYUOOHxS8vzCABb0XBZOAiFS6LasYbdFK8ALzs,32 +bitblas/3rdparty/cutlass/docs/default__epilogue__simt_8h_source.html,sha256=gc6hag_bRBvJHzKvFK29nuoDDBVYXcNADvTzBjipfy8,43811 +bitblas/3rdparty/cutlass/docs/default__epilogue__tensor__op_8h.html,sha256=sUokk1yTrKKetPr1MgloUjU4P8Rnw18ngBGYSbJbz2s,10758 +bitblas/3rdparty/cutlass/docs/default__epilogue__tensor__op_8h__dep__incl.md5,sha256=yTssX1_bNlUny2bKopohrbZJ0Kre2FVKPPTo_oxk6n8,32 +bitblas/3rdparty/cutlass/docs/default__epilogue__tensor__op_8h__incl.md5,sha256=amHtsMQhZwGzB7AEJ8VZjv-xmU2vh8pH5y9OJCDmqy8,32 +bitblas/3rdparty/cutlass/docs/default__epilogue__tensor__op_8h_source.html,sha256=OZCL-1ZC7o2Xl8gbEwB6TzL3HMQmwwrA5DdEiF3Nvzc,62606 +bitblas/3rdparty/cutlass/docs/default__epilogue__volta__tensor__op_8h.html,sha256=eN_DaWKKZvzCvYTNYJpLpXn052yx1Va0eEkgQNXThDs,10241 +bitblas/3rdparty/cutlass/docs/default__epilogue__volta__tensor__op_8h__dep__incl.md5,sha256=0I6Obp1M2Drqch9Yppm3iaVmTs7Carg2o5wVGD8cEfs,32 +bitblas/3rdparty/cutlass/docs/default__epilogue__volta__tensor__op_8h__incl.md5,sha256=NKYrmUQ_ZPDRj2RKZe68aWef5Iyj0VamnkTfZ1sUkFo,32 +bitblas/3rdparty/cutlass/docs/default__epilogue__volta__tensor__op_8h_source.html,sha256=6XDzNXIie2I-9uHZF58l9EXue4bCG1cSu0131s73HFY,48119 +bitblas/3rdparty/cutlass/docs/default__epilogue__wmma__tensor__op_8h.html,sha256=OHChG0nbQGEsMocUXq0sF2MC_VMHzoyxwg8i9yA44yo,9782 +bitblas/3rdparty/cutlass/docs/default__epilogue__wmma__tensor__op_8h__incl.md5,sha256=QWPfnT64GQQ45xaKMmZt-0LilUPlafRSekTmhf1EBPU,32 +bitblas/3rdparty/cutlass/docs/default__epilogue__wmma__tensor__op_8h_source.html,sha256=vgfJ3sG4K6CiuaB1pE_uCPya2whtUKWV4Ms0WVhoTQI,45431 +bitblas/3rdparty/cutlass/docs/default__gemm_8h.html,sha256=IS-10uc61555JJCQxI4K7mhOUXNNQy8cXB46l-wcmpk,15546 +bitblas/3rdparty/cutlass/docs/default__gemm_8h__dep__incl.md5,sha256=cY6kk7bE_5x3KOfCLLndn94H9EBn3vChwGLeJXlmGCw,32 +bitblas/3rdparty/cutlass/docs/default__gemm_8h__incl.md5,sha256=QY3N6Z-EzHUFuHFYM-UKoFHmrGeEGTYltdLInd3QgnY,32 +bitblas/3rdparty/cutlass/docs/default__gemm_8h_source.html,sha256=WttXz6lv50zVEtNVzut9gbOSm-TJc6-vHxNzBB2rJXg,101726 +bitblas/3rdparty/cutlass/docs/default__gemm__configuration_8h.html,sha256=xEx7cbLy8A_HCkmck5dlBuLpqrByu1kVziKscV1peZo,15010 +bitblas/3rdparty/cutlass/docs/default__gemm__configuration_8h__dep__incl.md5,sha256=HdnZbB8Q7TNp8TPsqBhdy8SmpVuPxIbIh4k_oV8U-kE,32 +bitblas/3rdparty/cutlass/docs/default__gemm__configuration_8h__incl.md5,sha256=8sUO2wNkuDQ585KLGidYi7GVQK2tio3viAAdke0IeSw,32 +bitblas/3rdparty/cutlass/docs/default__gemm__configuration_8h_source.html,sha256=_MEwJSE5vGqcGdihXAM_05B6_EBKM1FHkb5UrFqICz0,110586 +bitblas/3rdparty/cutlass/docs/default__gemm__splitk__parallel_8h.html,sha256=OPrEndHT-kh2OfCwvMe_HZSo5ZWuBiLzyzqwnVm1l24,8500 +bitblas/3rdparty/cutlass/docs/default__gemm__splitk__parallel_8h__dep__incl.md5,sha256=hdx1CnLy1uqn8HAGew6bVXZIQ71x61G0PmkJbrafH8Q,32 +bitblas/3rdparty/cutlass/docs/default__gemm__splitk__parallel_8h__incl.md5,sha256=rPcwTEWZG_nirDZynXacdXgb1I_kECXluuv19HoTZJQ,32 +bitblas/3rdparty/cutlass/docs/default__gemm__splitk__parallel_8h_source.html,sha256=jS_iJivemm8jRj5x_n3DVxZOo_kte19P1rDVjNY0ug0,21706 +bitblas/3rdparty/cutlass/docs/default__gemv_8h.html,sha256=SlJY51pHlbIZcBiHVbrDMg7l6-M4Kucvtu5xZfF_ATk,7283 +bitblas/3rdparty/cutlass/docs/default__gemv_8h__incl.md5,sha256=KlbfrNS-hwpqho3GnIWGm5X5RIFWjfbDhIRUP9MkhJY,32 +bitblas/3rdparty/cutlass/docs/default__gemv_8h_source.html,sha256=JyS0PxGpsdxyLxYcVk5kE528al09aWBQEy0puZ10J0U,39381 +bitblas/3rdparty/cutlass/docs/default__gemv__core_8h.html,sha256=PyHAHd6SFXTTVAKFWvcd1cBCt0zbAZIofB2T-CJbqRY,9077 +bitblas/3rdparty/cutlass/docs/default__gemv__core_8h__dep__incl.md5,sha256=U_DzPBwWFdpzwxigQDI74fc1hdWHj3JX01ASfsLVOQ0,32 +bitblas/3rdparty/cutlass/docs/default__gemv__core_8h__incl.md5,sha256=-sZy_xxg0pRlA3lN2NcLuQURg3Sba3Barf8JEGh2c70,32 +bitblas/3rdparty/cutlass/docs/default__gemv__core_8h_source.html,sha256=k7ZRgnJCVn8fukTu3xPV-Hc8V7JW4c3Xb7zjiD5wMyc,47921 +bitblas/3rdparty/cutlass/docs/default__mma_8h.html,sha256=yzCG7Ujbeptfpqs13PqTwcHplcmg0iYgZqYdIW31vRA,12026 +bitblas/3rdparty/cutlass/docs/default__mma_8h__dep__incl.md5,sha256=59hQOjfJ-YluW8e8IPS0mhwkHbMF7lLCDcVjrGFS-OM,32 +bitblas/3rdparty/cutlass/docs/default__mma_8h__incl.md5,sha256=X4wlnSTIGp1Vya_CSTyoozhwrlSRBwK3SoIIAFqUyWM,32 +bitblas/3rdparty/cutlass/docs/default__mma_8h_source.html,sha256=ZVwkyTIHbDyN3KRIIQ2ZjXPcBeVpZu4Ytw3zPiKPEuU,82015 +bitblas/3rdparty/cutlass/docs/default__mma__core_8h.html,sha256=ndg9lfhL5a1kZUGxeOrhG0WdHv8SS83KL1U1H4Kl1_I,8576 +bitblas/3rdparty/cutlass/docs/default__mma__core_8h__dep__incl.md5,sha256=K3RRQbYiaevs5XlZ0FUNzoNUmmYiowOenXjXLCKlkeQ,32 +bitblas/3rdparty/cutlass/docs/default__mma__core_8h__incl.md5,sha256=qhGE3avwmsfsZB6DuWXJgcuGWIEemVOpE04O7ktyhIg,32 +bitblas/3rdparty/cutlass/docs/default__mma__core_8h_source.html,sha256=cUlQwMVuj5cQ7yE5cZcoweUyBEgIDPjtAQS99ExWsSk,18727 +bitblas/3rdparty/cutlass/docs/default__mma__core__simt_8h.html,sha256=IUD5dheeSTR1mmYi0MAgBlrutHYo7lZJmU4Ysw9jjLI,16524 +bitblas/3rdparty/cutlass/docs/default__mma__core__simt_8h__dep__incl.md5,sha256=kZm5_9M25iwgHnvgEntk3OuecicRiyWaevJBsYVPodo,32 +bitblas/3rdparty/cutlass/docs/default__mma__core__simt_8h__incl.md5,sha256=34fjhrqWGDC00PsqZ4K_K1IvkKqkowPYy4N1Vy0nQNE,32 +bitblas/3rdparty/cutlass/docs/default__mma__core__simt_8h_source.html,sha256=YGXXODknb2DI9DNh8eRui1cCk2YJHWiWSWFWcmGXmyU,325484 +bitblas/3rdparty/cutlass/docs/default__mma__core__sm50_8h.html,sha256=5WCX-zdAem9gsinN5xIfU3hpFdte9CesDCed5mp20dM,8637 +bitblas/3rdparty/cutlass/docs/default__mma__core__sm50_8h__incl.md5,sha256=57G75pMh4qviWVzFxBuM2JW12ZgOnxOjgWphpVFUJSg,32 +bitblas/3rdparty/cutlass/docs/default__mma__core__sm50_8h_source.html,sha256=UHkN7c7AsXtNpdwptzowhdVkJHTZ042ZES_OUZqRDmk,51464 +bitblas/3rdparty/cutlass/docs/default__mma__core__sm70_8h.html,sha256=FwnnzP1CKqFvI4D-U1UtVW93BfGCh15hFEHHfzsGR14,10907 +bitblas/3rdparty/cutlass/docs/default__mma__core__sm70_8h__dep__incl.md5,sha256=qWJ_zCI3Vg4VlE4zi1oDnsQX9JTVqpmP13cNX0nZSOU,32 +bitblas/3rdparty/cutlass/docs/default__mma__core__sm70_8h__incl.md5,sha256=Me7Nq6OCigyNuHwnq7QeKbHE-ks0dKY5ctaaRdvDZ0A,32 +bitblas/3rdparty/cutlass/docs/default__mma__core__sm70_8h_source.html,sha256=OyuekLD2_xC8N-eemP2S77INmqCWZ-cRQeDpnV5VXQI,158935 +bitblas/3rdparty/cutlass/docs/default__mma__core__sm75_8h.html,sha256=AC3QAy4XqjObtiZ0HZyJh-W9vzGggp6A7rNo-ql6qaE,11659 +bitblas/3rdparty/cutlass/docs/default__mma__core__sm75_8h__dep__incl.md5,sha256=9YkcEaek0GRIDJdxyKKXDYiwb15TILrmFsphyNQnlSs,32 +bitblas/3rdparty/cutlass/docs/default__mma__core__sm75_8h__incl.md5,sha256=JHyj4qs8Tmhh1A3LJVbYf0chnMf6Atv1i3juHadjVvY,32 +bitblas/3rdparty/cutlass/docs/default__mma__core__sm75_8h_source.html,sha256=6MNuRYEqmu79wo8OFZhwGfEtDbuEGvx5mQcXdCjlCtw,200230 +bitblas/3rdparty/cutlass/docs/default__mma__core__wmma_8h.html,sha256=6i0RNv_0hHz3FncnfknbW1GK5NLr7A_s7FvG2fEjzjY,5987 +bitblas/3rdparty/cutlass/docs/default__mma__core__wmma_8h__incl.md5,sha256=Ezgph0qmrE8W-i0KzOmRNLYaZiDbAXP6yCXAxZh1IDQ,32 +bitblas/3rdparty/cutlass/docs/default__mma__core__wmma_8h_source.html,sha256=kehuaLAbmEcsbJ2tWVU9-cQMvbZH3CHSE1vypIr_Ci4,87624 +bitblas/3rdparty/cutlass/docs/default__mma__tensor__op_8h.html,sha256=ELBFI3rtYiKeSU19NdjaSMhWg0-q8-9hkM2nCD0JqtE,8672 +bitblas/3rdparty/cutlass/docs/default__mma__tensor__op_8h__dep__incl.md5,sha256=NoKxRO0mqWET1-1iMTL-ebe8A9w6PxF7LMzvmRVdmwE,32 +bitblas/3rdparty/cutlass/docs/default__mma__tensor__op_8h__incl.md5,sha256=FmRn8yDemzKX9w_obLG9KCju1rmurGVUfkoZX05rcIg,32 +bitblas/3rdparty/cutlass/docs/default__mma__tensor__op_8h_source.html,sha256=0zX0uToz3ligMBPY-iHcTxpo9cmAo6hom6mh9enBQUM,21707 +bitblas/3rdparty/cutlass/docs/default__mma__wmma__tensor__op_8h.html,sha256=Hz5XtVEshN8AJOLOFKrOPoxmWKO30IXTNR9xXV87Q9I,5423 +bitblas/3rdparty/cutlass/docs/default__mma__wmma__tensor__op_8h__incl.md5,sha256=crgV6Y1togenTm_0y-Vmov9o8tmBpsRhSGg_hOIkKk8,32 +bitblas/3rdparty/cutlass/docs/default__mma__wmma__tensor__op_8h_source.html,sha256=P2kpW-7GHlJTbO4hyw81oEO8kEgVO4gPg_T5hvV3Irs,20149 +bitblas/3rdparty/cutlass/docs/default__thread__map__simt_8h.html,sha256=CMJWUDCwV4BruyRZk1aZtJXJhaiK2IWBm_FXvJ_W5BQ,8426 +bitblas/3rdparty/cutlass/docs/default__thread__map__simt_8h__dep__incl.md5,sha256=LFO7LxsVfkRHsW0YveWVeoomxnzwOZ1ZNm2NY7D1OzE,32 +bitblas/3rdparty/cutlass/docs/default__thread__map__simt_8h__incl.md5,sha256=NgNB00-tXqKXvmUsCbGhuDKsmEPYhY_7s9WZRY-0YJA,32 +bitblas/3rdparty/cutlass/docs/default__thread__map__simt_8h_source.html,sha256=BXEm_A21VQESuu4Zdz7kW2meBsqQF7dlSemeWrwAcEQ,33619 +bitblas/3rdparty/cutlass/docs/default__thread__map__tensor__op_8h.html,sha256=EX7XK4xvdrXiBPD5hYZZLMc-pe-8srhupoVUu9dXlqQ,9885 +bitblas/3rdparty/cutlass/docs/default__thread__map__tensor__op_8h__dep__incl.md5,sha256=OW6Y5kCGREIQDtfuSNknM1SPK5US-qgPzszGde5mG-g,32 +bitblas/3rdparty/cutlass/docs/default__thread__map__tensor__op_8h__incl.md5,sha256=ztuz_MjkENGA8EMSFKcbvwbyCYQem7PghYpvSrhWU_4,32 +bitblas/3rdparty/cutlass/docs/default__thread__map__tensor__op_8h_source.html,sha256=xwHEYYSEJYlk8CZYfvckg5oZbmsviGyObKI9i8JhvFE,43396 +bitblas/3rdparty/cutlass/docs/default__thread__map__volta__tensor__op_8h.html,sha256=cCjxvAAU6n6o9bjsByea9UlqVySCvww_3tUyYXl9Pmk,10929 +bitblas/3rdparty/cutlass/docs/default__thread__map__volta__tensor__op_8h__dep__incl.md5,sha256=fQxeE2vpLkasnJSL63NHfn0XGTYscx3y8JXKd99L0Fs,32 +bitblas/3rdparty/cutlass/docs/default__thread__map__volta__tensor__op_8h__incl.md5,sha256=glAAW9uZwot5fWrM36Ce5QdR4mdtVc0zOPDyJ2Ohlts,32 +bitblas/3rdparty/cutlass/docs/default__thread__map__volta__tensor__op_8h_source.html,sha256=rJ7j_oej7-5ZyoNYVbe9iETj4Rj5eVLkYP2CeW9gRl0,46724 +bitblas/3rdparty/cutlass/docs/default__thread__map__wmma__tensor__op_8h.html,sha256=et0IANJB8dmM6Chigk0kAl8Dd6ggppZzzY6_3gO94sE,8743 +bitblas/3rdparty/cutlass/docs/default__thread__map__wmma__tensor__op_8h__dep__incl.md5,sha256=hK3t_O-QF7KKYrDr83_8qvi7YHs2qWMqgQSPJ_CXhfY,32 +bitblas/3rdparty/cutlass/docs/default__thread__map__wmma__tensor__op_8h__incl.md5,sha256=9FasRYbFDmVwRq-9uxQvhBqrMD3ZXLLep86EMWTza1Y,32 +bitblas/3rdparty/cutlass/docs/default__thread__map__wmma__tensor__op_8h_source.html,sha256=BlAMZUsTJmsUmX8qpXM22pg84LyrXwOTsyCaruhztyw,31730 +bitblas/3rdparty/cutlass/docs/device_2gemm__batched_8h.html,sha256=YIz6p-Qnpp-Mob0xtCVqOp4KhaWhqJkI47LKs9to3P4,10962 +bitblas/3rdparty/cutlass/docs/device_2gemm__batched_8h__incl.md5,sha256=0vSGXq6cs1BUkuCyokM31LrC_gwut6Uw_RaxY2i7EZc,32 +bitblas/3rdparty/cutlass/docs/device_2gemm__batched_8h_source.html,sha256=6-_s5eOizzGwMK_PIF8rcaAT_Z2uWvi9_WBlrXsHksU,184654 +bitblas/3rdparty/cutlass/docs/device_2gemm__splitk__parallel_8h.html,sha256=LKwNZPP_X04DwvA0nj6anq8q3E2F3L71Mm6HfPt6q5E,11632 +bitblas/3rdparty/cutlass/docs/device_2gemm__splitk__parallel_8h__incl.md5,sha256=rrL597bDLzMIELNSdTAy9RDIxoCgtIKL-ATQnwLR0Fg,32 +bitblas/3rdparty/cutlass/docs/device_2gemm__splitk__parallel_8h_source.html,sha256=hFPbtXB3DwZsxKElvXNOL1Z7p0F1LKHz7_00_iqt76k,174100 +bitblas/3rdparty/cutlass/docs/device_2kernel_2tensor__elementwise_8h.html,sha256=z7Tmg1ajyNEGGFoeNNBrblw06NFWQDf3JoIkBkND9yo,11425 +bitblas/3rdparty/cutlass/docs/device_2kernel_2tensor__elementwise_8h__incl.md5,sha256=ZlnScF7e70ikftSB7_oEcCP2a3euEVStk0NkIfFq9yA,32 +bitblas/3rdparty/cutlass/docs/device_2kernel_2tensor__elementwise_8h_source.html,sha256=B6OH3sJ5FLC9_vQT5FuVPtpbCg5RH2wECP4WulS7J5o,33406 +bitblas/3rdparty/cutlass/docs/device_2kernel_2tensor__foreach_8h.html,sha256=XqX1nS33Ze_f9UTBXk09XLMZrXWh1dCbIzDsVlmbCzU,12693 +bitblas/3rdparty/cutlass/docs/device_2kernel_2tensor__foreach_8h__dep__incl.md5,sha256=cQaenDvI9mtIXdZfqzLTEU20n-X6d0o9B9FNJGDqOnw,32 +bitblas/3rdparty/cutlass/docs/device_2kernel_2tensor__foreach_8h__incl.md5,sha256=egiZMt32oXEqlXfHqa22OTMGXRasZYg49h8b1nIue7Q,32 +bitblas/3rdparty/cutlass/docs/device_2kernel_2tensor__foreach_8h_source.html,sha256=7zBA068l6D9u6cAbvM8PC6whquwnm2R4Ou9uckZLnAA,31396 +bitblas/3rdparty/cutlass/docs/device_2tensor__compare_8h.html,sha256=qu9XCqzIpD165Y-Xcnr0kk4xO3kp1w4zdKkWrcca0CQ,11044 +bitblas/3rdparty/cutlass/docs/device_2tensor__compare_8h__incl.md5,sha256=vxaMQ6lm34qs8OJYETzL5_ULGPHO0a2RruqjxhaGjuA,32 +bitblas/3rdparty/cutlass/docs/device_2tensor__compare_8h_source.html,sha256=TZNU8uSFJIbJ3PGQLywTJu_7sHVfA8KeCtFfrem6KpA,38547 +bitblas/3rdparty/cutlass/docs/device_2tensor__fill_8h.html,sha256=TRq9rRR53SDK_i3Z8iP8ZphnRwzjjYKEeH-a2YoSnx8,37269 +bitblas/3rdparty/cutlass/docs/device_2tensor__fill_8h__incl.md5,sha256=vHjb10i4WzZ3lUyLquClchy6ewaZ6ojm180uebazmJ4,32 +bitblas/3rdparty/cutlass/docs/device_2tensor__fill_8h_source.html,sha256=sOiAdb_PszCYDKij27pGcpq_IGaRMGFPQaZmKkvsFAw,273799 +bitblas/3rdparty/cutlass/docs/device_2tensor__foreach_8h.html,sha256=0yascrzMtR9JVk0QiwCMF4SUqAzyVKZ-i35NS8hUra0,9106 +bitblas/3rdparty/cutlass/docs/device_2tensor__foreach_8h__dep__incl.md5,sha256=84TcUoOhb85DmXo93TqRsz-ZY4IufchDxZsES0-8KEE,32 +bitblas/3rdparty/cutlass/docs/device_2tensor__foreach_8h__incl.md5,sha256=C4baqSKmN5ySbTskYLp5PP7iyJaR8aolD-j28jT-aQs,32 +bitblas/3rdparty/cutlass/docs/device_2tensor__foreach_8h_source.html,sha256=6yAsCbpWkgkCRsHm3y4NuEdNQUDtsr2K37x0T3LVlgc,27318 +bitblas/3rdparty/cutlass/docs/device__dump_8h.html,sha256=imcpqnHewK39y1RATg1qVpn23DzHIkV41JXF7a2uNdc,8936 +bitblas/3rdparty/cutlass/docs/device__dump_8h__dep__incl.md5,sha256=pw1hmxXdKusUwPEaMSyYqabQ5Bw1EPghItgBpHoxXAs,32 +bitblas/3rdparty/cutlass/docs/device__dump_8h__incl.md5,sha256=-jjYGE_W_7cZnrDuDqlUDjckFZ_SwaFbVkqUuow6tug,32 +bitblas/3rdparty/cutlass/docs/device__dump_8h_source.html,sha256=5GcagrtZyQoBW2lDyAc5PaIoNIZIB5uVHwxvITm0f-g,31089 +bitblas/3rdparty/cutlass/docs/device__kernel_8h.html,sha256=LRbh9_m62PBwLrjPQdRQAm3Jg7FYxpW0yiEJbIv_YG8,6918 +bitblas/3rdparty/cutlass/docs/device__kernel_8h__dep__incl.md5,sha256=SBatmu9GHGvAUNT09jHct2U8rrSC_zIU6Xhe9jB-JjA,32 +bitblas/3rdparty/cutlass/docs/device__kernel_8h__incl.md5,sha256=Tld2lXNV-noKin62SkuE3guy9XEKZXKQJabkkxQi7E8,32 +bitblas/3rdparty/cutlass/docs/device__kernel_8h_source.html,sha256=dcy9mZlyU2kfMP4ayt4ddlcp3MMeKFqff2pKpnGrvCo,12943 +bitblas/3rdparty/cutlass/docs/device__memory_8h.html,sha256=ZazpIHSzQ0MYDPINWv0v_o3Ti_5X2U2htDqAZU5zgAc,14980 +bitblas/3rdparty/cutlass/docs/device__memory_8h__dep__incl.md5,sha256=IcXBhCpSoLNKpelJOmLAHufABu4Do1jGGNTpaQWeeLk,32 +bitblas/3rdparty/cutlass/docs/device__memory_8h__incl.md5,sha256=abNIRV0kuK0k6w7Yck2J1toBZWx0vabxNkBY7EJas9k,32 +bitblas/3rdparty/cutlass/docs/device__memory_8h_source.html,sha256=StSi90C9--DNpQ2vN35ulN8XOJ2Udg3AK25QB9rzdJM,53490 +bitblas/3rdparty/cutlass/docs/dir_000001_000002.html,sha256=e52eGhzRagsX9W1B-bpqqG3dmJUXfvl85vMblpSZX74,13789 +bitblas/3rdparty/cutlass/docs/dir_000001_000033.html,sha256=BfJuFu4OQP3dzTgC0nvazImEuR2Zfp-rw4lpTCk4sB4,6575 +bitblas/3rdparty/cutlass/docs/dir_000002_000013.html,sha256=AMXxTk8FO9fEVFM5Y5woRp4LT8_X404FXgncLaGtjOI,4811 +bitblas/3rdparty/cutlass/docs/dir_000002_000025.html,sha256=L0JpbIC4UJFo7z_YOg9q7bArtxVOTR5OCXh-hdF1kFU,6115 +bitblas/3rdparty/cutlass/docs/dir_000003_000025.html,sha256=pwT5gS1C8uqhwOhaB0USpUXKl3Feq56ypvt4kvYy7NM,4685 +bitblas/3rdparty/cutlass/docs/dir_000005_000000.html,sha256=Fdxa7N64usBEJKZQeu1jBHYqXrErB47gMGlPkxDHWcE,54933 +bitblas/3rdparty/cutlass/docs/dir_000006_000000.html,sha256=WMgz58dN8PWjwr8pj0oeODbOCryVgpqOoPELSO7yZnc,49130 +bitblas/3rdparty/cutlass/docs/dir_000007_000000.html,sha256=gfDjNguJVWHMT1hpXbu_0POcZyahF8Rvg815J28jy5k,43321 +bitblas/3rdparty/cutlass/docs/dir_000008_000000.html,sha256=FRf4HAMzyox7cOA2sv_ZswOkbC5vf46JRWBqAINPmDg,37704 +bitblas/3rdparty/cutlass/docs/dir_000009_000002.html,sha256=cUbyjE8rImnNjMZYp2D3MYaKrTfWATvsbe0kqCSF4Mc,4669 +bitblas/3rdparty/cutlass/docs/dir_000009_000013.html,sha256=6Ya8Ycc01Ay0ezBiPtutvoil1SvaZflYgig23PL4NCA,9506 +bitblas/3rdparty/cutlass/docs/dir_000009_000025.html,sha256=oXiZc5IaE17zu4gau546pPDoyRH3m0B0gFonqrvhZu4,12873 +bitblas/3rdparty/cutlass/docs/dir_000009_000032.html,sha256=jv2NdjS4DhhTWBD44OMLWCAljOwzFi9zPdwbUlVKdFo,8809 +bitblas/3rdparty/cutlass/docs/dir_000012_000010.html,sha256=1qBSEihv7vycAaY2Ff6HNajlLOSSgFeg_z9XOcY8tpY,8044 +bitblas/3rdparty/cutlass/docs/dir_000012_000013.html,sha256=H0K44Bk86TONrCQjVt2qwqZRrg75XnXgGnaj6ftXnN0,7765 +bitblas/3rdparty/cutlass/docs/dir_000012_000018.html,sha256=OrqJMp4JIYhuekeZqVNDOS3HRVweFUtqqqDhSD2Wy-s,7141 +bitblas/3rdparty/cutlass/docs/dir_000012_000025.html,sha256=KwebTUNdGaOC3zOj2DeZ2EjP2Baq7v0IfaDRl1aUyos,6784 +bitblas/3rdparty/cutlass/docs/dir_000012_000032.html,sha256=rGlzqMye-bOgJD5agYg4AgQBHhyonydhp7fPQvWjFyk,7929 +bitblas/3rdparty/cutlass/docs/dir_000013_000002.html,sha256=SG_ZRXSDc8m3F0yJBV7_gkcL9nZro7t-SYt0YnS-KiE,10978 +bitblas/3rdparty/cutlass/docs/dir_000013_000003.html,sha256=5InNWR4SFdzVLXF8YWo1A3xK0ZlZvDtPIP_byqAfHgM,5573 +bitblas/3rdparty/cutlass/docs/dir_000013_000009.html,sha256=vcz9jk7CvDL0DE3kOrMjo8I46MOs0zEckge-mj0-GU8,7556 +bitblas/3rdparty/cutlass/docs/dir_000013_000010.html,sha256=7jPWwlThB2uzpXLVCwXV8dWA3pyJgg3Q9mqHwmtxdZI,5648 +bitblas/3rdparty/cutlass/docs/dir_000013_000012.html,sha256=i8AeAGG0l9wBaBMytW_3WTV_jHavS3cg6H-9Om_yNeM,5605 +bitblas/3rdparty/cutlass/docs/dir_000013_000025.html,sha256=ItoD98x0UE1D6t6CSlm8gCVN8prJF1eEreDwoFmOaRs,9406 +bitblas/3rdparty/cutlass/docs/dir_000013_000032.html,sha256=sBbO1MhSdA--7pjD3Pfgh_nYmCR_4MrLQduR-USFXOI,10007 +bitblas/3rdparty/cutlass/docs/dir_000013_000033.html,sha256=-sgwnlyzfOwWj3kNMfL4av1OETdbSuVcTkh-NS-TxVY,5582 +bitblas/3rdparty/cutlass/docs/dir_000014_000002.html,sha256=Ou-g9eCoM3ouBv3oU4NuRyNoQ1nBHBws9Qvj6mzNDzY,4658 +bitblas/3rdparty/cutlass/docs/dir_000014_000009.html,sha256=I-olQ5dIKJL2rVHtUz7PyR5aTw-BVXu47BkHwkDLqvw,6008 +bitblas/3rdparty/cutlass/docs/dir_000014_000016.html,sha256=h8yzkhYx1cRF23L4eCZFL_3bNwn2t6X1PV7wJCsGMxw,6211 +bitblas/3rdparty/cutlass/docs/dir_000014_000025.html,sha256=qyxqUxT_crRDrZaAjreICG1jcNKXX4YGfPx9Zqbx7fY,4683 +bitblas/3rdparty/cutlass/docs/dir_000014_000032.html,sha256=UFlIxpaflge-jeYoBrYiYzDtwY2eg0E-oKxiQbucKEk,4852 +bitblas/3rdparty/cutlass/docs/dir_000015_000002.html,sha256=CYlJZbIZC15ZHRTg0CAu7LGsXi1OSWUn2nUzH6_k7xk,5966 +bitblas/3rdparty/cutlass/docs/dir_000015_000003.html,sha256=l1JGM20Dk4SQnKlV6XX5HfRl6aheGFDgzB2AFq-cV5E,5139 +bitblas/3rdparty/cutlass/docs/dir_000015_000009.html,sha256=_Nx7RquZDMwNxc4zrIn_nFLMQMnXYvo5t0qozvKn6_w,5462 +bitblas/3rdparty/cutlass/docs/dir_000015_000014.html,sha256=pFDdfMPPlnXs9dINKyn3Byy30faLK2XZ5speyQbqvSM,6268 +bitblas/3rdparty/cutlass/docs/dir_000015_000016.html,sha256=3SW2KNxS4Q0KosI1FFAfACjHSAbH4F8hleKCofHHuSI,5633 +bitblas/3rdparty/cutlass/docs/dir_000016_000002.html,sha256=PjMABaW6udBB0HjvNOs6m1wC54PlNJcbShdhj06uqDo,5221 +bitblas/3rdparty/cutlass/docs/dir_000016_000017.html,sha256=6UAI5sIA7_c3U8kCKYn9pW4q75pQ1ETfQ5e9poLS2e0,5807 +bitblas/3rdparty/cutlass/docs/dir_000016_000025.html,sha256=jFf_NWjpxmfxRzLyLsrbjNlCk9veKm-tFNdYZbGPLj4,5422 +bitblas/3rdparty/cutlass/docs/dir_000016_000031.html,sha256=YB_gXsjymPfGqcbHjaTM2Mob-FYOCjKy8FSqVeVuuaM,4724 +bitblas/3rdparty/cutlass/docs/dir_000016_000032.html,sha256=MLA6EZ3EKc9Egrud_uhrxSR0zLQoTttzX-z-3sk2_-c,8511 +bitblas/3rdparty/cutlass/docs/dir_000016_000033.html,sha256=5Uo0yjOuc82w7kDC6Y-Mc6__wkhbipS801TVrY-oWfU,4914 +bitblas/3rdparty/cutlass/docs/dir_000017_000002.html,sha256=AF_TzWrfvksdP4Ahgi2iQsoj16jg4wMG6VUW06M7NEE,6320 +bitblas/3rdparty/cutlass/docs/dir_000017_000025.html,sha256=jTZK87z588tD9J83GRhrj4smiPOcUSHupejF7aTBp_s,6374 +bitblas/3rdparty/cutlass/docs/dir_000017_000031.html,sha256=nd7EpylkB03TIv1DpPlOm5wx_saWGex9HVtjLHg51XI,4677 +bitblas/3rdparty/cutlass/docs/dir_000017_000033.html,sha256=au6iZnTmyuiil8bsUmr6JasLN5CAvgHGuh0rCxZMsY8,4932 +bitblas/3rdparty/cutlass/docs/dir_000018_000002.html,sha256=HyB_Lb6SC7qX-bgFX0I2bXx6nvyALNVItJKWiz7Bthc,4678 +bitblas/3rdparty/cutlass/docs/dir_000018_000013.html,sha256=M44W75YNv2T8B8Pzj8NxKzkFsGNNInR1aWUB2D5RFSQ,4992 +bitblas/3rdparty/cutlass/docs/dir_000018_000025.html,sha256=bUg-4fs6UAp2Kxa8wz_SsHUYDd1c380M92HbHo1PUzA,8268 +bitblas/3rdparty/cutlass/docs/dir_000019_000000.html,sha256=aATj3Co3UJ6zVHYY8Ty3p6RolGcvhDbfHbb7B8jWaok,28994 +bitblas/3rdparty/cutlass/docs/dir_000020_000000.html,sha256=LD-OMUgNpxLqlhrlczWFBPUFv2TViYd6dZgfjWJPIi8,14346 +bitblas/3rdparty/cutlass/docs/dir_000020_000021.html,sha256=bvQQ6pKfN2k_mQq2MwqXnfcHIYgUY-mRm6UHdrRhwFo,5467 +bitblas/3rdparty/cutlass/docs/dir_000021_000000.html,sha256=-GUqMAzWupQpdPiXwxwSUVQPbgfV8_pdxWo751DaUdE,7443 +bitblas/3rdparty/cutlass/docs/dir_000021_000022.html,sha256=GJXIBcj10QNpqF_YeDzgZTJbrltXVcoTsZKtYJZSBWU,5340 +bitblas/3rdparty/cutlass/docs/dir_000022_000000.html,sha256=gYOUUiu19-m6MGgHhzeaHq7ALrN_phpmgkweMVH8jPI,6527 +bitblas/3rdparty/cutlass/docs/dir_000023_000000.html,sha256=uSfDA-HXE6hoMvhdUxyjLEqqLenDhaZewMK2GCOYzJc,14400 +bitblas/3rdparty/cutlass/docs/dir_000024_000000.html,sha256=XWNkV18z9sF61qy_pTpsE4zK5JM5YZ0QCq_738PNKaE,5329 +bitblas/3rdparty/cutlass/docs/dir_000026_000000.html,sha256=yXUm-llzckSD4X_G2ZNATLGoU9vNN3DQK1IBG4Na5PI,7095 +bitblas/3rdparty/cutlass/docs/dir_000027_000000.html,sha256=s3KD4wAvKu0HwDAORJNZz9bqAAePzIm2gBsnF7o_12s,6767 +bitblas/3rdparty/cutlass/docs/dir_000028_000000.html,sha256=4W7ihX_-e06_yI-lyI8PTDO2HumE2FJK0v13wBsCNB8,6439 +bitblas/3rdparty/cutlass/docs/dir_000029_000000.html,sha256=EU59Rl9NiyLu0_DSeUMCMMBpOjxdMoa6KJ2xJtNr68M,6111 +bitblas/3rdparty/cutlass/docs/dir_000031_000002.html,sha256=rwN6r0pH2sbty_d41ZkPuNlUz7Y8DqiTUDq4kFwvSs8,4878 +bitblas/3rdparty/cutlass/docs/dir_000031_000003.html,sha256=JrUb94LMNyZB7qc6j8blx_B0T2UZTB7H6aUGRuEuTtU,4781 +bitblas/3rdparty/cutlass/docs/dir_000031_000025.html,sha256=-5NgkcFPGJkobs10fcMz--TR-qMT4CO3jWo8aCO476k,5129 +bitblas/3rdparty/cutlass/docs/dir_000032_000002.html,sha256=nSTuHNRHLWyaohrhgY9-8E7rgUml0RIgZQWajY1Nelc,4735 +bitblas/3rdparty/cutlass/docs/dir_000032_000025.html,sha256=t6VpBzUrLNK4a77cZmMqJN-qwrn5HHI82Q9lQdCAuA0,9476 +bitblas/3rdparty/cutlass/docs/dir_000034_000002.html,sha256=rZkzUGNb58vjIoab6jVM_jIkWyHDKNIYDmuVTGc0VAg,4763 +bitblas/3rdparty/cutlass/docs/dir_000034_000025.html,sha256=zBS0dn13YlL3HP0knUkRBN1F9IjrEfXdym2yAzwQaZI,8103 +bitblas/3rdparty/cutlass/docs/dir_000034_000037.html,sha256=v-fcbgLIaKtx92Lpt1Qd7rCNW_fzh31JPbv8ODGs26s,4766 +bitblas/3rdparty/cutlass/docs/dir_000036_000025.html,sha256=dsKMhT1BtaKlX2upklcYm3Y46lZ0j0mrep7l0lM_Ahs,4698 +bitblas/3rdparty/cutlass/docs/dir_01de8928c960cafb028e5f164701e1de.html,sha256=8yjNMXyVyK7pxAlGpkUM01IWdchqPitcxWPnZ92gOvc,6371 +bitblas/3rdparty/cutlass/docs/dir_01de8928c960cafb028e5f164701e1de_dep.md5,sha256=KeqpJ6g6cQ-gGIdNVk4_YjtMJQ26sOnFGRp41-Xf53g,32 +bitblas/3rdparty/cutlass/docs/dir_048c1df36ab9c2efbb0733edba6291c9.html,sha256=XnCv3NaVkw5GZiG_a6WTfJmaaOjkxh4U21tRp6A2ivw,13121 +bitblas/3rdparty/cutlass/docs/dir_048c1df36ab9c2efbb0733edba6291c9_dep.md5,sha256=A9WW9hxp3H7ZLcQ8fuLrnHm-nNZrFGJ1s3Prj3gme9I,32 +bitblas/3rdparty/cutlass/docs/dir_05a6795d99d74f63b7300fc6eb9e55c2.html,sha256=1_LkRd9qx1fj82ozI9qFw5cj3lVJxldNVs2eXfJgMRc,14393 +bitblas/3rdparty/cutlass/docs/dir_05a6795d99d74f63b7300fc6eb9e55c2_dep.md5,sha256=h07lYWogtvB6v_YCs0OYCH83ZxwRbn3FeESkU0p-8O4,32 +bitblas/3rdparty/cutlass/docs/dir_1315f14109599b6cf6873e0273f5d760.html,sha256=3TCW--hkz6lz_k0hOJz5H8HG4EnpS7KLuJvRJ8EiI3Q,7175 +bitblas/3rdparty/cutlass/docs/dir_1315f14109599b6cf6873e0273f5d760_dep.md5,sha256=oIQ8DTiXBnujJvEj0FV1kBVRKiSu6e7pHNumB-zBwKQ,32 +bitblas/3rdparty/cutlass/docs/dir_2296cf082f2778f9a3503c8ea1010763.html,sha256=GNc5pUzKEDGt_3zn2vqcWKOejEGRUYWCTybQoNZQjZg,8429 +bitblas/3rdparty/cutlass/docs/dir_2296cf082f2778f9a3503c8ea1010763_dep.md5,sha256=0cY37STfJ6EuOeleYd6k9TEZ9PjaJaMKzydYTm66wJw,32 +bitblas/3rdparty/cutlass/docs/dir_36528dc2736efa40b421028b7309c671.html,sha256=9MgLvnEOYuWDq_Haor_qcTBUtXnZTRXUs7_OZyR6Lj8,8255 +bitblas/3rdparty/cutlass/docs/dir_36528dc2736efa40b421028b7309c671_dep.md5,sha256=r-l31NDoyZg4zMQAuXOfcss7cOp7RX3hKjTSbzWQHxs,32 +bitblas/3rdparty/cutlass/docs/dir_4c6a163a0476cba0bed73ec4471f0808.html,sha256=QUpFH9Fsnt0uahhes98rCUROu2htEYOyLi-_XQ-MVzA,6247 +bitblas/3rdparty/cutlass/docs/dir_4c6a163a0476cba0bed73ec4471f0808_dep.md5,sha256=8ei_ybSIyoQVDsPwU0tRspP2wiyuirbu_6fhsInkIXk,32 +bitblas/3rdparty/cutlass/docs/dir_4eeb864c4eec08c7d6b9d3b0352cfdde.html,sha256=1_pTJ2KEw62YS4ZGyWd0xfIDjHldMjBFroRouV4mmb8,5534 +bitblas/3rdparty/cutlass/docs/dir_4eeb864c4eec08c7d6b9d3b0352cfdde_dep.md5,sha256=EAaFT1MThfA3-WDin8z22AOU3etVJYdndfODaLE060c,32 +bitblas/3rdparty/cutlass/docs/dir_5182a53bfc5d70ef5651acc985c58dc3.html,sha256=t4vBeHl0ad5anFeZYeiDvBQCA-eRgOqD8jk39_7PojU,13477 +bitblas/3rdparty/cutlass/docs/dir_5182a53bfc5d70ef5651acc985c58dc3_dep.md5,sha256=Cj-sZIULB1zcDlxxswjOShl6SZMdi7pkG5L5WAjBuok,32 +bitblas/3rdparty/cutlass/docs/dir_568e97a0eb81cc0d3daf98cef30c9135.html,sha256=2iZeYQgY4vVXtm8irQ5H8AKvG9gkwB5UsFGUISd09lo,6476 +bitblas/3rdparty/cutlass/docs/dir_568e97a0eb81cc0d3daf98cef30c9135_dep.md5,sha256=8ZgHbguVCcvydoAL866NNcrvrhANujBXtZfa5fYDstY,32 +bitblas/3rdparty/cutlass/docs/dir_58e788c69476ee3a6457c1bb0aea7b40.html,sha256=j68JVFWrj6aylfx7cg7H2uO0OauNeyCpvcgS_VnCLAg,5312 +bitblas/3rdparty/cutlass/docs/dir_58e788c69476ee3a6457c1bb0aea7b40_dep.md5,sha256=kdBjmLLk5p19PUc-EFaIVlrsV67Vv9S7gW1mx9vFnt4,32 +bitblas/3rdparty/cutlass/docs/dir_5a68e39c181f2defa4dd959f7500739b.html,sha256=MfXhmkxvTpfK2EP-zNWJtBp3YSwfk5qT_GwdZ-iBf1w,13261 +bitblas/3rdparty/cutlass/docs/dir_5a68e39c181f2defa4dd959f7500739b_dep.md5,sha256=pZ4sT_mS0_Vj5cFKyVjtGaIyz_x9cSBJsrJhxdcXCoA,32 +bitblas/3rdparty/cutlass/docs/dir_5e89e81286c01e462f661f26ca186996.html,sha256=zz9C2p3kdgtmqFB9njUDfqFs5NhzW1sBRthSTfHxees,5970 +bitblas/3rdparty/cutlass/docs/dir_5e89e81286c01e462f661f26ca186996_dep.md5,sha256=sPrwoAdVSGyRSnMO0riHR-j7eiFwdftdNo_a7tGzPrs,32 +bitblas/3rdparty/cutlass/docs/dir_6baf2bb612a2f0daa69af3101ede80a1.html,sha256=jhzgIUETPUxZE1AEPHthEAwuKDZAcTzt1d3U0YosTzY,21657 +bitblas/3rdparty/cutlass/docs/dir_6baf2bb612a2f0daa69af3101ede80a1_dep.md5,sha256=ajxswpizBVTonzC4qphW6RR8HjaTGtIQMzkHn60VtjY,32 +bitblas/3rdparty/cutlass/docs/dir_6c0b0ac954bdf2d913b6e24246bcb749.html,sha256=iiRyjdcVpHo-VaaczMsQLRBAATz4iLANVGr4Qwln7S8,5258 +bitblas/3rdparty/cutlass/docs/dir_7a8f757b2dc0884f3cac82bc42925c19.html,sha256=mKxbkLJ3GVSzy0q9LYxsqFoIGBqOin0qh_q0-PaXFqE,5411 +bitblas/3rdparty/cutlass/docs/dir_7a8f757b2dc0884f3cac82bc42925c19_dep.md5,sha256=LvX_dG7ZA-Ja-sLYdpBCICFWMs4bmzEbKu_yLHrhbWw,32 +bitblas/3rdparty/cutlass/docs/dir_7cdbc08f6364188f63879ce58a570796.html,sha256=oRPvSLPrf6jQTykg6TMFzYHWIerS9IALNNZ55Lf5ilw,8045 +bitblas/3rdparty/cutlass/docs/dir_7cdbc08f6364188f63879ce58a570796_dep.md5,sha256=-QXvyHNWdKruE01aMZyhO2CXCUfNtBZTRHlpD6zWC70,32 +bitblas/3rdparty/cutlass/docs/dir_7e9e609009df72bf6226de354e72c328.html,sha256=LOHqB_kiUyGyp5UHB2CEV5rwpTHVXZuQkwPhWeISv5Y,5408 +bitblas/3rdparty/cutlass/docs/dir_7e9e609009df72bf6226de354e72c328_dep.md5,sha256=NEfQiohvEieY2Nsa8snCyvfmGnGKMRQrL3eSFyVmWZA,32 +bitblas/3rdparty/cutlass/docs/dir_88de82f9e8d739a2f42f92d95f0d7933.html,sha256=3n1sZzX2PaOcNUEC_O5xKAq3lFEMZC2NLwdVLJYlhFE,5297 +bitblas/3rdparty/cutlass/docs/dir_88de82f9e8d739a2f42f92d95f0d7933_dep.md5,sha256=jznsBQQwxBoyLrsUPMEmJLcKaQomIBgczo02TjzY04c,32 +bitblas/3rdparty/cutlass/docs/dir_9aa36bd9cfad59a1f88859a38871c977.html,sha256=8S2zk6jz3AsvCU55_2c0c0R9WyaRbkKebwL9grBfiXI,7444 +bitblas/3rdparty/cutlass/docs/dir_9aa36bd9cfad59a1f88859a38871c977_dep.md5,sha256=7m4anMihh5oeU3lQ6J-VquF3rHnYaBpwA0NoZjqQWKU,32 +bitblas/3rdparty/cutlass/docs/dir_ac488927e63b76ba9cb3ad9c317bbde9.html,sha256=Naq6FDKPcvO-fybFBk4NkekLmIYtUqOtrAYSZ0EWi6Y,7716 +bitblas/3rdparty/cutlass/docs/dir_ac488927e63b76ba9cb3ad9c317bbde9_dep.md5,sha256=MlljmIbz05hqB5F_O2wkJLUQR1blARJLeNYELcxiHPQ,32 +bitblas/3rdparty/cutlass/docs/dir_ade2f6ff57439d30f4164e14e54bcf30.html,sha256=liLrrxUOAghRUSO70NqsNg22-kNTuHSvOrPKxNz1SJY,5504 +bitblas/3rdparty/cutlass/docs/dir_ade2f6ff57439d30f4164e14e54bcf30_dep.md5,sha256=xjCX7hGgV0Y67KB0_PuHjJ2NJp3tRsxAawBEAW1cMvk,32 +bitblas/3rdparty/cutlass/docs/dir_b790a865367d69962c5919afdba4a959.html,sha256=1HBdrhJpTg-bNU2t1dl8Qi9XYHEA51MtgYg9-d3P0oM,9143 +bitblas/3rdparty/cutlass/docs/dir_b790a865367d69962c5919afdba4a959_dep.md5,sha256=w-nPPl-2P0RZrhin2K1i6fI64j8zL9HNCgtP3w6QcCU,32 +bitblas/3rdparty/cutlass/docs/dir_c4a2560cb67fbf4e24d3d775f040b990.html,sha256=9zJ8s0OsvkJrEgYsXIPLoc4-jv-SRSfIJqhOWslXkBE,9537 +bitblas/3rdparty/cutlass/docs/dir_c4a2560cb67fbf4e24d3d775f040b990_dep.md5,sha256=Esxx0im9MvAkLKCTSv8lz7wH3lTlulucHi_7oLCa-4U,32 +bitblas/3rdparty/cutlass/docs/dir_cab02fdf7c366af2a4bd9c2fdea5880f.html,sha256=BiiYuMYpUq3STjqAbG5wlKEQYWDMPYniyrAENPYCuXg,6331 +bitblas/3rdparty/cutlass/docs/dir_cab02fdf7c366af2a4bd9c2fdea5880f_dep.md5,sha256=yG1bnd-rIliSxP3EM9dP191OsSxhEo8G25hysK4LuSc,32 +bitblas/3rdparty/cutlass/docs/dir_d44c64559bbebec7f509842c48db8b23.html,sha256=8_P7h-ipz1qoOmw2kk01BA5-5AXu4vqK-P3HmvhQ8R4,5215 +bitblas/3rdparty/cutlass/docs/dir_d44c64559bbebec7f509842c48db8b23_dep.md5,sha256=Xd-uVpQfKKskHJgEiNXebMLYuTop7ltMwqamx13I2vg,32 +bitblas/3rdparty/cutlass/docs/dir_d7bba2bfce089ad47efd3f3908281e78.html,sha256=VThLW1YnSp4_yXeTY9AdNXcjTO0TASKK1O_CoIcIOEw,5510 +bitblas/3rdparty/cutlass/docs/dir_d7bba2bfce089ad47efd3f3908281e78_dep.md5,sha256=GKfK8idGpDQLldEZ7mGr04HUM9h_Gxrf1Fx_KLnIGcE,32 +bitblas/3rdparty/cutlass/docs/dir_d9e7e9e63637345b8b26a82972709306.html,sha256=W-cknXyd2sVzZGBOiD_SXH80j4bqZaaGjxs_gAweW0Q,6082 +bitblas/3rdparty/cutlass/docs/dir_d9e7e9e63637345b8b26a82972709306_dep.md5,sha256=iYRibcuVNloGJi_SPDQwWWEOreF3dYvpwdAP_UAdSAQ,32 +bitblas/3rdparty/cutlass/docs/dir_df998829b150afe92f54393d2430470d.html,sha256=PhayFKuL2Otqa3Lqr4vCl8e_wWgDvxPOS5siB69seQo,5584 +bitblas/3rdparty/cutlass/docs/dir_df998829b150afe92f54393d2430470d_dep.md5,sha256=JvGiWjXZhtNcYqD3ylcEwGIyd8j5NExXkPg1f-NNv54,32 +bitblas/3rdparty/cutlass/docs/dir_e7fd38dbfb1fb5decd4aa6571e13ec6b.html,sha256=x03-j6DyR9J-vYVcqFaqF3gtp0UE3XrAQAWlmpAZuoQ,13045 +bitblas/3rdparty/cutlass/docs/dir_e7fd38dbfb1fb5decd4aa6571e13ec6b_dep.md5,sha256=5AYjFvTIfq7WBmNftSZ8DHT_-KgHBwuJ_jJdu9QaKUg,32 +bitblas/3rdparty/cutlass/docs/dir_e972dae4cc8aee063a6567ed2b9b6a51.html,sha256=UcKCZoTwmuGMJmE16S7UIF005k_U-4PnUXXm_ISA_yQ,7430 +bitblas/3rdparty/cutlass/docs/dir_e972dae4cc8aee063a6567ed2b9b6a51_dep.md5,sha256=Q7mkfFaBpOsP1GgYUIi4vTxCeRdUMsd53w54Yf3GWxI,32 +bitblas/3rdparty/cutlass/docs/dir_ebbbb6f6f10686db77ac27d0af6d8201.html,sha256=JkDcgkKNFw5ZUkdzGfZ0AUmLs6OiNPrSxjg9MzQN6qY,8141 +bitblas/3rdparty/cutlass/docs/dir_ebbbb6f6f10686db77ac27d0af6d8201_dep.md5,sha256=ijDU0axFoaafdREPFnvFHByjWCyDadCPeoFpXxetNf8,32 +bitblas/3rdparty/cutlass/docs/dir_ed1948a6da781e7f72c597b5619a522d.html,sha256=ika3WiG5qyxMn0qu_jVJBFJwmyLtpcbPvu655ogK1bs,5627 +bitblas/3rdparty/cutlass/docs/dir_ed1948a6da781e7f72c597b5619a522d_dep.md5,sha256=n56gavqpFgrIqUlrMbjof4VXJzvT8RlOrgRaTCi9zBY,32 +bitblas/3rdparty/cutlass/docs/dir_f62bf0d745be7e70cdb24777e561e6f3.html,sha256=gVkNbLJwDGyWoC2Mcxg6PBynrrzSWL2_Msl25yclfI8,5713 +bitblas/3rdparty/cutlass/docs/dir_f62bf0d745be7e70cdb24777e561e6f3_dep.md5,sha256=DwJq7taysuEpXnx5mWZBzdeE1S0TGYma-GsPHFFOOqM,32 +bitblas/3rdparty/cutlass/docs/dir_f97022a05803191deba9644b471136c4.html,sha256=lZ-ACiQdHSURMaILEBpFZBdjzcElMP67gpIjFfNpB8c,6235 +bitblas/3rdparty/cutlass/docs/dir_f97022a05803191deba9644b471136c4_dep.md5,sha256=0j7gj-6vKR2a-yNLmgFUz465-lhhVCll8K4Xx0pXuiM,32 +bitblas/3rdparty/cutlass/docs/dir_f9f54b1d82c28725d6670ba47204b309.html,sha256=6MRwyr1GhOwtPhgL3t3Y50Ut5-xpLFtBCEGCGEb0hVc,5269 +bitblas/3rdparty/cutlass/docs/dir_ff60863f958a43c892071bb1f8a4c81a.html,sha256=rGKHX_6mrYdKVkLH1jC7oh4-eDF3kxjHMYrqfFqx5BE,10610 +bitblas/3rdparty/cutlass/docs/dir_ff60863f958a43c892071bb1f8a4c81a_dep.md5,sha256=I2d1wqI4Rd6K-zT8RhBtuj8u5QN2gsteoje4zArAEy4,32 +bitblas/3rdparty/cutlass/docs/dir_ffb18c781d484e5d1c680f712f01a439.html,sha256=JPCUE-vzA-stKy3QlntZtXiqGihrqKsxj3BYYQIIDSM,13030 +bitblas/3rdparty/cutlass/docs/dir_ffb18c781d484e5d1c680f712f01a439_dep.md5,sha256=CViwn2uz7itv6sJToAGXzPrVEw_Lrg2GQ2Sk2t6oVIE,32 +bitblas/3rdparty/cutlass/docs/direct__epilogue__tensor__op_8h.html,sha256=yDE8XRPb-Vun62URVHGp5ZMxtMay5Bv7_C8ZIRPvI-Y,9324 +bitblas/3rdparty/cutlass/docs/direct__epilogue__tensor__op_8h__incl.md5,sha256=9oNNhGH5LiHLCMJljq11XOjY9CDvQrY69mEEsdhK8kk,32 +bitblas/3rdparty/cutlass/docs/direct__epilogue__tensor__op_8h_source.html,sha256=pmwQG1S974Hkm6EUfh1V3P2lbkgu0s-TTI0GpzcNkpU,60229 +bitblas/3rdparty/cutlass/docs/distribution_8h.html,sha256=X4RYpby5OZjIBpIvl_wdkx9oUUNCVcBDbvN0yToBo9c,8888 +bitblas/3rdparty/cutlass/docs/distribution_8h__dep__incl.md5,sha256=RLQFXXH0XKTQ33Z2cL-8T3N2BtpUi1CItQFItHbCHT4,32 +bitblas/3rdparty/cutlass/docs/distribution_8h__incl.md5,sha256=sm5B63fkpZiPvtZpS1iNY4o0npLucxHzuxonXoN-NTk,32 +bitblas/3rdparty/cutlass/docs/distribution_8h_source.html,sha256=FZe8z0t09nW7hemnn4Jd9E3MKfqqaSgnQgNnJzjH068,37146 +bitblas/3rdparty/cutlass/docs/doc.png,sha256=-sxA9i5ORxSm06h-Of_Wj3zQmWh-fHMw_8HwneN05WU,763 +bitblas/3rdparty/cutlass/docs/doxygen.css,sha256=ETQnL-fvlaJ-nKK-rcLVVIVISsCI9VHbjEq34SlpwaA,25871 +bitblas/3rdparty/cutlass/docs/doxygen.png,sha256=le68dh97lQJzH3ym0NC6_y20NQStlj12ak_EIm91tYw,3872 +bitblas/3rdparty/cutlass/docs/doxygen__mainpage_8md.html,sha256=baThsd2g5n0XUUQ5LTn-PQQrogMqBMirVoZ5x8n6q1I,4202 +bitblas/3rdparty/cutlass/docs/dynsections.js,sha256=XF2xg9H3EhdhAI-Szwx3JXnYOfPFbNmd89m0elqzLdA,3140 +bitblas/3rdparty/cutlass/docs/epilogue_2threadblock_2predicated__tile__iterator_8h.html,sha256=wfzUGpydqnN4twy4KHJmPdCiXCm7j0Ffei4o24GbsZw,11723 +bitblas/3rdparty/cutlass/docs/epilogue_2threadblock_2predicated__tile__iterator_8h__dep__incl.md5,sha256=QPcZyfmB7bguO_zL3pNzs1PQbtlXhB2ZSVZAHf_yg-w,32 +bitblas/3rdparty/cutlass/docs/epilogue_2threadblock_2predicated__tile__iterator_8h__incl.md5,sha256=cnnPj84-JtQ_vDggw5SIoxuQVVGys-AjnT2CEpY1Ir4,32 +bitblas/3rdparty/cutlass/docs/epilogue_2threadblock_2predicated__tile__iterator_8h_source.html,sha256=bZjUNdJX8hD1W3iahsv4dZqqwVhP_n0mNExJ-2aH_7k,171481 +bitblas/3rdparty/cutlass/docs/epilogue_8h.html,sha256=e1wGyEMuuKmXbCSywkpXzcHdkBSN1qVLGjPSYQwZl4U,9684 +bitblas/3rdparty/cutlass/docs/epilogue_8h__dep__incl.md5,sha256=ekCtM8f01e1AEHm8vay7Ptfyeqvjpm853DHIFKAJOhs,32 +bitblas/3rdparty/cutlass/docs/epilogue_8h__incl.md5,sha256=5HRKrw5PZK1D7OM1b-6FX6bcVp3lI6ir3Cm8Css5uxg,32 +bitblas/3rdparty/cutlass/docs/epilogue_8h_source.html,sha256=V-2IjqJz0hFBZmSUEmAfHGaYNFcb1wZ2Ay5LQH3kxto,70063 +bitblas/3rdparty/cutlass/docs/epilogue__base_8h.html,sha256=B5uJCAoGGOYDVG1i2h9U7tlUYPUsKuNkLWGKGUaWG64,9861 +bitblas/3rdparty/cutlass/docs/epilogue__base_8h__dep__incl.md5,sha256=Cvz6VlKca5cax3NsilNAy4DTX2itZxeQJZBBsvabWq8,32 +bitblas/3rdparty/cutlass/docs/epilogue__base_8h__incl.md5,sha256=JNwQIf2yGmiOvn_7nGdm1wBViOD2sKih4IESEq24QTA,32 +bitblas/3rdparty/cutlass/docs/epilogue__base_8h_source.html,sha256=oycY6q-y94UGEFEgvnYRmQn4anOROsMdvktX0K8kIPU,55560 +bitblas/3rdparty/cutlass/docs/epilogue__workspace_8h.html,sha256=DVdwLGYt8wm7fYOGcMga8-gAP6vMwDL0JQKNK7_pdxA,9220 +bitblas/3rdparty/cutlass/docs/epilogue__workspace_8h__incl.md5,sha256=GUKv8rqJmk8f9eQZQYb5Frg5dPJu0qDzvP6HsjgM6WU,32 +bitblas/3rdparty/cutlass/docs/epilogue__workspace_8h_source.html,sha256=yz9CWRq2YVnP_7RZPboa1SFIk_rhNGTPL54D3bFyumo,43581 +bitblas/3rdparty/cutlass/docs/exceptions_8h.html,sha256=jjHXx3t9g6ptCPUWblqq5feim8e6_DgLamJ32Pk5UxI,8748 +bitblas/3rdparty/cutlass/docs/exceptions_8h__dep__incl.md5,sha256=sQi3KDu_tHnhLHKCxi5qHBBeQsiS2E_juFFFh4_7Z60,32 +bitblas/3rdparty/cutlass/docs/exceptions_8h__incl.md5,sha256=a3zhgoRm84L44Zq5coxUhPtEiXTfuSNjEmSc9cBKyT8,32 +bitblas/3rdparty/cutlass/docs/exceptions_8h_source.html,sha256=Z8kfffZxOJ6uYWfpa6DfhjkRH0IFlflCIEixsqQZet0,17072 +bitblas/3rdparty/cutlass/docs/fast__math_8h.html,sha256=BtZRJ6_v7HUxto7D-o4N2oLtzyous3PtRY9o0FOrs_U,15223 +bitblas/3rdparty/cutlass/docs/fast__math_8h__dep__incl.md5,sha256=Rpa8Qxdl3sfucKa2Htz47o-E3AQxydLp1UBegyg_uTI,32 +bitblas/3rdparty/cutlass/docs/fast__math_8h__incl.md5,sha256=5aFdP9HAJDE9QFV6EAeuI98COeB7mGLWAoHzCGA59fs,32 +bitblas/3rdparty/cutlass/docs/fast__math_8h_source.html,sha256=MyBkJjO3_GKRBF4jX6Ury-jdQev3A_GwUO6Kz9uYhfw,43431 +bitblas/3rdparty/cutlass/docs/files.html,sha256=O4UMN1Rc2LUr9g-feTohMVZ-K9H1dtQaNM7qBJQshlw,72965 +bitblas/3rdparty/cutlass/docs/folderclosed.png,sha256=qUo55Bnmx_R5IcVXB5QLEvewtlBpkTvTN3IozfrplFk,637 +bitblas/3rdparty/cutlass/docs/folderopen.png,sha256=PgEGVwmm4tfWi6LEoSwxo2lRUW7qSCY3nnZDqBDroPw,629 +bitblas/3rdparty/cutlass/docs/fragment__iterator__complex__tensor__op_8h.html,sha256=oOosAONvNUj52lTcAhs9wAoRn8P_RfrtW7SmRb0xueI,9417 +bitblas/3rdparty/cutlass/docs/fragment__iterator__complex__tensor__op_8h__dep__incl.md5,sha256=BeyDg06HrSGkSV8J75d5LrxXz9wE8dQHrbBqjP71IuY,32 +bitblas/3rdparty/cutlass/docs/fragment__iterator__complex__tensor__op_8h__incl.md5,sha256=D1N9RUVtnbavQ9TdUS_vOyDXz4-eGAxmfc3jXj5IeuM,32 +bitblas/3rdparty/cutlass/docs/fragment__iterator__complex__tensor__op_8h_source.html,sha256=sReVkTPDQfTI86uASv8HpG9ewHDUkYikXKR4YsB4VKM,41298 +bitblas/3rdparty/cutlass/docs/fragment__iterator__simt_8h.html,sha256=ZhWL646eyz36FuhDc6kyOF9otl5VW8GdPIBO14dTPQU,9383 +bitblas/3rdparty/cutlass/docs/fragment__iterator__simt_8h__dep__incl.md5,sha256=O3qucApQKWXAXRVvXp9jHQYslK1R0zKKXLY22i-8w4c,32 +bitblas/3rdparty/cutlass/docs/fragment__iterator__simt_8h__incl.md5,sha256=29nU9YLYZFqz_nPrOBQ0C_-w-h5p8a4xvImraCPQDOw,32 +bitblas/3rdparty/cutlass/docs/fragment__iterator__simt_8h_source.html,sha256=2rxOYscC73yoz71KzbRiENZ7EpJLgJ5XLdFfaHydOJs,36014 +bitblas/3rdparty/cutlass/docs/fragment__iterator__tensor__op_8h.html,sha256=scurM_Ase_Ma6KtrinrJP2H7Z6qKtszcrGYx4dvRRrU,10137 +bitblas/3rdparty/cutlass/docs/fragment__iterator__tensor__op_8h__dep__incl.md5,sha256=Cnj7r3tkkwC700AG017Zo1R496GZQz7tlUtDFLNV6y4,32 +bitblas/3rdparty/cutlass/docs/fragment__iterator__tensor__op_8h__incl.md5,sha256=EynU5wyD9W9s9e7dkTKkL6Y7nj1oCweRJpMH_I2h71c,32 +bitblas/3rdparty/cutlass/docs/fragment__iterator__tensor__op_8h_source.html,sha256=OkxH8nSMKNge6U4ipCpKcm8jab9394C5Us0vRsh1jSc,61002 +bitblas/3rdparty/cutlass/docs/fragment__iterator__volta__tensor__op_8h.html,sha256=ehmUUITorvY82_gOnXh6hllJoEATeXQZvAp5i1N3y58,10320 +bitblas/3rdparty/cutlass/docs/fragment__iterator__volta__tensor__op_8h__dep__incl.md5,sha256=EVRAc4GMr7wPHfFau_4JhLuG6WjjBjgo5el0SSeSUZ8,32 +bitblas/3rdparty/cutlass/docs/fragment__iterator__volta__tensor__op_8h__incl.md5,sha256=uGoKbIpJtTYC5XIckCYPDCmVTTsCbp8xnNEtwJn0nGs,32 +bitblas/3rdparty/cutlass/docs/fragment__iterator__volta__tensor__op_8h_source.html,sha256=QbECFxhJ4X5zQPQOLudJU6J8CMVWcUD8YRN3Cyo0Wfo,64730 +bitblas/3rdparty/cutlass/docs/fragment__iterator__wmma__tensor__op_8h.html,sha256=ruNSxemkhYXHirSJ4pEtuYiq7WE67k-eCZwES-7Swk8,9394 +bitblas/3rdparty/cutlass/docs/fragment__iterator__wmma__tensor__op_8h__dep__incl.md5,sha256=Bf7Ivm5xeNEyF2uOkrJrm99TBvLWUXzGoh9c_mj-DfY,32 +bitblas/3rdparty/cutlass/docs/fragment__iterator__wmma__tensor__op_8h__incl.md5,sha256=Ej2YzJURTEtPzSDqcDq6TH8McENnlkubc2b8jb3EcjY,32 +bitblas/3rdparty/cutlass/docs/fragment__iterator__wmma__tensor__op_8h_source.html,sha256=pDQHRRo_uPH4b3-V2OnFN9VI-i8x-AK9czggb5Xn3v0,37631 +bitblas/3rdparty/cutlass/docs/functional_8h.html,sha256=MznmAfvWcYDosw4lgCOoTQVQXeFLvd_e_BCMuemPB38,18225 +bitblas/3rdparty/cutlass/docs/functional_8h__dep__incl.md5,sha256=ZsCeAS7SzVH4dX6bNoQrDFa9Ci0_t17iGwjllrpJg9o,32 +bitblas/3rdparty/cutlass/docs/functional_8h__incl.md5,sha256=I_OtC0ltZ8TIpEwj-MIzSRwQptMIn6WGmcc9sQbI72U,32 +bitblas/3rdparty/cutlass/docs/functional_8h_source.html,sha256=OmqMseE3s_8HPeH95k_HFpDTU6jMexvAo1lwDW9S-8w,230739 +bitblas/3rdparty/cutlass/docs/functions.html,sha256=tLp45D4QO-uuT9ms7H4xW8Nrmk_mbetNMZ59TFpPIrs,100922 +bitblas/3rdparty/cutlass/docs/functions_0x7e.html,sha256=nW_7MhU7or2YVLIK2raYxskAVHartbOXsFlAwb_6xhM,7342 +bitblas/3rdparty/cutlass/docs/functions_b.html,sha256=cHduXDHeuWKhHDLRY9A176zu_P3hITx8G06U_BSepQU,24657 +bitblas/3rdparty/cutlass/docs/functions_c.html,sha256=EyRqXPw2-HTw8vktsJ8dTtiEgkeaT_z88bZRlljpZpQ,48651 +bitblas/3rdparty/cutlass/docs/functions_d.html,sha256=7Hl6OUhjQ7Y8wL0pdbj_q1suCu2hmN9cHb11_psT86w,21588 +bitblas/3rdparty/cutlass/docs/functions_e.html,sha256=A2sNdmWMbWMiRi59rjYp1_VjteVV20MeoA_QcN6wZJk,162209 +bitblas/3rdparty/cutlass/docs/functions_enum.html,sha256=FLk66wJjPV6ksMnbN3svC4CaDBOzslc3NwaAOGY3kng,4901 +bitblas/3rdparty/cutlass/docs/functions_eval.html,sha256=vqmZqOFxzeJxAj-zkSPoPb-OAiH-dGbhufIj3FjdS1w,9185 +bitblas/3rdparty/cutlass/docs/functions_f.html,sha256=mCnNxu-DLO7r03gkqciacVqY7QTRnyNrwRNDOtyKBnc,93136 +bitblas/3rdparty/cutlass/docs/functions_func.html,sha256=S7AN-liqpq68bKDu1I0CmO7AnomiG-dqyN7N8Bm8GcA,67905 +bitblas/3rdparty/cutlass/docs/functions_func_0x7e.html,sha256=vn1QYDHYQe8g9VrUzdp1_KSqRJBq4L43lc-jyUa72h8,7300 +bitblas/3rdparty/cutlass/docs/functions_func_b.html,sha256=kkyq6ye2DQe9FgRXcsL6JgVtVnmrLjBG66LuK82dOS4,8871 +bitblas/3rdparty/cutlass/docs/functions_func_c.html,sha256=1Pyj54KgG3Je95xTbBanoRV5d7mahMD6qhaPDipjVCY,36787 +bitblas/3rdparty/cutlass/docs/functions_func_d.html,sha256=RS99KCIRmi4TvbH3hsTkx_J_ycfVZxOEEQBeaenFLTk,9812 +bitblas/3rdparty/cutlass/docs/functions_func_e.html,sha256=Vf5pt6i5UMdlyKUXhJsmFZq91e_Mwv_sNNwfkt5xqUc,16920 +bitblas/3rdparty/cutlass/docs/functions_func_f.html,sha256=Cgyh2l-G_u7Enk5mgQklOMvt7UWE_XaDPsIDSzOsUxo,10349 +bitblas/3rdparty/cutlass/docs/functions_func_g.html,sha256=-A2PZ5dJHcaAzp04q_tQ7IDZpK8Irt7LTprrZdfjSa0,37653 +bitblas/3rdparty/cutlass/docs/functions_func_h.html,sha256=UHi9qLPVrQrHsCzALqXn6Z18MZLqHeuMTJS8fduglnQ,7698 +bitblas/3rdparty/cutlass/docs/functions_func_i.html,sha256=3jJvgxpew1qo7wrz24-IK6h8VS0pMOCSp2dfJvotmUc,22428 +bitblas/3rdparty/cutlass/docs/functions_func_k.html,sha256=lPLEgKBDKLgNTn9A2IpOtijAA0NifnuNiF9zqPdUSK4,7503 +bitblas/3rdparty/cutlass/docs/functions_func_l.html,sha256=rswVeLSnU8QbETfqwvhw0IMEQ7ba0Xp1Hf32l3QtnpY,63081 +bitblas/3rdparty/cutlass/docs/functions_func_m.html,sha256=UZwe_RSND5E9s4PhIzXwX9lweWrn4LnOvBZaRHPWV-w,21668 +bitblas/3rdparty/cutlass/docs/functions_func_n.html,sha256=U6aZ1zDRMYGSj5YWYVizRBvXmZqeFUtEY-25gXVjK-A,7606 +bitblas/3rdparty/cutlass/docs/functions_func_o.html,sha256=m-HPc33-GqV2iRrhbiEOxyxUwC-uXWmyW4gnK7xxemU,149288 +bitblas/3rdparty/cutlass/docs/functions_func_p.html,sha256=Ck57xU0JfuRGRSga7ESejnEEfeKtprt6WVyunzo0fkk,31245 +bitblas/3rdparty/cutlass/docs/functions_func_q.html,sha256=tR1E5pva4lN1CSmQKiny2fLNdC-1iyQnAAYdnfEtheE,6807 +bitblas/3rdparty/cutlass/docs/functions_func_r.html,sha256=Wx6qmPWoVMgZ7pZYlHeqNacVBRvnCrN5Uo07iAitNF8,33209 +bitblas/3rdparty/cutlass/docs/functions_func_s.html,sha256=S2zyWS3zAUcyfCfjxzKxOivoo3NPaNLLv7hbWBAe2r8,72806 +bitblas/3rdparty/cutlass/docs/functions_func_t.html,sha256=QbGZnntNRK5470eLxAb4cqTOui1LgbXdFuqbaKF-kT4,24950 +bitblas/3rdparty/cutlass/docs/functions_func_u.html,sha256=Lg3gWeIQaKx-2asndwPrfBLdouCf7V4FMzN33Lg5MQc,10501 +bitblas/3rdparty/cutlass/docs/functions_func_v.html,sha256=V336kBhHGhgAulZOJ7vmNT7q-UHDgC_eb9_tAy9gvrU,10399 +bitblas/3rdparty/cutlass/docs/functions_func_w.html,sha256=qIlOwzq5rtFFJZcUuZ0fSDI7A79EdvGLC3J91kQJ5y8,6879 +bitblas/3rdparty/cutlass/docs/functions_g.html,sha256=XykBzSRbO88jq3b_whzWafd_HOMU4Svg1H7CpewBwDI,46660 +bitblas/3rdparty/cutlass/docs/functions_h.html,sha256=yJsthkIsOWPJ_De7GSTJggAX1_zpHY3yUOs2gBYswKM,10885 +bitblas/3rdparty/cutlass/docs/functions_i.html,sha256=Ra80MvWtoilntbV3rkelIXwc_CZvqHZI6AH1ka6Zea4,126104 +bitblas/3rdparty/cutlass/docs/functions_k.html,sha256=-tr5JJHF4I4fOLdjeeUxeZDN54Cw4btCJMa7rWnBtNE,247808 +bitblas/3rdparty/cutlass/docs/functions_l.html,sha256=VcSgMSfvKVH3dbnsWYACaOsVj3L_sBMIzyXFQWXaOtk,235653 +bitblas/3rdparty/cutlass/docs/functions_m.html,sha256=KVWQytlJjtjYHn2VC2z4uvr6OyCIEzaF6IULuG6EGps,55875 +bitblas/3rdparty/cutlass/docs/functions_n.html,sha256=SmELwpIYzqCLJkWWHC__hsEc_RhIWGxczIFHyt88gOc,20513 +bitblas/3rdparty/cutlass/docs/functions_o.html,sha256=CLXvqSL3zVMe3SzqMVen-lK_h0IHSbnRpW_WXMrh1Hk,211122 +bitblas/3rdparty/cutlass/docs/functions_p.html,sha256=lZnHmeihfGfRQsdEusEEEtQpbTFMph69S93B9xfdbKY,79435 +bitblas/3rdparty/cutlass/docs/functions_q.html,sha256=lXEcnrFVb9jFYNGQ8gjc-cxZp9Qrc7-kjwbUKvEd7LA,6849 +bitblas/3rdparty/cutlass/docs/functions_r.html,sha256=8jfj_tH_Tlf_8qtwKprHU2slBOFSbWdiMQACPlwB0Ac,65939 +bitblas/3rdparty/cutlass/docs/functions_s.html,sha256=sPBGSuj6_ATQoik5iQB9vv18McSoqJk0dX7iobjiR5Y,210014 +bitblas/3rdparty/cutlass/docs/functions_t.html,sha256=O9UFcKkyrv15_U8yJy7_n2b-mxFvcltVgzyaO2_aaE8,183958 +bitblas/3rdparty/cutlass/docs/functions_type.html,sha256=e-6ttxBgerVCFH4KqU41JOURDzJzVlf9r1RHcrx2Ob0,33450 +bitblas/3rdparty/cutlass/docs/functions_type_b.html,sha256=l3lASPLnHyLGtY4b0YARhbx6A40bnt9z2VrlkkvMgog,14967 +bitblas/3rdparty/cutlass/docs/functions_type_c.html,sha256=X1tGb8QuUTlicbkHuDFdd5VViCuXN5CVRxCBFH5CR9Y,13971 +bitblas/3rdparty/cutlass/docs/functions_type_d.html,sha256=ZS5qc7vKas9rquY7A_PZ0Wz0dHJlQTFwfe6Xa_tkdqA,14832 +bitblas/3rdparty/cutlass/docs/functions_type_e.html,sha256=a52nlM91XN8By8_Sld793qt9K2PbBKZ9TGhlfPZ2kO4,146274 +bitblas/3rdparty/cutlass/docs/functions_type_f.html,sha256=-j4QvKEcoZazNH31HBWtGH1he6R5tgaIpq60Rhd8ZtE,87953 +bitblas/3rdparty/cutlass/docs/functions_type_g.html,sha256=Uqi19Q1jmDtD4XX8TBYziD6Y-6cdiPpDDpGL3rVZjrs,13282 +bitblas/3rdparty/cutlass/docs/functions_type_h.html,sha256=pG2OmdxRZC0kQ98KX5FzvVz3tM4AJoCNI5jg63T1_sA,8719 +bitblas/3rdparty/cutlass/docs/functions_type_i.html,sha256=truu7c7GZNaJmF6OpAvl-sWpevBeOY0AR_Y96F_-20g,104065 +bitblas/3rdparty/cutlass/docs/functions_type_k.html,sha256=2mtLIyHHr3xtnxcI5Q18Vmz8gmKRJ7LTWwQGxlif_PA,6899 +bitblas/3rdparty/cutlass/docs/functions_type_l.html,sha256=XOlCOrR74MV-C7g_7D7wpeR_w-_NJQAr3ifIHCo6JMc,161914 +bitblas/3rdparty/cutlass/docs/functions_type_m.html,sha256=3c4bldkkf7O0C9zbs47LJqr-fKoy60kegJWCR8yL0V4,36364 +bitblas/3rdparty/cutlass/docs/functions_type_n.html,sha256=LiUrxu6dBxfHirlFbZVJw8_KVC72e5q0pvhNFqoYaGk,12690 +bitblas/3rdparty/cutlass/docs/functions_type_o.html,sha256=FL-kkpjesQ9PO_IG2r-uDZdOoJeJREtJbmXMjWeS3zU,65706 +bitblas/3rdparty/cutlass/docs/functions_type_p.html,sha256=zPYwB-crLUN8fd3VNINVbCQPz-6zFzGQFWj2mdnBlZU,36066 +bitblas/3rdparty/cutlass/docs/functions_type_r.html,sha256=CYQxdNxtDV3AdkWV8Pl5PRWVPmqWkqBmtFzlDbQe4dA,13413 +bitblas/3rdparty/cutlass/docs/functions_type_s.html,sha256=4ISp8hXX1y0agc9AfuZC0m0MTDiYOSCnIOUj3lm5fnY,123446 +bitblas/3rdparty/cutlass/docs/functions_type_t.html,sha256=0wm92x7NfIBIKQUF-ytZEhPq0Z1LrlwKJpHQrzPeG_g,155155 +bitblas/3rdparty/cutlass/docs/functions_type_u.html,sha256=QLze1SaxEmpuLs3bk-8CIt_vy6J-YxCynHEyC7qAdRo,24768 +bitblas/3rdparty/cutlass/docs/functions_type_v.html,sha256=g6D4KTO6b4OyMSl8HEhj-aY0sQdm0KaJlxKJ18DGCWA,7173 +bitblas/3rdparty/cutlass/docs/functions_type_w.html,sha256=y3ufUPjg7i7muso4u13S-lSL785pMqnHf5LQCJ3pebU,48431 +bitblas/3rdparty/cutlass/docs/functions_type_y.html,sha256=yPt-SIysuOl-OdVvGRdhzolxEGaAgdql4Y82cOswXGE,6728 +bitblas/3rdparty/cutlass/docs/functions_u.html,sha256=_ndw07E8rN7nozyB4vOnEKlU-2EOzzovEjOUeRskGVQ,29343 +bitblas/3rdparty/cutlass/docs/functions_v.html,sha256=RFjPw34v6SPMjpRvBUQ7rtcgV1jhrQtW6brjQx8rm9M,21527 +bitblas/3rdparty/cutlass/docs/functions_vars.html,sha256=gqv6dprhvueThxg372HBzAfaML6aOGDNGWtrVZNF2L0,12542 +bitblas/3rdparty/cutlass/docs/functions_vars_b.html,sha256=o1zUUqbrvyZUY-e2JoMsYbCUxv95qATLe45Esy1C_70,13776 +bitblas/3rdparty/cutlass/docs/functions_vars_c.html,sha256=VFRFhyLooYGE4I2jUqY8Mt79YgpyjRxTfjRgS22__ac,10940 +bitblas/3rdparty/cutlass/docs/functions_vars_d.html,sha256=NuwoR1KbrkZnbEWiE0oUYZG71JqbmrxMze2CBvlDKQQ,9901 +bitblas/3rdparty/cutlass/docs/functions_vars_e.html,sha256=fOue-g-Fsn7wLf7yzF2eB26a5BO7QbiPYFxhgbJiizU,11882 +bitblas/3rdparty/cutlass/docs/functions_vars_f.html,sha256=1y8LDiDs-i684bV78JQ-2cYdMWwq5HaP6ujtfrClBTA,7773 +bitblas/3rdparty/cutlass/docs/functions_vars_g.html,sha256=QS37XiuPQ9I1YNYI8Pwhr2Zzz2TvXO__g2CYR7bZuNc,8512 +bitblas/3rdparty/cutlass/docs/functions_vars_h.html,sha256=uB95wRPFbWibfawE6QWkCpm520xvcz8mp2aTJWf5JHg,7425 +bitblas/3rdparty/cutlass/docs/functions_vars_i.html,sha256=2GgDbVrfHhzhC7yA2i-DC3PXV0SSefjbBKqZ6Q-l3NE,12244 +bitblas/3rdparty/cutlass/docs/functions_vars_k.html,sha256=YqJWvNrB-rj55WSLohmdtQBv8ljgkdMiwpxX-sXegxc,246189 +bitblas/3rdparty/cutlass/docs/functions_vars_l.html,sha256=ef3Xsa9wtHhsgk3OWM1585OAwq69gyc-nXXYboKbu_o,23640 +bitblas/3rdparty/cutlass/docs/functions_vars_m.html,sha256=SMy-d0LLGl0yxjFZ0ucXH3BowieZ7V8xAllU37WvRwY,10871 +bitblas/3rdparty/cutlass/docs/functions_vars_n.html,sha256=ybfmkZGATmfNPRLHhENYkFqHWmr5FmpLHvupnyBnJHM,13174 +bitblas/3rdparty/cutlass/docs/functions_vars_o.html,sha256=uw0QQ3vMET0uUp8ZpBxrTud5kCGDafr68gTWMJZIm3A,9085 +bitblas/3rdparty/cutlass/docs/functions_vars_p.html,sha256=u5J5YuICB5pVMkYxYX7BFRjavYH0wtyrS7VoTd2edLk,24889 +bitblas/3rdparty/cutlass/docs/functions_vars_r.html,sha256=9D-X4Tx58Q3y1S8oBbSiAPEN18ONIje4vi9g73F1DwI,32296 +bitblas/3rdparty/cutlass/docs/functions_vars_s.html,sha256=vvhFw2JFxU5UeM2JJRFhTCGCDukPz2TEx_f1A3ir1Dc,22259 +bitblas/3rdparty/cutlass/docs/functions_vars_t.html,sha256=6xHRj65oDZ9bJWrq5ajHlCpbz8UQ4A_z5wv5FaJWYAA,16855 +bitblas/3rdparty/cutlass/docs/functions_vars_u.html,sha256=MA8qBby84yqUQuEZpSAtnW5b_ar76jrX_JkpIqyAw5k,6862 +bitblas/3rdparty/cutlass/docs/functions_vars_v.html,sha256=0OxzycmkCaf2fJKjX4stQDd-dS2Lb97idMXpcaFvnSE,13376 +bitblas/3rdparty/cutlass/docs/functions_vars_w.html,sha256=voAgNoQ758P_jQNGYIlqMXU2aTW3bvDhjlnrUhbP2xg,14315 +bitblas/3rdparty/cutlass/docs/functions_w.html,sha256=_c9YIDtdOVPn67V2km2AR3Lq8kKNEO3k5kUK43mj9O0,56668 +bitblas/3rdparty/cutlass/docs/functions_y.html,sha256=cR9yyDTyeqDArnMZU-mLszRJvGVZu6PRVjmxpfIcUxI,6851 +bitblas/3rdparty/cutlass/docs/gemm_2thread_2mma_8h.html,sha256=LS2jjazDFjqEKm8hdhkzv7R8KW4fNpOaGFaEXfYXQx4,8396 +bitblas/3rdparty/cutlass/docs/gemm_2thread_2mma_8h__dep__incl.md5,sha256=O2pJ72_A2FQH2Oc6mirddvjbfDydrS5Q-DXVjGdcXfc,32 +bitblas/3rdparty/cutlass/docs/gemm_2thread_2mma_8h__incl.md5,sha256=bSrFDbWjN2-pDYDI11G0uwm5btCDWMXEcTkaM5fSfnQ,32 +bitblas/3rdparty/cutlass/docs/gemm_2thread_2mma_8h_source.html,sha256=WOsgR0wGYaVQ1E2qNJmiIiZMCSJilpKX6QpVC2bVFI4,17259 +bitblas/3rdparty/cutlass/docs/gemm_2thread_2mma__sm50_8h.html,sha256=5J2w2qMfARPl6OD7Al2L-MnUXBM903J2Pvjs1i0igQ8,9048 +bitblas/3rdparty/cutlass/docs/gemm_2thread_2mma__sm50_8h__dep__incl.md5,sha256=6VfN-yOipiwr6OcXyzvYEJ7HvBgoXYcn_LBJ7iBO_5w,32 +bitblas/3rdparty/cutlass/docs/gemm_2thread_2mma__sm50_8h__incl.md5,sha256=KZyaMSLvHqa3JO4AZ2LWaS588dCv7zaKi31qrERwq_4,32 +bitblas/3rdparty/cutlass/docs/gemm_2thread_2mma__sm50_8h_source.html,sha256=LnZTtauxeMHqIwKa09uMnDDMY5enxPJCLR8E29N2Bg4,62984 +bitblas/3rdparty/cutlass/docs/gemm_2thread_2mma__sm60_8h.html,sha256=NMx3FnYv3lPMcM7kyh6AIhr2IftwGBeINyWpZWjxNsU,16000 +bitblas/3rdparty/cutlass/docs/gemm_2thread_2mma__sm60_8h__dep__incl.md5,sha256=7sCfixhroI1h_qilRwDmwsR3MfIOuGy9jlOrqAsw5RA,32 +bitblas/3rdparty/cutlass/docs/gemm_2thread_2mma__sm60_8h__incl.md5,sha256=J_bkNLrgicqf5VHIC1qOoxDLc4SDE1YoD9i0XJakl6s,32 +bitblas/3rdparty/cutlass/docs/gemm_2thread_2mma__sm60_8h_source.html,sha256=YvVWGCfdYmBeWJLkpYoS-K6VdSnBQ3AMPWX2WJx7KRM,224096 +bitblas/3rdparty/cutlass/docs/gemm_2thread_2mma__sm61_8h.html,sha256=Rqt_ZYZmlEzk_rVa5JSbP4IQ2HWpsso4CoajhsAJqpU,9130 +bitblas/3rdparty/cutlass/docs/gemm_2thread_2mma__sm61_8h__dep__incl.md5,sha256=Xx7I4AmxCCyzjhbwYSKkFUQssrJbTHZTl2ecESevNX0,32 +bitblas/3rdparty/cutlass/docs/gemm_2thread_2mma__sm61_8h__incl.md5,sha256=mTSKcFeq2_PzvLFKX8AkY4N46bMtY8QEDqj6q01gOb8,32 +bitblas/3rdparty/cutlass/docs/gemm_2thread_2mma__sm61_8h_source.html,sha256=NhaJ32cx8FKykNZVCZdXQX8TBgXsYD8GperHfeBQX4g,68347 +bitblas/3rdparty/cutlass/docs/gemm_2threadblock_2threadblock__swizzle_8h.html,sha256=FF9jR3QKdukX57mz32PyLOkE03psidFyew0DUZyGrLA,18053 +bitblas/3rdparty/cutlass/docs/gemm_2threadblock_2threadblock__swizzle_8h__dep__incl.md5,sha256=n6yRj_xm6LopzR4iNH5RSki5eSGiOOD5Ynq2oPPlfkk,32 +bitblas/3rdparty/cutlass/docs/gemm_2threadblock_2threadblock__swizzle_8h__incl.md5,sha256=o3PPqA2EDA4gdI3Ks6S1faIZV06agVH_KreIte7RQPk,32 +bitblas/3rdparty/cutlass/docs/gemm_2threadblock_2threadblock__swizzle_8h_source.html,sha256=reL0GzwicpAPQGHvYMRzZUsPyOlrtJ-4ej2iR0jGsLU,90068 +bitblas/3rdparty/cutlass/docs/gemm_2warp_2mma_8h.html,sha256=PKlCPfymSRnxupmlIyBAbxDLyV-QziqRY9U8LuJZ19I,7453 +bitblas/3rdparty/cutlass/docs/gemm_2warp_2mma_8h__dep__incl.md5,sha256=SVhxHNEu1sKFWLlzl8487IHN3Iv-yoGdemWYXxEuQs0,32 +bitblas/3rdparty/cutlass/docs/gemm_2warp_2mma_8h__incl.md5,sha256=e3BP1M86OX2OyMHVclChm_gtcIddmwHIN4I9nTSSKsA,32 +bitblas/3rdparty/cutlass/docs/gemm_2warp_2mma_8h_source.html,sha256=4TQNjXQ-Skl4TH3JRpCGluFyjvSCZKtY-7igPEskMKM,13141 +bitblas/3rdparty/cutlass/docs/gemm__pipelined_8h.html,sha256=QWUduKq0hzCZ6ilG3zCTQ53pCjUShSHHfj-tjDV2gog,8632 +bitblas/3rdparty/cutlass/docs/gemm__pipelined_8h__dep__incl.md5,sha256=LmWfzOod5GgjM6P42Jbk03CsLvwMbcDCtXFHZ5RDIyg,32 +bitblas/3rdparty/cutlass/docs/gemm__pipelined_8h__incl.md5,sha256=pRSlZjooM4RyoJ2nVzcBYlIULUpIMENnQ-N9SIQUGhY,32 +bitblas/3rdparty/cutlass/docs/gemm__pipelined_8h_source.html,sha256=KKWbPfbjsZNT6N-ISkyiikMfwm3ApVEgwwGfkYtuCkk,29972 +bitblas/3rdparty/cutlass/docs/gemv_8h.html,sha256=Y8WXfeaux0WaOJC45fVUDO-yL3J2hY8OzpkPIOGjHsU,7908 +bitblas/3rdparty/cutlass/docs/gemv_8h__dep__incl.md5,sha256=qvYB2Q-njlZw38KdIT6QON4YWQKF7kzyg4G_ysk1T4w,32 +bitblas/3rdparty/cutlass/docs/gemv_8h__incl.md5,sha256=8-PA7H3YLFLMBpvCyPLJH5bw12na8wf7rHMfx1IXtx8,32 +bitblas/3rdparty/cutlass/docs/gemv_8h_source.html,sha256=L7SkViYUzrQcOk11ZZd3stz1pzFwyRPtiZ4ILegQZsY,32356 +bitblas/3rdparty/cutlass/docs/gemv__batched__strided_8h.html,sha256=AxyqOKwZMiDy2YU-maosouGv78mYsdItg1X77uDgJh0,12721 +bitblas/3rdparty/cutlass/docs/gemv__batched__strided_8h__incl.md5,sha256=Q8hcyZJNJtcnVxVab5qE-bg7-X6Rjf8__LtpZlG075w,32 +bitblas/3rdparty/cutlass/docs/gemv__batched__strided_8h_source.html,sha256=aj7BiGS_9im2DuIHErRIskAn7Ijgmn2d0ydbtDL7q_o,50407 +bitblas/3rdparty/cutlass/docs/globals.html,sha256=yuoabVhbg6vrLoebiAEmi4BgmJjLHEcjIxxiPmIS0Xg,10033 +bitblas/3rdparty/cutlass/docs/globals_defs.html,sha256=xrfCqy440V61zuu5jcNwlqeuwRm2nxcbUnRT6gB3mEU,9104 +bitblas/3rdparty/cutlass/docs/globals_func.html,sha256=WBPMVYbo5Qxb5W1VyFYhJYWG2PqeBIqvLILj_4ki5Ek,4969 +bitblas/3rdparty/cutlass/docs/graph_legend.html,sha256=KGIEVd4tkBOps5uJJDFzNRBdddsXhnQm4OKuHMMG-V8,9168 +bitblas/3rdparty/cutlass/docs/graph_legend.md5,sha256=uuC2PyoKJT1i0t8gRi4UN6RSejxDjEFL44lZHB1PxJs,32 +bitblas/3rdparty/cutlass/docs/group__predicate__iterator__concept.html,sha256=z-IelCkatsUGmzdm7erD2nBXDmzhZFffjxvz81TadhQ,6632 +bitblas/3rdparty/cutlass/docs/group__predicate__tile__adapter.html,sha256=XER9nQs0LkMJu6bR0LE-UXK6LLPO7C6VZDgeGLYI0kw,4608 +bitblas/3rdparty/cutlass/docs/group__predicate__vector__concept.html,sha256=iSbWeoXvyR5wd3oCaHk1vrf-1af41r04NO5BddY-DOk,5662 +bitblas/3rdparty/cutlass/docs/half_8h.html,sha256=k1uj4sutwauMr5kcHPXQbe-4nk9W4_mkgf_6dBKfPZs,26332 +bitblas/3rdparty/cutlass/docs/half_8h__dep__incl.md5,sha256=EhnEj48-J-9GSbA5Ejx8VlDE1adKV15eZN8Kxuqw3i0,32 +bitblas/3rdparty/cutlass/docs/half_8h__incl.md5,sha256=DsnEs9qgWRGpci9peaLLQe_S6W-u0B2YOwasp8tlyrQ,32 +bitblas/3rdparty/cutlass/docs/half_8h_source.html,sha256=ku39N8Qj5pH-1mmpIiRpQesDM82yTRhJXN41_qKCpW0,155959 +bitblas/3rdparty/cutlass/docs/hierarchy.html,sha256=3ELDnL8qHwGsZflwSouoMYABGuugSkH72aiVWJT9kIE,384991 +bitblas/3rdparty/cutlass/docs/host_2tensor__compare_8h.html,sha256=1EnUNp2-WwYxn30R2A6mIlr8W0mE9WQCIsU3wx2CdUw,12902 +bitblas/3rdparty/cutlass/docs/host_2tensor__compare_8h__incl.md5,sha256=AS6JP8xRz2mmu6JxI8txKSw4DoZ4iRxM5YgCZr-G3mg,32 +bitblas/3rdparty/cutlass/docs/host_2tensor__compare_8h_source.html,sha256=A4I_pZRQsnKXXfH90veTGVpVRjtg69z9Th0cZLTUQrY,53230 +bitblas/3rdparty/cutlass/docs/host_2tensor__elementwise_8h.html,sha256=_EYKu7uPKx8KzsMB2Qry2BV3bri3Fg9toVVx2QLMMco,18864 +bitblas/3rdparty/cutlass/docs/host_2tensor__elementwise_8h__incl.md5,sha256=zqXF9SVGA_8OHbooeZN-4Gwy94a2X7zoSK57_jCnJcM,32 +bitblas/3rdparty/cutlass/docs/host_2tensor__elementwise_8h_source.html,sha256=WXosn0ZDK5V4A1ogePBsltUHFEKDpQwMkLMdmmlJagI,62360 +bitblas/3rdparty/cutlass/docs/host_2tensor__fill_8h.html,sha256=gf5-yArbluV49uqA-eUjJSZPxAguAIjhxVTKAeq7udU,28662 +bitblas/3rdparty/cutlass/docs/host_2tensor__fill_8h__incl.md5,sha256=eKjdTOd8Kkm8ij7SACJsm21PAl9NIUnCDnXhIOlE_b8,32 +bitblas/3rdparty/cutlass/docs/host_2tensor__fill_8h_source.html,sha256=lmeRlZ6xywBebgCJNwgQSfRE3EGEu89RNjP7gbczxIM,181522 +bitblas/3rdparty/cutlass/docs/host_2tensor__foreach_8h.html,sha256=3Asb0pLwuQynUohmom6t3AbDZsJB9kEsDMCLI0b3ygI,11492 +bitblas/3rdparty/cutlass/docs/host_2tensor__foreach_8h__dep__incl.md5,sha256=ytojieSTn7K3f9fF_zI7QIt91DY6yYVWxxT4uZRlE_8,32 +bitblas/3rdparty/cutlass/docs/host_2tensor__foreach_8h__incl.md5,sha256=WN0QN5wzmukXUH3mDOm_kKjZhUNQawO-9EJz-hCq5a0,32 +bitblas/3rdparty/cutlass/docs/host_2tensor__foreach_8h_source.html,sha256=b7knr6NxPzt4cvxRtoKCUz3o9FOp3nZnEOt8gVNREpA,29028 +bitblas/3rdparty/cutlass/docs/host__reorder_8h.html,sha256=9rAEY8Nv3AL43t2FtoYoHdPo-tCeFm_ZwUuNT0hlbX0,7320 +bitblas/3rdparty/cutlass/docs/host__reorder_8h__incl.md5,sha256=1SjXi-MacHjT9L61zwVLMY4aCbhgifSbHi7D27fagcA,32 +bitblas/3rdparty/cutlass/docs/host__reorder_8h_source.html,sha256=IK_mAbVloW3vMBHTebkom7O-Af3KKkUf190zDwhxpyI,18744 +bitblas/3rdparty/cutlass/docs/host__tensor_8h.html,sha256=yjGBGRECI7ajk7KcwedX55wXHRugcSgs5gBsWF22p6M,8154 +bitblas/3rdparty/cutlass/docs/host__tensor_8h__dep__incl.md5,sha256=7h025VDZyP69JbvF0DgBIdKFRBDaEDsC6tz6nFPHqHo,32 +bitblas/3rdparty/cutlass/docs/host__tensor_8h__incl.md5,sha256=QTAeqoJnpUWXWn6vShf5yNPDi_xwXwQilnYlMsGukiM,32 +bitblas/3rdparty/cutlass/docs/host__tensor_8h_source.html,sha256=fzfQv6sTiCs8z0LXjygNYiMvGR78h4WghvHyNWtHIro,120752 +bitblas/3rdparty/cutlass/docs/include_2cutlass_2gemm_2device_2gemm_8h.html,sha256=x9AnruMRn-CeML7nszHsd2RnqbRnXwLHgYBo2S3jHEk,11045 +bitblas/3rdparty/cutlass/docs/include_2cutlass_2gemm_2device_2gemm_8h__incl.md5,sha256=T8HS_qFIs33UEF7OFCcUbA_ADfyJUE8d37cTJY2vQ1s,32 +bitblas/3rdparty/cutlass/docs/include_2cutlass_2gemm_2device_2gemm_8h_source.html,sha256=Ex94u0LYqXtnANYY51GVMcgu1h05wpWLWfpyQP8bN6c,160713 +bitblas/3rdparty/cutlass/docs/include_2cutlass_2gemm_2device_2gemm__complex_8h.html,sha256=uTAOSJ5Tk7VM81thIHTDCFmbrdmHwlLo_LAzOU1Arnw,11025 +bitblas/3rdparty/cutlass/docs/include_2cutlass_2gemm_2device_2gemm__complex_8h__incl.md5,sha256=zo2yhFkskapmS8oEyT5-dFQ_VZK_lrAKKsBsuxtraso,32 +bitblas/3rdparty/cutlass/docs/include_2cutlass_2gemm_2device_2gemm__complex_8h_source.html,sha256=qxoH1pKDgCjC0zkcCKVPQxS6JLCFh_0Swh-dbs53Sac,155460 +bitblas/3rdparty/cutlass/docs/include_2cutlass_2gemm_2gemm_8h.html,sha256=OO-blqqXZwDJD8Me6rjpZSr4_UdMpVdYpQunYrMpMH4,10416 +bitblas/3rdparty/cutlass/docs/include_2cutlass_2gemm_2gemm_8h__dep__incl.md5,sha256=MhFBKkynHDZku7AYA27166AnQqLA5D_T6d7eOh-ebEQ,32 +bitblas/3rdparty/cutlass/docs/include_2cutlass_2gemm_2gemm_8h__incl.md5,sha256=WqI7MAsae_aXsr_nomUq9Rd080u93zOW6E5xnQmFFww,32 +bitblas/3rdparty/cutlass/docs/include_2cutlass_2gemm_2gemm_8h_source.html,sha256=vTePd-mXN2OjKknda2xN4DxSWEH-qG54bltJtAlqMUY,96228 +bitblas/3rdparty/cutlass/docs/include_2cutlass_2gemm_2kernel_2gemm_8h.html,sha256=5qqDta3tEl6Ab-E-R984f8t9Ktj3-6PNalnssJVXuZc,8972 +bitblas/3rdparty/cutlass/docs/include_2cutlass_2gemm_2kernel_2gemm_8h__dep__incl.md5,sha256=L9PVhW3P_RQ4LignmexqS79IVoxUeC0OaEREAVa4lLU,32 +bitblas/3rdparty/cutlass/docs/include_2cutlass_2gemm_2kernel_2gemm_8h__incl.md5,sha256=P4DXJQCez2E1IVWr1bcCbqMAJXtTYHVkxxnnDt-FTU8,32 +bitblas/3rdparty/cutlass/docs/include_2cutlass_2gemm_2kernel_2gemm_8h_source.html,sha256=9vWJCgZGhZbIJ8f9D22XahKl70hNO3Nw5Rh9mSQix34,85812 +bitblas/3rdparty/cutlass/docs/include_2cutlass_2util_2debug_8h.html,sha256=h-UasJZzV2ifv9QV6wR8io1RXbxy0bVWShaWKnVvqLc,13739 +bitblas/3rdparty/cutlass/docs/include_2cutlass_2util_2debug_8h__incl.md5,sha256=l7mSR2fRTj-R34yxjPQ9wATkZErNq_8viuMjT_KwJwo,32 +bitblas/3rdparty/cutlass/docs/include_2cutlass_2util_2debug_8h_source.html,sha256=anilmeFSMfbs8Efif9tiDph_-Mlhc8jKSAoRua8-zeM,20500 +bitblas/3rdparty/cutlass/docs/index.html,sha256=oEvt17eMaTu6KAE15AhgmmnF4pfC5svQwxB7JL-7E4o,16232 +bitblas/3rdparty/cutlass/docs/inherit_graph_0.md5,sha256=-UV4BeufsDBBBFddrdE6YcxLekJJ8MP3AQu6_j1e5hk,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_1.md5,sha256=0EfqC3R8ku6XZP8-MFt99jvHHIIk39nDoFEQ9uYUwGU,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_10.md5,sha256=KW2618TJXonRb7rbbnhOSdihpcJ9p-Z5OR3YTjvA8yo,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_100.md5,sha256=g98LYNGsPSebcMJfApEpTOgjLoH9f1QDF8f3RH8Dl78,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_101.md5,sha256=f6RGgwxNr_iLdrG1ok7glWF65DwXWko1SirqYmn8JWI,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_102.md5,sha256=szLlOqEsr3tdgkMRRgBeSuu4ZFiCNQ4LCd9Zb4YYwJg,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_103.md5,sha256=i6Info_hRmKFx4RdKJqqEJzUC-HmV5Byuu4IycXmsds,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_104.md5,sha256=opO3C-ShvSUtsdTeUUXacdh3R0-lYhPVI0x_5KHi__U,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_105.md5,sha256=t2InQI89arOhT9E5_i_uSAsMCpV_XqPGNapNbwTIB54,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_106.md5,sha256=AKecdsxwE9sRIi_CTsCV41SBtSG39gIPkIjwvd8VT1c,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_107.md5,sha256=4_fi0LaEflN2qzthFinyRzw0MbkYHvC_n3jLAA2GUYE,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_108.md5,sha256=ZRVake5Ykc3J4DPmDqEIRDX4c-ZihInBWY_B1LvoB_0,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_109.md5,sha256=2WfWpSytSnICx-PxNxsfjckl-lXB6AQ-EdhDV4w6bWM,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_11.md5,sha256=s_yvNZ_qc7sFbMuw9PtyoX7fbgqQrexQhhSNHfcN8nc,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_110.md5,sha256=KW1PBNZjlhq6sDZF6dyqlfStpQ4CGUiRj3GXVpkhhCw,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_111.md5,sha256=_JN28jzYXbibb_W7ZOC3Dy7JuBl9t7GFbm8a2mwJumE,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_112.md5,sha256=_NPEbGuhK5xvBOvT6ow_QvjZCNV7imix7XgxdDavMxU,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_113.md5,sha256=dZmSww_4D3jNctLKjHtxe1qMAb3cpJ2Dh7r6ALXz4Rw,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_114.md5,sha256=QaBMI2HGAGsX6WPn0aXAUCFses26_K1n1zVm8KxT64A,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_115.md5,sha256=1msvcZge-N3pv3Q4QkEiupY77UhC4icjajsj4DYhOnE,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_116.md5,sha256=UkrKD0LFBj1499rTrLNZtXpLu3KvoqCwBfDDnSTOTv0,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_117.md5,sha256=MUXrh6tvQ96ditEo3bKqJ8nihGu2rRMiiAyxAyXflPo,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_118.md5,sha256=sTPIRy0uXFtUsSmD3TDOkjiuHsNaRrkdYr698UgQn80,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_119.md5,sha256=0TlwS-FlWJDPErbJgTkSFWzG6Lj0ZIJC9MdIGkziUfM,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_12.md5,sha256=M2c6mAegmehhtcwoZFXHb_5EBGdJ0jTK2ts1eU4MSHw,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_120.md5,sha256=nvwuuAeqYjM2rCuqn_m2qubL_n20cLuU1qJrYF1LDDI,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_121.md5,sha256=OPn_SLA4dCmwXR90wwwavs7BZ8WeA5m7dWDq54MyQe4,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_122.md5,sha256=iJ9kwuRUTzWii_3hSi69gQcoZEjW60pklnjitJjNulc,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_123.md5,sha256=XoNlZ0-o9tniaHFuHXC4s1CU4h4e4EffspDMx8tvXjE,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_124.md5,sha256=iI4k5-8vhvuM_8s4SFcH1gkXNYtL6s_OctHkCo8ABRs,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_125.md5,sha256=p2jSs2AJhIbGtsGEJcIf3wogdlg0llq1lr7Xy08vB8M,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_126.md5,sha256=XYUGXQVfmv-Ym381r1SbIMCNC0HBqrza21CwfKcZyfE,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_127.md5,sha256=L1mJuMXvgBFLZIhJnfzffYPDyZw5fmfR0bGJDhBXBMA,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_128.md5,sha256=AciG0IPw-EO14nLHECENAb5YP3Du9Ea0HpRNNBtCvvo,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_129.md5,sha256=aDrFKhESNpr4T-iLws1ujFuKD7gVynw-RwzLSoxnrSs,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_13.md5,sha256=EumSgQnSDRd2wOswQyaTfDISzQ-nJtfBC5GZQdf4vrQ,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_130.md5,sha256=zCEG0aOCQRyDga0-EbntKhkWMrqjtCOZNiMJnQ3yLH0,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_131.md5,sha256=_XHckSiU5vgVCzHAIH2mwtH2Jj-rjX_nYoI_bbOjPVI,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_132.md5,sha256=uMepB2o2RtCxNX2vV_f3wFLy69MN6IZ4AvQz-cxk-7U,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_133.md5,sha256=K-zxIxKRVevDrtKO1p-LVyY_ay_gqCLiNYxMImpXoFE,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_134.md5,sha256=R4t1acVYAKHqh60Qw4tfLA7KZfgcXihInHvF-LszbPI,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_135.md5,sha256=X0MlUycZ23whvhtbS-2Vs-mOgj2yiDipk49r06F-HKQ,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_136.md5,sha256=44jQOpSGeD6gnFvRVxcp_vxt22uPCOhO0LwkgYUwtMo,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_137.md5,sha256=ISz7Bir7zkEaFIWSRfRouIq0qHmdzG7a4xvX-Z7WnqY,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_138.md5,sha256=WGyNacR2HgxGOSovVW7Pr-NiSrk2jzsW-mK6003H3KQ,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_139.md5,sha256=0SwUoaqPm5sXrz5xQHk64EWYiv5LRMWVdodAfg9mJqw,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_14.md5,sha256=tTdVIjTeP1V0t2kqf5ptE0pMNEtfYqPkjrPctu1tLqY,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_140.md5,sha256=StLhuOX0vWg-edK0oE9s0XSdz8VzXC5-7SwZl2cHFlk,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_141.md5,sha256=5d3oM1V2xx9BDhk3XTTC04NpRCr4frCcDbUsRxQaSCg,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_142.md5,sha256=JC8K9e04Vod9FpvPlVZzk5pv9Fh3Uw1hv-INaViPFls,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_143.md5,sha256=1CwpykK4ImNs4PzElgRQoQiVyp9eAmOfPF2KHhNddR4,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_144.md5,sha256=EA22cLWJyEEHDt-4oETCsb_TXzd02mjqx0oNvihc4Is,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_145.md5,sha256=JuzrpOlNTA1V9p5P1VVkPNE8jXsuqC9x7s3Wy745trM,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_146.md5,sha256=sr923CyrwCuYfMMjo79D4F5F9OoWEoWytnVrJeK1Gw0,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_147.md5,sha256=vzjLpZf-2GH_vCQkYP8iaNmDyIgSwso3E_vy9yyz61Y,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_148.md5,sha256=fPRdcbI8e1RTSLyV0FMUPo0b7kf5agiNTDPpUXOJswI,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_149.md5,sha256=9kxdtTgPRZrN3awuq6oTHh1S8CB8Z49I5nxJF2LSDBs,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_15.md5,sha256=fMLaLPfeM36uO_j-47q0JIf57qtqoPHY1sgL-qOFoQ4,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_150.md5,sha256=o7KI-OtoPL_89jMFf3LGxBoZPe775YEy7FEnDFmBcG8,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_151.md5,sha256=uITk2ttjrAjFUiV4tyLSSVELhmSmCt8XKnmhLPFA6wI,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_152.md5,sha256=X_zncvhJN0eJt9jcV4DSIROZk6LVZYr2gIKAQHvDwBE,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_153.md5,sha256=ZyzTJTpJk7sHVrTPcmtLD0j5gKlXCaw9mUS8-zBWeHM,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_154.md5,sha256=JlMRa8SacCsxBwGLKpEhEcOPVv303gANSH8qS8j-1gE,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_155.md5,sha256=1a-FCe9_gzCVd4tWhs-UJiALA0TRbYWWd2Bvg-yq8eA,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_156.md5,sha256=X_bRopyYvWNw5qyWePEMulkKimbN6TFW14AL690CvAY,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_157.md5,sha256=aM5QboynsUsk3UgamqkTsOm_dgL8qK9qWHdFRhxq62A,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_158.md5,sha256=0oTvS_MFXaS1-JZYgHS3hIvGKfSYi0VxjNkJ9ewMf3Y,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_159.md5,sha256=WRSP5Rn7qCXRvVFtk865v31lqC-mhDoQWNBNppm583I,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_16.md5,sha256=fyBxZZVSSPvkLJYEejQh8T3EHvafTpi6K2zeJOwayVc,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_160.md5,sha256=C-EORPpVHVQrVyU5GV6kuOJ_jgLExRcppOjQT_bxXTk,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_161.md5,sha256=ay_7rF8ZmTF0SFMhNySSVzuvle-nyFMv2oR1xEoVR4M,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_162.md5,sha256=e_3RClXeuZXnj00kSFXCAQhynB4tpl3WUjCowgssqu4,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_163.md5,sha256=ZdpxhDuai1oMj-Doxx2di8A_QTxhyRGeoaGxbHOezpE,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_164.md5,sha256=qGgWyRKXzamWRdcgF-11bWAqvVC--0JvrxZMEAQUH18,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_165.md5,sha256=Dam6qVWyPWI1AnEzazHVkBV12NvZ016jAW6cOyzs6n4,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_166.md5,sha256=WjJPL5kAi7jBE26DukpgeT1BzFyNHosZj3cWGEmGcls,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_167.md5,sha256=aTnlGLy6gRo-G4xF25DpvKxrKh7fVoJ-aToxKJRFeb8,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_168.md5,sha256=hrbUDRW-oY0KLRAHSyNhXsIY9hWrtRry3O-_RJaMOQc,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_169.md5,sha256=eecFn9O5Kqxs9ixjDKAo-xx19HKirU3vKdZDRJCa2So,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_17.md5,sha256=qTpq-5dVs9TsnLi47ozkgY_zXHZfhwV-yTsLwhkOM8M,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_170.md5,sha256=ZJE4lIi94jYTw5aexYkpYtwFp7ASw_9l-GUO36mmZv8,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_171.md5,sha256=5Ut3xwx5TueqVXPdISpJplvwE90Ee3oIwWjoQrVMXDw,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_172.md5,sha256=qUK3AMi-fh0v7yKPAIdhvTEpFmmmSRLxqvE53mS5aBk,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_173.md5,sha256=GckvAGHUU0F2K4uxuJRxwcmyxkdaKzPA4Gf_ufg60cY,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_174.md5,sha256=xJq8Ak0eIHFa2toZwIu_oxnKvROC8PVZIouJuXPLKo0,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_175.md5,sha256=FT_IDQnNgNrwmJYOxZhZOcoDqWTnll8Zlgrnh-5Sg_4,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_176.md5,sha256=qmvlEkhYUYUA09CuSjlgqFy4z2Uujsq7xDp9_lUmLUc,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_177.md5,sha256=pX289LcjzuKspakkXafm_8dKMWkoeZc_QnJAzmR8ut4,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_178.md5,sha256=kbZTo6UnwoDBJEsiD6a24k2xFwNuw85omN5vz2_RFJg,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_179.md5,sha256=RV6NScKDqKATDs_P0a1BGKbmy22yTDbAYGjUuGzMo94,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_18.md5,sha256=6ESP-R9TqfWk5bpDlQ_mLQPi0bPiYqPjrsZtKHnWjuY,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_180.md5,sha256=428uD9_tc6q9IQe_lUdfY6ENjX7TrW9d-8wW0sx3CXw,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_181.md5,sha256=2AuHrN0XRVKCXzi9zStBArviTg0JltyEjtVN0O0GM0s,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_182.md5,sha256=UCupB6nbIvqZVIkhp7uTekHeGjs90JkQSKZssFgq_5g,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_183.md5,sha256=umC1opBqYXl59oaLFQe6NrGTy9d-dsOkBqgLdGimMBU,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_184.md5,sha256=1MJN9RqnKJ9YNVDo19WMaAR2-T7wmUVtvYOHeYDJKpQ,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_185.md5,sha256=2Z6xIc6gCU7l-nfRUzHhkPY15diXbBiGY9XVWelES40,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_186.md5,sha256=NLOIf5mE1mADCvtl6Abod-OEDJWiPFBiv57E1Rv01ho,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_187.md5,sha256=TLTmQIyDslkoiT8gfr7eKmsfI2K-TMF5XR2LjtlF6wU,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_188.md5,sha256=IUoTNV82C8fZRfaOe1S55GV3tlikdMvIC1aSF5BKL8U,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_189.md5,sha256=m3dHMX_UkMy8lHfE-6Tm8ukBBYa34VocJfDMhGvuy1o,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_19.md5,sha256=qwEzsWgR4OdV0dtLxEPQRocI_qRjMoRAoUd5ufXuqNQ,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_190.md5,sha256=EG6bURLIomXSuNJLj5H5j9aOOwEHSe9wDxWukXaspGg,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_191.md5,sha256=cfcPWPxS0jjp9lRo_5UhGFvvFouf8AFz691MymLJUDg,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_192.md5,sha256=fY7APyRNPAz4HVOo1uf7z273fuTYpcOJU_IF_Jyjf9c,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_193.md5,sha256=NmoCq7wbmY1m7xIm-Xsvn5PaYVvfCYziJ6u4RXsQFk0,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_194.md5,sha256=W7jVAdRtFa30NI6bVonZVBmbvCN8VZnZG-l1LR2AvcA,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_195.md5,sha256=vKFATujC1N1_8fzRS3WxuyEgdllTq81i3FPusaDkBZc,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_196.md5,sha256=Zxjhrpr0LCzj38h1yijRmg3Jo4ahybVvpKiHi9FK5j4,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_197.md5,sha256=Bf6FpaGrNyVs96olpTikEYynR7HjI2HFYLlWZNL8NVU,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_198.md5,sha256=12-2pa7qdT-vnghqrZO9jH7mVviI7Wr4exfZRXwvu2Y,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_199.md5,sha256=yYux3Y1GKznoF800Rmt7kgCxNQInBwRIaoPWBVn4Sms,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_2.md5,sha256=OLS1WxMLLA5PPy2MBN8EB4m-ZNOvD6lvESAXs9H-SnY,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_20.md5,sha256=oSrz7Nz_zAtu0JfOgkZwkEwV41BsimpGtC_kh0zeGqw,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_200.md5,sha256=lLgRxvvUjcDK6w_HN3QyZoKA6CImFvsJxSi73GWGomM,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_201.md5,sha256=mj4p7qvzcvQ_dxV38z4P-dN2WLQQTPXyMvXZBMfSYpc,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_202.md5,sha256=T_KcbE0HIwm9KKEVuQhCaynqexkV5hy1kkKhQpyH1Pc,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_203.md5,sha256=LRxERcLTlwowH62eZFuJSvsdS5A4g7kbuMJ_f3nEXiM,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_204.md5,sha256=anfYPYz4_EHcXtXLGuHeK3HtXt_8HGxqWXz2-TXFXNU,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_205.md5,sha256=2ho3fT1BQNMRtTCtvQTFF72DOFAqiMKdtzAheJ2-CTE,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_206.md5,sha256=jBg1lUG6NZ9U6VC6s4gFRjAFmdxBAa7PgZQ-gXbxFH0,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_207.md5,sha256=K8vgz8NsV0MW2gGDlZ65zlQGoGVOL75mXt58ikrwJE0,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_208.md5,sha256=cWQV71nsp7d-FAUJiekMGxEvKazGWyT6BCxUXW7SP50,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_209.md5,sha256=MngDjLYqo4c_LxDidrEY9CaZCzrmx6sbis7mgqFKnvM,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_21.md5,sha256=bQYA_i6ABSaGKWK71MK5dDkzGtXnGOoN5cs7VuwyrhI,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_210.md5,sha256=ZQKbMEfyuJn4A_MtpPvlxVGm2M5nBMHF1PefvmmIyX8,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_211.md5,sha256=Sqq7wd2fdTJF1QrSwR4I8ayE5f8kdogcm15Z5P5uteE,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_212.md5,sha256=rNF6U00vun8DAZT7gVE73osPOndiGvTPnif89T6BI-8,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_213.md5,sha256=XD84iIzE_oXS6Bzz70tuBXTQLKRnpgDsnpQtFQWjvS4,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_214.md5,sha256=60i5sh9hBrxuVQwQgXWa_bDIeK6iYtWoi8THXvZquAY,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_215.md5,sha256=XbmFpfvrrXCYMumAPSWmCCE40DkeYC5mrIwthNfSuRs,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_216.md5,sha256=Nyp0KocxkaeCGhuxddx_TN3D-43Ig_0V-ds7wa6jo-A,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_217.md5,sha256=-eahLVDPQKhktBHqspzqMOgBYX1Ztm4RwpX8V1lYdtk,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_218.md5,sha256=_bo68sn3cG1PG62NbGhI_I5bnsmSSuD8_T-ssPdogvo,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_219.md5,sha256=ER9Pt_GlyRZQDpWxPg8Q1Uuj-1sfztCeFvMN1gNVxt0,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_22.md5,sha256=3HK70OamPPmUVlH-lm0nqHkQ9SsegFFALS99bMbFxw4,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_220.md5,sha256=o4Mr2LbMeYECoBeXKbjb2zuBwr8ZnpSvTkiZ_xXUCu4,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_221.md5,sha256=3E9W96xYGbpp3iqSwJ_kCttHwmPq2oSyx4DU6lHv3R4,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_222.md5,sha256=-jrLpUtpOS6FIH_q0wSFr_pmVHkSvHdE0Aa04ycjnSw,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_223.md5,sha256=gYxqICZs8bbRjTy2Yx8dru3S8-CuRo9N5orsQgkUcqY,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_224.md5,sha256=NfQb35GCeIU7yHnmBrvZLwcr1LaUcn4xJXNNg-1BPFE,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_225.md5,sha256=QBjD5Ydlvl7UVQPWDDiteXkg5V5zgkA_YqVsacrNb3I,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_226.md5,sha256=n2gGhkqm3XH3N6wT_HWSKeJyM4FvQ2sj_Aah-sIAy6o,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_227.md5,sha256=al221xDAT-lhNCDZ6IZVDEoP64HhKge0Ajr2Ra4xYPk,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_228.md5,sha256=tJHsWfjs32bZhLjv6j_U_7VeRATjWxW39s-Y_is5LR4,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_229.md5,sha256=Elx2xEOnj1ByG4WCzhY1EGqaIDTR5Xn4UTZIE-aSkqM,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_23.md5,sha256=BuDvAedhHrvv--pNNwyA4gfEI6XVzigc5_zCbShKWf8,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_230.md5,sha256=wv1k5d5gW_IOp7hoh50l4I_UPegF7K_DFhAVTruXcMU,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_231.md5,sha256=9a-Rve4qzawgjlwIypkbPuZl-6X_WPsmVheWaxyVurQ,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_232.md5,sha256=jHix2UqOyOfvOmtG5TguCsjNbwWmUltHKAq64KF6coo,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_233.md5,sha256=zJbCTEyhkV_kDNTcwOYTwmIz243WXNVpxDxj__I5fe0,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_234.md5,sha256=ZF9H_u055eIJEw4nD-F8q0xDxlPVVGl1VP_9SpG4Y6s,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_235.md5,sha256=y4sUxCmU67SR3LIz5si-3_u2uYzBsRCinLuAUdCCJTA,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_236.md5,sha256=6sIDAE1e3mY7-Fz2FWHcvVcJqKp9t56Tt6wiJrqRIlw,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_237.md5,sha256=_Pl8zkyGW0HaePJmT61D3iW-Oi5soYoCmhBJRae8p1I,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_238.md5,sha256=fnLzgpnp5d5wuFH7_zKl-ll4zM_tDvOEI_AJyBCSR6Q,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_239.md5,sha256=iDX-fu9CVE0_66rORplyk6OzlAnIu-d4QRFteiYhSSM,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_24.md5,sha256=JajFF6W28vkIZ0ySb2h3cNUrQYCKHdHutJca4N6_Kys,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_240.md5,sha256=YxelFf64RVZX2kbIRU36oI0U722iPUr_84b2dj1dr0o,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_241.md5,sha256=fZ-oslYg9NNhJiwe1mSYmy5gxifrDoiS_QV2Y315uQQ,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_242.md5,sha256=D-ceL2QI5B1zDmxPNZ5KNhO29d5OK9_9YrN0IAncYfI,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_243.md5,sha256=2UCzdEyJqa635qY-EeOimJqj8bwkhFYOOnQJp7ZNIos,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_244.md5,sha256=YGFWSUNsDtvjjwG8ShEdvP8ZpmOCfThAytetLiCJqxw,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_245.md5,sha256=-Y6aY6TLt6HyuHT34FXtvNc-kwfG0B67eEQTk1KOJio,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_246.md5,sha256=EwXSdz1aKrdVAxMjVzJjyznuB2YvKvAsj9TSf2E1vz4,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_247.md5,sha256=2vxqzJPzJJjsINCD5JoOJITiFN8R7Hj5AssR3NDTEWs,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_248.md5,sha256=0AaQ-mI6khAynXKLs8q7ci3j2LviVr31E1BJcOmor6g,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_249.md5,sha256=oAg0Gc_goKPz6IUdpYGYPyiJsbnrlEf4xNG3wPepvZo,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_25.md5,sha256=MK4PM1TZsWRpl-dkGDrxy5jgM-yA3rU4b7diBwoG1DU,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_250.md5,sha256=acXCuIhISZIf9CDNDaY97RZy7yAlGfbrUAbgyP77S2Q,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_251.md5,sha256=VWfOTlp_H_iP2RdCc4NpecqUvW7ZC2CqtfyrDCigU8I,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_252.md5,sha256=X03yRVoXqGrs3muNzmKdUmjFjkILprTGKpzoKPGytZA,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_253.md5,sha256=DduR4QcTBE7qLklLd_049WXmXiW6G28b45hMFwymssc,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_254.md5,sha256=53XzcVMjZXUmtHNzhdeEkj1XN1H0m6PHRaR-WmVAlKc,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_255.md5,sha256=RVVJoBWSgUBowpLm5LfxnlUsyCaIBGjOknQBXY2mRJ4,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_256.md5,sha256=1EfGCyLRQSgWGV0-c37IY5ArBxsIwEUgc0GO5RmAMR4,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_257.md5,sha256=Dkq1zdXhsI6ReKQKnQb9Kk-bqumNov79ulJ1T9yGisU,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_258.md5,sha256=f87Q21nnkplr2X06WlOP3_-vzVgKEVcnQj4wxPe4AUY,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_259.md5,sha256=-nN-Pt3D3e-0BDCn1ITZAq3bGb9ycm_oUjMmZzRgUuE,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_26.md5,sha256=N0VmFEGl2VMCOnWCTZwXDQPrcehAFXnuDozJfqk0FLs,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_260.md5,sha256=HwsevL-_T91dBzDN1t5pKOiJotprNFErUAhRHtFWkaA,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_261.md5,sha256=AemwVqcTvKKF409udM36kAefpm_8j8C3n5xe5jLhU9c,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_262.md5,sha256=JbleTIdfJJeS39ecuBnC591_eNIDutIValwMBhQA6nw,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_263.md5,sha256=bNKclpiCYmaSh5oZnAmPF12p4Cjlh27AYNKk6wOc8Ak,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_264.md5,sha256=-Pu3OwbjITmd1oCrHR6vkJxoK0u_S2uJ4_wlfJLswFw,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_265.md5,sha256=Xxk6aIUu7pZ75mqRZFfWGNGCraPcUXybXkN5e_gHxhA,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_266.md5,sha256=kBbEe_5hqthnGjHPBK86HHuEwYeITLENd6EqXe7czyw,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_267.md5,sha256=yuLS_nntYiX4VGlDiJVCf9KysaPcRmzYyn1rzkR563I,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_268.md5,sha256=CoBJfgqrPqI70YFRKAn11VbqciCQfFXbcONMlFQrfx0,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_269.md5,sha256=oaQBkCgtwJt0a0wPl9cNZ9O_nA1ZVV7U_BqpAIHAsy4,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_27.md5,sha256=wL3IApBE4MMgjnfJgmfvaIV4SXgPSt9sWht7edtH6gs,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_270.md5,sha256=dgF_fe7ccnQf5uP8JDrsRzM0G2fAKsPpFjTQH0mO09o,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_271.md5,sha256=_OfezDinKnHPmPhtkAUlYircHNPSurBWB78DcVyWlEY,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_272.md5,sha256=8i3lWrH6OrCU9ERPRpqjvWxUnZ_pO2vIMOOkGqbnf5E,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_273.md5,sha256=UNBSDQuaMPYOLh2V3Sn2uQHpwHTLepdTMY7_faROV8s,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_274.md5,sha256=k6o4uVeSrW4gGhq8YX2DXCM-36Icc7LRlNtoUA2D65s,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_275.md5,sha256=wbuIPyfI17eEMgOoCFPSmc5H9m-0xmxXUDKuR40DHGI,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_276.md5,sha256=3Bp-M5ntkzacOXbRysfDoevhX4s_idJlYLnTBGzdB0k,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_277.md5,sha256=Ti2YurHNOUpC2JEfJaZbVbWnIvAX05gVbR9KEpRvIgQ,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_278.md5,sha256=KxRaVibPj_1oZJA0raSGOedmYPjtwY11HGTBQsLZs9Q,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_279.md5,sha256=Snv8hdUaDXdjt4CKPMAMcWo029DtYEBOutID6fcrkFQ,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_28.md5,sha256=FFRkIY4-Fmb-805erVi-ieFohqQrbsWmVc1ZwQWl3mw,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_280.md5,sha256=p0W_GKa1gZTjmtP6mtsqbFVFeEk_ecCj-Al-vai7LF4,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_281.md5,sha256=Zd6nyVCg9CIi9LoKlti5XHZGD8sj3gVkRizD_fBvBvA,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_282.md5,sha256=_jrZEMYKUX03KNMejwz-4kjCaCNgwxMXccI59MCyqjI,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_283.md5,sha256=L9v26LWlOpWG1S5dgL3PZZOH1pBv0L0Bjc1WnM4gj5Q,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_284.md5,sha256=nOVBZNuk0snzdG4lJ_YEL9jScfpVC4C3TgvFdCQmxu0,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_285.md5,sha256=AdQXviDdGjIwzYapfiZyaHRp0xKuXqOCADK8rq24jW8,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_286.md5,sha256=RsZCeOnKD1TSFEP5l1VfpuQpR4yl1HQZHfgYgFHYa6w,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_287.md5,sha256=iZBKFfX8cVW23xWz3e55qsdLefAGA6GWPjSBB-bHdHY,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_288.md5,sha256=T_rtsWeA1674lZFEqt6GGCdWFgiNs_ZUx87V9cGAE_E,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_289.md5,sha256=mImHneq9jpxuvB367LdVcOZ_xDqmWE1AlPRlwNb5i1k,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_29.md5,sha256=2FBhCTIWULTs-8KTgCQ0AsEoJfwUQk_r8S_Vhk6tKaA,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_290.md5,sha256=8kygCMiyslPTb13bUxIxvaWz58gOijxR8o_wGlnwoDs,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_291.md5,sha256=yUcBF3xBhnXyxt5bP1WArd84_clUdqEkawOHEXJ3Z48,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_292.md5,sha256=cAcLqvZo-RlNfy5VPLsDnmuZ9Kf7zSwewkdrANwLtxg,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_293.md5,sha256=-fB96PxmMtVZ2W9W4V89q6eJ48JHt9LHszG05TzHNVQ,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_294.md5,sha256=N_TPSjuX3lDf-lVk4I02_gkbJMLwT51v1BwfqeIUVJE,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_295.md5,sha256=AT-4h9wHl-p8QJzW4wv_uhoYLC4kPTGh_nGTYPskh_Y,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_296.md5,sha256=8eU6M4NM5QVamJu3Db1ClsHdxwJkBdKIOnYwR0RSnX8,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_297.md5,sha256=dvo41DWK9sdmNg401lj2idl9qvIbwGqeG1p9md2mpWk,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_298.md5,sha256=pgLOvh_P1F-UPE-iHlCarZR2jj8dFxbScOSgqf_HE44,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_299.md5,sha256=1KoUS00kdzmO1nPf2IjlQ-e66rk4fbuoQ0bCbY2JG68,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_3.md5,sha256=xhZe43dVSAA9hwWFnGPDVOPCh94SpjRDUvOnb-eui_4,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_30.md5,sha256=IQkHNA5WRe4aV-8mzWtoMdde2CrlXT78_U7806JhNbg,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_300.md5,sha256=AdKCQBbiQUZD5f4u_7Umsh-V81jzUb7O0EKv5RIJ5ms,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_301.md5,sha256=rAaMUm5zxtzTVbvCePCaxTd5p2csOsNot8qQIFOu67Y,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_302.md5,sha256=iLPGd6ZeOXfzpaRd7UdrI89xVRbAX4X6u8JyuZjUct4,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_303.md5,sha256=U3rtY0P6Ebqd4ME2wwGtjn0UXF2-TqseTQKLP5UzjQ0,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_304.md5,sha256=bGxzB4OsfmQCnj6j7fueAMaFqzNdZDJfZKISEc9Fvh0,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_305.md5,sha256=MlJFnQlSxTtHirwqBnPRuVil0zE-Uz1vf7L_MrTBGTQ,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_306.md5,sha256=aRgw3LGgSJGmM4ZwO38i7zZGjNiTS4wzJBMv5yrI0nk,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_307.md5,sha256=cRA3RZC-WUjEifbzWLTHsHK7G807xG-FzaYPfIPpvdg,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_308.md5,sha256=_KoGdW4i6YGasMTinkMoyFv56zbWwqKf4-gBayKrglc,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_309.md5,sha256=ew4u6ED3jMqT9fzgaOK6wYfGwTVCNOrvlvxcHS_VQbA,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_31.md5,sha256=O6QArVwjwtOn988dBfDGODCEqvjQlCN3gJ1K5UcRU1E,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_310.md5,sha256=m2fZc4r9ndOmqcU3ga9d2UJvzj1gsDpIJ4PkciqPiro,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_311.md5,sha256=XXxXctidLtfYrAhnjFWdVjpg6ZNgpiN4LgN-iZj0Jec,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_312.md5,sha256=RjjoSnHCOdMcJaho9esvdPRDDEYipPiPyyMOGG3IBYA,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_313.md5,sha256=O8rm6X_WoBe-W4BvGO93reEtmKA6m4stZn2IOrGP9Bc,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_314.md5,sha256=hbevHN6zDkH1CdarkqXz7siUYiSJCG697yBHhhMZoM8,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_315.md5,sha256=f0nmcjRq1hx94BG4ShuQGNVonFbUBd7Y5Pqc1W9us-A,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_316.md5,sha256=wP4MsPtNwJv4LaIa6sAR8MPDasi1BaKo1tS1-Xw4Wlg,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_317.md5,sha256=ow-Kcsp2JzJ6TYLEGhsJD-_vNFTnkwp-OzBO-bo0FQU,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_318.md5,sha256=kpc1Q92CUJ_jBMLaMNuorp85_9Oe_wq0-w3BS-YUQrg,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_319.md5,sha256=gI5Or40kceey6Adfu5SYp7ltWe3q9xnXfLZtWwewZww,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_32.md5,sha256=v0HejR4-OxukeMib2QMwhEXzUCzRhcSN2XcNJMkiO7I,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_320.md5,sha256=VTK89wKfxTGK-LyhU99XvyZX04ZoYmptL93CiWpcvlY,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_321.md5,sha256=NaTbWnLozwrwPmsHrqXTehciaDsUCAMbzaitY3aujpo,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_322.md5,sha256=_UlfR6aSuemhP1WbXVq6kdv-DpKh-96IpppAiNLuC9E,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_323.md5,sha256=-q16GmC5uz04rl5M8I_Pdc6q7nOfF_QGNarqoLPg_18,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_324.md5,sha256=IJ8bs9R46RWYLCUvudo3pEeZ-aFJQq3qxRC8KGJhjpk,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_325.md5,sha256=9ZHsJ_0nQnHCLW8NuhrTp1oqzIpcumwTZXmdPnNvuIU,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_326.md5,sha256=t3aVavj6NROu7VZ6gKwBeMmzK0Blw8BGLthrkRei7J4,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_327.md5,sha256=ynz0uPPYL0AAhuBr93tUL1eTUtZRPN-HWwAI38IrUao,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_328.md5,sha256=MxRdDJrXi8LgFKTgcsgFz3STnxaalAJFSmeO9S2Lw8E,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_329.md5,sha256=5mHFY_gmLweUv9eY8tply1EjiuadgEt3gFkJAnfvQUA,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_33.md5,sha256=4-FXYkI3buti4dbMLi7cniJ4QYIvmUYpwcEgDdpLNbU,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_330.md5,sha256=so7IDlue6kg8FkMuQHTu6oeIpZSfmjBU8KIGG8_dilk,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_331.md5,sha256=4sC0wdFqW1XsJduuPjno7pETKtr1XLzqIQiDc7_xJnc,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_332.md5,sha256=T1PX7rTbrPvhz5zn7x4UkyM-GMOxlbZSnO6d8OV0WOU,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_333.md5,sha256=TgZ0ePHYJQYo_nZ0K21iQ2PCK9gTJ1UzdEJA615a5Fc,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_334.md5,sha256=zrNtzOWR_HOGQ63M9dJ7shPNXTHh_Lxziqx0GRPnE7E,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_335.md5,sha256=d93bc3N6HO7_MgtUwhE9Qqyg0WTD6lqrWmLwga_VQVM,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_336.md5,sha256=snUY4mN8mEuNVTNVuxJZKA-sCMfUh1l9Rzv7NIk7Kic,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_337.md5,sha256=ARxIbnMQz6R7GLX0DQ1dSK-qET_6R45SqSJO1qZ0Tqk,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_338.md5,sha256=zagZSS-NzQ60zadxCerPYKWQFm_jVQRiTNmtER3LIxE,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_339.md5,sha256=ODdzphJqC5nmE-nkWbmCrvrNhZ2i4QJCcLrEQHLnFps,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_34.md5,sha256=r6EQSKdq1zwdogdEOU2Ut9HP_TVgtCDVVqBJnTvRC4A,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_340.md5,sha256=fgimuEpq6ZVuJmvVgfaGti7aQ7Dtl4kyKRbmpHenhCs,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_341.md5,sha256=jPH940yFHXfV1D9YvX9jCHmfwIiTUUdhBcWN_8Dg1Po,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_342.md5,sha256=Rnp2sogMel-Wq0DgXRUdH6r2Gr5WuJZ4NR2d_QjpYs0,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_343.md5,sha256=PPlbBCdB4yKts04Kxk7nQfLXNwTub6BCGa_oqwIZ8fE,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_344.md5,sha256=EgaOlvcYNxD1XDYa_rEJJnmiGbm0xD3NBSjpbdd4PlY,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_345.md5,sha256=AlhndSSqGOcUC9C4_4Rkg7L-ijYNlBJG2qauV7fgfWw,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_346.md5,sha256=0do4GN0vj3S_D3oVblXDT5mzxqPi_SyR7iMasOhXkn0,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_347.md5,sha256=pRwZuHfqobktZ6-HT8rxXHdMAnkwmiCq_wPLfZq4uWU,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_348.md5,sha256=okYQJCoU07LhHOhUeO4EsnHzw7n7SCF29u-OTv5DiQU,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_349.md5,sha256=P-tFCVu7cXaNmbubX5EqF01aJ-i2PDGbpWAkXlNUTng,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_35.md5,sha256=d0A4Vm4LlgxZHTtT60mce0Y8q04LzP5a_1TEUYSafsI,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_350.md5,sha256=xM8OeAkQls2ITpyRfecMYX3BH1RHnxwnwdx-gNOfyDk,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_351.md5,sha256=YGZ-3d8dU18FaodrR3M7LOBPVS2x80AyTBlpi8u9wpk,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_352.md5,sha256=xn6nqkI8xyGQVmG9BxQ_hTO2bKdPxE6dbXeuPEg92WA,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_353.md5,sha256=N7EVgqWDYETtxC61fqYGf5xmwLfGymscUL6cf6kAjDs,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_354.md5,sha256=9pMVcFvsjlJNPRwKidS-PBkue0o_tpNkK5qRWXEAFHk,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_355.md5,sha256=8h438LEZ1Q3bT0_Kv9RCHgckbFPYaxvkL5j1wFr4ZKY,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_356.md5,sha256=fvDz2UgLMccjqnM3lIhVqUoUFmZXABb0zvoKjSH1r9U,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_357.md5,sha256=H4ChiCHeMB9cp0d9UPUptJU2jPiGTPv_VMdhpz2jdNQ,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_358.md5,sha256=NXrEGQE3IiNTLNHfn2v_H0Eq_51GxB1lu1YZjup2qUY,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_359.md5,sha256=OLHiNCn7Bo3GQfSGf5FN73DiugLpJvCWrwOUy1jg5AU,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_36.md5,sha256=_SdDIv9CaKfp40gEwh4fWAE5QH4aX2M5MaF9FirLgsY,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_360.md5,sha256=afhLyPz_V0zIYpwVPhH0sHvueulUG_ZiEz-NAxuekBg,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_361.md5,sha256=A913D_hRtHkthrerf7VmVtRa77NjwonQdq_Cdd4skNE,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_362.md5,sha256=uFSoQvFO4Nf9XKhWk1ECdeqa36Ilm6i-eXC8VxLuwwk,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_363.md5,sha256=8-GHEl2cLAsERF8_fVlvOhmVVKXFMcwuQUHcp7nmiPo,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_364.md5,sha256=p4T8bEAIBlTOgoWKG2n7QDZMBIbDN2XvXrkTia-c2vw,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_365.md5,sha256=XjzGeluIjlXfi5IZs1Ojsg_KWJ6avpR-A1GEgqIKhVs,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_366.md5,sha256=IIDhW7_giO9Bgk5c93Pko_1EYnGviRFeT--HyJglB98,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_367.md5,sha256=_69_l1ZBksPN08vV1JELz97WVXP9YXPfmHUmTA4Dh5U,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_368.md5,sha256=MRjpXg0gKSNfXnvBXEjNHi2OnumyP7RZbLjMEu8BnlY,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_369.md5,sha256=k-fNq3-7ttOucG5QuquVy5OfjYXi44O_xj9uzZvTBo0,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_37.md5,sha256=VuFmZd_E7vQgV8HAj9inyzWDmTClKP6dan9inCMSsUU,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_370.md5,sha256=bMTB_RcG4EIUuWxGySfIbMru-Greq7QZ_tUzJAU3x6U,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_371.md5,sha256=XnpBFGkUZcHs1RrMg3zHuEglwm__o4yw0Ph1kVr4Bq4,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_372.md5,sha256=tQ6j-e62yiCRORBo6pZL7UMaNFRMvBrKLqusYolAAvw,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_373.md5,sha256=d2gND7geA8ti2lr_JNKgpdQGCYoxE5kNypprxLcRxZw,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_374.md5,sha256=i7icUcPazTlONbqAoU1zSxNXQ30O5-s0Kn6j_9uAshI,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_375.md5,sha256=mFI6-xMMCc-2a3mbzy31D0Fl-pEltW6atWvX5iyPTdM,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_376.md5,sha256=SBU8KiuP0dJ_X1uyj7_wv9m8xk_2ACRnqqzqcZSzRtg,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_377.md5,sha256=Ic0sFTIF8czftJ_MRILlsBwCBteigKIvvqfPtkN__WA,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_378.md5,sha256=O9LuBOqUsnzFb3ol_neUtSe2rmN6fA0COLw7ftWnqwo,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_379.md5,sha256=rm0WUWfiC-N7mZRFhYR85_fmKyGHDZAhnkf5a9TMAjc,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_38.md5,sha256=Zama42yvuR_tcL5ZzeSNKR9-CvrW-KUlA9P6wyaZR6Q,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_380.md5,sha256=6BK0WtCi4T13GSW6fgWynTm2w6IB70uFNNo2uIgW2OU,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_381.md5,sha256=i43_0RPLYynOPQmMlaJmyC4xqCjkTTPBwTqCeaH9vg0,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_382.md5,sha256=zHP4fCqwMEd1utXkajG_u3-2LUZoFERtXuTho0PVu_Y,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_383.md5,sha256=QMSSIjCC3aE7Gzu_GPV2Mk4akUUXgL_NNpZ_In_ddnE,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_384.md5,sha256=E1F1jl2BVlGDVqXbdPWlgWiQt3zyrlaoxNXph9E2f9s,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_385.md5,sha256=IJ4nvi_9F9jgVYRT6bcweuUBaGak9XcO9vyi5gJZndY,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_386.md5,sha256=VFZL2IflKef83G0bEsKD6hEtvGviJkAdnhUbkXRvbM0,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_387.md5,sha256=ExSDtWxawU8QdXy2hEvQosu5ql46Zmk9sFYf6A_6yHo,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_388.md5,sha256=qj1ApRZFJzSQlf6caTNCDQqsgb2czV3Yaf9P8zrL2WU,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_389.md5,sha256=NOvwDL99mK8FmyefRkpZ_gH-FeHdV4yC-ek8_jbcmUI,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_39.md5,sha256=OltD0tUjXeOBzrc3V_QWJUTCX6O1nQDGr5ACtjiCtk8,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_390.md5,sha256=_xTsIYcQbtqihhWqvWM-kL3YIVgj0nIVBAIcpidslhM,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_391.md5,sha256=x7vxgVelZO_zj0ct_HhNYpjBxYLO93ZeHAnX2Ch3tc4,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_392.md5,sha256=MxEG3k-5BinzMgBOAfcy4Ci9LYl7kxrh4MDWs6855_s,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_393.md5,sha256=t8r7s4JdsLm94QYHBdiWFGvNb-RAQiFT4l4fzneP13o,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_394.md5,sha256=mFYbk7tcXENJOnBtBt96ry3pABW4CRoYO6QoY40yPxw,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_395.md5,sha256=6AchcwkS_wSge6KYFZTL-tODF7OrObuY7b8rnBnZkOk,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_396.md5,sha256=a5n24V4DvzMk3DFrB_BGNQdbF9uMKuACJP0v5MB3tpA,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_397.md5,sha256=siOkFT0oTroD0rzKY86XCrxqIgkHQEWdkTiGZ2Wuw4c,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_398.md5,sha256=6bapS_keOT-FZm0XbxjGcl0sjQpWCZ3-cDfkHKn1qc0,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_399.md5,sha256=YWj4uZYfFmAmQElhACLZ5lBBx7t4K-I7KTdh94ItMFc,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_4.md5,sha256=rowSjdOoaXIi6WpduqA5sMm12fu0jTsCUSjOA2yFoLA,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_40.md5,sha256=z6WhTr9mhBC9GoasCDcX7Ro5ME_KYpSLNAvcqRcv9Co,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_400.md5,sha256=7-mJSN9UtatKOc9HUQemKgC-mUOSBRJv7mjwU3C25N8,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_401.md5,sha256=OcYC_WNk5-bzCVUEQ2714IxXd0zwTIS_UXAvFg07bFs,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_402.md5,sha256=K8fTCztR3sBD2clbsZXWeoUE1QmA-N-926vbzRsRHd8,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_403.md5,sha256=KqphMijPTGfpVG55sR0M2-5pxpShLnXMghsj8yLbtNQ,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_404.md5,sha256=MwoKOWkkX5NQHf0_BQDtR92ReycuiA-pyTuBPHwg-yM,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_405.md5,sha256=GNnnedqRecdstC0R_T_Scr9Vuq_xtzBJ3jXbc7hwN6M,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_406.md5,sha256=SMZgW_ATWOJ769wxvYCyLY4B4LHEf5gIi6TeyfL-FMw,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_407.md5,sha256=rgAB7G8aC1PnXT2l1rNA5tU-3V0azJaxz4D-V9oUotY,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_408.md5,sha256=uwiHkB8J6pxTS8DJlfFYBr8rSVRNJU0dgoSgXpQDC6E,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_409.md5,sha256=bsfReS7UVIRDkTEG4rxqHwHF0w25SIkPA2gGDQEBL4I,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_41.md5,sha256=OMHocWiS9swqGjSDkcTiqIYmwTTB_2Gc1gEpBR4Hifw,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_410.md5,sha256=f6RQv4V4lgwLQt2O3GvUj1XDQN43nmWHS_TBlgy75fo,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_411.md5,sha256=NQzEhXVBj_u6fh2Lz7ViDRPafNS4AnVQxxlNPZIhs-c,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_412.md5,sha256=Nwvf8vCJjr7IlfvefHBXkc4KykBXZCUP9I7HaDBfqRM,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_413.md5,sha256=SkpmOhN5ujTpD3UR0Q3WRkcNL-gd0-ZietN2pFnsM7g,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_414.md5,sha256=AgHObRNJm9Q6h3k8J1e1n0nUaSjAsuJS15e2us7QiHM,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_415.md5,sha256=QqoZH5joN50Y9u5IrwpyyMLmplpjy_hOrovc18o0PHs,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_416.md5,sha256=yZ1j5pbNUeukzXXj7-LW1E6_jb9DIQln9mBUzVK7SIg,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_417.md5,sha256=a6FJ0SBGEEumr_eVcdXa3eI2GIoNWSFIujlqtwFWHkE,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_418.md5,sha256=Xp4i1p3DUFbdQwxJolzWzaPWL3zM249bemhZvIup_qQ,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_419.md5,sha256=Cldf5MCCYAHQVOx_Dv1HKGli9IOwPIdXje1hXkWNCzE,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_42.md5,sha256=cyqwqMhqcYvw2tx7gPLkffpBk3iucR4mUn9cUI27aM8,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_420.md5,sha256=Q5gWSt41fe73h7WvxK3CsBeIXrgzZMs7mwGbbSJ8CyY,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_421.md5,sha256=bI47qh6PZXhMGee08IpuOwsAANfGM8G0Np7LQVpWbbo,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_422.md5,sha256=tpNMfJCSw7EwfIfaC2MRomatsRCM39zo81Ffd2cZ2ao,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_423.md5,sha256=0AZwqBGkt-mLZu8bIFggCID1_Bh0p7765z0upxeYOQE,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_424.md5,sha256=2b4b__kmZAQv_cTsbmy_3G22kbHfPirWlDeuOJhBxMQ,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_425.md5,sha256=b0_7V3tOlGQqtIuFjg4o2wrefKezsGgTnf6r00oGf6Q,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_426.md5,sha256=k8Qnx0vRKlpKeLGSGyJDrhYl_V4nayowrwulU_baLDc,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_427.md5,sha256=aSGa0Afv-bmZA7q9lwdQ6j-JBMfLInNwLkZvyOUy818,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_428.md5,sha256=E7VATmZ2kY_MxIapfnooegyLZ9ckI1ChxVFfpeXLtqo,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_429.md5,sha256=GqFFISBWW6qPAwydsTqfWfh3CycAf7XrcpHYF8P3KL8,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_43.md5,sha256=3QrcIPj7Zv-HQi1mkCJtmVS-CEvoiJ8ravXSiWny8Jg,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_430.md5,sha256=tpC1Ov8JD7RTdcyhuOcR5JgqRwmIRY0zfY323EtUwcA,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_431.md5,sha256=l8ZNElg9IsnLc8YmacNwsGs1FZ1K8SMDiDnyW9BYAm8,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_432.md5,sha256=g-iKVUu53zl4nlXyihtuJChfpNWbll01oDBs_5redkY,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_433.md5,sha256=75rllh4T1yfXBK0FNGTR8MRczQuYtN9sSnu_7OQy6VM,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_434.md5,sha256=vXaGT-vp_8O8F60CkwZe0Dx30iV0IbawbY9Xo8bQhIk,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_435.md5,sha256=ZcqYiBYEHsHmfwqIl9_-742qUIYOJi97q_sdLVdkQaU,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_436.md5,sha256=PtgQatAbc4Wk_KGZd1YLw1oY275opSXEGYpiCzDf8B8,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_437.md5,sha256=mHNx66-qKII8ldzMsWcKPNixNFUdzR7czzu2L5PoqxY,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_438.md5,sha256=71eEIpIKLasBOP74JChSnvdf4NTZBugviK4MhGDizHE,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_439.md5,sha256=X24eLDhFG5xMtaEQheBn5EC-rRbR2dvhvT9eUw3hGng,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_44.md5,sha256=SO-ct5khZWfTVVDUMfHZ9q57hID9wd8QyC6P0ksL_Zk,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_440.md5,sha256=jWJ-pdlNNxJhHZ9jGAfMfsVFCWGhMPAFCFidYjk_tzc,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_441.md5,sha256=_7pN4pbvNaeJ_0Iq2TA02c87aVHvGYf4lP9JSAy_D5U,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_442.md5,sha256=pmWvk0004xx-MuRiE3Mgoh8EbU0gwlT2rRGNyMlQstE,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_443.md5,sha256=3TALtr_HeLg_AUEAXsRuXKQ_NMa1NIiUlagPLPqkvCg,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_444.md5,sha256=BqrJdy5HJdZniVSJwser8Bx7Mzct9TziawfAvfbdJnY,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_445.md5,sha256=n-rKI7YtEEk_SsSknmHkqGQONYARzM9eXS4s5Bzc-fQ,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_446.md5,sha256=pezXF15z83zDzksEhYtTUXOi393s-a1UnnpHtsIUEVs,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_447.md5,sha256=tTsAuDx6IMgSVE6Wx8LPXIzv7VdvBwCXhGe1agOadZU,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_448.md5,sha256=LAuNjDPqvMT4I0Tn4DEmP9wfJUBN7YzSne8N2aRSDYc,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_449.md5,sha256=zXp6ZpqcRZmzqXzuNoH8THn9wo-30cucbubfRXmdh7g,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_45.md5,sha256=6XmN3czbqrJ82EehAEP9elAosvWLX8HMW43aCZYY9lU,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_450.md5,sha256=kk8M8Rw1SBfwQ6-YbpaDyAaZM70RLVSVUgYL5Ra4riI,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_451.md5,sha256=vdRr4fEAsnLg-d2-HTlFttjEQoBSw51dK4aWKNGmzUA,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_452.md5,sha256=-hIMSVMGiYwzDgW8WdaJI1nNTi8a-P31gmxsIz6f5PU,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_453.md5,sha256=czgHYMLQAnMAi6fTU-dB-3lU9CzIJ8PVRWX6eCxHHmY,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_454.md5,sha256=-YCXbI2oegG0NqWQP0-xHKnyMq1R5qOT8oDP21FFnCk,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_455.md5,sha256=V7oeVoPltV6ld4wbPWWFXeOhKN1CA3nKMZUmYIy1Z_k,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_456.md5,sha256=Aj8xRBXqa81AQv_TKVSSX2jCmTd3FD7rtoNa-3e1ROc,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_457.md5,sha256=E8SCnu3X-hIeKCjwlw1YulDqyF9V1IL5v6S4poGB15A,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_458.md5,sha256=dDG_KInGqYxNtsGV2qEdVBmaHlcRcGz8839J9TQw_xg,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_459.md5,sha256=d0Y9TRqpN6ubSERvTjLu5G7w-UYDMsXn4d_rHcYn0Zw,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_46.md5,sha256=3zWgHE-wDhl7A_COWikhHGAyqw4l8JK6UnlGtphBW3w,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_460.md5,sha256=ditRq6NXW8xLj0CggX4FmmiBBqudisCdtsiGSplQIqs,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_461.md5,sha256=XAGOeyHkLwLPr-9JLicGAUHmfwYDwD3TGNPKUmS1Htk,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_462.md5,sha256=0xB-9YAeJctaaajnaqZJtE52N8n8j2DMJFT3NtkJT8c,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_463.md5,sha256=77Gdb6bznolFyYW7NPgBlPdGrxn5kXSs_Cm15W5dj-I,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_464.md5,sha256=umyOy1oj4yGLOzYi_K5HaVfVDFrO2X6p7ByXXo_FlzY,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_465.md5,sha256=LUM8ryj6xQIFs6H_L-1T1jC7crdH_XTY6WctKnAmXmk,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_466.md5,sha256=zRYKocK4ff9UEcNq5Ea-cp108VolHl1j_PZ0kvO8mkQ,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_467.md5,sha256=eCjYOTmvFW1IZD7CEsLioeDluOz7NE3rB5hNrjRDLP4,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_468.md5,sha256=w40ibLFG8w0D8NlEjwhC9ewaD8VhkgbBp2yLzpDqLEI,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_469.md5,sha256=Lq_jfdNv-IrQOE0UgdvEbDReWq-cHapA4CPBRCSStPI,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_47.md5,sha256=KveRalotngnycLOTvuevnowtuJYBhXJ56Nea2Of-ZUk,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_470.md5,sha256=_iEZvioDRvP_PmVI3dwdQ5kFp0eiesEj8toxbm5Bd7Q,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_471.md5,sha256=2SV3mmnWmDzszbmXfqaYgSp1yTNFUtvs8wKpu5vvlKU,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_472.md5,sha256=buVgDaVIo4Iww3OKP3NMehjqwE73mBu3L_M9S7A634E,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_473.md5,sha256=hpCpXL60w6y295Ge_WXlcMJgC-5lyf9FNPUVO7oyDjU,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_474.md5,sha256=KIdX1dqTyo0mzi5ewa5jy3Lc26a7IO-2TBnmR-SJSKU,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_475.md5,sha256=S7V41M7sNq53TslMLq3y3mt4DQBqB0OT9vWCW3UUPRs,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_476.md5,sha256=rEtc0aJSEVBaCYBAmDWIMQZKApcthBrcM7PI3-30UME,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_477.md5,sha256=L510eK-mfuhGeDPN0po9SLpOBsckpkCpEKx_bq04Vlo,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_478.md5,sha256=GFpdgjoiNzTUIlkcDmEA3xO6yQpQZHQFa9YrOMAwQ3g,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_479.md5,sha256=MXqD_uM2TB_jwNij0-NzBXHYqWD5s_VcQNhIcjOebyI,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_48.md5,sha256=QawWb5MEzCDtCtAWOugb-nVmY_L6alBd-U1mQk5f5xw,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_480.md5,sha256=1GIkRVw3xJo8l1kTPk4kLEClCAWGvFyzhP5ywLvY6Dc,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_481.md5,sha256=eg--uqEZU6bEbHgZ1_XXzQy0bCRmKd1hexZXNlRaZ8U,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_482.md5,sha256=i6jqgOZD90GBzUAm9hKOC8avpXo4gAQIBwVhq2zasyA,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_483.md5,sha256=WDQrBPTGKEbYEAIT6CJ6YaIKdC2R1MbLSK9zbuqgFoU,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_484.md5,sha256=_Jvdz_2I7ttAd8F4KM6_BtBD9_XkbXb6kc4pyEGFufg,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_485.md5,sha256=MvZ_QdVFyBvTlhJV8YYRImyOC5NNrMYDlnHqwzdtnw4,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_486.md5,sha256=N8bOXtI3J2fLzLNVxXkNJ3wz80wT0cdSYQYDQw2AXN8,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_487.md5,sha256=s1--f04_lJsPEkCDSHe-5L9W2tf8Ck3ryKrxpdQxLEg,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_488.md5,sha256=GAR3GDCw2JaO7Nj31J3aqGLIMPXVBZf_8hHhog_cyCc,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_489.md5,sha256=JUz2d4TCRqA3HJS9xOS5KdBCY603y3VOctEsIomihUY,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_49.md5,sha256=aqVXuzDotUHwDde09xNTx8E2F_nM2evaqmQWnVefSog,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_490.md5,sha256=rFNtjVCW33T2LFnMBg26j-wCo0YGBeqpbIkxsc0AbQI,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_491.md5,sha256=EiV854O8TfmAHQnbcj0MZwXRuv3moBwkuNUOmWSDvH0,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_492.md5,sha256=mDfGMr1OD07gf9-huT30xuqak-3v2AQoolTpScATi-o,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_493.md5,sha256=u90Ape-W1OiL9k4ha9Voj4yytwYTmZAS4yhaODu8Pto,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_494.md5,sha256=G9Rx5Mt2zNHx2hl-chJOjojGu7n9YXn_dvqT712mslI,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_495.md5,sha256=G-P9sEqVEzvlNOBSC7cXxPV-qr3mPq5iWJaq_yRbyr0,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_496.md5,sha256=VthKZY4vPMgW7p3wanCL0R9nA9JF6cVzSuXPUgfu1es,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_497.md5,sha256=Y3AVnnUWBvXTcFkv3A-Fs6YbvDtpmbZ3L8P-iy11z9o,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_498.md5,sha256=ee5FTNA4HEpux5lM5_vhG8nPI31XbMM5UsvFZ9-9-V4,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_499.md5,sha256=q8kgWvSJq5zstdDpkPuIoB8Aw_SkQstqNszZWGVKDVQ,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_5.md5,sha256=SOPk-oyW89J0GFprp38xoS4mz50lzMoYapC1ctckCLA,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_50.md5,sha256=XyyxYx3mMnILJ4ODnDvxZ47-UUyPAF59Nl_yt-b57OQ,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_500.md5,sha256=TVMjGT-KIaaNSQ3G6hLbRZUpIuGn1HudeCwvhWWxW-Q,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_501.md5,sha256=9NvjXFhbv-Tv3iL3EaHWrQmak5Yn7uITzIvWnGDjcvw,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_502.md5,sha256=kLyJuu93zUcZjc5UA7XDhd0axRH2sQemzat5QZ73TL8,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_503.md5,sha256=v0TS1scib0-fzlStsSi42Nm6d_Ut9LJva2JMW6YxeT0,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_504.md5,sha256=OZn4fxQHQhqns6S1Wy_gLtZNck8Y-sgyw8DlrIVFTFc,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_505.md5,sha256=cp0U2abFiINJSWvnrBMWYjYK1GLHtWL2Psevw07aHj0,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_506.md5,sha256=-zFrpp8e-Y7_BXL8z92kS2JcvvpBNLccpefYI8dZCPA,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_507.md5,sha256=h5DuYSEYh32WuLN3kwwXe7sXNg9s1y7s1E1IBlIFKN4,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_508.md5,sha256=JqkVWBg8PCecJ9vOpHhl3-IS3eqBrecX05zP5-L-WZw,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_509.md5,sha256=-0LIcVerUEtHmBG6MujE0FkqsQJT6IH4VSViroZWELE,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_51.md5,sha256=A5M57xOu_plRSHoGKjlOOtDZgkx5VmYpvFO7F7YiCkE,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_510.md5,sha256=WLxKxvi7woekwuXf_WJd1cJiLZ8AVX-2BkbSqwdWLF0,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_511.md5,sha256=4OULbA1x4OyeGh1w1kd1snuUChCrr2732Dq12jP9rho,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_512.md5,sha256=VqBNOzoYjWGivA7JtCcXMDtVX9ciqgS0eiFxfu-2PvA,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_513.md5,sha256=Ce0QczJ3DvNeYES0kzR1qhzW912b1e6JSwBGsE80ks4,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_514.md5,sha256=-aOxK1u40cyeTM8-2xVdDXAS7z7ifTQITVU5sk6LiV4,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_515.md5,sha256=ubrsj18g9GHqBMPlTOAgIn7lRxxCF734quRKfgskHBo,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_516.md5,sha256=G0XikB177782Q-L6-_dzujuATk7igiGpG_6Ql7htLrc,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_517.md5,sha256=Ogn-48RcQcFu2-vBZYl4LhSalB9VbRjCGkVoUnUex3M,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_518.md5,sha256=4f2i0xoKMhdpw6kmi5gZg432ZmNwh5l7EKqNxj6c9pA,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_519.md5,sha256=43Y2zdWmMjNGmpMOTk8aiEFvb0wFCid3zA-AnxHcwgY,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_52.md5,sha256=gQlqC-YL3DjUQRetwuMB5HXteZzRg8izEjqG6pzR9bA,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_520.md5,sha256=JPFxuFdd5jbuLpTfjmwF8xK0dJI_g87cPzzEIwVrTBk,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_521.md5,sha256=vu8mgjz41yU7hxgoCy-WIFtyS2Jx3-DSJcwcleLsHFc,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_522.md5,sha256=F-PQ_3z6CmHCiWh2eVNIaURrUFPT0s8cbuCcqWIhjRk,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_523.md5,sha256=T-wgAFZT4ft_gLuWcGf8wuuFVLVR1pVGquL3HrfVPa0,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_524.md5,sha256=F_n3SJU0WN7BiafVb_o52YSPvgk2J9FSZP1XWS5d0hk,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_525.md5,sha256=FXGkAlSMTWeRNiw83ga7biRmjraAlRYGjiYAGSPj19U,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_526.md5,sha256=upvh2dkNdNzNaKV8AtNdW1nE2bjGIO2cQ1WNzOXJJks,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_527.md5,sha256=axINRljCLFc4067KjuA4W9YRPC6jPlkj_cncI2CfS4A,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_528.md5,sha256=pTVZ3KUrdshCq9LJePqAmkfoFCiQO986tg017RoTykU,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_529.md5,sha256=74iF1fnUvth9ImcXL9EJYzO3gD0-b29mPwqbmkOB_Os,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_53.md5,sha256=VadSTGxvN_QbIvSDFCWa6XVrjCMsX5OeTPbfM9rTv44,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_530.md5,sha256=UkQT-EDb2abUJgWJLQQ9tx_GFEg-rdB0o3SCCpcn3fc,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_531.md5,sha256=dT8FLQMQ1rnZn6bpUuc_xt0XYwSijErW85dQYL__vBM,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_532.md5,sha256=zs9WXZVfEU6RbRDTFVIR2R0w4354Mh2oqYhcVajN6Hw,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_533.md5,sha256=c5kzAlCZh4yggWSnyCqfCUO3XhaHpuah2Ro0gm5wBoE,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_534.md5,sha256=kRpNmTtmwxZU27WW_uNyos0fwGFWZC8_HN92eaGz8nU,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_535.md5,sha256=3iJs-lvzZyXoK_AMR6ZOa6nkIhYYsAT-7MHi9MiMCus,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_536.md5,sha256=5CG4Yeg7hCmwFmj-iVf4LmI-ksxSl2w5HMgyw3fSXCk,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_537.md5,sha256=41PvKSxtNsE8GlNBEKhJS5FsPNsjRpkQAI8a2J-KAgg,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_538.md5,sha256=EvJM7FRyF9a4rt7vbmgltbtPctt7Yb320GjSL_nV5Dw,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_539.md5,sha256=N1GFqVl0kVB2K5rmKiZPcnJ7-Et9XR4iYNV6k39MRio,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_54.md5,sha256=XDegQxHGtpK3tZOmmvjrfvaGg0A0ebP1pMK3qfUd1mY,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_540.md5,sha256=ZHUX8_LoCUYHOjSqGlu5QIEoeUyRoNpO9RI2LypxaWU,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_541.md5,sha256=OPQqgVjzIw-R3CYHVZVF6HH5q-sFvqitOoZhbaGRYqU,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_542.md5,sha256=WLuAcW9hJw6euoLeZKOg2BdilWLjFi5tUOjfWj-7lVA,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_543.md5,sha256=Y_KCQWKY5_-frYExXvQUlRdLeE1YFprglt15kF296WI,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_544.md5,sha256=oQGuvgyOlFjr7jYEB26hXicg4xt6S4DdbxgLr8AkZrY,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_545.md5,sha256=lhbjkslK387WbFE-jc1VnXHHjc5FmbSaPvcUQrCtPTQ,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_546.md5,sha256=9NC8fM5D2hWc8F6Roi0-WzPWVpTsN5GOds_9BBslL40,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_547.md5,sha256=2drXoBWcqf7of_FeAEEtH6esmgR2P6QqlLAec2gwU6g,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_548.md5,sha256=pQ8yWZIDQrBfSOAiAv8ndnmfKVKHiOUTIAH8B5-t8pw,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_549.md5,sha256=uzZvzrrQ0pht4nCW8NgYRVmtl3ALOB6InxJnhLPVx4I,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_55.md5,sha256=pfeYs7YLHDtdx4lgp2U42teErZ9wdQoi4Ic3qpqpgZU,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_550.md5,sha256=nuXLrqj6gJTfwBItzlDORrqD5vZCBzkPdGovMMyZpo4,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_551.md5,sha256=-Na6j08sMnBnpsWKOcnc84K84B409ynH0JEBuLMHtyU,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_552.md5,sha256=ua8AIb1YJKSur62yotHFxIcIHm7lo1rmPOuqmU1tOjA,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_553.md5,sha256=UW8Y3ZLbBM1aNKB3D6MVA7OPLCjmZt2ylAr4A3MQSK0,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_554.md5,sha256=qPxnRReRP6s2wT0BkCUxx-CWy0N-lJypXNAptKn1DgM,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_555.md5,sha256=cO-cvYnqmuZhW6rDxmpXu-ueaXIFOsrFJqQuBCi-3Hs,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_556.md5,sha256=cctdQiYZZu8eO_QEudov8PZtk0hvoxrVJYQ2B1s3ufY,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_557.md5,sha256=wTu5Ytf8Zvu3apiZcRpVdSEBbJPcbqnnSSw9w6VTLYg,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_558.md5,sha256=Mn0-cLSowJvBw_Vk9mDCMTGvuFZ5L4fPijrlW1uwK6c,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_559.md5,sha256=xsPnDylyoXFrS8EH_Hsnrl7REYi6HRABRs6kANQPn4w,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_56.md5,sha256=3OnmiU3G1-TiECSR1eYYkLKOduVb92-oTuOYSQ92oi8,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_560.md5,sha256=XlTRY6BIq3TZ04xVoNVn7Bu7ZntP0jMUof1BpcZ0w_E,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_561.md5,sha256=NoH8b6x3IxKmo3wbXCbSWtLiHzepcKn8hoMQPgKTVUY,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_562.md5,sha256=3c5IHBGrr4i2EMX-6Hwy0ldt2gzg9NkEqqe1AKfQQPk,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_563.md5,sha256=rt8_3YQqjkYG45RpBrYXc7ihla5UNQWW1fuRAD5ImzA,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_564.md5,sha256=ZjbRIgB8mPMRyWwiTjc4O5xkP8A0etqsT3tjaoM2Nqc,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_565.md5,sha256=F7EqV01T24hid4H7nNGP3m3JOGNp5Yr-48F3hvXcWpE,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_566.md5,sha256=RfASQpQCNAd_bFmid_s6xGQvXGc_92SzdC16PVvwncE,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_567.md5,sha256=GtYbMT88SPiydLsbG4Zpl_J0ULQ0fg6cRE_kl08PAfU,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_568.md5,sha256=OxEYvZpOQ0jtjzy8fGRMQxcXjUThxcZuZ5tQmk_jRpg,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_569.md5,sha256=4FyKyFceyKdmKadPs2Wj-KObAieI8chOyPkamuC34Hs,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_57.md5,sha256=pwa2S66rIOQWtU3bl63VC7Eu8sULqXRgbulKYKXms6E,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_570.md5,sha256=-0cfUBLpT4XZ26abQIi2eFqrDrzaurnNms2e0ZafbAE,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_571.md5,sha256=03KjDV6W2ycJXl8ksNd39TeQ5GC7YsR5H6n0a7zNHuA,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_572.md5,sha256=UNl1oBkqCfq3NuWSHWDQyLqeAIedQJOeULxeHvujLWw,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_573.md5,sha256=8cfHxJlFih0B7EkE-pY2UirGfrm3RWyvM-RNULC6Ye4,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_574.md5,sha256=vRoofSyIgStCm_kaHZsIOomdpBnx25RDA42RLOgD90g,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_575.md5,sha256=r508TWr18Eed-oGHrrBSooIuDqgwfReG7DEpSl3RKQY,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_576.md5,sha256=j8bJqtjGy6-NZyJIceIDn1aWM0vVe1htBn1T9y1NCXg,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_577.md5,sha256=AqVRmuaixmrg5AKgb92AKzkodNAl3-Q0eY70qf_slo8,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_578.md5,sha256=4A79TYQhrhosvus3R0PKZe7oZPjOF6oI15GHr6YBTwc,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_579.md5,sha256=G5e3W-k1ihkzOk0In2I7ddg7OM_9gvGA_laVDRNRLWk,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_58.md5,sha256=ajGvlI2Y-b11RQg31LrCFkib5lGv3549loYOyCbJeXI,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_580.md5,sha256=jBKYvL8q2oXTtYSpAmBp-tX4m4Mki6Y0ukYWFmaxkPI,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_581.md5,sha256=nm5QlVv_U4-7p5eZBf8G27xX_rlHJs8r97IyJ5SIM9Y,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_582.md5,sha256=GVLllGteg51SVViJ9-R7wm41xWqvUSctQT_MKRfI8-w,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_583.md5,sha256=FAjeWkAZa81cNUvXrFiyh_RO1x45S6zBfLky3mD6Vok,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_584.md5,sha256=G7WE68ZKKi0awWrAurc-v35OhqgOdsiz_RBtfbTrZ78,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_585.md5,sha256=4um6QnYMB4pNqDMeXOOWHTYYBjOnfqtMLkLzPYmHVXg,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_586.md5,sha256=aNfnbAln1LssV7lh-i6cAyHsmVBmOx-Lqk_E2etJIRo,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_587.md5,sha256=6g0iYbIEgDCH0BjbDal9-xnUuzbzDwXYU6Y1zNmyzhI,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_588.md5,sha256=cSrN1UxMjYlIBTLPmGZc2boQdIE8Qy4ZrbyYK2mn6_o,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_589.md5,sha256=9DIx3SvythIjxhvCxeYwemS7P1grw_CeH2oYrbEqIG0,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_59.md5,sha256=fP6Je6oBVkBhv_jzJ-1ZF1NsXL1dZFv7GG2Zq7FJXWo,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_590.md5,sha256=EFLfmT4Uw1BUCFGN9ooppGJ_T3aS_LY9GRBPpewcHsE,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_591.md5,sha256=Cdwnn_C6nReyktoi2nK74n_Qu764V8dOMvxNalN_Jew,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_592.md5,sha256=9gT3cybt8udnoPMAw1DnLVGTQtaEosAIB6SQZEzZQvM,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_593.md5,sha256=PKPtpj0CMkZhXt3-Uhku07iBhzOBa3GRqmCaA-jGPIQ,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_594.md5,sha256=dQJKrmNWNiR-lT2LJK6NHz-Xc4-X7OLjBayzLtpzpJ0,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_595.md5,sha256=XtMOJxlcmD1lDXRsqLW-heP6SMAVFzcUF2T4ZnOTvfs,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_596.md5,sha256=BQa8zTHqslWRITxh8dUnUiLTlgL0grENE1Lx-EGVxtI,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_597.md5,sha256=7gAe5BcfHpSWgZrLf7i48c9JUyTgIrephDd0djihKBQ,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_598.md5,sha256=iyQ7wv8w2Wn_rnloXEk6zBIHnur7I3p5G5NxnkY_JXY,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_599.md5,sha256=Ccxv80f_DR_LQs0nDItHdbMCb180xSJaGYuCJ8y9gDk,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_6.md5,sha256=cy0yiPDcdRUN7AGCIyOWdsNPi_g40AgIoah9ApLLT8c,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_60.md5,sha256=D4FJ7yivp22-uiLXwvLUqHOxjvX5_oz3umqS7Ub-p_0,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_600.md5,sha256=qn8fn4ufkhdIrB13HxfpgVL5eEkxVRdOkdqMhBnm1ww,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_601.md5,sha256=nbAoozRdx83tfdtir-ehJzCjFmf8ZHYQSPa7E4IMK14,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_602.md5,sha256=ytYBkDj1NI40pZTo6UODRhX_PYlEnEgAESXWzZGjEP0,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_603.md5,sha256=G-hJIQtHYZRWkXHSQu_u95w65j4NqPMagfradIrs7x0,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_604.md5,sha256=fPhHRV2JRDGSkA0Z1QfqOTL3XpN-kNVgjCoIZ0k6Ii4,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_605.md5,sha256=k1SWRhJKnYUBbLn95iQ3Vbc-mM7zURG1-R_ET23V2CA,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_606.md5,sha256=C4ebHmgfs7CKPrzld7q4OT00Xb3xyyen4l9q1sTzgfc,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_607.md5,sha256=uucIpcGHv8LJ-UvqtQV7qGvvZ1EFAixf8M-u1m0YA5A,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_608.md5,sha256=XaHg9vlmTs-ogAtZ4y0dDOJM08El19O8ZYC6jqm4Sg8,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_609.md5,sha256=VnUYYjlgMgKDv04JJ0ay8w0Eaob6KaD5S2fP6ImsrOs,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_61.md5,sha256=kNk4kWNkifvw1WGInaYEnOhT9XP3Kles1Apmx1pg8oY,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_610.md5,sha256=ug9nJjrnF0T1F0l85l2eFwUmAsdNYe3jQtWYC-qIjoY,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_611.md5,sha256=jT0GEFVB1XvSL8cEp0bgD5VJEa2mC9ViOtItyQg7RTk,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_612.md5,sha256=oBB4rQxTg_iRINxQRSKrWitMM-M49n_1Q8z6q7r1ZmE,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_613.md5,sha256=E07F35EK0XpAKhcFBeg-p5r8M3nha5a-s6wNufd-Sa4,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_614.md5,sha256=dDY-NZWC6DXhH-pDOnWKbVcTv3hFX9iQNt_rBCrFNK4,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_615.md5,sha256=riwU2Q047VFz5NK-ODQUFRVE8CSbLSmPNh-RJwCqFV0,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_616.md5,sha256=tx8SjLG230y1kf8a_tdz_Dj_T8DsZVodGn8vCUm5DOc,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_617.md5,sha256=lckr0tcs9Njh6g2a3XB0G2RQ2_364KahLi2gkg9es6s,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_618.md5,sha256=qnv7nplVGdBpwy4x0OvG-uayRpyNCWpWowEd6KAHUfE,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_619.md5,sha256=rrS97tw2yjaQthQNdYV7PcIYWe1dIVH2MdVkOVH_Wug,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_62.md5,sha256=3x4ix9a4rqqUqX4w4ZdndEHN5UaXwmiCgstQK8gFWHY,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_620.md5,sha256=39l75csnqrMxs45eGBmq8kuuvC9-cJainafK8ZjouHM,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_621.md5,sha256=7YyTVxBXlQtDT2vDhk7NUwSA-Qf-rVXp8ObFM1jU5SE,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_622.md5,sha256=LPFln_FGO8MdVuUNUWV61ygLJk1USm0jElkYV-2iHoM,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_623.md5,sha256=J3evC3FoEMwhsGBUJNHiq6b2fN3tRtvU8Zm1GlERtcQ,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_624.md5,sha256=NmpVfTu9ku2PxTKQFopL8URNpyFfc8t0gSh-vHmJVM4,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_625.md5,sha256=QpZB89suNud5c_FHeFKhVxors-4xZYnlWVlYcPtPoZ4,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_626.md5,sha256=aomfxhLc8MzhoXgxYCAbKQrqPlP0xBaI4NGp63dJV4U,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_627.md5,sha256=QSh6p7Swu2e8T8ddBDdBBMH6_Nv0J9iiNBFCy0j6vk4,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_628.md5,sha256=PNmXa-o_3U7z8zeooLEyjGRRhmelQ4hR3dPBuo76cOY,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_629.md5,sha256=8KxV3zW6CoJNHJk-OJpIKuisa32A2y7zCcDXySVhx4U,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_63.md5,sha256=PHRP_fwoyxA2Q9k_TNUETqyRCiQfgVlEMTccoik66Bc,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_630.md5,sha256=1Tj3f_MH6VQQ2RNXCwnLX3S6OvUNM3ZwQkHtBZXn9OA,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_631.md5,sha256=k2yrsuXFnCX7wepPKekNnoIdaf9l0YX3T__ZBtR4zl8,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_632.md5,sha256=VUsM_0jemD1YrycNAYTplTApZCkvLIG_y1JbuvV4o3k,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_633.md5,sha256=1PIqoBPHLDnQLIS20lZL2OPMP9Y8B5cjV221ywi_G7Y,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_634.md5,sha256=PwH-00bsY9iLv46WUnmzz4OwSgd4u0rw6OlClAemRmQ,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_635.md5,sha256=qG9tt4M1lqFiCZ_FM88sXR6Qu9l3mV6yRdCbSvxEEyE,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_636.md5,sha256=CgC4dMaXDzQPavhWDstOoVnehTdHi2t1wqq98mouN0I,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_637.md5,sha256=LKaCvlszkLEB7KrWGdHWhDF4--EhTIzSLYludGmzD50,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_638.md5,sha256=wVfnqbyuU5ehtmIgqvTxnD8kiUhrbUYN9DoLni5DQdI,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_639.md5,sha256=L-kLlZQEhC2GKg-2o_oLapEkJu47GkNIsEo2Xb3aixc,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_64.md5,sha256=3Y4mioPsmR9KRg8gdQuTSYsKtvcB_vpeZU17zaB0IwE,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_640.md5,sha256=-Ktp5zMdsTUq_4l-finFdtyx_cP7Ck_8OBkikyxQFCQ,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_641.md5,sha256=kt4D8XBa5U7m5XzU4oBhS69YmNKk1IQp9sK4PWW676c,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_642.md5,sha256=aX_wvzc1GLsehJVjwdjWT_D1-c1kRdT6MA2jPmaHIpk,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_643.md5,sha256=e_ZegI7wA6J4snJ3Iu-jKC8Ozg4rcpQz8hlLkZWg9WE,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_644.md5,sha256=n-TJxITGdAgLzkocHLgz1c5DaK27m52G8BOj9c6JqcY,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_645.md5,sha256=JlB6R-eNVkmRH5yJyWWS2AqgGQsF2OJNnw_VKPmULOY,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_646.md5,sha256=4n1_V1FXoHt1YmC_iP3j65IoV4cRpc-sGFJSsYjD9EM,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_647.md5,sha256=0AQwjvHY4Hj7k3tWgMiVQAM7NtP-sEj_bPEqX6liPk4,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_648.md5,sha256=uktlgjJl2l4JDXpdeZsiS0WiHSL6dhgaTDhgEGVAWWg,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_649.md5,sha256=d0NjiLhs6Z60EERrdvV34JDJ4osWSgoDaLev4dt0loE,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_65.md5,sha256=HYbBLBXaGTMTG-YIB9JAEmBinn9zfHgUmc6p1-3On0s,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_650.md5,sha256=oM96KuZaGfEbD-awbL_T-x9nAM7-Ldm6D7nFnLSPKio,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_651.md5,sha256=O3aW2VcSzQo9h-v-mm9dSp48pNT1fS1te7RSTep-T78,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_652.md5,sha256=EzWQs8NIL-yG-76d6iCsKvXq8o8kl3bWHnxsVsQyvao,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_653.md5,sha256=D6aixE8K_HpGkJn1cuHz0jn2Y-sevKXEHx72-iZf6Bg,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_654.md5,sha256=RhiceOd26X7l3Pmrm-gc6GPvNo6-hTTYtGEt3oGnZ24,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_655.md5,sha256=wBQ2GI269v8gjYY4i-eDTa0qKmDLdAsUH-phfDjVCPs,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_656.md5,sha256=D5biLw_pikUzBDn8oXb7BTS2SNkpkflApD1y1TqTkaM,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_657.md5,sha256=HTRx8ZhEPQcdBNs-zPWztB8X31PaEPpf-ABlTYZjYwg,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_658.md5,sha256=Gt-F-NdLgFTnxjfjQwEjR0vRF9H6I4k5nUI92IrvgnQ,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_659.md5,sha256=DqMgBNTU5N7um_Dqk_9r64VzAMytcH4CVW3Z_NG3-dk,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_66.md5,sha256=KFg0Wz0LlAidsTLbAZCQJLWIfFpJweUcbOYhWqpXIA8,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_660.md5,sha256=Vo--3bLPrbn1ZZEJq0fTOr7-Zrr5xdACsSuPZy4vIPI,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_661.md5,sha256=yqPn4l9V8rrDlS9YoOlwNcq-21bHRv90eqZaNe90CGg,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_662.md5,sha256=W6EnuQ_gDjQrS4KBmLB2FETDv0dfz_6TcjOcTcQPUQE,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_663.md5,sha256=A1_z2bZ6nV4hxIIWDZaupKhpYm3Ys62_JVBFLZUNsrY,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_664.md5,sha256=6bD_Y-PM01m9ni-K3cP_P5AVFAhBwJk_cvKdyLwoJIQ,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_665.md5,sha256=5BqGdPpPPB3r5vqzpwrVnn53kLyI0WYfAh_VGLkds6k,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_666.md5,sha256=mcbE74KVu6XLdaEVXWhascIQnMOoBcF3jGG58JuAEsE,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_667.md5,sha256=3leZ_qA4NuQ8XbB30bpWxO254lwy2pc9DRCX18txe-Y,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_668.md5,sha256=L11h5XiBb1fKNTb9QPr0RBayQhu1NAynCHgQFYtIPJI,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_669.md5,sha256=Xfdq5-MrbXXt2j43ZcFtduT2ojDeT9h956fKRf3cgY0,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_67.md5,sha256=8y0OGfCLGydcqIhmn04bM4sBmEku9qf6PK37WnGE34g,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_670.md5,sha256=5FAjq0QjiYNGZSP_491Pyj1oFLexhqOa1GcYz_fGiaA,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_671.md5,sha256=8AZWw7OZw9jZK2Bd2JhKl8vzr9VLeb1e_YylmeRZvGI,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_672.md5,sha256=hnhkDkY5_VSxOcBpyddX3TObcT-WjZ4aSwDZhGDOp3o,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_673.md5,sha256=GFnmp782eY-9Q05-fx8WG7FfHb3zJBTvAPiPQgr7WCA,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_674.md5,sha256=7kMmVTdzVd7qb04zd4HWAJVmVUw31AQ8YKmP3Z701jE,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_675.md5,sha256=8dURJqxo2-0v-QGzOrV-ZY1k82bCy9xWeFYfBnRODoc,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_676.md5,sha256=HBl6zHPPxKYrfDFbz3q5JuL18w20N4B_iHid8mbMTFo,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_677.md5,sha256=NY_i5nKVX4Veim2fwB3YFEs0VYKQTLRDZDAyX1LGRKE,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_678.md5,sha256=QcaqL6rA1hi4UhsXH74cGM5JwNAFwKIDnAo7WOZiG_w,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_679.md5,sha256=GsL9BMlreJGyJrNxU09d6K1HAwVMa-RZdYg4aprS5I0,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_68.md5,sha256=tRbgBJSx4F9ctZwukEUs2iVLxRftFT70bxmZTUY48Bo,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_680.md5,sha256=seZrPkPX9ywPynyZollbGa9X4Yuq_X_4RR27bDopF7U,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_681.md5,sha256=MnRqsgHu-7nERauhIV-6GhTFeFF7uGlap7eIDhaa174,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_682.md5,sha256=7tp4RjWR3kPQCaJra5FEka60YOIhaNsztX45tQYbfIQ,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_683.md5,sha256=UyD60ecKCqkDK0d_QSImy39ktzNypTHpE4LYa_Vumsc,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_684.md5,sha256=T3UrwHboz1onf7MKPRnWwdIK8er2uIU-cs8U4BXhL6M,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_685.md5,sha256=vuqshQeXq7w2fyk-iRZwCEevlRlob-QAH-KPSxoG7iQ,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_686.md5,sha256=uyZbJnBrWu5h_h_BSlK8B3P8X6P4ScLq82z8zx8iiLg,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_687.md5,sha256=5mTLZ96f8vBWuBVsCzTc7Wwtpp55qJ46dIO3wDCLijU,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_688.md5,sha256=n6rAf1RV9I7TMk16uSaGTEoJSb-jR-HpIfbvbXZ7vM4,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_689.md5,sha256=dIcKIjeFKcGw6Tkw-BpF2C-yi4qjLtF6C97nJ4r4J2M,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_69.md5,sha256=LcOsNjchZgSlS2T7dAjY_SfYCHcbKPnjwDMR7ytvbT4,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_690.md5,sha256=26YfcndXqc3ELjRVYFMng8f-Nd8FIyyGmJsDIfqVkTE,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_691.md5,sha256=xyVTtW44Ykd6LZflLetRxCWACq-WfekdGQByItSp5Go,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_692.md5,sha256=UfCkgDFXCTu6jhTOSac2DIcr2B4oAWwveE436pAg3vs,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_693.md5,sha256=3CQyebYSKd7B8tP-HkKLCNVXXif-lMqm_jisjl8t0k0,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_694.md5,sha256=7eX8bZyW2OOh07j1UXmvb6WrJULHgmko-ABrmI8hnUk,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_695.md5,sha256=3L0OMWByKaMVFcOGA7lmNwVwxk4pV8VdVkRXCq1b1nw,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_696.md5,sha256=7uZZ4Q7G9mVhPP9Y7Lam4egxvQ5gGzAHgMQIVZZMJXA,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_697.md5,sha256=QYXVpu5urHJHwekX0AEp_Qwh29iR91oqD1Yfpdfo7k4,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_698.md5,sha256=6qXp0sdAhV1H8oOiCY14d6gGI7x0TMI5jEYfGM-5Zvs,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_699.md5,sha256=Y82YHDwqxCzbr-aQY0Cg1R7mqB_qr9tIiBupZ9UXrQ0,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_7.md5,sha256=_FZKCsSC4zjiQBgGxx2vpSMalIbbadXXGn7As7xmk9o,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_70.md5,sha256=mWjRncXBvwYBegsneVqQbV_ZdBfgUYn9Q3m4LRohDQ4,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_700.md5,sha256=p-nQhvk8gOocBvhOj1ay4_hXrck9E71CoXuihd62wx0,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_701.md5,sha256=xt8Pjg-MWlSZy4hGshudaQtw1HdZRDmfezWQD7tq2AM,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_702.md5,sha256=UPSVuHMrRgiIf2HJARghcksQvOyox4dpiYLPlu9fTnM,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_703.md5,sha256=FRNANvYL9dSs4e9lMjBeBlL_4CyUWqXMAatwiobZlVg,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_704.md5,sha256=-nGwgoUcf6_1UrLw6DXFLknldsvD5EFruwfxRU32Mvs,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_705.md5,sha256=FmTq5Tun-HVVugoppeoYtvZKqr6cVqfJ-8vAMbSUd7o,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_706.md5,sha256=JcR4K6QZvfOBo8mK4yp1KHPI2VfSWaEqU7W7rO5UgsE,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_707.md5,sha256=UQcWYO9SfuKHAlg6OUONWXwZC9WsWIkLXr3pfWJtj6A,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_708.md5,sha256=b5yRALu7mGJ_QfiiHyWLXoZIse1c9WdmixbaCs9fWvk,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_709.md5,sha256=p3wsAHftLQmaPTUOiPbmFpodzSyxmm0-zLNSCMIA2EY,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_71.md5,sha256=g7j7L_HGh0D_d-iYyZm38qYuE-9C-vi1jB4NdatbUDo,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_710.md5,sha256=s3mFRjZDExwhtfXUedG2s29V6QR7lckHyJQO6BrpyBw,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_711.md5,sha256=a-xryEguPOy0COI-aEosTEYhWnlngrbygqMEafAcMTo,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_712.md5,sha256=xt90Hztt0y_nBi9gVe58e2dArdTUQLCXNSKV5AZEMZ4,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_713.md5,sha256=PD-VzGC11v7gKkdyZH6xe265uD62GlAE8r2Qq-QuvxI,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_714.md5,sha256=0fhRm0eMuApddmL8MP9M1MIyk6k5meIl_wp1l08mEOw,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_715.md5,sha256=nJphXPCxmQOTFABqEKZBjzx8InGYx1kKmaokVPaSC18,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_716.md5,sha256=h4vbUiCgJclqmSTtEBMybWmIYQNIN7XkoDoRDxwQL90,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_717.md5,sha256=b7NZj8hBCJG4GAQcRL9Horg-TriElzBBFYYYf-joalA,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_718.md5,sha256=aNzhZRh-aiJWwHzlF-ZH9vh7XJFLm7W1C7bIoyj5d1k,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_719.md5,sha256=9N9b1DSz6BZk_2M5swJxfBL64XPj1RgP5odkMfzub9w,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_72.md5,sha256=A7fCLyjOd9ZIN-qJY6fiu9TXdCvQRWaQlCh9Mn5XSV4,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_720.md5,sha256=pMG_n6OnWrWTWWhFzsEjgRl1JrIgSza7BYoORZiTmtI,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_721.md5,sha256=nRpzCJcAPwt2p8D7-gdcru733XGiZD_Lhx6pb4qCIx8,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_722.md5,sha256=lGJTm3Y29lLcV4VzTxCsqf-e5DNOopNAgfTTEj4MKEI,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_723.md5,sha256=UrNvr53fyQ_9D7szQavvdxrrPVrNbJNXR2zFa9qISR8,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_724.md5,sha256=MtoA3Eu7o7_dyM5_BTqf3ZrV_nnavOivhOuOqeeLQu8,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_725.md5,sha256=vJFjdSNeuhEz-exWXE3AX33YhxZFVhUg6A8KrDt2I3M,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_726.md5,sha256=PePN4ARrUMR8u3POlKqIzqLM4FhWEiGuT0iL0uoQ5NA,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_727.md5,sha256=rSxRVacOOQH77va2WIbsrH_mO2IRI7r8LMWLsc8wh7g,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_728.md5,sha256=jf5U15H8w_WT6FustDiTRw7hlIxHdcbZ87DnOhdcYUU,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_729.md5,sha256=xO4jkHDKSnyMCCfzceDjNFcpUvoH-5qdaopbmJ0pPJ0,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_73.md5,sha256=VNVyD9GIjs2TkVeBbmfK5pjrNYKf_CKZZlXJIWlWTt0,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_730.md5,sha256=Ghqeq1q6yEkxHo2ci2Vkny1j-OkgRnjrGlkIu_cJVFk,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_731.md5,sha256=6Y4d7aGgKDZU8v88bLVWDv7AHfzNBfLiQBkIWmnEJuw,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_732.md5,sha256=jGR8TbcJxJmoO1vUrabkf6EO6pI8HMHBS5_y4DeYwgk,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_733.md5,sha256=jLj8OJKjvY5wARrkOCzPuW7ABWo9jqDU3cfO1Yu2Rtg,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_734.md5,sha256=C7DjUtBxg8T5fMek7dWncLnjOmdYVJVS2oapgDGhdpc,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_735.md5,sha256=2FuGq3vOQkeiguA-aItYE-g02ZISBmJVD_60-AM8t0E,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_736.md5,sha256=gh5IshJ8-UB80RVxemcNd8Nw2iH9EPUqz7qDOcGlSWE,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_737.md5,sha256=t8W_rgZPIc2N_9Okvku_Qyi4oOGJ4rOtcE5w2u8JNvc,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_738.md5,sha256=HKj4T-m63MgsQOX1SIQuWIIjDF1eyrJ8k9ZNDW9hwZg,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_739.md5,sha256=I0FrLmPoni8z3vFCsmNEtJYfyIbNcyBeAom5wAIyhDs,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_74.md5,sha256=pYotmboaziUCYB13SLfO-OjZkyrUf8VBsbtFdSqWQto,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_740.md5,sha256=2GkZCZZAfWi6F9XV3kS9_FmklRjEGX6aMmZuzQnvE08,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_741.md5,sha256=VLJ_37-CTmxmHGZ-WKancuBTHSrF9sdBneA8sZcF5_M,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_742.md5,sha256=IhaZh3ZCnQmk_dd6-TKn8Knp_bud1Ac3JFFj_uQlBHU,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_743.md5,sha256=U7b633ReNamonD4lknk-ebZ4qQ1yDAFkp_huZCo8UwA,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_744.md5,sha256=vZ9Jvg5LJ9bAGJjtsptuOdJsCJmouHXK7zZfVQmp_I4,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_745.md5,sha256=-BWRwHh6ElaANyaWOp2SfpHe4e5ZVDRufX2hls9vml8,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_746.md5,sha256=hPjzxd6lKYqiEQ97f6liBB-RdusdFot9wlNsqxm_L3k,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_747.md5,sha256=n7c_OwlOWpz27ABt614fTw1ACnVgxE4D3jNgsePUTIA,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_748.md5,sha256=MeMzBXu50R-jI9A-XLpNlcQVSnr_oCKfBz_NLUf8DAE,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_749.md5,sha256=bzmzudWiWzkQCFxjJlsHnl2SEHCyj7Ih6_uv3d_I6Wo,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_75.md5,sha256=2U_5HJwGeWcqLNBU8WIQ2YQhVKi0Ar6dnrP1gRoMeUc,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_750.md5,sha256=ISCCoAcy2KtsTk4SnZ9Fbc-K0JLCPLORmngJM9-3RU8,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_751.md5,sha256=C6OMezHyhgWtt4GdiqpSMHHSz5mpQjPzcZnWiDJhUqg,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_752.md5,sha256=N3rJ7jJwivpaRshtOU99_WjdlQwjhZtdGJ_CAaZj_UI,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_753.md5,sha256=XbI-r22J5wdgK9HhziBEBiZjo_1-fsRgatgjB4F5PXI,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_754.md5,sha256=zZTd_ivDV2ILt4plXf50_S2VR-Qh7lWvCeyD3_sjDPA,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_755.md5,sha256=XVVq9JPDJX8xJsU5knjp8DL2fBqmIZ_-ze45t5crVD4,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_756.md5,sha256=YXakGLlEbZabi7Nh8dxL-eA0QmX9B5Yb84dlWk2AXb0,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_757.md5,sha256=sqUH8f3Fe6tx37C_C_GQXniH4N5Q5tQcnKQrkg6TSFM,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_758.md5,sha256=W2Q80bvMEvDXkDHeBUW9Xr2yjx0bZUxH_ix8N9N4glo,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_759.md5,sha256=E3SVQJemNvqzix0xDLsVDkyhHIslr2AaYh7dYm4S6r8,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_76.md5,sha256=_QQbg2gM8Gh7TqmZFK0RuRfq5qH__dY80qOJOIUoIjU,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_760.md5,sha256=HPuydTLF66e8_7SekA4p-7NvHnGLnMnFuImqwkrcWr4,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_761.md5,sha256=5AMsa4QsT3O67Gb6XFzix3-93iL2FJGSawwMCIi2y8I,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_762.md5,sha256=tzELjyI4BG3CUekZGSnTHt0FUyLvgBo98Jwyq3GjUho,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_763.md5,sha256=Q7C9IG_PEX36uCUBt_0P44_T_lzZoNoie8LlVCrVpRs,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_764.md5,sha256=Y7VmskpJPdTcWfJ4l3frTDzsfcJ_E4HacrcFEoplnP4,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_765.md5,sha256=NSdpUnmcmtPp5nT-8c1i0eH9faMqXgcHCcEF4qNdsPE,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_766.md5,sha256=5vaSEq_L49JtyS35XJHbd5E2rH9f36A06FyEf-ixnFs,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_767.md5,sha256=ltQZ2H2qwMpuP2YlVkZEFlT-evUVdA0A_AWdlZPp4yw,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_768.md5,sha256=s-WUhlzml_BrIgavnUgiKhDigOrQCXeTK9NtE2wQDSc,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_769.md5,sha256=1R0vM_ysOYt_kLgtgkGGBkOENIW2DUZmeBGU2i70RNc,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_77.md5,sha256=r23Q6vzhXYfaE9hHH2LyykiOcaBNm9iioUhOBFzJm8Y,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_770.md5,sha256=XOIrOoKmPmFXUxzd_JAJ7ONQF6YsIoddtxNII4Cn35Y,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_771.md5,sha256=5FKSkSAGe3fn6LPheXDCbneO7MgInKU9vDMmKaKP0fQ,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_78.md5,sha256=6CNg7BEmltl6U1SQP28dDCFUrwvt1Aawy1L2dgDQQ5s,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_79.md5,sha256=pcsAyC0Px9y_zWAttOOF5YNYkHAhToZ-h9oyvTAPfzU,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_8.md5,sha256=3vCEHzjFcBBAcyz6BTpKcp_G19HZfKWBoKksTIB5z5o,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_80.md5,sha256=lyLoeUUMZJb_iHPM8T3nOq77ct13L28y5NYNPM-jHw8,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_81.md5,sha256=d1LxnAEQf4xDrzCibfMb5R_bLdpM7AqB0ue_JrkmS34,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_82.md5,sha256=yQMHMMqoEI0iSWq2XDlO1pYYdZ6iWF8gkprqakK77YM,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_83.md5,sha256=ncZoHrJ7qrR7KFwW2ZqblO_qcuY6dkUjxrO7Hhad9jQ,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_84.md5,sha256=cpvvNMMfCAi5r3jeyfz0l79wGzK5-fXN4OYpDpbK-tY,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_85.md5,sha256=fiqHXpizoNFdJLzmwSALTbY3KsJy4sTFWDHnnf7ysTg,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_86.md5,sha256=1tqkNYQwsPSCwSXBR4VD3WjQNtD3PxGuPoByGV0ISMY,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_87.md5,sha256=X5pKGqcpCzcyZqcpTNCHaf6vbn0RbZUYKZKi838dMaU,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_88.md5,sha256=AhDzywmWI0uEr5bx-p0VeqAnuNR8wlsf10AK86BmyLo,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_89.md5,sha256=jqxTb98DSwNKVJO-0x8vSPk0IZyosO2IDwobbMkO5wM,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_9.md5,sha256=qyRDUfVp0dMvJboFRjP7Ad1QUvaXu5ULnuJCvy-BHTs,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_90.md5,sha256=qcJhidMKiB5nRlQprTwc88AzsBM84g95hgyGF41-E1E,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_91.md5,sha256=v6tusXjsO4DlDzEsqDsmitv8IzMWp-Liko_B8wryVWE,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_92.md5,sha256=tqY11RQ8nf1bU9ku2lWrtBbNOTfB4VuX9VHs-ndvNAg,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_93.md5,sha256=d0qNlJYwAWeKRKxG1DSsC2pF95rfLKItouSeV1L1Nk4,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_94.md5,sha256=Vkwb5SU17Vtht0qg06UYbzfrt5YtYvf-aoAAZblC7JA,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_95.md5,sha256=ui_EeLVb9nK8_G9Z_MUG8toabs4dygg_OXqSoYqv7PI,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_96.md5,sha256=J6SZt4VDJ1degmPv8gEgBnfgMn0_uL7HgQLl_02-l0k,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_97.md5,sha256=iTWlbrKaJe5hW0q5E0e__B_SyGm5B0HWP6Zmft7Xm5g,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_98.md5,sha256=VP4bZIVY0fIOO2nwiJxAvLXjOG5tTUEdMWjxBKsvzJU,32 +bitblas/3rdparty/cutlass/docs/inherit_graph_99.md5,sha256=P8eL4eh0xdViVaQawPrpZBR_yDiDVUvT0ZzGjFwUCqg,32 +bitblas/3rdparty/cutlass/docs/inherits.html,sha256=33DZUmeB1TzWTQxmApasMlrOMq1e_fv8JkfMycqpdBQ,436234 +bitblas/3rdparty/cutlass/docs/inner__product_8h.html,sha256=IGgTKGZHfprCpKCC8NE2QXUZMylGyoQU_ciOZZ7iPvQ,10415 +bitblas/3rdparty/cutlass/docs/inner__product_8h__incl.md5,sha256=uLhHaf5bN_7qtrgCgR_0gM6dwDaiOJ_8neg5xfsx8WA,32 +bitblas/3rdparty/cutlass/docs/inner__product_8h_source.html,sha256=KNGfZRixlyX2dBzXVX2cW6r9aNMJNGQccXHeJK3cbWk,27427 +bitblas/3rdparty/cutlass/docs/integer__subbyte_8h.html,sha256=Y01lgfbxqtonghQoIjNw5RWePDSE83V58DY72O6IcX4,10629 +bitblas/3rdparty/cutlass/docs/integer__subbyte_8h__dep__incl.md5,sha256=iCSWRRZNwztz9UrbLiRm2QYEprG7poEhNNJ0kMkJYcs,32 +bitblas/3rdparty/cutlass/docs/integer__subbyte_8h__incl.md5,sha256=r9PoSk__IbY8rlCmyVX97MpKCORkkAP5MQRMunm8rU8,32 +bitblas/3rdparty/cutlass/docs/integer__subbyte_8h_source.html,sha256=0w9_40mXdy8qkbYFkfhQvdR5JNf-nBEvwJNYryaK9Ic,41573 +bitblas/3rdparty/cutlass/docs/interleaved__epilogue_8h.html,sha256=O-Bo1qRuBViX-bIzbJLeSRn1CqFXIUKopzurOye4Nhc,10525 +bitblas/3rdparty/cutlass/docs/interleaved__epilogue_8h__dep__incl.md5,sha256=wMruU3r0M92keWCfO3nC60cSkHeeMrklVOyf28Kv4lY,32 +bitblas/3rdparty/cutlass/docs/interleaved__epilogue_8h__incl.md5,sha256=i7Q4ZPaS2sDbhnUQ1ILLamtWcYrHyFm12dDcUoudl_E,32 +bitblas/3rdparty/cutlass/docs/interleaved__epilogue_8h_source.html,sha256=gYZZkEpOvsWgTZvF5Xk-z4TCmEum_h3HMSH2QHw_XYU,57442 +bitblas/3rdparty/cutlass/docs/jquery.js,sha256=04UrZpLeKNBuhU7AQ-0uYk_IKd3j8sNliRaU9wqzRaw,146331 +bitblas/3rdparty/cutlass/docs/kernel_2gemm__batched_8h.html,sha256=7YO4MA5eYHTqDWOpOz1IOXOrskkAaaJeMpwbQetsm2U,8867 +bitblas/3rdparty/cutlass/docs/kernel_2gemm__batched_8h__dep__incl.md5,sha256=ajdkcqcFOV0gA6ZJodlXnYLWb3vLcyyBzQEZdAJmcoE,32 +bitblas/3rdparty/cutlass/docs/kernel_2gemm__batched_8h__incl.md5,sha256=QwmtLeDTPfb-mMNXSWWocTj2O1i5FElWpEyEe-TevsU,32 +bitblas/3rdparty/cutlass/docs/kernel_2gemm__batched_8h_source.html,sha256=WxchJDtWlO5kIHzId_r8Vlcdwty4blQwG_wUA8Nf2H4,68830 +bitblas/3rdparty/cutlass/docs/kernel_2gemm__splitk__parallel_8h.html,sha256=rMuFJw6ygDENkc6IhSTawdEtU9msyNX1h8Uy4eBBVW8,9016 +bitblas/3rdparty/cutlass/docs/kernel_2gemm__splitk__parallel_8h__dep__incl.md5,sha256=N1gBHc11870AD9TaDutkmw3rVBgokEd3JubBNjKeOwg,32 +bitblas/3rdparty/cutlass/docs/kernel_2gemm__splitk__parallel_8h__incl.md5,sha256=wEUws-Dwf9f3aCO0YnFwqVEJpWJSucNhY7JXxXwk2Ck,32 +bitblas/3rdparty/cutlass/docs/kernel_2gemm__splitk__parallel_8h_source.html,sha256=InqTL4jUOyKc_mmtdPZfo5UQsNsZCI2Qt4mHZbhrqc4,63877 +bitblas/3rdparty/cutlass/docs/kernel__launch_8h.html,sha256=yn14j30CwfRZ7w0QVh63VQiy39XUJx-CdC31_zpqfm8,6358 +bitblas/3rdparty/cutlass/docs/kernel__launch_8h__incl.md5,sha256=DikntMNrrQEzVDABxMRz8MJR-Ffcl8lfgbEo3C8Vmhs,32 +bitblas/3rdparty/cutlass/docs/kernel__launch_8h_source.html,sha256=RglLgYoNX3ulNEs9QFTMQe_sDfoDbboP83rpRGHPK-c,16497 +bitblas/3rdparty/cutlass/docs/layout_2matrix_8h.html,sha256=Ye0fB9oGsuzM1KQjy3FFhGLt73d_h52R_eE-lyjt0gg,13374 +bitblas/3rdparty/cutlass/docs/layout_2matrix_8h__dep__incl.md5,sha256=2ywbIhHKg-5RZQS_sjrOFsSLQU4WHzuzxcOK8efxwQI,32 +bitblas/3rdparty/cutlass/docs/layout_2matrix_8h__incl.md5,sha256=ZfqCKTkKfv_47JyII2NndVxBCcAi-DxQA14jgv1U_RA,32 +bitblas/3rdparty/cutlass/docs/layout_2matrix_8h_source.html,sha256=Ekhy1Sw5adUvHUiBzvdhVATr3P_STaEFc7MrsTkNsac,207983 +bitblas/3rdparty/cutlass/docs/layout_8h.html,sha256=mN9hwgViXj7eiBr3Lh7U4l6as-X0gNcyX7O0LCKVx2M,7427 +bitblas/3rdparty/cutlass/docs/layout_8h__incl.md5,sha256=sXZHV7vDNqCV21aOb851-81WgaLeCJO_KH8CBsZVKtM,32 +bitblas/3rdparty/cutlass/docs/layout_8h_source.html,sha256=WMRlfvPT_aRn076SRnqe5DVCq3lPRwqOmYO8ew1CFDc,14168 +bitblas/3rdparty/cutlass/docs/library_8h.html,sha256=4ZPVWTo1W3t8wt9MESnGqEJNorNmGY-9ngy8wDOwjiA,52105 +bitblas/3rdparty/cutlass/docs/library_8h__dep__incl.md5,sha256=hLyz-m4pTnAJpFDfBGhTpZql0EKq6gCsueb5GY_QBVA,32 +bitblas/3rdparty/cutlass/docs/library_8h__incl.md5,sha256=ebZmcFeYb4N8Xgyv48tYTbSz9YLKXAxVezCbewcG0HY,32 +bitblas/3rdparty/cutlass/docs/library_8h_source.html,sha256=zSrLzjJr23Xmy6PI5omHuha0Z9v8mu9OSS41MfTGfWI,182031 +bitblas/3rdparty/cutlass/docs/linear__combination_8h.html,sha256=SHhoOPCyYVVcH280CrVb4uZr-Vj-qPJsH_XwykeXUCc,8625 +bitblas/3rdparty/cutlass/docs/linear__combination_8h__dep__incl.md5,sha256=Mz8UuxS5_rTez5vD5GD1kCalYsxF2fJViV_mxqUtLZg,32 +bitblas/3rdparty/cutlass/docs/linear__combination_8h__incl.md5,sha256=KPD9DKfWqUsePiev2_m38JEnqjcnucoHDLngkAu85WU,32 +bitblas/3rdparty/cutlass/docs/linear__combination_8h_source.html,sha256=9A2ErZh6Wk0vx6Iwl4QCjn_Eq96E_YQRauWSsGFC61Q,49465 +bitblas/3rdparty/cutlass/docs/linear__combination__clamp_8h.html,sha256=2I_2Z-47qQwMfqS5IAeFZufGEUXNPqso962C-Ol832g,8792 +bitblas/3rdparty/cutlass/docs/linear__combination__clamp_8h__dep__incl.md5,sha256=otNnFz24KssD5gGEO-EssDETeZPah9x3ny9Vd9t-SJ4,32 +bitblas/3rdparty/cutlass/docs/linear__combination__clamp_8h__incl.md5,sha256=pLuyEJwFOJrk5ZxuN_7M9pOjp7Rb8TnUvvEvbKFp7wM,32 +bitblas/3rdparty/cutlass/docs/linear__combination__clamp_8h_source.html,sha256=FHoP5Q-omLxyJ_9Np6lCr0Sysk3IKhLRPL-2fRkGZu4,78773 +bitblas/3rdparty/cutlass/docs/linear__combination__relu_8h.html,sha256=ANvErv66dcYNgRzLktwzjCewQ1moNd2WCi5KLI5E7_8,9641 +bitblas/3rdparty/cutlass/docs/linear__combination__relu_8h__incl.md5,sha256=3cMFl9_Q1WdNBehbF3o7An_82w80B5mIdw1OzgHhkwg,32 +bitblas/3rdparty/cutlass/docs/linear__combination__relu_8h_source.html,sha256=RcELuItRTVYK4DCKoTeXnKnivIK0mCPk271o78K3i00,98793 +bitblas/3rdparty/cutlass/docs/manifest_8h.html,sha256=rFsy1yaI3UfSixDQRkbhOkmhG08Q1ktAS4RqvvSpHAc,8124 +bitblas/3rdparty/cutlass/docs/manifest_8h__incl.md5,sha256=DvT58x8k9RohwIskhS3GBlbfRrnSA9ND-Yt9iLcL_vI,32 +bitblas/3rdparty/cutlass/docs/manifest_8h_source.html,sha256=d19b1BpePjtIQBFn4blRTkYBzwC4zI8OWE4YUeYlKic,20144 +bitblas/3rdparty/cutlass/docs/matrix__coord_8h.html,sha256=H63cY10hKoCq8ErcADPkrkNYCQI3KYUhqqi-xAiIIpE,6533 +bitblas/3rdparty/cutlass/docs/matrix__coord_8h__dep__incl.md5,sha256=v6ombtDUF5A12jzAp-aDr05QuN2vEHBXY-s2JR1_JV8,32 +bitblas/3rdparty/cutlass/docs/matrix__coord_8h__incl.md5,sha256=3RDETNrKag4qd1BV2l-bHgp3r1bTmQVAkLRTtssE7xY,32 +bitblas/3rdparty/cutlass/docs/matrix__coord_8h_source.html,sha256=CFuhqc-AUkY1U_u3PgL_KWrJ6JdkZnoUSM3zVCNCTiA,39473 +bitblas/3rdparty/cutlass/docs/matrix__shape_8h.html,sha256=VIZpCOkxeO2-vN5lpIZ8rVSfZhpHU5ViFFqeHUq_N0k,6719 +bitblas/3rdparty/cutlass/docs/matrix__shape_8h__dep__incl.md5,sha256=waq9FN50bEFrnL0dTs9rUnW_fLCDYY1jzQ7F10VFxFw,32 +bitblas/3rdparty/cutlass/docs/matrix__shape_8h__incl.md5,sha256=VH5n1lwS6BaahFq0R_bQQBrt6hp29RTio3S_nsVDLFQ,32 +bitblas/3rdparty/cutlass/docs/matrix__shape_8h_source.html,sha256=TavvgVfokxQ0ARi8TPhnxzPsguD4Rw1TRzM8VY3xaVg,17211 +bitblas/3rdparty/cutlass/docs/matrix__traits_8h.html,sha256=2Be2fvycERZnrdnplIf7eo1aVx1Bw5ZcCeIRO9jjf4o,8094 +bitblas/3rdparty/cutlass/docs/matrix__traits_8h__dep__incl.md5,sha256=9FTW-m3tNPJRss6YwYlmRcOpB_LHjxvchHVtzXCuRbo,32 +bitblas/3rdparty/cutlass/docs/matrix__traits_8h__incl.md5,sha256=GKrjuVHj_TpbQz9Ky5XldHQVqxITqlH1oSVE7ySxxz4,32 +bitblas/3rdparty/cutlass/docs/matrix__traits_8h_source.html,sha256=XfEiRiIV2OQ8MHGKE0_pJvNmNXwxsGRPJ9oHzZX5ppE,15203 +bitblas/3rdparty/cutlass/docs/memory_8h.html,sha256=7aJD8HFP75k2d8p7KRBzzNzLE26GZz-yGryOKcPNdw4,6228 +bitblas/3rdparty/cutlass/docs/memory_8h__dep__incl.md5,sha256=wCxaqloIo-HGjAUFqyEaJEcCVVmTMO6NwlvZqJ1LQPU,32 +bitblas/3rdparty/cutlass/docs/memory_8h__incl.md5,sha256=MtlFZ6kDE-KxXYYOkg6ON9Z46w70sOM1J3lqSmC3I1U,32 +bitblas/3rdparty/cutlass/docs/memory_8h_source.html,sha256=wgIr6V5YNE4Rdo3szA4YsCr-2oY0jyv1BdB6QAtd1vY,10991 +bitblas/3rdparty/cutlass/docs/memory__sm75_8h.html,sha256=iTba0pwXU73jd2RkJO3-hcS6RX-Uy7F9Sv7R4698fn8,15403 +bitblas/3rdparty/cutlass/docs/memory__sm75_8h__dep__incl.md5,sha256=prvIW_NsO09oNPXj5Zl0sepo0si9duqlhkRTzzKvbkE,32 +bitblas/3rdparty/cutlass/docs/memory__sm75_8h__incl.md5,sha256=wHqxSEXNKr9h3vRRN6QDUyDYQvkhgv5bejg8Be2ImC4,32 +bitblas/3rdparty/cutlass/docs/memory__sm75_8h_source.html,sha256=t1AXWoplS7nJuUckL438Cmm4Qo-KUUpRdarlLEHspNo,37152 +bitblas/3rdparty/cutlass/docs/mma__base_8h.html,sha256=JTXQqPwbVSvt1KG9Jyji0dtOtHHYEdPRsDSeaxhk1Uw,9261 +bitblas/3rdparty/cutlass/docs/mma__base_8h__dep__incl.md5,sha256=s4BKJFoLMZsydT93BaQpfyg-eCQuQ6wNY01nq7tAoxs,32 +bitblas/3rdparty/cutlass/docs/mma__base_8h__incl.md5,sha256=Bo2Ly7lbYAJqh6RG8Zb2oprSJuX3gLy9Jtrje-RjhUQ,32 +bitblas/3rdparty/cutlass/docs/mma__base_8h_source.html,sha256=wV_gnxmlsFxidEsAJ3pMqAT8oOw3BKsgNO_p82Wng6c,47320 +bitblas/3rdparty/cutlass/docs/mma__complex__tensor__op_8h.html,sha256=bp0wr3mhMbThFHOZlwX4TsiFD6C9tqvlz2pO9_5mcyg,9491 +bitblas/3rdparty/cutlass/docs/mma__complex__tensor__op_8h__incl.md5,sha256=dHtpjo89iEzkYkcnNr1jHk5m-7YcbpRyU1uNlGtYaKw,32 +bitblas/3rdparty/cutlass/docs/mma__complex__tensor__op_8h_source.html,sha256=kBKhD_clTF6k9bHLa5xoDhAAtSreKGCgTmKmt5DXLGw,70736 +bitblas/3rdparty/cutlass/docs/mma__pipelined_8h.html,sha256=PzoJaha76k7aHVpI_Ag18iNedZ6rKW7rNarDegKXaGE,8574 +bitblas/3rdparty/cutlass/docs/mma__pipelined_8h__dep__incl.md5,sha256=cMWh3Ir6tWpLmUl0TG79SRxYK_-Lmn3Bx0xdawuzSwI,32 +bitblas/3rdparty/cutlass/docs/mma__pipelined_8h__incl.md5,sha256=gGw7kggT_1ZtJDARvDkB-36TM0bjYDYpIoj-8x9sOO4,32 +bitblas/3rdparty/cutlass/docs/mma__pipelined_8h_source.html,sha256=FqNbN_6Kt6n-2rcXQdyzUUbnKFTUL03-t5zywrD4i2A,68216 +bitblas/3rdparty/cutlass/docs/mma__simt_8h.html,sha256=XvtOjgRYNMPo1BsYbTIaJc9ShjvUsknsb7rGgli3_bs,8584 +bitblas/3rdparty/cutlass/docs/mma__simt_8h__dep__incl.md5,sha256=o3fh1KwrB8LeonHeTs8O-jR_7oQ7qnb9nVk4AdUWm0o,32 +bitblas/3rdparty/cutlass/docs/mma__simt_8h__incl.md5,sha256=eyaFgxTob_2LnTOcUW-7fntL_6RKRaQlT8tVOalMTBM,32 +bitblas/3rdparty/cutlass/docs/mma__simt_8h_source.html,sha256=mD0dqGC3Etg7YkibAhe28QQHPlruLHoqV3FOibSI9yY,52360 +bitblas/3rdparty/cutlass/docs/mma__simt__policy_8h.html,sha256=t21mO_ijXJxhDTPLUSH2L5YT1v1qUDHNNLm4IC5UYgE,7679 +bitblas/3rdparty/cutlass/docs/mma__simt__policy_8h__dep__incl.md5,sha256=xYNyj2WamcxwEl4Nf97BTvKgi0vww5pXqnX73tAotTI,32 +bitblas/3rdparty/cutlass/docs/mma__simt__policy_8h__incl.md5,sha256=FUVdrSyH_8Bn4ICJ0cK1685kSg-fauMZNzu6OXDY0ZU,32 +bitblas/3rdparty/cutlass/docs/mma__simt__policy_8h_source.html,sha256=OATBNk-jTohFqhkfETkB_dSRysvkpibpA1YUZiSSWVY,17740 +bitblas/3rdparty/cutlass/docs/mma__simt__tile__iterator_8h.html,sha256=3mRR92be5nwrgEVt834UIFjkIPPZxrSiYjIjr2Y4vHA,11343 +bitblas/3rdparty/cutlass/docs/mma__simt__tile__iterator_8h__dep__incl.md5,sha256=W007Vvo_L_6PmnY_vPsm4MpxTFt6WNhXoYZm4T3ZkEw,32 +bitblas/3rdparty/cutlass/docs/mma__simt__tile__iterator_8h__incl.md5,sha256=ilUwIp6YFIvmR_Y8rbLZ0rO4JO1x9Qen_FAXAGxa9n4,32 +bitblas/3rdparty/cutlass/docs/mma__simt__tile__iterator_8h_source.html,sha256=cpDbUk2DTZh1dCQ8WUv7cFmg9ISX4dUa9ICnoXyT1x4,327751 +bitblas/3rdparty/cutlass/docs/mma__singlestage_8h.html,sha256=UJiR7KpHSz5XWZn5A6okM5D48I7_qFodt7OV4nsDu7c,8449 +bitblas/3rdparty/cutlass/docs/mma__singlestage_8h__dep__incl.md5,sha256=rDzHSCbGk0Yjeek4gD0V_tNzQe4wH-MgJS5pGk-5R30,32 +bitblas/3rdparty/cutlass/docs/mma__singlestage_8h__incl.md5,sha256=9zG4ukhpKDKqPgXL6-hVfIogSXZx2jU2YP3eqTYZCmg,32 +bitblas/3rdparty/cutlass/docs/mma__singlestage_8h_source.html,sha256=sQoBzU9nlhJsDqhFdBZhu6mbUjsehlyOylS1Z2YwrPg,57650 +bitblas/3rdparty/cutlass/docs/mma__sm70_8h.html,sha256=ezQET9Aim0iQ149b9ydlYTSNc4CzgoacdTjdiNpLomQ,14317 +bitblas/3rdparty/cutlass/docs/mma__sm70_8h__dep__incl.md5,sha256=yeoR2_EzUBWIaNfvM6GmLtXSZsDSGnPfdQ4smAkgoPE,32 +bitblas/3rdparty/cutlass/docs/mma__sm70_8h__incl.md5,sha256=Q9M27cEXSnrA_mcg87j1IcPwf9KrG9I_dmlL21ecWXI,32 +bitblas/3rdparty/cutlass/docs/mma__sm70_8h_source.html,sha256=C5g_810aKAmnbU27MEMurKcLQiLcblNArbo7O0pWR6I,168823 +bitblas/3rdparty/cutlass/docs/mma__sm75_8h.html,sha256=1Whcb3w9BpquBR_w-nAP7Pj5ZGf2p-3ylPSyYxDrUdM,22988 +bitblas/3rdparty/cutlass/docs/mma__sm75_8h__dep__incl.md5,sha256=guB8Ndv771lm01xj0OaF-8DYd2lSoF__LcuAr7tN7rM,32 +bitblas/3rdparty/cutlass/docs/mma__sm75_8h__incl.md5,sha256=2J62jWl_ajm99okdEEXbOvq6xa3ERaE8Bu2ol-4Usek,32 +bitblas/3rdparty/cutlass/docs/mma__sm75_8h_source.html,sha256=4nMlJqRalHKi833gWO6waxoNqsbLdmZ6ftaG14mVTrQ,367180 +bitblas/3rdparty/cutlass/docs/mma__tensor__op_8h.html,sha256=Gckjt44RmLhHYLpmJQVvD--S3S-oBdKTuResEChrzek,8859 +bitblas/3rdparty/cutlass/docs/mma__tensor__op_8h__dep__incl.md5,sha256=upNsTnmcylNGnQiMYG8fF18rTdSa0Cy6LU5k7LH9-P4,32 +bitblas/3rdparty/cutlass/docs/mma__tensor__op_8h__incl.md5,sha256=vNMJcVfrxlwYz4DI815-q775usvvlf3yWYuZ0acYtGA,32 +bitblas/3rdparty/cutlass/docs/mma__tensor__op_8h_source.html,sha256=7A7tYpb7EPy92pufCmas7MUQRAnMVFfgZnT1YRBhoOc,51771 +bitblas/3rdparty/cutlass/docs/mma__tensor__op__policy_8h.html,sha256=GgllPAcr7dCEnlfQmG6LMPr4XsQf4dev73Tqs7FFDWg,7881 +bitblas/3rdparty/cutlass/docs/mma__tensor__op__policy_8h__dep__incl.md5,sha256=Sf2SfMR6XEaJyn8OeaafQa6tf4IvQYe6UaOoUYs-AKg,32 +bitblas/3rdparty/cutlass/docs/mma__tensor__op__policy_8h__incl.md5,sha256=PD8buTLzKujtzfirhH7T8QtqPAypnSULKNLnw1-CMlc,32 +bitblas/3rdparty/cutlass/docs/mma__tensor__op__policy_8h_source.html,sha256=lsrmfNAskRawC4NVlmtOyC1XBMKOwCGK49cN_aaF_9E,16083 +bitblas/3rdparty/cutlass/docs/mma__tensor__op__sm70_8h.html,sha256=nlgmugvBf5QTTUgBOiJNmRjO9RhhGDvb57U3_OHMtwM,8927 +bitblas/3rdparty/cutlass/docs/mma__tensor__op__sm70_8h__dep__incl.md5,sha256=9XUmXS_ga5ybaS0zoP3cjpVdvJN4Lmdo69JEyQ9ry9U,32 +bitblas/3rdparty/cutlass/docs/mma__tensor__op__sm70_8h__incl.md5,sha256=H78es1S3GHEgCxhBgpFmKNx6tJMcAam3XvnovoTms7U,32 +bitblas/3rdparty/cutlass/docs/mma__tensor__op__sm70_8h_source.html,sha256=Cf7uQoTO6-WTo1dBKdGRBoz9_eiFXAhoyY3Wf4yfCfo,57450 +bitblas/3rdparty/cutlass/docs/mma__tensor__op__tile__iterator_8h.html,sha256=DJZ-_lTv3WGAuxLhYKdrgvLomZ4pOtXtAS6e03VjmwA,19386 +bitblas/3rdparty/cutlass/docs/mma__tensor__op__tile__iterator_8h__dep__incl.md5,sha256=c6inWbPdC2X2m8CcwaaYvKXFFL0xiONT96X1NdRv8VQ,32 +bitblas/3rdparty/cutlass/docs/mma__tensor__op__tile__iterator_8h__incl.md5,sha256=CxQ2dGLkYT5nmWBRXumWzcp-HlzPZXDd5Bo99dqhOZc,32 +bitblas/3rdparty/cutlass/docs/mma__tensor__op__tile__iterator_8h_source.html,sha256=5rVrg_5CKcqQRzxFR6ITs4oyK8q5QWWNdGBjLltM1eg,632948 +bitblas/3rdparty/cutlass/docs/mma__tensor__op__tile__iterator__sm70_8h.html,sha256=lPF1xx7zOmXcbi4_-ouOWzjjB_Lst1YK7qAa_xZy3EE,17158 +bitblas/3rdparty/cutlass/docs/mma__tensor__op__tile__iterator__sm70_8h__dep__incl.md5,sha256=Hvc-PCGXL7CEyKrDvl29DyaPiqFAMyEA4OHHnekgz8c,32 +bitblas/3rdparty/cutlass/docs/mma__tensor__op__tile__iterator__sm70_8h__incl.md5,sha256=Evu3xE3EkrxQv_PdZ6OfLWPhBbEBg6diJwoAozIte9Y,32 +bitblas/3rdparty/cutlass/docs/mma__tensor__op__tile__iterator__sm70_8h_source.html,sha256=KBjHZo5Ngn1uqAzMwzYUhBDrbL-KhC3brNsJbDVUGmc,535332 +bitblas/3rdparty/cutlass/docs/mma__tensor__op__tile__iterator__wmma_8h.html,sha256=fC-09OWmm0qvrDPq-YjvcsxEqcU8-05Z7jgwhB5__Rs,5582 +bitblas/3rdparty/cutlass/docs/mma__tensor__op__tile__iterator__wmma_8h__incl.md5,sha256=cbZ_tww-1nTnZ76Gx1IvDA3XgB6Z2ILSWfCKa4NfXrA,32 +bitblas/3rdparty/cutlass/docs/mma__tensor__op__tile__iterator__wmma_8h_source.html,sha256=AkLPiFG8be8EW-v6XNlzkxGBVPSsDm2tViSr7mjdjrU,101712 +bitblas/3rdparty/cutlass/docs/mma__tensor__op__wmma_8h.html,sha256=8mpuP566ozRHNKOELHjhz85h7XalEK4cVwVg1YPwxcg,5468 +bitblas/3rdparty/cutlass/docs/mma__tensor__op__wmma_8h__incl.md5,sha256=-Lblm0EuTzLyz20GM4QQguUgFqBb3Cttqv7ujPS0Zew,32 +bitblas/3rdparty/cutlass/docs/mma__tensor__op__wmma_8h_source.html,sha256=a08JiZTrmGEDr-K21HIOkY05Cl3GCt_aNaRQvbczLF4,31673 +bitblas/3rdparty/cutlass/docs/modules.html,sha256=rLPBEXhpLG4w1iNcnGjGs-MKUHre5fpfXxC2cUg1LFM,4795 +bitblas/3rdparty/cutlass/docs/namespacecutlass.html,sha256=bKpMbchA1ROFF4_2HgW8Z-jxzRCJJ7zxEI_Fp_OqjmQ,256753 +bitblas/3rdparty/cutlass/docs/namespacecutlass_1_1arch.html,sha256=qh1wczSKCkGMF7d5WLEjiUixeFf4ajVmBhI0jyU9uVk,107951 +bitblas/3rdparty/cutlass/docs/namespacecutlass_1_1debug.html,sha256=iCGSfBvtEj6KlfyhZKJe_AJ1_KZWVagymXDFG_9vwAY,8489 +bitblas/3rdparty/cutlass/docs/namespacecutlass_1_1detail.html,sha256=rn7P0mveB9y7TqqKedPnitbPqMmMywwhDq5f1c7A3eI,12462 +bitblas/3rdparty/cutlass/docs/namespacecutlass_1_1device__memory.html,sha256=JGKfExZWMHKSVDUW-1bgmhkgoIC2T79t-O4-E6KhsgU,19820 +bitblas/3rdparty/cutlass/docs/namespacecutlass_1_1epilogue.html,sha256=K6MCrenIiIjmT9vcdt_Fycw9AstmOg85ylqunbD3WK8,6171 +bitblas/3rdparty/cutlass/docs/namespacecutlass_1_1epilogue_1_1thread.html,sha256=qjeUMo1IQSUHugH6XfGNQpytYWoktPKujaUr3B1Qcv8,6842 +bitblas/3rdparty/cutlass/docs/namespacecutlass_1_1epilogue_1_1threadblock.html,sha256=DLaib9zlfZSZaDpjbMqi0esKiyikVCBkyLwCr7MUiuI,18604 +bitblas/3rdparty/cutlass/docs/namespacecutlass_1_1epilogue_1_1threadblock_1_1detail.html,sha256=r0e34WFjQGB908EH14EswSP6M0b_4p9MMCukQ88Kaag,7717 +bitblas/3rdparty/cutlass/docs/namespacecutlass_1_1epilogue_1_1warp.html,sha256=XjlvXC1CH3yjEa3lh0dtsDNmEG9A-fKs0bcyX5hGKGw,23900 +bitblas/3rdparty/cutlass/docs/namespacecutlass_1_1gemm.html,sha256=72Lo1OZX3le8YOX1tJODD2ylPv93j4oVdL14PHEE6T8,12221 +bitblas/3rdparty/cutlass/docs/namespacecutlass_1_1gemm_1_1device.html,sha256=1Qbg1G2lUTW-utwHogwb0lsFO1qNslHUYDNG3-l_rIw,16625 +bitblas/3rdparty/cutlass/docs/namespacecutlass_1_1gemm_1_1kernel.html,sha256=Q2j9hUJPkhs4KDei1n6fhlg_K0to0azEhVgW3nPy-Dw,30346 +bitblas/3rdparty/cutlass/docs/namespacecutlass_1_1gemm_1_1kernel_1_1detail.html,sha256=z_5GgWveCbzL0Vvta0xMeb--lbQStuKQmgG7a4cu_F0,5260 +bitblas/3rdparty/cutlass/docs/namespacecutlass_1_1gemm_1_1thread.html,sha256=OWyn_3anvQZXWgstsqs7wlrl3KPYeGl6Igd00Q1lMG0,10429 +bitblas/3rdparty/cutlass/docs/namespacecutlass_1_1gemm_1_1thread_1_1detail.html,sha256=aACopBwL6KFBTi2F6sbxQqF6-25fEaHPbxh_IC8OILY,10692 +bitblas/3rdparty/cutlass/docs/namespacecutlass_1_1gemm_1_1threadblock.html,sha256=LJ37aqOfXUT0MSxNNgXfWJuIsinp6N-aticXY12bdTQ,36946 +bitblas/3rdparty/cutlass/docs/namespacecutlass_1_1gemm_1_1threadblock_1_1detail.html,sha256=mU0DOILrUTGJGDtmp-8xUbgYnbNcyLKXm3wnmyj6N5I,8033 +bitblas/3rdparty/cutlass/docs/namespacecutlass_1_1gemm_1_1warp.html,sha256=qqrtIWNi1behk-BBm_sUFMMT-xRMHJ3Oo2EYZb2KqKw,23898 +bitblas/3rdparty/cutlass/docs/namespacecutlass_1_1layout.html,sha256=krs4aaMjh3ASKQ8fVAiUMUe3OezTlQsTqfXtzRxdkfg,25531 +bitblas/3rdparty/cutlass/docs/namespacecutlass_1_1library.html,sha256=9-EOAKtgb1eYR8xj9EosAYetg_YyBRfbJZG898spg-g,86210 +bitblas/3rdparty/cutlass/docs/namespacecutlass_1_1platform.html,sha256=_jaIDtCAvu5I2Cx-rLjMe235xMEw7yord-UjhBzkqhw,66476 +bitblas/3rdparty/cutlass/docs/namespacecutlass_1_1reduction.html,sha256=hGQmypxBhXdqTmGwgBwyvkzt_fJWUQSihZBaLLLhl8Q,8186 +bitblas/3rdparty/cutlass/docs/namespacecutlass_1_1reduction_1_1kernel.html,sha256=a25R3UmCqAZR1GgMC5trtRUYpMVvw23xVx66V7M0M2M,5114 +bitblas/3rdparty/cutlass/docs/namespacecutlass_1_1reduction_1_1thread.html,sha256=j0RmVoYfn_ouKfRUbRgxtGmCZRYwF2kjnHc7ucNZuG0,9190 +bitblas/3rdparty/cutlass/docs/namespacecutlass_1_1reference.html,sha256=z7p92YtKadpbQKe3uSxFLIPq1FinqoLbJQ2fcjPdqvw,5661 +bitblas/3rdparty/cutlass/docs/namespacecutlass_1_1reference_1_1detail.html,sha256=pQEdT_TLa49TsGRUv1etLusOMplWQ8VvBuKhAsqSuO0,10800 +bitblas/3rdparty/cutlass/docs/namespacecutlass_1_1reference_1_1device.html,sha256=JZMbnNnFP9ROXt8aTXZxvGFfGg4_36-oqRaQXCBhals,63819 +bitblas/3rdparty/cutlass/docs/namespacecutlass_1_1reference_1_1device_1_1detail.html,sha256=3eH0lpm-x_zj5rxWEnHI5iq7rYlytM3Dt8qNN42ZnuQ,15986 +bitblas/3rdparty/cutlass/docs/namespacecutlass_1_1reference_1_1device_1_1kernel.html,sha256=WnBchLbMqgO-q9EwEdgM1xe2KGqOVC4rACsCgNcW3T8,32695 +bitblas/3rdparty/cutlass/docs/namespacecutlass_1_1reference_1_1device_1_1kernel_1_1detail.html,sha256=IjMwr4DSdRLTd8SOYd7zjgS1ZDtPheyslbwgE4g-W88,6377 +bitblas/3rdparty/cutlass/docs/namespacecutlass_1_1reference_1_1device_1_1thread.html,sha256=5UGHRd7PA8WzGDGQngaTElfMZIUvqQcRNE37FfSnrxM,5466 +bitblas/3rdparty/cutlass/docs/namespacecutlass_1_1reference_1_1host.html,sha256=aROckIcFpGjjw-Zqn2vj808UK15nFdD7_nh6-i8U6Uc,121101 +bitblas/3rdparty/cutlass/docs/namespacecutlass_1_1reference_1_1host_1_1detail.html,sha256=lzeqfWaoQobkTrrBAVeLFKq5GyYZsNF9oopzgUQkJG4,14425 +bitblas/3rdparty/cutlass/docs/namespacecutlass_1_1thread.html,sha256=vAVWg-Ux8lZ_V5SQI8A-IcWE6FASCLK-S-NnRxTCSE8,8505 +bitblas/3rdparty/cutlass/docs/namespacecutlass_1_1transform.html,sha256=mgSZYFkPIxtY2D3kWWQjykgMV9LKkI_7WH8--NwhGSM,9504 +bitblas/3rdparty/cutlass/docs/namespacecutlass_1_1transform_1_1thread.html,sha256=5n-awbRFTp5gcM0FdM6zdatv8KDC3DnR2Xifrue08XY,6087 +bitblas/3rdparty/cutlass/docs/namespacecutlass_1_1transform_1_1threadblock.html,sha256=nuzBsRMgDTnz7637rxxKojlFUDBcTtuVZ5uhqtDoUn0,33503 +bitblas/3rdparty/cutlass/docs/namespacemembers.html,sha256=Y9NOeVvIRZEaUGtpd5Nux_3Q7M8mMZfHQY2zm7Uv2IY,6496 +bitblas/3rdparty/cutlass/docs/namespacemembers_a.html,sha256=kfHWhpYExeSesJjkoF91FEQnDoBHoTreDTvimy69BVA,6575 +bitblas/3rdparty/cutlass/docs/namespacemembers_b.html,sha256=Q3jNmYHXAOMqdBVxfMSOrCl5vzTaXNcoKRBC7Cr1u5c,8754 +bitblas/3rdparty/cutlass/docs/namespacemembers_c.html,sha256=cKhuuYrutS_sKjIiP2Lhp3LWv-ioM2GCxII2hq1P0J4,8816 +bitblas/3rdparty/cutlass/docs/namespacemembers_d.html,sha256=LS7NUyWbypDrj-aCDAytosJEUquLfDd7067taqVLpn4,6600 +bitblas/3rdparty/cutlass/docs/namespacemembers_e.html,sha256=cOjjzSFB7mw1ImWc2QR_g4v5qOEph9wB6gap--mfNNs,6323 +bitblas/3rdparty/cutlass/docs/namespacemembers_enum.html,sha256=KP16ZTZ8uNavtKLXDwDzNvX3m0bXUQp51Twsl1XDPZA,6381 +bitblas/3rdparty/cutlass/docs/namespacemembers_f.html,sha256=kLVGqOeIKspARFBBnj4c43k9NIezp8QQ_GntubCCX8I,8411 +bitblas/3rdparty/cutlass/docs/namespacemembers_func.html,sha256=_TPLUSz6lGm-OLVv3U4xsaB6DEuE_JsBGZhWc9OwdR0,6389 +bitblas/3rdparty/cutlass/docs/namespacemembers_func_a.html,sha256=yyjzha3M6MX39nzFiat7toBHcn9jOALCTWMCETaVYZ0,6468 +bitblas/3rdparty/cutlass/docs/namespacemembers_func_b.html,sha256=Q2IY-NCVlkGP8wqAZNJkCt67aGVIfWBUeLk0tw7Rvkw,8539 +bitblas/3rdparty/cutlass/docs/namespacemembers_func_c.html,sha256=v6J8Kt1nHwxnbSLiOtbCAYOYmtRGhVHzW7-hPJOj1nI,8348 +bitblas/3rdparty/cutlass/docs/namespacemembers_func_d.html,sha256=yVO-we1sKAT-P6WbpRES6VRMBKyJPEB5DEqH4_P9xSg,6493 +bitblas/3rdparty/cutlass/docs/namespacemembers_func_e.html,sha256=SWF_AqVl-igq2VBPkZM3WVZZzriagPx1SWknk2Ovr20,6216 +bitblas/3rdparty/cutlass/docs/namespacemembers_func_f.html,sha256=0eBrkcHkoRV-gZ0v_p1Vz9q6htkyZzz73tM-oj8UIxE,8053 +bitblas/3rdparty/cutlass/docs/namespacemembers_func_g.html,sha256=kkYoZvB4QtZ6eVpwZgK1Kb1JUGYwh7tU2WwfdYCGJk8,7283 +bitblas/3rdparty/cutlass/docs/namespacemembers_func_i.html,sha256=0UAZWrdX0sW7xiT02NNNN4Wbd2USmc0ls35aUb4UK3o,8295 +bitblas/3rdparty/cutlass/docs/namespacemembers_func_k.html,sha256=3aF-TS8afCv6kPYkzDoY070kZfV96CIVBuIxE-kAOm0,6219 +bitblas/3rdparty/cutlass/docs/namespacemembers_func_l.html,sha256=eqAT3peTkN739OAzv2Gce-mlHkZWf4Iy1f3HNVPS08s,7605 +bitblas/3rdparty/cutlass/docs/namespacemembers_func_m.html,sha256=x2u-oxA5Xa6KMHHYMCp28wXBUdPGrhmEQ2sLMzRBlvQ,6974 +bitblas/3rdparty/cutlass/docs/namespacemembers_func_n.html,sha256=5ZqGoa4yQeVmDAUbE5xh6t3LDYHn9bk3crXXs2N7v-E,6444 +bitblas/3rdparty/cutlass/docs/namespacemembers_func_o.html,sha256=zE9tw1co-vdnXtGTS04oWD7v3IAjx71g6f7he0g4PkI,9172 +bitblas/3rdparty/cutlass/docs/namespacemembers_func_p.html,sha256=k2Grf98TIe_NYO8n1jdBRTJqmDIyl_2I8wmT1bmocaw,6326 +bitblas/3rdparty/cutlass/docs/namespacemembers_func_r.html,sha256=qq5Q1BXdVK8HthNiTAqg1cGmAE1bFARAXD44n671mvE,10915 +bitblas/3rdparty/cutlass/docs/namespacemembers_func_s.html,sha256=5pe9NeA2bY2dizhmhZg-zVnqnWqakS4XQGtM9rdvk0s,7073 +bitblas/3rdparty/cutlass/docs/namespacemembers_func_t.html,sha256=hGEoi9S1FSMsSMm2hpG82wR6FsIfqYDBkGDZC45Bc6E,12970 +bitblas/3rdparty/cutlass/docs/namespacemembers_g.html,sha256=SfF6ZGxH_xWOPskeNYq_wY-v9L32_cFH1bcAeYZ7t9c,8098 +bitblas/3rdparty/cutlass/docs/namespacemembers_i.html,sha256=wqNhrwJB1vAVB-dNAbwGS4HIz2GdMmqcTAh32W5YOGM,8511 +bitblas/3rdparty/cutlass/docs/namespacemembers_k.html,sha256=jDi8kgqYbeTKniPVW4aTj6OdaIfAUCZcqDU-pmncoaM,6326 +bitblas/3rdparty/cutlass/docs/namespacemembers_l.html,sha256=NS_vc93RjtUbAzzbCm2Bdeg8b-EjaI104EkNBejUbK8,7846 +bitblas/3rdparty/cutlass/docs/namespacemembers_m.html,sha256=jlKjjsRHpPubYvNOrJiF8r5iVFSaGJcTg0sthul32-Q,7438 +bitblas/3rdparty/cutlass/docs/namespacemembers_n.html,sha256=Ykza2mZt25sUqxcPQuj4u4vEvlbgmg2gOf4JXBPBmfs,6686 +bitblas/3rdparty/cutlass/docs/namespacemembers_o.html,sha256=9Dw6HN_cynd3ztRfKGMejn9UmpKs5XV-Z6QmrcK_o80,9809 +bitblas/3rdparty/cutlass/docs/namespacemembers_p.html,sha256=yYyLaepXGeOf3rnjyHEQ-PSjlbjdbY1y9e4qq4Pcyl0,6433 +bitblas/3rdparty/cutlass/docs/namespacemembers_r.html,sha256=ay-U5wKlSzxwBZHAnY-PO3EAcNA4MhyLVEyvL04ezMs,11151 +bitblas/3rdparty/cutlass/docs/namespacemembers_s.html,sha256=SlPtn-GPSXYhT8bGHO7w45JzvgyhjstqT7hWgJn8kfY,7559 +bitblas/3rdparty/cutlass/docs/namespacemembers_t.html,sha256=drfTnv3bq2wt_Rf1IVpSmReubwOnP-XL51ix6wMCBLU,13210 +bitblas/3rdparty/cutlass/docs/namespacemembers_type.html,sha256=nvM-rtvuF2yCzzawPRDmmBeQ9-Mqh8cX0HbR0yIOMpk,6187 +bitblas/3rdparty/cutlass/docs/namespacemembers_u.html,sha256=p09lEQJrSaVmES6d-0roGLIMmlPKmejFlbukxiNhkCg,6436 +bitblas/3rdparty/cutlass/docs/namespaces.html,sha256=TV4nc7zhy2bH3LZst4o_j1ip6sjXQjOWHhdNL32IQXA,16442 +bitblas/3rdparty/cutlass/docs/nav_f.png,sha256=QwcZbqHNNRp87wtBjIROHciIfiBLfyfbzRJwZx4i8lY,153 +bitblas/3rdparty/cutlass/docs/nav_g.png,sha256=MXEWTBa6pZU8F4IafOX-rGc8BaVrKHRTzjoL9QSPCZk,95 +bitblas/3rdparty/cutlass/docs/nav_h.png,sha256=hskP8E8q0JXub8WHzgRfLMe1PqEEjruOcDGs8rhbEn4,99 +bitblas/3rdparty/cutlass/docs/numeric__conversion_8h.html,sha256=IM35RI6euE8nFf-xxAnsGYj06IWd4OcT7s_EIgdlv2g,15432 +bitblas/3rdparty/cutlass/docs/numeric__conversion_8h__dep__incl.md5,sha256=DrDos91XSKvag7hb91tTnZ9JkMGOd2WdITzscJoJlzI,32 +bitblas/3rdparty/cutlass/docs/numeric__conversion_8h__incl.md5,sha256=QND6XENYxpJodzq1gHeJ0U6Pff4wDoi5nMR-Fp8czus,32 +bitblas/3rdparty/cutlass/docs/numeric__conversion_8h_source.html,sha256=__ofEMCZ02Nl8H_ONnKLdIbm3rrPgimgNHDeLOUFly0,157030 +bitblas/3rdparty/cutlass/docs/numeric__types_8h.html,sha256=ou1uhrLhzbQhbV5cDlGZdOAQE5fDuZkIOzEapftsW54,14060 +bitblas/3rdparty/cutlass/docs/numeric__types_8h__incl.md5,sha256=vLAgWFPvWCpyqV2gKlrU9WOPmWvn8NP77v08K3-r37M,32 +bitblas/3rdparty/cutlass/docs/numeric__types_8h_source.html,sha256=EaR51FofVOxZbeg3VmRpYdYF13i_w5lphfJRyJZ1b8s,39446 +bitblas/3rdparty/cutlass/docs/open.png,sha256=kod7MWlh0MEZN2FThNKUiA_4q7yddZhFUaIsIiPluk0,123 +bitblas/3rdparty/cutlass/docs/output__tile__thread__map_8h.html,sha256=qoEmujd1EQ3rBSQvAkpbaoQHSlM04fW6ACcqeXLwYJg,15356 +bitblas/3rdparty/cutlass/docs/output__tile__thread__map_8h__dep__incl.md5,sha256=9_QNIGtE7TfeRLsFdWBH5CjDoWarBb0GeXJvwqn-i_k,32 +bitblas/3rdparty/cutlass/docs/output__tile__thread__map_8h__incl.md5,sha256=ZmlMXTapULCFCQd8vPkXPnQ68jGpj1n5zB1B5HTzIs8,32 +bitblas/3rdparty/cutlass/docs/output__tile__thread__map_8h_source.html,sha256=DaCpspWW99hCzxV5p9Es4uVkQxdvPF-9AKbZsR70uKs,108752 +bitblas/3rdparty/cutlass/docs/pitch__linear_8h.html,sha256=vGXqAKy1c01tapfoUA1jHtH4qfJChe4CIqym6Od7wIs,8299 +bitblas/3rdparty/cutlass/docs/pitch__linear_8h__dep__incl.md5,sha256=-2iyOJDSWvqIk_7WoJW8ozNpOJN6xz96OgjhD-vzX2U,32 +bitblas/3rdparty/cutlass/docs/pitch__linear_8h__incl.md5,sha256=hrLqchaQ-n0hQ2MZ4V3bQ1VyubF5cw9P3y666iJJmm8,32 +bitblas/3rdparty/cutlass/docs/pitch__linear_8h_source.html,sha256=hiFq21s5Dls5C44TpZ3B1QPCBxPGNhmGTgo3Cabtm7w,65203 +bitblas/3rdparty/cutlass/docs/pitch__linear__thread__map_8h.html,sha256=dScdQS8zT_CX_fkHDtxuMCOjkHvp2aCpOGz_vqTG5U4,15651 +bitblas/3rdparty/cutlass/docs/pitch__linear__thread__map_8h__dep__incl.md5,sha256=G_PphhL_sufEna_0s25bXeu1ZZulKGNc9gMSQyvTyjc,32 +bitblas/3rdparty/cutlass/docs/pitch__linear__thread__map_8h__incl.md5,sha256=-dpq1WppgZcGBXxqZl-th89edJ_y9JpFoGtf7iWzNGQ,32 +bitblas/3rdparty/cutlass/docs/pitch__linear__thread__map_8h_source.html,sha256=yRfORUITwxPRYc4K-iqUh4qqXtAJWFvOOfR4YVT51U0,158958 +bitblas/3rdparty/cutlass/docs/platform_8h.html,sha256=RWj5v4VJEZS5ujgAwL4sqSEskhJfLdS4m9jMlZwkVPM,65306 +bitblas/3rdparty/cutlass/docs/platform_8h__dep__incl.md5,sha256=G5oLsMM2jh-3f4ZutWcpkLGSeu-M6ptgQvHQiWwFkck,32 +bitblas/3rdparty/cutlass/docs/platform_8h__incl.md5,sha256=UNCmmTBuz1kKq0wPh8iHBPWHrFfGI3rbm52VDR9fXsU,32 +bitblas/3rdparty/cutlass/docs/platform_8h_source.html,sha256=xqGdJFoN5qdy3hUZPQ5y8BZEiQy4iNzgNciKTBTNlV8,152200 +bitblas/3rdparty/cutlass/docs/predicate__vector_8h.html,sha256=C-HnvQh8blICh4sSWjsh-Mu_b2_5KilZ6zsMVvz-4FI,9280 +bitblas/3rdparty/cutlass/docs/predicate__vector_8h__dep__incl.md5,sha256=PDJPmH1thQppKVvq_e4uaqYtkZ1g50gQ3pUV39sbd_E,32 +bitblas/3rdparty/cutlass/docs/predicate__vector_8h__incl.md5,sha256=t-Z49_vwSkrzBCR2j3FM9i1to1eyalw_iGq80MlJKrE,32 +bitblas/3rdparty/cutlass/docs/predicate__vector_8h_source.html,sha256=EVg0M8A66o3L1lO6HW_RB5N4VoK9fS7Z3USqXiPT5sY,106711 +bitblas/3rdparty/cutlass/docs/predicated__tile__access__iterator_8h.html,sha256=u135zEzKYhqTtCspsNeEIjYnEBCOfg_6i7smdx850Z4,16149 +bitblas/3rdparty/cutlass/docs/predicated__tile__access__iterator_8h__dep__incl.md5,sha256=tLIkbSpQIm8bh7eNj18vid7-0aDGwuBFUWPWLB7DW54,32 +bitblas/3rdparty/cutlass/docs/predicated__tile__access__iterator_8h__incl.md5,sha256=wwu8VAY7H8RvC-_FrfzhUx1yoGL7rJd9R4BKSW2E41Y,32 +bitblas/3rdparty/cutlass/docs/predicated__tile__access__iterator_8h_source.html,sha256=_fSjOCbV8O0cc_xYmNfL5UasSNQe4PR2I7xfFSEuqvI,315165 +bitblas/3rdparty/cutlass/docs/predicated__tile__access__iterator__2dthreadtile_8h.html,sha256=t8WRIgsXOeFhJPB7KJ-xtG0dSMUlzI_gn6JehP0DRFE,13528 +bitblas/3rdparty/cutlass/docs/predicated__tile__access__iterator__2dthreadtile_8h__dep__incl.md5,sha256=DRpsPbaQgjLSQCFlzhpsMdNqb1awygeMP5oTUDtUKWs,32 +bitblas/3rdparty/cutlass/docs/predicated__tile__access__iterator__2dthreadtile_8h__incl.md5,sha256=a3FM2IQ3UrnYr_68hvt4n68w58QnlCOm2-X8aWaHkm0,32 +bitblas/3rdparty/cutlass/docs/predicated__tile__access__iterator__2dthreadtile_8h_source.html,sha256=I9ZZMr23xEoBU-tKFRR5AM5aEro1Y4_GaMM8LMI1iRI,208170 +bitblas/3rdparty/cutlass/docs/predicated__tile__iterator__2dthreadtile_8h.html,sha256=3ho_Pdw1SVgssHOVl7TDIG60sZcEXhtUGFGl5ObMgrw,13201 +bitblas/3rdparty/cutlass/docs/predicated__tile__iterator__2dthreadtile_8h__dep__incl.md5,sha256=L8rQRXubZzmwy8UnlfnNIBhTfS70sYRsrKGdIH62wEI,32 +bitblas/3rdparty/cutlass/docs/predicated__tile__iterator__2dthreadtile_8h__incl.md5,sha256=PYTIc8p5FJ4JBEraLYeiEXN8c7OAIqRNDcCwRfGD5Fs,32 +bitblas/3rdparty/cutlass/docs/predicated__tile__iterator__2dthreadtile_8h_source.html,sha256=DH6eAGdBVYyCewwYkCUDFM88nOLDlTE0EQsBVb9W8zo,152471 +bitblas/3rdparty/cutlass/docs/real_8h.html,sha256=SiMNpc5wczyQvfUePfYPrH6WlgmmWzVNgNLuKXK2rSM,6044 +bitblas/3rdparty/cutlass/docs/real_8h__dep__incl.md5,sha256=UMve6tmTVJihejbZZyGsYrwIzobHypA0YrwPpsGCY7E,32 +bitblas/3rdparty/cutlass/docs/real_8h_source.html,sha256=0D45lzdHb2q7zTANsMo_WZgQygr5VbOkXfX_HX23EvY,12424 +bitblas/3rdparty/cutlass/docs/reduce_8h.html,sha256=El36Y5xVYsjqF0w7vuUHw43IQLoqfqaBkSnhqnK78To,11387 +bitblas/3rdparty/cutlass/docs/reduce_8h__dep__incl.md5,sha256=msEjC5wa02qpSFBz6KtXxSYLZy_Y9bqCwZQ8q7TDnO0,32 +bitblas/3rdparty/cutlass/docs/reduce_8h__incl.md5,sha256=Pco23lllnDol2A752Rs68VO7BUwtbjMcV-SOXQtW45U,32 +bitblas/3rdparty/cutlass/docs/reduce_8h_source.html,sha256=h_1uGmdbeuRAhmvDB1YGotNUDXM3s49O4YwZx6H0O5Y,43259 +bitblas/3rdparty/cutlass/docs/reduce__split__k_8h.html,sha256=PwTN5jig18n5lQI6MWtMP4XqnZxMR9tznge5dHti2Rc,9432 +bitblas/3rdparty/cutlass/docs/reduce__split__k_8h__dep__incl.md5,sha256=j1ic7FevQKdEYUzwsaRxoQeQZ5HgJH8uCpqawK4njcY,32 +bitblas/3rdparty/cutlass/docs/reduce__split__k_8h__incl.md5,sha256=IFZQO0QE3Mybse7ly15cyQ_IX5HV7YMF8yoylYHvfd4,32 +bitblas/3rdparty/cutlass/docs/reduce__split__k_8h_source.html,sha256=kXH4qKeNy-P3GxO56OjI_5piGbegdvSY6cXZvSF8Ax8,64953 +bitblas/3rdparty/cutlass/docs/reduction_2threadblock__swizzle_8h.html,sha256=4LUfw-10SK_JhlhDWK1M__HsZQQbGyuNq46LvLgiO8I,7039 +bitblas/3rdparty/cutlass/docs/reduction_2threadblock__swizzle_8h__dep__incl.md5,sha256=PcB-ZdDDutgaDel7us_GzMvMnSKnBAILGrZedqxh3xc,32 +bitblas/3rdparty/cutlass/docs/reduction_2threadblock__swizzle_8h__incl.md5,sha256=RFmal-1Ko7K_TR5shrIkT2JXBtafjNjXGItuqyG1uWA,32 +bitblas/3rdparty/cutlass/docs/reduction_2threadblock__swizzle_8h_source.html,sha256=qIINmGCj40f9XYm_PVlL36dGt-xNsGaZgpZgyQYxMS4,18377 +bitblas/3rdparty/cutlass/docs/reduction__op_8h.html,sha256=hfA56ZMCRS9U3ShHWuLDnsK65kC7v7z9Nh0MEWM_2Os,8432 +bitblas/3rdparty/cutlass/docs/reduction__op_8h__dep__incl.md5,sha256=qaKwnhaAbEC_lIC51OFb2c4V8wBBTFDUkYMGafH_5Qc,32 +bitblas/3rdparty/cutlass/docs/reduction__op_8h__incl.md5,sha256=ltUB_HOAz16OMtlrh1lxQHOZUQ9BUrpp-82bdGhtdSM,32 +bitblas/3rdparty/cutlass/docs/reduction__op_8h_source.html,sha256=mWVwgyEHlx4cOch5YDO0RtZHqrAeyIydlmGtLKhswK0,23019 +bitblas/3rdparty/cutlass/docs/reduction__operators_8h.html,sha256=R57BsFol_28nsUwWYKQSE7fT-A_IPXkf-PxmX_tMRp8,8648 +bitblas/3rdparty/cutlass/docs/reduction__operators_8h__dep__incl.md5,sha256=twKZwd7e546ujQmhJJav-PoYtlyxhVSLsgzB5Gd-5t0,32 +bitblas/3rdparty/cutlass/docs/reduction__operators_8h__incl.md5,sha256=RwuZW9HSsL1nQ6SeHRSHVYKUq5j169hWL4tjJT3AihI,32 +bitblas/3rdparty/cutlass/docs/reduction__operators_8h_source.html,sha256=rszRVv_dOc-wtG1a6nOXuUnR_TvXKQ4RKAxHBYxdTjU,26337 +bitblas/3rdparty/cutlass/docs/regular__tile__access__iterator_8h.html,sha256=XwXUIbPsr-GfFVikSYjotOJJ22_RYKTdyfgJPP5xm3U,7699 +bitblas/3rdparty/cutlass/docs/regular__tile__access__iterator_8h__dep__incl.md5,sha256=yg6sAAKEEa0PwpBiqs6FrEGq1rvi8hyRdJw70UD3mgg,32 +bitblas/3rdparty/cutlass/docs/regular__tile__access__iterator_8h__incl.md5,sha256=YWDK3qneCUhHhsv2nU4PS9S_1RedwHrjF4XhqUFZ6Xs,32 +bitblas/3rdparty/cutlass/docs/regular__tile__access__iterator_8h_source.html,sha256=GHOh7dGPbKDTxaRJiIS5PuqDoIxahl7ZSBFydef5ILI,13504 +bitblas/3rdparty/cutlass/docs/regular__tile__access__iterator__pitch__linear_8h.html,sha256=he4OSUXOLSTiWWov95iJsVivg8pWnKAff0MoH2TP0s8,9368 +bitblas/3rdparty/cutlass/docs/regular__tile__access__iterator__pitch__linear_8h__incl.md5,sha256=RjQbR9W0mpQ9COPrOZ7v2ze__vf0BM6rb504oouVKpc,32 +bitblas/3rdparty/cutlass/docs/regular__tile__access__iterator__pitch__linear_8h_source.html,sha256=6RnFv3DAmJEIIdZDHVIbTIcZ5IsjuU-eujZTKCYxznc,116736 +bitblas/3rdparty/cutlass/docs/regular__tile__access__iterator__tensor__op_8h.html,sha256=hTxq6MBNDeQbHwQJJTgGGa-jZ6G6XKaWjVo3NT0MNmI,13788 +bitblas/3rdparty/cutlass/docs/regular__tile__access__iterator__tensor__op_8h__dep__incl.md5,sha256=WdQo8qLldh7B0eQAIjObrCMh99uLSbeCaVcFvUhaGhk,32 +bitblas/3rdparty/cutlass/docs/regular__tile__access__iterator__tensor__op_8h__incl.md5,sha256=5mhOEqwElGkTdPHnI7hess01SwdEqrAIGLqf3qDw7Iw,32 +bitblas/3rdparty/cutlass/docs/regular__tile__access__iterator__tensor__op_8h_source.html,sha256=Xz37_XdxsBZwfpp-v76xS7n9lbDAGZZWkh1FNTgVbCk,232445 +bitblas/3rdparty/cutlass/docs/regular__tile__iterator_8h.html,sha256=U1f74EwqIqlOMXL8jtWGZ_Zhl_gOG0CPg2Ho42L4AsA,7686 +bitblas/3rdparty/cutlass/docs/regular__tile__iterator_8h__dep__incl.md5,sha256=PuDZduwENlPyPkg0Edqs37SN8UL_dlHtrfVI2fM_O5g,32 +bitblas/3rdparty/cutlass/docs/regular__tile__iterator_8h__incl.md5,sha256=NLrUpPwBf5S8A-3rliOW52p5AMWO0T3LpUefhrPrfJU,32 +bitblas/3rdparty/cutlass/docs/regular__tile__iterator_8h_source.html,sha256=xbMJrklN4xQl9GehY3wehieDPL8waRpS8WdgETxTkgc,13979 +bitblas/3rdparty/cutlass/docs/regular__tile__iterator__pitch__linear_8h.html,sha256=5E2W97aXnODqpHNFMPy7OnVSm5yw50MewCrE37JPpoQ,10734 +bitblas/3rdparty/cutlass/docs/regular__tile__iterator__pitch__linear_8h__dep__incl.md5,sha256=4D9cJAXkDZBj-nbZ_VjQo-onR-VDprGfulwoKDKb_sU,32 +bitblas/3rdparty/cutlass/docs/regular__tile__iterator__pitch__linear_8h__incl.md5,sha256=DM3rWBcmiAkOQtIbFs8dYCU3Ur-aywh6CefjCKCcfwQ,32 +bitblas/3rdparty/cutlass/docs/regular__tile__iterator__pitch__linear_8h_source.html,sha256=td667X1_mGahK237JD3DJYbI4XkJ8jUKbysqyeFNv3E,153362 +bitblas/3rdparty/cutlass/docs/regular__tile__iterator__pitch__linear__2dthreadtile_8h.html,sha256=b-pzMnxp0e2Afb8fF9KrLBCiBni5ycYcF7L-adQPN-c,11542 +bitblas/3rdparty/cutlass/docs/regular__tile__iterator__pitch__linear__2dthreadtile_8h__dep__incl.md5,sha256=qa7xDd1NcJLIxNyklEamBXDjQlaMACJQBv4P1t5d8js,32 +bitblas/3rdparty/cutlass/docs/regular__tile__iterator__pitch__linear__2dthreadtile_8h__incl.md5,sha256=8wQ48G1h963A4QCzmTkE2spvcWbbMkUXINK3ooMlf-o,32 +bitblas/3rdparty/cutlass/docs/regular__tile__iterator__pitch__linear__2dthreadtile_8h_source.html,sha256=TuCFZpQDG-o12azrF2sGQiHBMIe9bjAuCmJQmHNHIvM,153931 +bitblas/3rdparty/cutlass/docs/regular__tile__iterator__tensor__op_8h.html,sha256=YvOmy4F4YtwE1viIGQCpHDcZyUflPo-zQ7Kx9-zY-ns,12965 +bitblas/3rdparty/cutlass/docs/regular__tile__iterator__tensor__op_8h__dep__incl.md5,sha256=pRARc10-LMLutB7tzVN6a2aeTml3EXTrky8_lgd1hBU,32 +bitblas/3rdparty/cutlass/docs/regular__tile__iterator__tensor__op_8h__incl.md5,sha256=J1Gm5nCzf0qFHdO-xILAXPOP9Lvwp-r8EVjRm17YeCE,32 +bitblas/3rdparty/cutlass/docs/regular__tile__iterator__tensor__op_8h_source.html,sha256=4AxAIZn_Wiaw4wBLFtdiMAwf4-TRil-hBhXXZ9Mq6OM,252548 +bitblas/3rdparty/cutlass/docs/regular__tile__iterator__tensor__op__sm70_8h.html,sha256=fqUU9lkHxmjJj6l-xs7x0MAWQYGUsnZrTGCPAyBp55Q,16671 +bitblas/3rdparty/cutlass/docs/regular__tile__iterator__tensor__op__sm70_8h__dep__incl.md5,sha256=EbE5y9-mgxY8WpyFqLXzD_-SB-JLiJSgOk7F-MH_ILY,32 +bitblas/3rdparty/cutlass/docs/regular__tile__iterator__tensor__op__sm70_8h__incl.md5,sha256=uhMmwOXAaYHBkZfORbrZdoWtFZpBuC4NmH2br1XBzrQ,32 +bitblas/3rdparty/cutlass/docs/regular__tile__iterator__tensor__op__sm70_8h_source.html,sha256=SdHSAoZT1JlpSfakqJdsL48uHGVXekgv4qLDd6aH3qQ,407026 +bitblas/3rdparty/cutlass/docs/relatively__equal_8h.html,sha256=VlW-hJBmX0U30xgQ61U1YT_RSw5ZWpsgbpFQRpNLTd4,17207 +bitblas/3rdparty/cutlass/docs/relatively__equal_8h__dep__incl.md5,sha256=0O3dLxBN6afpz7mp-dtpDx4WoaiIVdqdLxkMl_4FvLE,32 +bitblas/3rdparty/cutlass/docs/relatively__equal_8h__incl.md5,sha256=KX1UD_4y3oa9iyqhTsm2ZWDGtw2oR7MH11JI9dPrARc,32 +bitblas/3rdparty/cutlass/docs/relatively__equal_8h_source.html,sha256=wDi9ybUlVFryr_QeD_SlUpQacYXQ3LdlzJ7DCc2nVLU,40734 +bitblas/3rdparty/cutlass/docs/search/all_0.html,sha256=shipMmxY-9Azr-5LbbwmqlHpcT3L2JVaNFiBaze8-Qg,1013 +bitblas/3rdparty/cutlass/docs/search/all_0.js,sha256=Mf0j405-D97YzxFbFJyEZqbo1lnZF3ks4a8g2E3CDcw,2499 +bitblas/3rdparty/cutlass/docs/search/all_1.html,sha256=jCtq085ng_PTAcYCmiGKRwAM2yPLDmXD89U01wNV83U,1013 +bitblas/3rdparty/cutlass/docs/search/all_1.js,sha256=wsKRcDKhV8yg-Z7sz_rYLyVjfh9vNXMviLCfVOik7p8,104309 +bitblas/3rdparty/cutlass/docs/search/all_10.html,sha256=w5lReCTCAxdrhDwZsR69ewYo4O15vVgg5jeNrfGkSIg,1014 +bitblas/3rdparty/cutlass/docs/search/all_10.js,sha256=DTehvmaXRp1B_o-FHmrK6wzpQzE6dWbQD0HVGvYPC6c,205 +bitblas/3rdparty/cutlass/docs/search/all_11.html,sha256=ryPu5gSR7CagWDG1yNqMMc2HB22yjj4IlgNZgRjfDJE,1014 +bitblas/3rdparty/cutlass/docs/search/all_11.js,sha256=x3YuSKi2ISgwwqg-_vaXzJ-U1xo35BLdBiCgo9Kjj14,103295 +bitblas/3rdparty/cutlass/docs/search/all_12.html,sha256=TNm1h740SRqOx6lZhgWuDThSXLS3buXvuU-mu9dAmRo,1014 +bitblas/3rdparty/cutlass/docs/search/all_12.js,sha256=qgrFy_wY57NrZTGRVjGDZoCNqrDg5ZyhuVFfh-4wgZs,207309 +bitblas/3rdparty/cutlass/docs/search/all_13.html,sha256=Py5RCGKXWpf8k9YisYqkymkNnXih0bqeFbLDdg2y88U,1014 +bitblas/3rdparty/cutlass/docs/search/all_13.js,sha256=t8y1Yt0K2Gw1U0s8if2NfJdj7awHivD34GmpUaR86A4,202099 +bitblas/3rdparty/cutlass/docs/search/all_14.html,sha256=CUi5aZ4e_m2afSJHwI6Z44zsmgZx9NMZdhaNnEjex1I,1014 +bitblas/3rdparty/cutlass/docs/search/all_14.js,sha256=uWHPNZa-He1OR4EFgAm-gK5SWxIPoysc7CYWLpTAFAM,22914 +bitblas/3rdparty/cutlass/docs/search/all_15.html,sha256=yTTxK4I0xntmqwHCSu2TOdIn_fLHbZAt9Fz4Vcnw4gc,1014 +bitblas/3rdparty/cutlass/docs/search/all_15.js,sha256=00ofAQ8Ecs1v_eSWn2rJ6_OL7fGX8_A1cWsf_VvqM0I,16033 +bitblas/3rdparty/cutlass/docs/search/all_16.html,sha256=lPfdeqU3BB4FbSVxK3GxWYyc97aUlE0FYttEIXjbuf8,1014 +bitblas/3rdparty/cutlass/docs/search/all_16.js,sha256=ozUmDMCIXeubU9wxjsUSzGsdO2mvcg_99FGpF4oSVj4,48095 +bitblas/3rdparty/cutlass/docs/search/all_17.html,sha256=F5dGX-3Opb03lShL33TxIzhfoHjXVOwKACoRbYhjUYE,1014 +bitblas/3rdparty/cutlass/docs/search/all_17.js,sha256=bIkyQc2KSobGfkA5vzgaiHa9AbXnmfyK41_nU_mLwxo,99 +bitblas/3rdparty/cutlass/docs/search/all_18.html,sha256=8-kXCiLNUS2_2Be5zVThnQQdpxhx0enSD0JghRqg6tE,1014 +bitblas/3rdparty/cutlass/docs/search/all_18.js,sha256=6Ic3XoeH_TujWVl2k9E95KhWD7_5Vp4hjqQzhhPkohw,176 +bitblas/3rdparty/cutlass/docs/search/all_19.html,sha256=GWiYC5Yv6KvSGI7l1tatt5v58anJ3LuYdwmnKMkAluM,1014 +bitblas/3rdparty/cutlass/docs/search/all_19.js,sha256=ezpVB-bMEV0QSLVQRqtFFcpUq9ZLFvDczMUj5n87Vq8,631 +bitblas/3rdparty/cutlass/docs/search/all_2.html,sha256=fbrNJtjCBeC43O6FMXaVFR1gB7F2otJepqKSxUTdM0Q,1013 +bitblas/3rdparty/cutlass/docs/search/all_2.js,sha256=5zzWzfya57lSjEbqNuysse1bB_8tHZc7sM-9RXR3qdI,21042 +bitblas/3rdparty/cutlass/docs/search/all_3.html,sha256=_FLOuRDMdnQbjnPDU3P1qLh9ZI35HOiOnc76E-tkYTQ,1013 +bitblas/3rdparty/cutlass/docs/search/all_3.js,sha256=gi8Q_E4oJ0qgKyB4NMB99cNfCeZq8IIGW3OtTc2ps1c,59498 +bitblas/3rdparty/cutlass/docs/search/all_4.html,sha256=OEwkkv-l_GV6mmsO-EUMq7hydUMjHcpF5RCHVxaq5Gc,1013 +bitblas/3rdparty/cutlass/docs/search/all_4.js,sha256=K1SzRRnXBjANdPGcSQyzK-UaSXKFxJUZTUJny2j9UGE,56952 +bitblas/3rdparty/cutlass/docs/search/all_5.html,sha256=YjrX8Aj_O0dII9xjM2irLwuJjOHC6woEtqhCmKpkxXg,1013 +bitblas/3rdparty/cutlass/docs/search/all_5.js,sha256=prnOr4Td2doMnlMMXOZMaQ476QEQGOy1CTrKTAOi-Xk,141106 +bitblas/3rdparty/cutlass/docs/search/all_6.html,sha256=NNRzcfZPF_ZsH7YxePyahWzT4tkBQuax-P6xdYev-os,1013 +bitblas/3rdparty/cutlass/docs/search/all_6.js,sha256=dpipk4RlVtVuSCmDBFVsG1u_oTq3FQP9BkqM_8gkwow,90132 +bitblas/3rdparty/cutlass/docs/search/all_7.html,sha256=oGlZz5xiGFuGXnfA6YNcHD3Sjib4BqF7pkDoGFbhPhE,1013 +bitblas/3rdparty/cutlass/docs/search/all_7.js,sha256=fPidWR1toVEG5HtyA25gB8WPcal-lOCAUBhsVyDllzw,56210 +bitblas/3rdparty/cutlass/docs/search/all_8.html,sha256=28bhJS5bWCBLlR1kKTAqje1iAfWEIak_vwaY_SLNM6c,1013 +bitblas/3rdparty/cutlass/docs/search/all_8.js,sha256=lI2LhDclnhgKNAIuEE2zJdu9UqMbHDuaFklh-nFYcpo,6597 +bitblas/3rdparty/cutlass/docs/search/all_9.html,sha256=fZGfdUYRf6UGrocv9UxtUxomfAbQsE9Xm6nILpDdl7c,1013 +bitblas/3rdparty/cutlass/docs/search/all_9.js,sha256=G53HrM0BdNH5l3iK0hZSy6mdPcmVHC_-9zMifHLSzmI,125452 +bitblas/3rdparty/cutlass/docs/search/all_a.html,sha256=OBa4sN5jR987rIFG-AHS5GUHwhsUh6wwK89h55eg27k,1013 +bitblas/3rdparty/cutlass/docs/search/all_a.js,sha256=1Ht0lPWVmLXECJfGENgRhqMOF-nD93u9A2xIQGQTXL8,236914 +bitblas/3rdparty/cutlass/docs/search/all_b.html,sha256=Ubuq0L7sh9hHWI6VzN7snKXA4pMTTAmv9ChO6-Z8HHM,1013 +bitblas/3rdparty/cutlass/docs/search/all_b.js,sha256=FHdKJcOVKLoRKj5OxeJ705VIythtR8eMZNXG4qX3f4I,249038 +bitblas/3rdparty/cutlass/docs/search/all_c.html,sha256=LU_mflJa8paYmuZCejf8hR2PIvGAaUmONPdK8DPDrE0,1013 +bitblas/3rdparty/cutlass/docs/search/all_c.js,sha256=NGa1dY0U8HFnkJsynDfBB1VDEjDQPkY3S7ON0Y2XDzk,119436 +bitblas/3rdparty/cutlass/docs/search/all_d.html,sha256=E1vCq3iLa-Whphdl7DqCgwVqhkkY3XrnshafKvABFKg,1013 +bitblas/3rdparty/cutlass/docs/search/all_d.js,sha256=5ev1YdE9WgbLtFYThzmaPtTHBR5wA0i54Q_0pF4XbtQ,18812 +bitblas/3rdparty/cutlass/docs/search/all_e.html,sha256=y8Se0WO2eGSEso7UJx5pT3F0wuXs1LZLDSVij_WbM5w,1013 +bitblas/3rdparty/cutlass/docs/search/all_e.js,sha256=HhQuGKs_KoPquBUabT4uiQHkaUMM1kiO2hR5zkL7Qkk,234456 +bitblas/3rdparty/cutlass/docs/search/all_f.html,sha256=5AFqClAfHaTVn4g4oLYJ0NT-jsvrLxpxppnRvqzQivc,1013 +bitblas/3rdparty/cutlass/docs/search/all_f.js,sha256=BS-F4k-jEHRj8BGVodd9XjLNeZ4uZOPwOmMbKQ9H68o,121965 +bitblas/3rdparty/cutlass/docs/search/classes_0.html,sha256=BWp19CAU-JSR7cjdlI6N9pdUGAqdijztxnxxnTtEpnQ,1017 +bitblas/3rdparty/cutlass/docs/search/classes_0.js,sha256=2px17p2ckggbeRdtrNWJ9dV-VPgXLkj1GaqCVqCujy4,7168 +bitblas/3rdparty/cutlass/docs/search/classes_1.html,sha256=0p2o47xS_mJ0z2cHBRCE5_yvWFMvP7mNV5e2ljdFWNk,1017 +bitblas/3rdparty/cutlass/docs/search/classes_1.js,sha256=Ewk5TYMnvGkqOv00KoW8kkoKFE6oKEteNBQ2gt5TUnw,790 +bitblas/3rdparty/cutlass/docs/search/classes_10.html,sha256=pUXpjJsi_KjG3Ii5-vBtZKu4qpwuv-DRzzqgBNvLIS8,1018 +bitblas/3rdparty/cutlass/docs/search/classes_10.js,sha256=GnrPU-UGShQ1ru7K03p8Rvb0tLk2U8gX-eMnfx4eSPE,3902 +bitblas/3rdparty/cutlass/docs/search/classes_11.html,sha256=61LWDWN4v254LyqhcteLwNowxNPC1XVULmiO2XTocuw,1018 +bitblas/3rdparty/cutlass/docs/search/classes_11.js,sha256=yZavg-JL1XrxvI0pKtxAXZ2YxLcvHwLS2OsAHsgwqHo,17807 +bitblas/3rdparty/cutlass/docs/search/classes_12.html,sha256=4_qS8ZSdYrkb8a38MpSUnvfUcDFZAtsDpcMElmu44vE,1018 +bitblas/3rdparty/cutlass/docs/search/classes_12.js,sha256=VhwcZT0Ts6nPEKIOP0v1tqMMf42og8_RoVU3BFR4x14,812 +bitblas/3rdparty/cutlass/docs/search/classes_13.html,sha256=lxKk-vkfViARhClTwpA-cMAU83QZ0UcIoonBQCXdajo,1018 +bitblas/3rdparty/cutlass/docs/search/classes_13.js,sha256=vdF2_aRCu6k_iEVk-QhxqMqjH4zcNVQxx76HQxd8nPY,1532 +bitblas/3rdparty/cutlass/docs/search/classes_14.html,sha256=plu81FTBJg23NiIpb5aLJH1Gzp6i1d8STD22tx3aWVk,1018 +bitblas/3rdparty/cutlass/docs/search/classes_14.js,sha256=rkACFkZT9PZquxdkySqwGRFmBSOOLn3IVQgKUvcKL6o,2441 +bitblas/3rdparty/cutlass/docs/search/classes_15.html,sha256=TOwoQL6vMwBlvsFFQ9f2c3y0X_mUQ6VQY56hr8Ruw3I,1018 +bitblas/3rdparty/cutlass/docs/search/classes_15.js,sha256=bIkyQc2KSobGfkA5vzgaiHa9AbXnmfyK41_nU_mLwxo,99 +bitblas/3rdparty/cutlass/docs/search/classes_2.html,sha256=V8CrFMnA0OxzfbD2QIBwOCPTO4aZrFAlID-Nr-HZpGY,1017 +bitblas/3rdparty/cutlass/docs/search/classes_2.js,sha256=J5v6bjLIVCYg-tDEiU0fFcXDyPZZpLRObddWPR-HV0Q,5745 +bitblas/3rdparty/cutlass/docs/search/classes_3.html,sha256=QYQWQQbl2-cgbsKZiur4sRYkm3MfDCKo-mAyGynBLJw,1017 +bitblas/3rdparty/cutlass/docs/search/classes_3.js,sha256=h93fq2t7GId0Pl34zvl9TKGKQQNTIjEWTAXzb7MXq24,36685 +bitblas/3rdparty/cutlass/docs/search/classes_4.html,sha256=AZPTf2ARu284-FbIlWHiUTIm-lgb8CkEg9LoF6cpnj4,1017 +bitblas/3rdparty/cutlass/docs/search/classes_4.js,sha256=RBz2kcy1BEZFfdwLpKwd0PHkrlbCJzZ0ynlBziO5mTM,861 +bitblas/3rdparty/cutlass/docs/search/classes_5.html,sha256=Qtuq-W3KjiXLjZ70NldWoO1NrZVqbxs1wNTE3oMdKes,1017 +bitblas/3rdparty/cutlass/docs/search/classes_5.js,sha256=aGV6kB6RBRSsnscWrOW_mZKeQ1T4Fl2j0s9a-s_He0A,4494 +bitblas/3rdparty/cutlass/docs/search/classes_6.html,sha256=02OJmEOit4ot9tcb4fzUgH9MmZXx69ukm7QS7C33xOs,1017 +bitblas/3rdparty/cutlass/docs/search/classes_6.js,sha256=rrXU48QSUk1RAXrRlz8JXW98vBAz4tOQw9_HMRLwsqw,14101 +bitblas/3rdparty/cutlass/docs/search/classes_7.html,sha256=gPMyOGHR24nO8g4ETk6h6_Eoj1FbpGOUSc8ti0KHNMI,1017 +bitblas/3rdparty/cutlass/docs/search/classes_7.js,sha256=9qD_VESQ4Cavff4oPA4G5F2Qe_qfwoOKWkJp1z-VsA0,180 +bitblas/3rdparty/cutlass/docs/search/classes_8.html,sha256=t7PtzKGv4vSVE51vyN2iRZDf6MRYOLh_ymxr535n7q8,1017 +bitblas/3rdparty/cutlass/docs/search/classes_8.js,sha256=2smQvfqIHH9Ok6XSzwOmf6Hi6rTxrLdtgw_ASlmewK4,10703 +bitblas/3rdparty/cutlass/docs/search/classes_9.html,sha256=iwdpl05qGD3JdCBZGndBzhSpHk0n5bNGgL_FApwtlFo,1017 +bitblas/3rdparty/cutlass/docs/search/classes_9.js,sha256=4vKMlz2KeJfHKopBQjPiFBfjexu8fI5toyPlZmEotrc,150 +bitblas/3rdparty/cutlass/docs/search/classes_a.html,sha256=WQlIRFpODWuLeQ38c2LRbscOO5VZ9mhvqeQOwxqARbE,1017 +bitblas/3rdparty/cutlass/docs/search/classes_a.js,sha256=v4AmCKbZJwvK9MqMFrvJZVGYY_uTNUAOuR-UMPzL-zU,1851 +bitblas/3rdparty/cutlass/docs/search/classes_b.html,sha256=sFqkq-s9XMmrC1f2USfu93_2SUyU_jD4ouSN3mGT0WI,1017 +bitblas/3rdparty/cutlass/docs/search/classes_b.js,sha256=jg5wUXod2AxM11jkQzs-nVLHNAIwTpalXDn2cfbgw5A,57957 +bitblas/3rdparty/cutlass/docs/search/classes_c.html,sha256=nt6ycEYEqB3vibvDwvn_Kek9fp5x3waHr4b7-sZcw9Q,1017 +bitblas/3rdparty/cutlass/docs/search/classes_c.js,sha256=mlmgVX3cFNoR_l9BESmyHkOr_-gx-CQdeKBEa9D2tyc,3394 +bitblas/3rdparty/cutlass/docs/search/classes_d.html,sha256=x75BroiVnA-htVawjJ_ME6dsd9OwH8l4eq5E6cpFxfk,1017 +bitblas/3rdparty/cutlass/docs/search/classes_d.js,sha256=AtXzkNfe4NKExnjLxWBQCUValKvvECpuNNk_elTwzAA,751 +bitblas/3rdparty/cutlass/docs/search/classes_e.html,sha256=qLOILXVPtCilhdoHYNm_PZSyk3RmgRw68X9qEFYosBA,1017 +bitblas/3rdparty/cutlass/docs/search/classes_e.js,sha256=tq8_6pYzmBz2LTRXnwW8nY-lIrLpheNdZHU83NsbTcY,31979 +bitblas/3rdparty/cutlass/docs/search/classes_f.html,sha256=LmxQ0p_94KHArt3LaFLM_XNt-DkfwAQuGhDFuLMHLZY,1017 +bitblas/3rdparty/cutlass/docs/search/classes_f.js,sha256=li2kNngTP6PWNtT08aWwHkJx1cTlLo_yYPPwPpRoWWQ,37438 +bitblas/3rdparty/cutlass/docs/search/close.png,sha256=9usdNEnEFX8Ty6n-pUBlLvyjc8EsvsEdQ-fkWDZOdH4,273 +bitblas/3rdparty/cutlass/docs/search/defines_0.html,sha256=tofbURsgvtJ0qSiFkXCeb9yXPbHmNNLMsgkX4tjVrrk,1017 +bitblas/3rdparty/cutlass/docs/search/defines_0.js,sha256=UCcRsYtVWkJqH3OHm0-OfvaNfJaCCVRImSE7DzkJZBk,500 +bitblas/3rdparty/cutlass/docs/search/defines_1.html,sha256=qWwNITuUQr18WKRpNkRjDc-i5_vx2xQp9ohhnrsxlos,1017 +bitblas/3rdparty/cutlass/docs/search/defines_1.js,sha256=lE_I4rvVDyp7MeaFDb295irMNiR-nrH1OW1YzguHQwQ,3411 +bitblas/3rdparty/cutlass/docs/search/defines_2.html,sha256=xK1b-y-4k6Tvw3M0poF9xzYqxXQf8pz0wphEfM7sczQ,1017 +bitblas/3rdparty/cutlass/docs/search/defines_2.js,sha256=dFQEAHsK5sGl_K-hyTyxjj2o5W3yNMWSONxjbSjMKjg,222 +bitblas/3rdparty/cutlass/docs/search/defines_3.html,sha256=PK958DR1YyZId8xpcVHIkSrZvkWYLabVjD8MpPHqtO8,1017 +bitblas/3rdparty/cutlass/docs/search/defines_3.js,sha256=jMC6tPBzHbl-bPacPcKuP1SnjC6wjiJsJrlb5EaCf5I,259 +bitblas/3rdparty/cutlass/docs/search/enums_0.html,sha256=F6e-XU_T0z82WU8ggdGIacBwznwpljELuB-tde7P62Q,1015 +bitblas/3rdparty/cutlass/docs/search/enums_0.js,sha256=My_vY8p3EDtzSOIEf5prg9yS0utxL-8CwOI4263Lrt0,275 +bitblas/3rdparty/cutlass/docs/search/enums_1.html,sha256=LYU4HPtqSDo3bFoJuY5NlkMGSEl46-or7bF_ArZGlK8,1015 +bitblas/3rdparty/cutlass/docs/search/enums_1.js,sha256=kenJFhl75vhnHwWal-velIXl0Mnlna_tZyzEw-F8kIA,138 +bitblas/3rdparty/cutlass/docs/search/enums_2.html,sha256=NLvTfyvPmoHrREmBQIfR3oQzQfC828toKy1HozMYve8,1015 +bitblas/3rdparty/cutlass/docs/search/enums_2.js,sha256=alkdwjQZ9KX_bVw2w12QtaSUWNQxI6Vsaxgnj6vhmYU,144 +bitblas/3rdparty/cutlass/docs/search/enums_3.html,sha256=30ZQwxZkqb5fQCXGLX0H9fUxHpZFHG8iYP5YreNtK8o,1015 +bitblas/3rdparty/cutlass/docs/search/enums_3.js,sha256=6-WD-eYeIhyfIHmBw54mrrxsDYJkOuWLh1QOBqe70v8,143 +bitblas/3rdparty/cutlass/docs/search/enums_4.html,sha256=49sEPKXHkygdFe4forsLY9J5KyglY7h3E_GBGuZjUho,1015 +bitblas/3rdparty/cutlass/docs/search/enums_4.js,sha256=4V-lO7SbGhXSturhx83qLdM1oQ1pEdbW4cvSvetot6Q,152 +bitblas/3rdparty/cutlass/docs/search/enums_5.html,sha256=zSm9knLtAjZu_9ObZeXWpNomEg9taAHEijTPfk8zylI,1015 +bitblas/3rdparty/cutlass/docs/search/enums_5.js,sha256=yZCXnfz6x7HiWMKPeCXhOUJ9cicdp-4tII_vV08opTY,368 +bitblas/3rdparty/cutlass/docs/search/enums_6.html,sha256=FZvvgJqR0N0DL79AXA9S-DHa0AJ9oDdZQ_IIHGCyo2o,1015 +bitblas/3rdparty/cutlass/docs/search/enums_6.js,sha256=SQsNXY73vJWQS99UAtBh06cWj6WQI72a9rwTJ0qq0Uo,154 +bitblas/3rdparty/cutlass/docs/search/enums_7.html,sha256=4SZPPOyYEycvlDwjQe9oFHCELmskv7jJ_RT-j8LoUoQ,1015 +bitblas/3rdparty/cutlass/docs/search/enums_7.js,sha256=U9IcMu9gRn-dn4sQFO-MeI37hE9LjnfOhpH09IhnKls,404 +bitblas/3rdparty/cutlass/docs/search/enums_8.html,sha256=ntADW-bUli6hE0v1sjDFgTmh2jVMY7jSwm3GVrFN_o8,1015 +bitblas/3rdparty/cutlass/docs/search/enums_8.js,sha256=SGUaHEpk4BnXmTeBjarYUVNsWlGgnyCE_6Jb3O_1kaE,390 +bitblas/3rdparty/cutlass/docs/search/enumvalues_0.html,sha256=OVdwvqBkT60jqmAE50Wuqh_WWcTqbE6sL-K3NsyAZsA,1020 +bitblas/3rdparty/cutlass/docs/search/enumvalues_0.js,sha256=pFxKqsaWCfZSxUF5FJ5Zfjkf2Din1NDQZak29cpqF6w,184 +bitblas/3rdparty/cutlass/docs/search/enumvalues_1.html,sha256=PjpjLc5EmBFySNwpi6fqXF96tq05fOh-NR1K1QS4MPo,1020 +bitblas/3rdparty/cutlass/docs/search/enumvalues_1.js,sha256=p1sH4A7jdNxfYoEG8T39DIxPdaIldiyVXpm6XapqlNA,346 +bitblas/3rdparty/cutlass/docs/search/enumvalues_2.html,sha256=nvAkMtpYqTVECXhPWMmOq2cQCKbcV5nfOtBDrBnaydo,1020 +bitblas/3rdparty/cutlass/docs/search/enumvalues_2.js,sha256=GmJ9fiaCcN724x6D_kcbOOhAnwPZ98PVczeWm-5tAF8,12705 +bitblas/3rdparty/cutlass/docs/search/enumvalues_3.html,sha256=sh_nY2HrTtdT7Sf7Yxnw_zZiD0dsl_Z9KkDikir5gtU,1020 +bitblas/3rdparty/cutlass/docs/search/enumvalues_3.js,sha256=0SG597oL8jkbuikxy6LmDJn3sc1eB7yN9phb6K3ZweQ,1014 +bitblas/3rdparty/cutlass/docs/search/enumvalues_4.html,sha256=PO67Tco1eaHmep5_BmNtrIX-Yir77_wdnez4gp_7_Wg,1020 +bitblas/3rdparty/cutlass/docs/search/enumvalues_4.js,sha256=bVMrEmnFKAmWU1Fu1P-AVRmjHJjcu9Lh6Q_aV7sMFlw,188 +bitblas/3rdparty/cutlass/docs/search/enumvalues_5.html,sha256=fz0MG9zjnr1dT00QBupXCiSpNfdt0CIko5Cxw9o8bOA,1020 +bitblas/3rdparty/cutlass/docs/search/enumvalues_5.js,sha256=B_25hcHBkLKPU2eWbYYJNW4N4RW1Jxh_lM7K51Vqrrw,182 +bitblas/3rdparty/cutlass/docs/search/enumvalues_6.html,sha256=liBibQ96DD7wexTMyiFcltotWp8FSZ7o6IfX_hKbDjs,1020 +bitblas/3rdparty/cutlass/docs/search/enumvalues_6.js,sha256=cym1dj-udHSeKZHIhsEypQRijz5LwoEOpatTDgnPNew,3355 +bitblas/3rdparty/cutlass/docs/search/files_0.html,sha256=B5Q62Z3zVs6W4NjbeZRDD4OTZN6igb1FgUdSNnycTZc,1015 +bitblas/3rdparty/cutlass/docs/search/files_0.js,sha256=CnDW85SmF-5sfAMsJ7rjrIMga_I8OV7CC-EHMqblBz8,568 +bitblas/3rdparty/cutlass/docs/search/files_1.html,sha256=MR7S47nd9O5DXtrQ4FB0goVh-iRdjuI6q05eVZwWk-c,1015 +bitblas/3rdparty/cutlass/docs/search/files_1.js,sha256=vI9pXspmvg_lDOqW78gl78WIPmjio8pPORO_THLnsZE,232 +bitblas/3rdparty/cutlass/docs/search/files_10.html,sha256=ZzmE981-1LrFbdKzgRv54ulj_gTeA1APzoT5Tm_hM0o,1016 +bitblas/3rdparty/cutlass/docs/search/files_10.js,sha256=xJ77I2iZIG0pwQ6lfyFTyYVNVkhB79pGDl0a5GbkbRk,555 +bitblas/3rdparty/cutlass/docs/search/files_11.html,sha256=kcD58eMinAqmb9s9x7gsvyIXuaM09RDXXxyKkyfJc9g,1016 +bitblas/3rdparty/cutlass/docs/search/files_11.js,sha256=qXwdikBkqDBB8uNZ6tDWGSV1UMxIRbFJLzFaIaOpYxQ,2415 +bitblas/3rdparty/cutlass/docs/search/files_12.html,sha256=OviYcFYcoa8FJdYrE38I5c2ZDU40uvSiafHMvDKeLoo,1016 +bitblas/3rdparty/cutlass/docs/search/files_12.js,sha256=-HdVosiP__NWOdtxr0uh1YfwnE-l1LiEoucoR97Boa8,193 +bitblas/3rdparty/cutlass/docs/search/files_13.html,sha256=liMmGGwbIOcJnxWtxQrAkJz9yCCQXvWb4SL_zm2lpzg,1016 +bitblas/3rdparty/cutlass/docs/search/files_13.js,sha256=WK7c8Utnpzx9XeT3eJtlZ0HfvtzDxb_jyr-ObGXADMc,534 +bitblas/3rdparty/cutlass/docs/search/files_2.html,sha256=1qoVB3LamDV5Y9E55s2Iba58MQWUMXIhlPCnoja9MQA,1015 +bitblas/3rdparty/cutlass/docs/search/files_2.js,sha256=ioIxhlHk8AZ7pNdFm0tI7INMkwZpUKMh0A1YMX6tO44,422 +bitblas/3rdparty/cutlass/docs/search/files_3.html,sha256=xOxOSJfMxw8q5-RzkZrIqLuF8UHeaSUhJh9rTc2I0UY,1015 +bitblas/3rdparty/cutlass/docs/search/files_3.js,sha256=fOZ81Ndh9nyCEuxDCgipNSWXlCeAneSN7WGC3c9eMjA,3971 +bitblas/3rdparty/cutlass/docs/search/files_4.html,sha256=2p2JHV6RwFA4uEa8gkJY5ep9V3CVJ4g7t2Y57SQYXdY,1015 +bitblas/3rdparty/cutlass/docs/search/files_4.js,sha256=0uikx4HmdzG5_4iI-_-6FswS_O2G-aFrjANcOQHThO8,474 +bitblas/3rdparty/cutlass/docs/search/files_5.html,sha256=ioBA4bLzvqSjQPoetKhjuNrPib-22IEIzhD9EvYYxRc,1015 +bitblas/3rdparty/cutlass/docs/search/files_5.js,sha256=Jnl4aTRKxrJMCYfMRc96bCbnnK8Plt0D1eIEZCO7GCQ,858 +bitblas/3rdparty/cutlass/docs/search/files_6.html,sha256=PUAPrV165PxH1uvbRJmNdfehoofKnquzH9Sf1QaddEo,1015 +bitblas/3rdparty/cutlass/docs/search/files_6.js,sha256=zQSBlI7sR5sFW6CjmO2vmyrt9csZJT31Ykte1s2EWro,749 +bitblas/3rdparty/cutlass/docs/search/files_7.html,sha256=h4VwPp4n62e7PPISDUnVXpYeeG2JDuJYsZomWOioQ_o,1015 +bitblas/3rdparty/cutlass/docs/search/files_7.js,sha256=QUHD28EOYv9xDRkki4-Z4n14iVmAI8eWyKKBEJC-PpQ,594 +bitblas/3rdparty/cutlass/docs/search/files_8.html,sha256=FveKTn_rtmctY1Z0rNHqQRMu9WLYSF2oqUpSMIIPUaM,1015 +bitblas/3rdparty/cutlass/docs/search/files_8.js,sha256=JCZoMaLJA_WzBADsvCXhnWqWgTHpkei2p7vp4T8CtLA,727 +bitblas/3rdparty/cutlass/docs/search/files_9.html,sha256=xZwfvU4AkO1hH-4mqdZ1m9XMr3dAesBll2Pt2yePHVk,1015 +bitblas/3rdparty/cutlass/docs/search/files_9.js,sha256=dw9blSWMEvnCWjzinbA-xgFg9T_NxhuPF4h0c0nGtMo,303 +bitblas/3rdparty/cutlass/docs/search/files_a.html,sha256=bUeagtg0LaPMLAtkDm8T7tRpwZOgdNfnLfALtND49ZY,1015 +bitblas/3rdparty/cutlass/docs/search/files_a.js,sha256=HqdWliD1f6Kg9pLrfK_RDbVeZ-MW1tc_tBncxA418MU,535 +bitblas/3rdparty/cutlass/docs/search/files_b.html,sha256=Y8S11HEGb9eNza9U0pIGtfepUQEaBTpBP4vxqoSvpHc,1015 +bitblas/3rdparty/cutlass/docs/search/files_b.js,sha256=RT-aHnpSYE1q7nCtj41jhm89AiDcdLYi2rq3xJ_Addg,2049 +bitblas/3rdparty/cutlass/docs/search/files_c.html,sha256=a43TN4bsntZXSwmKWPBGvKn8dWDKr_hyYXkhpO_R-tM,1015 +bitblas/3rdparty/cutlass/docs/search/files_c.js,sha256=zz6MjwxyqjnLu8wOeAlhdRdGyVdBGEAobG96Istqbm4,199 +bitblas/3rdparty/cutlass/docs/search/files_d.html,sha256=pm3W1MIrZhMasgveI9SSXoKpfWNTp0IoawG4B1hS-lI,1015 +bitblas/3rdparty/cutlass/docs/search/files_d.js,sha256=rX02PJkMkOr8aif-_h-z31JIUG5KnwMEic8BxQHnzfE,135 +bitblas/3rdparty/cutlass/docs/search/files_e.html,sha256=GT3xl40GiAu2guxWDufDYURzLVHaB3S-CRaB9O1GRvg,1015 +bitblas/3rdparty/cutlass/docs/search/files_e.js,sha256=mxJ_7GFJeudWypg8kIn2PXKFSR07z6wX9rtMj9E7k_A,858 +bitblas/3rdparty/cutlass/docs/search/files_f.html,sha256=hhtXRHgvk8xwYNXg5kqfvcG_pQnbs4CZ7yF0Oj3Gv4E,1015 +bitblas/3rdparty/cutlass/docs/search/files_f.js,sha256=u38nlm9yfrgLQbMbgzajqgVDHe6kWf_-0t-_Nr1nso8,1846 +bitblas/3rdparty/cutlass/docs/search/functions_0.html,sha256=LKfVN19esK2GkhaFkrn37HloHw9acKiIHyc7uNaOinY,1019 +bitblas/3rdparty/cutlass/docs/search/functions_0.js,sha256=rekz1N9FFVhvj9aRpq_U-bmN7axl6zqb17Ouc-I0Yto,2019 +bitblas/3rdparty/cutlass/docs/search/functions_1.html,sha256=f3ODJEDJZzXKdI0t33bIlJ0HPXWTLkimeUJ6Yf2VnLI,1019 +bitblas/3rdparty/cutlass/docs/search/functions_1.js,sha256=oWDS8mgbKtEU0_55sSVjNLtStSMkNEnyVwf87XWEwCQ,67789 +bitblas/3rdparty/cutlass/docs/search/functions_10.html,sha256=7OJI-qlBcfWb11Acq1176kV5SuOE-tIl4uxms-cIWyo,1020 +bitblas/3rdparty/cutlass/docs/search/functions_10.js,sha256=DTehvmaXRp1B_o-FHmrK6wzpQzE6dWbQD0HVGvYPC6c,205 +bitblas/3rdparty/cutlass/docs/search/functions_11.html,sha256=PAqyd-fatLDhSu1YxeGl0YF0_JaMr26wfbsYxgxXeQc,1020 +bitblas/3rdparty/cutlass/docs/search/functions_11.js,sha256=rYvjqXn2TtqmERt7TGPOV6O_Cw5H8ie7Yq50tP-1uUE,37559 +bitblas/3rdparty/cutlass/docs/search/functions_12.html,sha256=y0bH5jUSfjTEmPqOfXZjbjrsMTYdoSslmDlCslZlVUQ,1020 +bitblas/3rdparty/cutlass/docs/search/functions_12.js,sha256=adtJopJaYpe0mH-7Mphus-C6TEfHokG_TzEnpSV8MGc,80864 +bitblas/3rdparty/cutlass/docs/search/functions_13.html,sha256=bORHiSzXPZDqsCnucBTe-cN1Zn1IXHA1Dcxmpskgw4I,1020 +bitblas/3rdparty/cutlass/docs/search/functions_13.js,sha256=bJsvBYzdr1eOlO-OyoddlmSdg5PakGxRhksAnExIqTw,35867 +bitblas/3rdparty/cutlass/docs/search/functions_14.html,sha256=HEIzhRM1SdbQS56jk8pRISOk9sh0Jr0XEsFA2dAe_08,1020 +bitblas/3rdparty/cutlass/docs/search/functions_14.js,sha256=21BsXqMXNTpihL5V4YtUs3qZHR09uTMQYgVaGRfCsyg,2928 +bitblas/3rdparty/cutlass/docs/search/functions_15.html,sha256=oFmpnKDJE5OQE3SiiTN2xlIw8i59Ox1IltV38odICNQ,1020 +bitblas/3rdparty/cutlass/docs/search/functions_15.js,sha256=b_F6cVYCFz_URHNhZ3rF84RJnXCllypZe_zPczUHHTY,4479 +bitblas/3rdparty/cutlass/docs/search/functions_16.html,sha256=zxY554oFVzpykieWcSHsFmilvgFFspAnvGLECSLEz1o,1020 +bitblas/3rdparty/cutlass/docs/search/functions_16.js,sha256=Wd8R9E6e-CVsA-0ceeVww2uoxJ8HilLvr-UYG4pm6rw,376 +bitblas/3rdparty/cutlass/docs/search/functions_17.html,sha256=1YaDE08L1oW_r8jrqqHYgA2LgTC3v8n2RRVkWeL1BsA,1020 +bitblas/3rdparty/cutlass/docs/search/functions_17.js,sha256=ezpVB-bMEV0QSLVQRqtFFcpUq9ZLFvDczMUj5n87Vq8,631 +bitblas/3rdparty/cutlass/docs/search/functions_2.html,sha256=YHhzK0IxZ4JBEU2DqUVZ3Bf3UiTdjn3DS2pboOFtwqI,1019 +bitblas/3rdparty/cutlass/docs/search/functions_2.js,sha256=YIg-Yu46KQTC_Q8Q-C2yJNIiIVObMtjBoVVLVjvIWt8,6601 +bitblas/3rdparty/cutlass/docs/search/functions_3.html,sha256=mAb8LRCRSDBbp5iBOO-EzsJyLrbZLsUbkfjuI2DllSM,1019 +bitblas/3rdparty/cutlass/docs/search/functions_3.js,sha256=g6Q-ZnQTmSbZ6Hw35HlXHiwKpeTonx0fOlOJas0Oiqo,36122 +bitblas/3rdparty/cutlass/docs/search/functions_4.html,sha256=zVyeHQnR9GQydUbbwTmDpVkUOPQYiX3kFJuGXNE3kLw,1019 +bitblas/3rdparty/cutlass/docs/search/functions_4.js,sha256=ZdzNluRg0q1oeiIbKSk0XKZqjBPQs6nBn8hrJBCDUGo,6956 +bitblas/3rdparty/cutlass/docs/search/functions_5.html,sha256=OqZiDVIsx-3GbneQKUrR9C4lyJ_CM-ojPBP7q7ukVjE,1019 +bitblas/3rdparty/cutlass/docs/search/functions_5.js,sha256=StIBTlwJz3ejPoyT5JsiKAhh2Sa5bkTBKVoQm42QG8k,9704 +bitblas/3rdparty/cutlass/docs/search/functions_6.html,sha256=B4R8wqCAbhBVE8uWTllp8Otu1RRgChqSQSm6WdSddEg,1019 +bitblas/3rdparty/cutlass/docs/search/functions_6.js,sha256=QVgkqhjtrBa_Ejm7eoLtuJQRhvkGYh-eZiMIDIazZqQ,6472 +bitblas/3rdparty/cutlass/docs/search/functions_7.html,sha256=bPUga8HyQ-qSe8JbU_bxn2F191a7cRkwZaSmQ4iRlzI,1019 +bitblas/3rdparty/cutlass/docs/search/functions_7.js,sha256=Oq_ASG-MJrPaNelQF5aNh9C7EPcnY1QJJ8ztkIGA7Vw,33332 +bitblas/3rdparty/cutlass/docs/search/functions_8.html,sha256=fZDnoJaWYZwuTst0bQvaw9tgwWpmEqM-rvk2kziTbPU,1019 +bitblas/3rdparty/cutlass/docs/search/functions_8.js,sha256=86A2iA-SLr5HApWMg-Yw14AQzpFSMOKuXkoqwtwVv8E,2745 +bitblas/3rdparty/cutlass/docs/search/functions_9.html,sha256=zOV8Lr2xRvdLaZxpm3CC7qI38mtvIYdog38gwhWltiI,1019 +bitblas/3rdparty/cutlass/docs/search/functions_9.js,sha256=QXnkoFCpEdHdmm5lMm2_p4HA6yR3iVTClUi2Y5dFxUk,16643 +bitblas/3rdparty/cutlass/docs/search/functions_a.html,sha256=b9zFVSFdZWrIRmPeUgk3eSuXysGc7J3e9bUHDe4Q3Dg,1019 +bitblas/3rdparty/cutlass/docs/search/functions_a.js,sha256=pSYM0_WSvnOho0Ip8Be8Pz1zniEBbpGg6uDy3UGGf68,1211 +bitblas/3rdparty/cutlass/docs/search/functions_b.html,sha256=8y7vGgiTcScC8KpoVEx0mb6kSxxKJELGiKMFMvSwLuw,1019 +bitblas/3rdparty/cutlass/docs/search/functions_b.js,sha256=muI1da9t72YYeLuiWZUa8mRclVs5i6cEM8cS7OEOX-A,84960 +bitblas/3rdparty/cutlass/docs/search/functions_c.html,sha256=XgvYqj5P1FzJeU5CNy2H1rjXFjsTHcnW6YgJ5MRSbgs,1019 +bitblas/3rdparty/cutlass/docs/search/functions_c.js,sha256=0KZTjRwW4s8hYSgaqk05JE-FmFfIFrJ6O0h92ESb-ec,26988 +bitblas/3rdparty/cutlass/docs/search/functions_d.html,sha256=1YSH_qkcajbvk-UCWBBcykaoZikoIi2K7Sa9DuCRUcs,1019 +bitblas/3rdparty/cutlass/docs/search/functions_d.js,sha256=-EfD4E2Oedsdt5hzJPCVpbv87kXwdL2JrrcXDP-DUac,2059 +bitblas/3rdparty/cutlass/docs/search/functions_e.html,sha256=BaD2JVbqwmIHC8T1TqScu5hwHPtCa1R4d4j1MDmp7nw,1019 +bitblas/3rdparty/cutlass/docs/search/functions_e.js,sha256=7cCUK572jvXWdju1IeB5jXcDSqSI24iD1ofgTgFlCqo,177586 +bitblas/3rdparty/cutlass/docs/search/functions_f.html,sha256=QHj0o3RrjaH5RRygPRIbcp7zqpICMVV-eUSUIVnSBAc,1019 +bitblas/3rdparty/cutlass/docs/search/functions_f.js,sha256=yY7C5ad3X0yyRflr6X1Q7RgLbrc3IjYiqG0k0Yu_mQU,46163 +bitblas/3rdparty/cutlass/docs/search/groups_0.html,sha256=T71xxF0pCtcyvGpEvySklA4lf2wmre00DHMWvnQClIM,1016 +bitblas/3rdparty/cutlass/docs/search/groups_0.js,sha256=rhzfunVdDiIAdtRypW67ym57QwaOjyGa1Qb73Yx_WCo,386 +bitblas/3rdparty/cutlass/docs/search/mag_sel.png,sha256=kgXvY_vaf9m2rE2aA-FyTMFS_Zb-mOb9NXbrL27qflw,563 +bitblas/3rdparty/cutlass/docs/search/namespaces_0.html,sha256=KJcMlZVFK8lojsCqGe-0uMfQ9q5ftdCHdXv8xxmQ_1c,1020 +bitblas/3rdparty/cutlass/docs/search/namespaces_0.js,sha256=JAAvjNBjDM0PFhXLONIByBEh0wl_zik0ijtTxilT54k,3655 +bitblas/3rdparty/cutlass/docs/search/nomatches.html,sha256=hkIAZm5gTIzNK6y4Cre0yw1V_B2H0HstQEjR118-LOo,461 +bitblas/3rdparty/cutlass/docs/search/search.css,sha256=8J_tKVRFHlwU0nf2ermlhTJfHNHWN8ozDSKi2YZFQvQ,4461 +bitblas/3rdparty/cutlass/docs/search/search.js,sha256=BwIZqLRTMvNWAjr3yHQKGRTGbE1Pfwa4NDc-U4HlIGA,22125 +bitblas/3rdparty/cutlass/docs/search/search_l.png,sha256=poWHLAq8xM-PqvpVzavzGvC31n_8LpU7OdhE2n-aRdM,604 +bitblas/3rdparty/cutlass/docs/search/search_m.png,sha256=G4RBqUJ9OzINkSwhCl8jinGxPm0vJt5-mLNtzljXto8,158 +bitblas/3rdparty/cutlass/docs/search/search_r.png,sha256=lvQZLZW9An63x7_Fi956bZhbCpWjf-xCD9l_jAssKd0,612 +bitblas/3rdparty/cutlass/docs/search/searchdata.js,sha256=G-S7bZDIV_bmxLDu4hpysTG3uxen05FMrOGThPPxyLM,717 +bitblas/3rdparty/cutlass/docs/search/typedefs_0.html,sha256=Igo9ckGcE2RGwOzHgQJNKPG-QZLMwVtZ-bgbSPsbpdI,1018 +bitblas/3rdparty/cutlass/docs/search/typedefs_0.js,sha256=YKe3XIhUR8MEwLUt_oAj5LmuVLW0qdZTBnXw0wuJsO4,23973 +bitblas/3rdparty/cutlass/docs/search/typedefs_1.html,sha256=vNr86GWa5r8JIKDbVtrqEWMUfaYh7TzYMkN5lmBPlTM,1018 +bitblas/3rdparty/cutlass/docs/search/typedefs_1.js,sha256=tNhoLRmOqJfv74OCL5D01b4_KENy65RTiKljfATlVes,7332 +bitblas/3rdparty/cutlass/docs/search/typedefs_10.html,sha256=-h3B0tKY6lbCKek-DF1wXlJVkxzo_9bSw3o4uYCQ4b4,1019 +bitblas/3rdparty/cutlass/docs/search/typedefs_10.js,sha256=zYrLn8ac-b71yofHs_7IQNZ8sIJbVU1U09PisrTDgio,108968 +bitblas/3rdparty/cutlass/docs/search/typedefs_11.html,sha256=xmyjio7Nimbu8-y0sk7encQegv6zX2YvghEhrd2reMM,1019 +bitblas/3rdparty/cutlass/docs/search/typedefs_11.js,sha256=aQYx5RMQgr3b2u6iVgyLtCd6AK-q5rGOwDJ6iIj82z8,136014 +bitblas/3rdparty/cutlass/docs/search/typedefs_12.html,sha256=ndUux2XLWMLww_tXpDZ0yhRTrj5MUMRonIvn2K0Gkag,1019 +bitblas/3rdparty/cutlass/docs/search/typedefs_12.js,sha256=u5wGIu0FQCKn9-92VyLz3sf4WHHWjJN_qP_ZoTN-02w,18778 +bitblas/3rdparty/cutlass/docs/search/typedefs_13.html,sha256=ZkscoQax4gPrBUNvoJpIXsrFnGVl8MEOH11gf0a23DQ,1019 +bitblas/3rdparty/cutlass/docs/search/typedefs_13.js,sha256=_U-X8MpNoP70kHcOpCk_bLjJNpZI0IMIPuvT4pZITzA,622 +bitblas/3rdparty/cutlass/docs/search/typedefs_14.html,sha256=ko-hagexxmKXfRglDmS_Tp1BLOkoq7wUQqfXVbV5fSE,1019 +bitblas/3rdparty/cutlass/docs/search/typedefs_14.js,sha256=1j7KigrzABkBMSHWpsFkOMO28TuOb_h3w8TTTifp56c,37086 +bitblas/3rdparty/cutlass/docs/search/typedefs_15.html,sha256=WQWwtD-X47p7CYRvzHrXnYNn9hotcd0Qul5OWYPIz0Y,1019 +bitblas/3rdparty/cutlass/docs/search/typedefs_15.js,sha256=6Ic3XoeH_TujWVl2k9E95KhWD7_5Vp4hjqQzhhPkohw,176 +bitblas/3rdparty/cutlass/docs/search/typedefs_2.html,sha256=S0gVLQBO-LvH6oJjqoDkFz6UQ-mFXc-82QDxTcbdhos,1018 +bitblas/3rdparty/cutlass/docs/search/typedefs_2.js,sha256=KI5Ba9rKrLpl65TCq0ZfOEgx-2wKrX25wNJ9iTUpsUM,6119 +bitblas/3rdparty/cutlass/docs/search/typedefs_3.html,sha256=-pxbD1stf5EefaRAzTFSwr66jf-K_aBeX3tnT0ecmiE,1018 +bitblas/3rdparty/cutlass/docs/search/typedefs_3.js,sha256=iEGwFCfhlMbaxi4T0yjnw776Epkn3FnzgO4XSl9MO_4,6871 +bitblas/3rdparty/cutlass/docs/search/typedefs_4.html,sha256=XpVio1Cy7RwPsXyunFoCf_CI2jBzSslgi5kMZcOzKNo,1018 +bitblas/3rdparty/cutlass/docs/search/typedefs_4.js,sha256=vrewr7iOrvDXF2y9l983DefRkFzlHw9bYHXS9S31hmM,126092 +bitblas/3rdparty/cutlass/docs/search/typedefs_5.html,sha256=K2ZinVuFk8KGi9oHZK_HYLdQuPHgbOck10ooWvgMxA8,1018 +bitblas/3rdparty/cutlass/docs/search/typedefs_5.js,sha256=-RzQbfQtm2GpeRR1xZcEx44vInMzqaVyF4EkAd0_zAA,77321 +bitblas/3rdparty/cutlass/docs/search/typedefs_6.html,sha256=MVEiaUm-aqOoK-XGJaPOtCnO3y2kdfMg5BnIapjAhB0,1018 +bitblas/3rdparty/cutlass/docs/search/typedefs_6.js,sha256=a_qK-cbc_V6kCTj1gTcumazWfYwGLgKeRLVfT8VZlLM,6057 +bitblas/3rdparty/cutlass/docs/search/typedefs_7.html,sha256=aSeYVcYx-FanwykFv0FMqufWucQoUDNykVFbjF5ZcOk,1018 +bitblas/3rdparty/cutlass/docs/search/typedefs_7.js,sha256=yItQSBXKRDzVSgqNjehXQw96nRgfn0Am5lufyrLxSdA,2163 +bitblas/3rdparty/cutlass/docs/search/typedefs_8.html,sha256=gya_XcrB3WH_9tzzbWQVYGZz2Bd2sccIFPtHF9ngpQg,1018 +bitblas/3rdparty/cutlass/docs/search/typedefs_8.js,sha256=_rS8lD9UnEv3Ba94B7JayEGFU5HIKKINRYsavDr-5og,91446 +bitblas/3rdparty/cutlass/docs/search/typedefs_9.html,sha256=QV0Xb2ipaqdHb-ZQUMQm4ItKFlnvm4DrbES_QBDfXus,1018 +bitblas/3rdparty/cutlass/docs/search/typedefs_9.js,sha256=Dg6nBnTuw-AYdxIA8szb_7ub7hB9G3C_wcDvlDPJyOA,201 +bitblas/3rdparty/cutlass/docs/search/typedefs_a.html,sha256=_IJ2WLtQMe8ubCW6N2IZGMawg7v0U-uaIcxn82zngyI,1018 +bitblas/3rdparty/cutlass/docs/search/typedefs_a.js,sha256=9S7DtsoMFUVdwwrFAGP1nFZoHjH5pUQbQpQKJ6Wt0Ok,145372 +bitblas/3rdparty/cutlass/docs/search/typedefs_b.html,sha256=SPfyKFb9YWRo1dLHyHEiQRFpcO4UrDV3kg73wNDTSz0,1018 +bitblas/3rdparty/cutlass/docs/search/typedefs_b.js,sha256=rsJg3kXrk4vRivmSAtvqaY3_P_d75doP_Xpqu1w2sII,28737 +bitblas/3rdparty/cutlass/docs/search/typedefs_c.html,sha256=d7QgjYs7kh4d-TZSh5AFD19kEJadwT2xJLNXAuqhNig,1018 +bitblas/3rdparty/cutlass/docs/search/typedefs_c.js,sha256=fbmTRS0PKT3TU0J6nOc34CYfeXnGUctwypILpnppD4c,6155 +bitblas/3rdparty/cutlass/docs/search/typedefs_d.html,sha256=OpWmLndWLE3Bg-IJuAJsxAIdH2OeJUmh03uonzlhXLY,1018 +bitblas/3rdparty/cutlass/docs/search/typedefs_d.js,sha256=anc0k816wkMcNt-CJ1_gBJDagxbeH5Cxa1v0wCQtafc,53491 +bitblas/3rdparty/cutlass/docs/search/typedefs_e.html,sha256=sW_MeImmo9MS2cER12TUEaDvMXwimzlirqEZFRwC9v8,1018 +bitblas/3rdparty/cutlass/docs/search/typedefs_e.js,sha256=ChNEaP3C5jdbtLuACjIomDO9krf3gkR6MZRBcyrllac,27052 +bitblas/3rdparty/cutlass/docs/search/typedefs_f.html,sha256=LKdtj-3SX4-Vu9srCIIgzYzMgT1oHS7j0EscKuey8gI,1018 +bitblas/3rdparty/cutlass/docs/search/typedefs_f.js,sha256=UXuVvMZBuLBGKImlBLQNMLy26Mr5LOgvyAvcpCq0E4U,6064 +bitblas/3rdparty/cutlass/docs/search/variables_0.html,sha256=7omYg2VcqmS8-Kmq7jWQId4RAz8TAE641nfbjy1Xrnw,1019 +bitblas/3rdparty/cutlass/docs/search/variables_0.js,sha256=H8MkvsFiko1s8rBm2DAsbiqiSASWnFae1sw8vs8Syc8,4905 +bitblas/3rdparty/cutlass/docs/search/variables_1.html,sha256=9H93mxbxV6OLUcrEkoSo8XTQD7pXg6pK07ifFM0lCRc,1019 +bitblas/3rdparty/cutlass/docs/search/variables_1.js,sha256=U2BO8sy2WDMmUTxQtK7M3cKytK6gSYhH4_lfvNZQf3s,6167 +bitblas/3rdparty/cutlass/docs/search/variables_10.html,sha256=f23_oMkCG0y3PAtSyK6Xi9gS7M2Rm5WvZJiMk2II1f8,1020 +bitblas/3rdparty/cutlass/docs/search/variables_10.js,sha256=itxUztUvDdABxIBqN2iorILTN1Qdw2bRZeYkvjsG_wc,12437 +bitblas/3rdparty/cutlass/docs/search/variables_11.html,sha256=EU0mkNk3nqxzSUi9htnRZ6TzWQhMORgXDYtxkJvmL68,1020 +bitblas/3rdparty/cutlass/docs/search/variables_11.js,sha256=biDIKYKrTOLDTYoA3SHaOXgweoz6_fQ9uuVzrUYuB6k,10145 +bitblas/3rdparty/cutlass/docs/search/variables_12.html,sha256=4smF9cKCph7oKd_F6YJqcSwyzFGP7b-rb7QkUzBbgcg,1020 +bitblas/3rdparty/cutlass/docs/search/variables_12.js,sha256=TLB_Zyh-JC0L7AizKi_8QmXRL9d7q9fE9ue_VsTm3rA,299 +bitblas/3rdparty/cutlass/docs/search/variables_13.html,sha256=DLA1Jb7v1hFIvmkW3L0CLUheUP_8OKtArtf-VrAIoR8,1020 +bitblas/3rdparty/cutlass/docs/search/variables_13.js,sha256=b41oZZ7awFVSATgIczmmly0bjlL5oM_qD9zfZ4cGMR0,5988 +bitblas/3rdparty/cutlass/docs/search/variables_14.html,sha256=0GV2QilqND1S3M4CXYW6Ivc5luD-w0L1CGaQvviqucc,1020 +bitblas/3rdparty/cutlass/docs/search/variables_14.js,sha256=H5S9GMWc-ktIxRHF3Wd7fJ6Mx6GSLRdZpDLqRYafTmU,7738 +bitblas/3rdparty/cutlass/docs/search/variables_2.html,sha256=DRAjK4-FlUPlfuA_4Y24_W1gIgEL7BGx8toF0nwykrk,1019 +bitblas/3rdparty/cutlass/docs/search/variables_2.js,sha256=8VM04kmOfEPXiiq5RChozFYbagVF2Y2gCvY8Eex7IH8,3998 +bitblas/3rdparty/cutlass/docs/search/variables_3.html,sha256=Km6LyatF8GgHoV3YwYTklQ4cUvT6IWccdTHAtQ01mcs,1019 +bitblas/3rdparty/cutlass/docs/search/variables_3.js,sha256=POb6y59ddUyoPC_NqSTslSyhGAXILSLg07EB0-K2Xm8,2563 +bitblas/3rdparty/cutlass/docs/search/variables_4.html,sha256=TgU4VtcEjK5e-4Q0anJqdl3ugyt-PxafkmapUrzml4Y,1019 +bitblas/3rdparty/cutlass/docs/search/variables_4.js,sha256=mxS6hJ9H2XXC-X7GrNKFKt5Yu1ckzIKXsJwqMuwfvPU,4129 +bitblas/3rdparty/cutlass/docs/search/variables_5.html,sha256=W4wX1hp-zNTwDIgnkcdhmQZgV4U5xOSdROGwdJzW1Y4,1019 +bitblas/3rdparty/cutlass/docs/search/variables_5.js,sha256=Wi_kySsINGv9EjdN2pxOmFTTHbS2NeqRalUaZZxtHsk,965 +bitblas/3rdparty/cutlass/docs/search/variables_6.html,sha256=3fXUfYUaMfoL0IMD0q-ksH0PHoJX3ykgiInvsvB1izo,1019 +bitblas/3rdparty/cutlass/docs/search/variables_6.js,sha256=X52phKgrCNmI2YhovT3VcN0adeDAaUJlr4W_A0JT7oM,1768 +bitblas/3rdparty/cutlass/docs/search/variables_7.html,sha256=ZObch54iYWKc_izqRBdXMriGPtnPrx2XAixypZG29Hg,1019 +bitblas/3rdparty/cutlass/docs/search/variables_7.js,sha256=6Tv8DW6Nit1ITzckfp5G4wW4kKRPqYmPyEONp-CsMO8,995 +bitblas/3rdparty/cutlass/docs/search/variables_8.html,sha256=1n4bgts6naGye0RkxJBm-_34vXcXaW0ZJs0_4TGcRZ8,1019 +bitblas/3rdparty/cutlass/docs/search/variables_8.js,sha256=Ei-uTP9VaelsYvsXFC96B7bkbQ4ALAwypUx7IK07mv0,5708 +bitblas/3rdparty/cutlass/docs/search/variables_9.html,sha256=6hbGTUKoTrta50PoRufWOfFSwak3YPcnvcySx82IaGo,1019 +bitblas/3rdparty/cutlass/docs/search/variables_9.js,sha256=_vQrnGjDYl3RvRlg_pN1hQrGdgUZ0mC_ufUGjQKveec,222361 +bitblas/3rdparty/cutlass/docs/search/variables_a.html,sha256=V0XXsmeyr1LEX1GBeFlFRaHYPeuKFoPwj4nxYDHpK8M,1019 +bitblas/3rdparty/cutlass/docs/search/variables_a.js,sha256=K82n_qvqQgtY2cSTVmpONxchw296jlUJ271k3nfXtSc,16359 +bitblas/3rdparty/cutlass/docs/search/variables_b.html,sha256=8N_EOL-nyewQpE_Umn9kq1Uz0_F6DuuTN4rxVUsZj4k,1019 +bitblas/3rdparty/cutlass/docs/search/variables_b.js,sha256=t6vtL-nrT9cvIuETEAXh8xIp4FG9jOuXjhk-B4NWNuE,3543 +bitblas/3rdparty/cutlass/docs/search/variables_c.html,sha256=v9bpPmA6Qo0XxUZ-BY3nahx7pvYS0sKptuGNggnoqhc,1019 +bitblas/3rdparty/cutlass/docs/search/variables_c.js,sha256=lxbQ0TeZCP3tbz3udSWoRR9BXeIKtAbCsIHHVXQ4CSw,6749 +bitblas/3rdparty/cutlass/docs/search/variables_d.html,sha256=6D4w2iqKZbxbcEoma-9MG11m8PpEDtTES8TZbasnLFo,1019 +bitblas/3rdparty/cutlass/docs/search/variables_d.js,sha256=a7LcyZxRxSq9LHYvSpcU_iLSFxkw3l1IByDqfOVZqMI,2189 +bitblas/3rdparty/cutlass/docs/search/variables_e.html,sha256=DNCjzhVgC28R92fSPVIQmELeTCnZVjZcwCby3NJor5I,1019 +bitblas/3rdparty/cutlass/docs/search/variables_e.js,sha256=o69XVaTiezQ79gaqqJkSvjRaRpJvXCWn2J5XcJIHBVo,15827 +bitblas/3rdparty/cutlass/docs/search/variables_f.html,sha256=H4oiu_4ThmunPpK234qNn0mu3iBeQBqH4eqizBB0mh8,1019 +bitblas/3rdparty/cutlass/docs/search/variables_f.js,sha256=FF2VrZeVVfUFZ4fi28bvzxSkJG1t4ubV8JtxONISZ24,19547 +bitblas/3rdparty/cutlass/docs/semaphore_8h.html,sha256=V6UQm2PxNmdCueVtJuT9cPvvqVq3VWtIcecNR5VXM3c,7168 +bitblas/3rdparty/cutlass/docs/semaphore_8h__dep__incl.md5,sha256=28MeJaCVeK90GUfYIfnfbU7lSD2YesD2JgQFqR5qGn4,32 +bitblas/3rdparty/cutlass/docs/semaphore_8h__incl.md5,sha256=hXkJ3BDyGivlvYDuOp_UUVeLlKlTyhx5SSX7HIBfGxs,32 +bitblas/3rdparty/cutlass/docs/semaphore_8h_source.html,sha256=R3M9KERY6uU2U4fGs0hAHga0HMbhkohSt2ewZ-lvXrk,25077 +bitblas/3rdparty/cutlass/docs/shared__load__iterator_8h.html,sha256=pFSQyrZP_lOyCBd5YIoXXzwTWMQGPJdbgV4wCPML83A,8539 +bitblas/3rdparty/cutlass/docs/shared__load__iterator_8h__dep__incl.md5,sha256=FT_oXK1FsYmMgoc2RtbAcUxFFKzk3JkgrkgyOq5FblE,32 +bitblas/3rdparty/cutlass/docs/shared__load__iterator_8h__incl.md5,sha256=RupnCD9myhrSmadULOAglescybKv5NFAagCX5k4SJP8,32 +bitblas/3rdparty/cutlass/docs/shared__load__iterator_8h_source.html,sha256=BW8d3IVo-xbM962N2DEE0PUavUQTxGTCwQCXRAQuIME,52981 +bitblas/3rdparty/cutlass/docs/simd_8h.html,sha256=5-AEhR4zM17H2USl7woCCQMFVxMuALQVWUSpoRbAlrY,10377 +bitblas/3rdparty/cutlass/docs/simd_8h__dep__incl.md5,sha256=KWUljYWE4CohwLb9m9cp3QsNpf5QQQPHb9gvs3YkfNA,32 +bitblas/3rdparty/cutlass/docs/simd_8h__incl.md5,sha256=DszVr_nXFjCqwyKquilvrMBF9c4vGYTELJdsGugv-SQ,32 +bitblas/3rdparty/cutlass/docs/simd_8h_source.html,sha256=X-RrP_D_iCgC3XbOTUmUQ4z2v9I1Sebx5PMmSzgqZtY,24845 +bitblas/3rdparty/cutlass/docs/simd__sm60_8h.html,sha256=rtGhTDbn7orBvBeIKjnbyiABUBSH8NGU8AQg5zuwItQ,12385 +bitblas/3rdparty/cutlass/docs/simd__sm60_8h__dep__incl.md5,sha256=3O_rEWA5eS8ZnRkTF6gRe-FjB55C8HM0iMfMRU3vs3k,32 +bitblas/3rdparty/cutlass/docs/simd__sm60_8h__incl.md5,sha256=06U8bkDCMx6sZLVoeqLFgt4qyKwxcdlc0aTCvTBOKQM,32 +bitblas/3rdparty/cutlass/docs/simd__sm60_8h_source.html,sha256=bWQAOljq-HTmql1dCYOAOi4fdGnPzD1CTiDThVJARLw,22731 +bitblas/3rdparty/cutlass/docs/simd__sm61_8h.html,sha256=L_t25UjVTH5sMG12cAtPQ5gzWMJ1uMyZKNdyK-3s1w8,18629 +bitblas/3rdparty/cutlass/docs/simd__sm61_8h__dep__incl.md5,sha256=NcP6pLW5L59VeXnSG_kYlgs3qIDAhufJmenTDM0GO5s,32 +bitblas/3rdparty/cutlass/docs/simd__sm61_8h__incl.md5,sha256=AdnnZw0giQ0Cs7Q689VkX75ixFiT3qj7rPRiXeqchzc,32 +bitblas/3rdparty/cutlass/docs/simd__sm61_8h_source.html,sha256=zdZByvThKuhGNIuYoznTn8TdYNGNEbmlfh3ThpGVbSc,25128 +bitblas/3rdparty/cutlass/docs/simt__policy_8h.html,sha256=JcdtKumSDWq5cERCGg9zVrdgFit9ecwJViRtQqfPWV8,8407 +bitblas/3rdparty/cutlass/docs/simt__policy_8h__dep__incl.md5,sha256=iuD-86BXxgP28Dr-N_uP0J-MlomlTNnUeq7FfU9Frdw,32 +bitblas/3rdparty/cutlass/docs/simt__policy_8h__incl.md5,sha256=WQjW7Fo-Kj8fVmYXIZog2V_AkFyi3Hiukf0Uv8G3NQU,32 +bitblas/3rdparty/cutlass/docs/simt__policy_8h_source.html,sha256=UNhWpqklzIc9eG5fxOnXyzfgk-wWoe7_GwicVNV2b8s,21597 +bitblas/3rdparty/cutlass/docs/splitbar.png,sha256=CcGUhsvLqzAw7HZJcyX5KVMyT-Xv_zBUc81snuCfsT8,313 +bitblas/3rdparty/cutlass/docs/structDebugType.html,sha256=tu98aqaDsopCcGD13hFMb5E2wgBBle7RsXymw4FdSCI,4732 +bitblas/3rdparty/cutlass/docs/structDebugValue.html,sha256=WpiUkZvnxUYuyqfB-leSYWmMT1675vI5rVBp0VngLc4,4742 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1AlignedBuffer-members.html,sha256=1lYF1K5tWswq_NueKVr6Y92uFCRoT6D8IqFjBZECAD4,10875 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1AlignedBuffer.html,sha256=bENlrPN3lLQnvf0oCbUEnQbsFjAJTKrQpPehyER_JOg,30561 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1CommandLine-members.html,sha256=N3rLKk_Jk-4lIPyfQpEUvEfiFEC9DR0RsErAQgdQtcY,10637 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1CommandLine.html,sha256=9ly-7tjxkos9GyoXZDGf2rNPTUyOZaPmVJ78Y6buwTY,30961 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1CommandLine__coll__graph.md5,sha256=Oakb2oK9ds5R-Q5DfAugiUN39IqY0M9jQxf2LVZvMlY,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1Coord-members.html,sha256=yypCrGt_NAwAccJ8JQNfpt9saWRnscwEg7684v2GXUA,16697 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1Coord.html,sha256=_1brv-FFLh68GO_4G2EmhCQfSTtRI9sBiu49-eRjSTs,71319 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1Distribution-members.html,sha256=BvtFjyK_ps87m4bhQtUSijQZVViTbDb-aAw6hBEmSac,11254 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1Distribution.html,sha256=CvYmpmRYnM3i3kUv0_aVghj0Y66Soe6L3Ywndf1wY_E,26598 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1FloatType.html,sha256=nJuDfuUCB46T5GbK6QsvJ6o_kDtOgEuzzVutTmArXo0,5022 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1FloatType_3_0111_00_0152_01_4-members.html,sha256=haXypJ-b_XrfvQCT1Vtt6yO5y_jlP3Vu2PpK4gE3p0k,5169 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1FloatType_3_0111_00_0152_01_4.html,sha256=WvxCbb7B-x2eAS3YmM7V5Y8T9J5NeEiOyi6Bo8sR7ag,6219 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1FloatType_3_015_00_0110_01_4-members.html,sha256=R_g72WfWj05CSyUfvoiOqknN7d3TEDumOthx1RtM2wg,5161 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1FloatType_3_015_00_0110_01_4.html,sha256=7CFYLsH2_cF0gRf2fKEAIC4DfuM6F8NZDyDJ5mtu_xA,6321 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1FloatType_3_018_00_0123_01_4-members.html,sha256=fjuFfwNS81YxWBgUHfzGWwHXrnv_vG1gI5DcFk2iUd8,5161 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1FloatType_3_018_00_0123_01_4.html,sha256=g2ntBESokkMlKWYahKhYuI7_ThEFjEEWLuRCfpkv50o,6209 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1IntegerType.html,sha256=wlI3Z0663jNLuVLJJBEbJ3dB1yOifFUyLgEW-ikzWZQ,5007 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1IntegerType_3_0116_00_01false_01_4-members.html,sha256=z-Xlz9oP7Po9-JTDlYYqXWf0Be6zDhwIxb53YOSeizg,5209 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1IntegerType_3_0116_00_01false_01_4.html,sha256=jiaturcB12zg-XLDY6QcE_bGN91B6oz6YSuLunIoMCE,6265 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1IntegerType_3_0116_00_01true_01_4-members.html,sha256=dq0P4UKAkaCPi9ZwEAMJgnmJ0EMzoDjgKJ_3Cl6IJH4,5201 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1IntegerType_3_0116_00_01true_01_4.html,sha256=C3Vzwlo8b41PF1Ld7kqWMsheHC0BJ65-qCL4zIQuK1c,6255 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1IntegerType_3_011_00_01false_01_4-members.html,sha256=-QSrtSscLahAL-7EERwsaGna2dVd5vYzK8-meVArHNw,5201 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1IntegerType_3_011_00_01false_01_4.html,sha256=FDqldpU6mVNPZaIeLKE417v405A949VHhRyIptkWEGg,6415 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1IntegerType_3_011_00_01true_01_4-members.html,sha256=hzzkh4agE915-eW7aGlsl8vShWfsmfhBGJE_bBW_Bfo,5193 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1IntegerType_3_011_00_01true_01_4.html,sha256=5i6ADz1Q58PjykDGM2NPkpW_ASuzYyDLXbc-lF7aL18,6407 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1IntegerType_3_0132_00_01false_01_4-members.html,sha256=Cer_5sp5x24ApR4tNvVrT5wGwSAeQCq5HqmKRVdzSQ8,5209 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1IntegerType_3_0132_00_01false_01_4.html,sha256=aVX2y-q52ju11CotVYToM4DGdcjcfcaZJYWqm14uFWg,6265 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1IntegerType_3_0132_00_01true_01_4-members.html,sha256=TIYJgwjOHvlMQy10U_FckxIhjbg_cPUpa-132rd0hew,5201 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1IntegerType_3_0132_00_01true_01_4.html,sha256=HlRcdDhe5_iv9gviIaR6HcdPSdaR_PmDm52HqPkZRRM,6255 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1IntegerType_3_014_00_01false_01_4-members.html,sha256=kEZcsrgwtQEppMcSyl84q0nWZkChFjV4EBIoYQ4IToc,5201 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1IntegerType_3_014_00_01false_01_4.html,sha256=QYKcWoMf0ewZRBMDAqI5ivpoa4kPqLzyn-HNR4fUDTA,6419 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1IntegerType_3_014_00_01true_01_4-members.html,sha256=27E8q5vpF68i58-5Te798gNPXhWWzKRRu5JtmZ2g0b8,5193 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1IntegerType_3_014_00_01true_01_4.html,sha256=0rQeY0BMhjdHWfUA4eEOYaHeOhn55Q7YWe5fEeDLt-M,6409 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1IntegerType_3_0164_00_01false_01_4-members.html,sha256=ZadDTmu-Yvw0GKFpNmZK3PX4IrchxCsWRRYp3JRslMo,5209 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1IntegerType_3_0164_00_01false_01_4.html,sha256=6qcYfjNCw2cIpfuei3qzVHziLrj6wW6_2bJe4k11BE8,6265 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1IntegerType_3_0164_00_01true_01_4-members.html,sha256=hIE6FoD_TMMDdW2t74QrexfwYXhjXLJrd4N-ZgxVfNI,5201 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1IntegerType_3_0164_00_01true_01_4.html,sha256=lOFpVGvkNTqdvLGM4XYt-IVKaUM3jyoIcrGcQrH4tz8,6255 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1IntegerType_3_018_00_01false_01_4-members.html,sha256=shC-s99WB_tS0fvN0B8WdyLT80ol7wtRdw79fq6biEw,5201 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1IntegerType_3_018_00_01false_01_4.html,sha256=tXQo3jAT4bfCgsyd8-GTp_OsaO3OSKPKFggNjIY16Lk,6255 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1IntegerType_3_018_00_01true_01_4-members.html,sha256=tgn_eabRxPhcHrbGrFnmMe09zeloKSUmRW9LlwYFTIE,5193 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1IntegerType_3_018_00_01true_01_4.html,sha256=ISTek-nXr_WYM1xOHk2_9Qt4oj2x1JJ_rmi3jnWk6X4,6245 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1KernelLaunchConfiguration-members.html,sha256=R4Gh7WVuUPGiiHRVso4X0kFN5-VjMKECrnqcRlg6Qpo,6196 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1KernelLaunchConfiguration.html,sha256=WOn532fjnv0dUC4uDRTl72spKj3QNRNyJtTqMiRXG9c,10551 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1MatrixCoord-members.html,sha256=BCTV2x-GVImeef9TfBlJ9rlnPCblpIxxJbhiUV2ft6k,21229 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1MatrixCoord.html,sha256=rWz2Xg43qPpwQj2pmDzTxZ_ecCqmRARXHKYBhE6Iz_w,68593 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1MatrixCoord__coll__graph.md5,sha256=n69l30Z5aaDuNNSUUH_j5gf60CHY6KXS_MTJwgr616Y,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1MatrixCoord__inherit__graph.md5,sha256=n69l30Z5aaDuNNSUUH_j5gf60CHY6KXS_MTJwgr616Y,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1MatrixShape-members.html,sha256=IEUAy77eY94kz1EcZhTIWn8V5kj2feY__xQmQOkuXeg,6135 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1MatrixShape.html,sha256=t_vG92-LwLjW7mLsT8plq8rpdacCdhg87_q0C0jWmn0,10925 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1Max-members.html,sha256=4YE-qmlob699Nnh9rqxlf8V51aXPOyPC5Au7ISLjQMY,5047 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1Max.html,sha256=WY5l1jjKlrkA4dN3rQ14_2KHSvg3VfvoOoZkuzrQdzM,6289 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1Min-members.html,sha256=zu79EhBheeJj9ytIEy0V6JlZiPqZMwaUkKFkXD-fC00,5047 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1Min.html,sha256=yrTHoAClIuioGnEkAKhKmTZHpXtj6m8-zYUheXWOnmE,6289 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1NumericArrayConverter-members.html,sha256=MSxLAfHDOZd1jOwRhfkrhBCXRCDO8UjsRz2amocMWis,6689 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1NumericArrayConverter.html,sha256=zypGRJIzn_T0ZWWXho1S8jQvGClM9C4e7KqkfQEdEEo,13616 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1NumericArrayConverter_3_01float_00_01half__t_00_012_00_01Round_01_4-members.html,sha256=pT5Ut9c-VGJc8zJnIfe1ZEbrFISNzjdNlNdE40RrAqQ,7342 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1NumericArrayConverter_3_01float_00_01half__t_00_012_00_01Round_01_4.html,sha256=-NTJLdrZI618rWfUHTPm7eA60tT1_dfV50Aom7MQlrY,14922 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1NumericArrayConverter_3_01float_00_01half__t_00_01N_00_01Round_01_4-members.html,sha256=3mKQJHs04Nw8q6QaCPSqE3_Il2XQH9d85MgJqCr9Y-A,7342 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1NumericArrayConverter_3_01float_00_01half__t_00_01N_00_01Round_01_4.html,sha256=1-SYTPaYBnRcj0ZHYHPhW4J94uPHWd2xTvL4P4NiBQU,14646 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1NumericArrayConverter_3_01half__t_00_01float_00_012_00_01FloatRoundStyle_1_1round__to__nearest_01_4-members.html,sha256=tOeLPK4Qvl2NoSjCTIT1OktNBadmx7UePTlnP_2_RA8,7950 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1NumericArrayConverter_3_01half__t_00_01float_00_012_00_01FloatRoundStyle_1_1round__to__nearest_01_4.html,sha256=lf4MttySFuSws4XZ26KuT3rzDO0LhefglJD_RtXTpr8,15903 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1NumericArrayConverter_3_01half__t_00_01float_00_01N_00_01Round_01_4-members.html,sha256=T1wv1Oq77BzQiueDehxN-VKnqCKGZHy4g_YpD34xVM4,7342 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1NumericArrayConverter_3_01half__t_00_01float_00_01N_00_01Round_01_4.html,sha256=vUbxrbtLRR_rPsVpqRRbvXtc7oJewgNRRpYSvFcBKXQ,14646 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1NumericConverter-members.html,sha256=6KwI_yFsf2w0Da0WRPcQXRqWPns-axPHVhWudAPbN1g,6568 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1NumericConverter.html,sha256=r2GJEFXx-zCDWvUATAQpWg4l35OdYPZM8mXD2nlYaCs,13300 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1NumericConverterClamp-members.html,sha256=hbB1JbfNci0gC27Ssj-N-XQEal127WCQ2nL0zCqbcZk,6264 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1NumericConverterClamp.html,sha256=0LqVYyU6oAj8qRZajZPqZcwv4UEUTyOfFMxfj_PJcA8,11564 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1NumericConverter_3_01T_00_01T_00_01Round_01_4-members.html,sha256=aIFgKDrxmvC-zDZ7vtIz2tqa67oQhYX-yJtbaxksemk,6937 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1NumericConverter_3_01T_00_01T_00_01Round_01_4.html,sha256=ehSxuMwoFZ0XZ-6k7t3BkZe_nlwns6h0KWdSC5gDbOQ,13742 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1NumericConverter_3_01float_00_01half__t_00_01Round_01_4-members.html,sha256=vtB0DojbViHtTfKdlxCBWuLeQD9MMLoEaNb8L00F7oc,7129 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1NumericConverter_3_01float_00_01half__t_00_01Round_01_4.html,sha256=FgCd6TJyfcn2jcQL85JY08Ms0e3a4eYO1QSLFHGy8-k,14322 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1NumericConverter_3_01half__t_00_01float_00_01FloatRoundStyle_1_1round__to__nearest_01_4-members.html,sha256=bsKwKUxwU18VQlmA37p-WwgbytqF4eKTeEBjlRU6UW8,7737 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1NumericConverter_3_01half__t_00_01float_00_01FloatRoundStyle_1_1round__to__nearest_01_4.html,sha256=hXp_X3aenhbCes673cA3E6KJMyAWTH-Xxi2oAY5KIgI,15474 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1NumericConverter_3_01half__t_00_01float_00_01FloatRoundStyle_1_1round__toward__zero_01_4-members.html,sha256=zTJfH4rIQoCUQRpb0xNjn5ydYvOJZl0SM2gYrjo1_50,7759 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1NumericConverter_3_01half__t_00_01float_00_01FloatRoundStyle_1_1round__toward__zero_01_4.html,sha256=_UN3CWAD-6tPwjl3Nbxtfta8Ejjs9X7Dr0JuxKqy-Zw,15709 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1NumericConverter_3_01int8__t_00_01float_00_01Round_01_4-members.html,sha256=1mL2Y89V1D_89zzaVikfuO2Lryk_Xmv2_ESC9pLKuWI,7129 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1NumericConverter_3_01int8__t_00_01float_00_01Round_01_4.html,sha256=DZ4swTAHgJuNK-P7nF4iHrKD_Uc4JI2NmozL2RvZFi8,13774 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1PredicateVector-members.html,sha256=P_0Ycc1uJsx-kLYCC4Hkkpa8dVdqApkDyNkRaEZxBpU,12585 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1PredicateVector.html,sha256=GLyM5d0O30UUeHVUBArwo8DwfZk7CKPFb-n1WJL6Cp4,42952 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1PredicateVector_1_1TrivialIterator-members.html,sha256=uvCtwCjrA6zzZBhagmLanrJnWubTlmHBvhvL-KbmndU,7758 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1PredicateVector_1_1TrivialIterator.html,sha256=W0_bDBfI9rMfrVA4uqziUs1GUjYM_BQ7AmH1Ma223tc,16789 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1RealType-members.html,sha256=NGhFkyIwrw83e74i2NGlUXFAjYC99wZbGFYQg6Q-yWM,5050 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1RealType.html,sha256=hsuNRcrBxDCDIJdxLNjYYGvjrBrEZu7M6PUi2_9E_zQ,6193 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1RealType_3_01complex_3_01T_01_4_01_4-members.html,sha256=DUrg9rnmRDOaT3VOfpGXy0EUL2mHgBfrQYN_wTpXIWs,5241 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1RealType_3_01complex_3_01T_01_4_01_4.html,sha256=sAoQy6YvtFsY94lAc1yWVgSdJYnQ_8pN7VnWmfQN1XM,6428 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1ReferenceFactory.html,sha256=1szc4fbLqPIyv8bqRV9vVymYu-geZy_JVTMKQqPG_wk,4980 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1ReferenceFactory_3_01Element_00_01false_01_4-members.html,sha256=qOEJSvwDpN4jC6PXMNST_gEb9U_w3-mV-zb7QhXYwuU,5833 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1ReferenceFactory_3_01Element_00_01false_01_4.html,sha256=XpSBxB6YVj-0__391Ilnd_jmPBDYcZXlwJxpzoCI-Ew,8993 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1ReferenceFactory_3_01Element_00_01true_01_4-members.html,sha256=TyfzMeVceGzLrWdvbR8yRovs6fI3570Vb4Hqx4MxoMg,5822 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1ReferenceFactory_3_01Element_00_01true_01_4.html,sha256=PWl86EIX98cGVdqf0B1wfwwgqvOm_L1JukZ8uivRpEo,9322 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1ScalarIO-members.html,sha256=q2q7AgixJDnBl3QExJTk6zdt2dXTPG4OtamQCXKmmW8,5661 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1ScalarIO.html,sha256=eqlttN5mFGe8k4Yk-lSjkXsNmUuEvRTUYVTRkfgc7zo,9895 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1ScalarIO__coll__graph.md5,sha256=F4HHd-H-wLJevA6fXVq6-RXnKVp6Vam9-9bY3RScpfA,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1Tensor4DCoord-members.html,sha256=UHChK43ZILfXnVDF_117pYF1i34bzth6Ci-78_QrHr8,23570 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1Tensor4DCoord.html,sha256=FAhfD3zCPKOo1VBWhL0xljiIKFm3qrhxRcaq_Hx_zKI,80956 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1Tensor4DCoord__coll__graph.md5,sha256=GXD6gDdDPDepMY6hufggR-7co2f7eY_U1ZVMJCqetUc,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1Tensor4DCoord__inherit__graph.md5,sha256=GXD6gDdDPDepMY6hufggR-7co2f7eY_U1ZVMJCqetUc,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1TypeTraits-members.html,sha256=iiqbtJsAFdoru59xboF4di4izu5nEcs6JVlKmaZajL8,6424 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1TypeTraits.html,sha256=sh932akEWf4UPdqEIlgg2-JPlidWLY0ERb2BBQ3AqBs,11357 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1TypeTraits_3_01complex_3_01double_01_4_01_4-members.html,sha256=i449g6a7rDX5bsF2IZYjGW6MdB8aaQ-RVWhmOVW5a0A,7459 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1TypeTraits_3_01complex_3_01double_01_4_01_4.html,sha256=tv2oU2xaOM1EljA5594PzzTFuPHu8iRtfdhCzKxi4kM,14999 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1TypeTraits_3_01complex_3_01double_01_4_01_4_1_1integer__type-members.html,sha256=TgyjsKcGVaMmdcWbYAKEsTWEkcfEWN1j89glW5Smty4,5928 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1TypeTraits_3_01complex_3_01double_01_4_01_4_1_1integer__type.html,sha256=4Q00GdWIZRHjokpW1M1YWynhB75FtPpcZLcBYlHoQTw,7348 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1TypeTraits_3_01complex_3_01double_01_4_01_4_1_1unsigned__type-members.html,sha256=XctMV3OQRIa1S3zrmGxyX07om2QGX2jwZpDqnLtfSSU,5939 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1TypeTraits_3_01complex_3_01double_01_4_01_4_1_1unsigned__type.html,sha256=1ClJuLqGSNJsphPZp0pqiNduPSxFzRTP6Txr9xI-HQE,7361 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1TypeTraits_3_01complex_3_01float_01_4_01_4-members.html,sha256=6ueP0-9ukFpR_42TR-3s4PiuH-WY90VufeL1awSK728,8179 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1TypeTraits_3_01complex_3_01float_01_4_01_4.html,sha256=hypPkAEFrz_EmW2WLq4ZFUj7kegqo5u1jHKzPoDmo58,16100 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1TypeTraits_3_01complex_3_01half_01_4_01_4-members.html,sha256=3ZebRHhBbBGHg6ktWw-A9d866kkoesAV6GcnN22Na5k,7234 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1TypeTraits_3_01complex_3_01half_01_4_01_4.html,sha256=U2Rn41veQdnRUQ8FKC9fd6J8A7lfpHL0cqIOXu9XQNw,13113 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1TypeTraits_3_01complex_3_01half__t_01_4_01_4-members.html,sha256=Z9RLba3YX6ilz0ueVvTRC4xy32HRCgpIPuzSyjAClFw,8229 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1TypeTraits_3_01complex_3_01half__t_01_4_01_4.html,sha256=c9nVnsVw3bcMVNCFznI5Xa8SQncynTYF2RXwdbXw7Uo,17253 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1TypeTraits_3_01double_01_4-members.html,sha256=uQHFB7IRA_bYaG5HyV4FKRI-Fi0XXuJRJcyAJIezb0E,7670 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1TypeTraits_3_01double_01_4.html,sha256=arHUfg0XQ1Hib2hgZ9gHmMYh6awYFfZ8q9YfHIGOeoM,14486 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1TypeTraits_3_01float_01_4-members.html,sha256=h9H8FYu-vzh2wgs1Qnpt0YEMtumbIAwK-1uA5fDfiTo,7639 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1TypeTraits_3_01float_01_4.html,sha256=8WBu0qn_xyP7aBHXTiejAK2Fe-tlo9yXvR3UW22s-g0,14445 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1TypeTraits_3_01half__t_01_4-members.html,sha256=FybA39mBwae6ZFF_oLyAYxwZUI3tfxY7pbpDDxrRIBE,7685 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1TypeTraits_3_01half__t_01_4.html,sha256=65x8vWgWdoRUZi_qydM0at4TT9mnxFcSeHIrhPm3gXQ,15490 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1TypeTraits_3_01int64__t_01_4-members.html,sha256=UCEQb4RdbR6OLE0y7gGoB7gQBC4eipMuRh9djrT9-0U,7719 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1TypeTraits_3_01int64__t_01_4.html,sha256=vZdC0sNtw7II_j5gy6vOtJgTBbflOfGjtfVA0-Bl29A,14543 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1TypeTraits_3_01int8__t_01_4-members.html,sha256=BRzdfYa7ISGOl_Y8Ctko4Xzh7ERyQZ74OA0umdW-O-Q,7688 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1TypeTraits_3_01int8__t_01_4.html,sha256=jOEDx4NxHBFYK8ewzrfFW9z9e1U8zDx1FTCg9BuFrSI,14492 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1TypeTraits_3_01int_01_4-members.html,sha256=rAk0hmsHMOZrdm3zWbWPjvlu9dbnbsxBGxxJwtM9xz8,7581 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1TypeTraits_3_01int_01_4.html,sha256=uHMIVCIHYEL3c3PSvAfr6vLbCM7hvDBhxk5-_Bm1WO8,14379 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1TypeTraits_3_01uint64__t_01_4-members.html,sha256=nTDrZKc62nrdmjsJiv0mgESzl_30d6iIlpV_1OFbyQo,7750 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1TypeTraits_3_01uint64__t_01_4.html,sha256=Qu_Es-IKX0cDaYzaqNlsZewpay-kF7vDeep0Mh_GDds,14586 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1TypeTraits_3_01uint8__t_01_4-members.html,sha256=Wk4mFY_2ZArOhBK8pibvY-2GXSAVp25IrcrH2MJBYYI,7719 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1TypeTraits_3_01uint8__t_01_4.html,sha256=ZS5174dsyk8oMQiQCO3g12PiRJTq3-Zv-dm336XsuSA,14543 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1TypeTraits_3_01unsigned_01_4-members.html,sha256=SGK5W9ggOReX0ty6sxiZWG3RCFq0nLEuvI1KSEIFObg,7732 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1TypeTraits_3_01unsigned_01_4.html,sha256=8DCUR6Z-znU-W79-NC6hfS4CqX2fC5fsLrIhbYC5qcA,14570 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma.html,sha256=QBNVjLeO8o7Q7wVO421LJw40E7NoPWI4duQ_KrG5WnU,5169 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_0116_00_0116_00_014_01_4_00_0132_00_01half_0bcc4d05f9811035f08cc1b7f0154a4d.html,sha256=EbYrjHREBOzKUetZCqkjYSgBZ6W4ZhM6fgZGU_VZXbQ,9788 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_0116_00_0116_00_014_01_4_00_0132_00_01half_ae0044daf80ba9fd16cab7f0051f1fde.md5,sha256=5m_dv6yg3EdFeAwrVCxj7h-KbFbu6tFqsnEHDbr2-68,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_0116_00_0116_00_014_01_4_00_0132_00_01half_e01aa2e557b893ec75f43c473a7e2298.html,sha256=K98ZoyYKONLkHjWMpL93GwpkOXINYawQfd32nm0dejU,5956 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_0116_00_0116_00_014_01_4_00_0132_00_01half_f064fdf1faf580060072347f2c48dda7.md5,sha256=5m_dv6yg3EdFeAwrVCxj7h-KbFbu6tFqsnEHDbr2-68,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_0116_00_018_00_018_01_4_00_0132_00_01half__02a3f19a78995f97d793a668e0e4d4f0.html,sha256=k8Ja3FNzIesBBVBsKdXGKTkIG-olQU-fQ6gQpeUgjt4,29037 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_0116_00_018_00_018_01_4_00_0132_00_01half__4fea29912f54a07d7b3a1f18094a4162.html,sha256=1-J8g3_Oj2jtzbp08B6SnUS3ThAU8vS8EDrPa06hhOc,12969 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_0116_00_018_00_018_01_4_00_0132_00_01half__6997b5a0687b06c1dc11ece72f57e04d.html,sha256=eW72OiQNCsrA8JL7C2baN7j8Fngf323fREgMQTXOjOo,12984 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_0116_00_018_00_018_01_4_00_0132_00_01half__96363097c47b056f0ca1911afd7f8b7a.html,sha256=X5lCDFWPaB2IcO_ZOi4UhDr2AYugpoDXv1Ti_vGWY3E,29730 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_011_00_011_00_011_01_4_00_011_00_01ElementAb13e13b2cc3bff17e7d9b004314a4d2f.html,sha256=IFhhtcPPK6K1JFqXAbr73qdV-AibXvKAsY5D5eE6qcU,6725 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_011_00_011_00_011_01_4_00_011_00_01ElementAb6e65b2cf5ede7f41cb070a767158dee.html,sha256=NzTzALrdGTb41RlWV2x-xDsOypVIEivRpeysO7Ss-jY,10411 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_011_00_011_00_011_01_4_00_011_00_01complex_0a4e7894a173a90c4c8a848e15443dd6.html,sha256=jl6HHTJVLxMPOlpZ1TTsB3ENT3NidjERTCvmQBaPXtY,6933 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_011_00_011_00_011_01_4_00_011_00_01complex_30fa42e1ad201df010637cd22fc070a1.html,sha256=r0qzD3G4TxOAD36MA00V2ERorVnpJ8c4CRLrX-8Weic,11347 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_011_00_011_00_011_01_4_00_011_00_01complex_48b3a43bc03fff93a111ac01abe7e40d.html,sha256=DX1BUXeEns2Svz_yq9Ndiu3U4uPhjxnTc3Ts-kUaMW8,11012 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_011_00_011_00_011_01_4_00_011_00_01complex_76f9d24016e1b4167b16f4d7628c9546.html,sha256=5na_XYfli3a1PHWRXQOJt1aLJwuKrk3eeCVtYfijTTQ,11324 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_011_00_011_00_011_01_4_00_011_00_01complex_79ecb4a44f8744132619f70250e841f1.html,sha256=_9UN5bP0iCc9rB5nLPpRTmRn8k71Yr3xP_3MgghZQ3g,7016 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_011_00_011_00_011_01_4_00_011_00_01complex_9a2c5a3f3ee674fa357dabc2a7291efb.html,sha256=iS5Gk-pkSO7w7vMzx8JGe23nJIgYL9uOJYgvGdgliqI,7035 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_011_00_011_00_011_01_4_00_011_00_01complex_a166f31c8e14fb2406c5abe3e6468fe0.html,sha256=Bnz1JPDigtALu9ihjSQ1s228fbDEqOLAcbaRqh6lzcU,6914 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_011_00_011_00_011_01_4_00_011_00_01complex_f1c9d2ee842455cd0c5b71d56108d468.html,sha256=n_yI_vzG_F9TLbelvO1OKco-gdm5fRqYWN2s9lBYOoY,10989 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_011_00_011_00_011_01_4_00_011_00_01double_044bdc8c1d710104533d255adabd276dc.html,sha256=WZGU7Lq6A1kx3Grb5qknHITp9723rAp9f1P_fiqd6F4,6933 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_011_00_011_00_011_01_4_00_011_00_01double_070b94670e040ed5855e5b42d5ca8a443.html,sha256=4tszMoFY5ihz4GuSOrfaKsnArs1RxSVlBZlQqWRm4ow,11012 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_011_00_011_00_011_01_4_00_011_00_01double_0aa57e6a2e6b5da37d10688bf99419a23.html,sha256=aBvnPUoFtnTXLrRDRsZmvTBtYSnsK--orJy9Do6kdqo,10200 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_011_00_011_00_011_01_4_00_011_00_01double_0e9de4e141d6bff0ca93f3c42e86e80ce.html,sha256=kUjB7CDMwiM6BTMTDKqCx7C74c8FacU06_qNUzzFl9Q,6712 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_011_00_011_00_011_01_4_00_011_00_01float_004bb3fd76ca2af7b3210676fa9644d95b.html,sha256=WWHdrY4zu71y4eq6Idp7Kk9ok8mrh5w-QJCpgLWjo10,10177 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_011_00_011_00_011_01_4_00_011_00_01float_00a0ac6b0d215d4ed4d6d321752b92707d.html,sha256=FRVUj_gqkqOrucSlKITX5AkYslJiCmwgCpyntmGwDNg,6693 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_011_00_011_00_011_01_4_00_011_00_01float_00ca85efee0ebb14556bfdbe5191960805.html,sha256=R9f57khAsVPtObt0UwpKllWWjfbIMAnEvyrSoJKJgaU,6914 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_011_00_011_00_011_01_4_00_011_00_01float_00e3e12e263df6506b8cf06c3f4d478b8e.html,sha256=rfRrRuf6dx2mdx26aazR7OxA74jl5In3Z3HjTUWWHQA,10989 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_011_00_011_00_011_01_4_00_011_00_01half__t_21792e1a5c20e3dff890e35812831335.html,sha256=ZHAlqplfM9fflRVBV_Vd5ll-RgyABfN7HBQE5KuRG0c,6705 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_011_00_011_00_011_01_4_00_011_00_01half__t_4f30ee91f7bb3844ff7579c68d078818.html,sha256=_fJktXBCO7DlyZyhuifjDnRQgmAYLveoFqhE1U_deHo,10631 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_011_00_011_00_011_01_4_00_011_00_01int_00_00b2dff9ce8caad9aff5bc6a355539161.html,sha256=gBK6BAvSc82lu08xadiIUt5L5MGveQSyWK7YgbSqQD0,10131 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_011_00_011_00_011_01_4_00_011_00_01int_00_00e09665ee92ae653939a9120c4351f2f.html,sha256=m4G29bdx1tfK0_7mXd53LCLy0iEdM3IpahChUvWdrFI,6655 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_011_00_011_00_012_01_4_00_011_00_01int16__t3dda54d0df2c21b051e222cddd982e9b.html,sha256=BllVVbACcEBTxKTOJs6IacQ-8fkk80IOhSI-P3npSks,6808 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_011_00_011_00_012_01_4_00_011_00_01int16__t8c4bac365710598317a69c489f7239db.html,sha256=w4zND6RxtnRW8lBG-qLFHBEyzO0xRmcuEDsJYPVksdE,10482 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_011_00_011_00_014_01_4_00_011_00_01int8__t_86807694aea1b966dc9ae0bc9a22ac33.html,sha256=LDiYJVPo9RVfuSP3XFTE77EdBWMRqFhlp-pQpJrPVE4,6691 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_011_00_011_00_014_01_4_00_011_00_01int8__t_a1ef6624fc8c10126f17f4ee88283d72.html,sha256=po41Yid3G7D3USwpm1Jd01KF3-eKjck1_B8r3P63Rek,10173 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_011_00_012_00_011_01_4_00_011_00_01half__t_7fbbb0aa08907075ded7a905cabe1d97.html,sha256=yoQiOV5cc1bgOUoTPLz_W56dS_2y8b2ao_1tpzGPI9Y,6757 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_011_00_012_00_011_01_4_00_011_00_01half__t_f3dc2e59f857ada163d1e0781ea8f391.html,sha256=pujANMeDWF1aYGpNUcfcVMDi7TegGg9sxCOWhXWlH_U,11107 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_012_00_011_00_011_01_4_00_011_00_01half__t_8cf78649807b93684f3d431bfa34ee28.html,sha256=Q5r0sm0dE_2H04aBlA6bl2fTdGLY21lLhomygdY6pAk,10970 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_012_00_011_00_011_01_4_00_011_00_01half__t_e8853112b7d418aa02cf5f6b1b6348a1.html,sha256=iXGQukqf_ztJEK7BW-SgVF_Jt5GvTxjzsFhEhvrrTK8,6712 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_012_00_012_00_011_01_4_00_011_00_01half__t_39c3b5f2ce80d79365e55c86a34c60c4.html,sha256=MYX-asXB5VI0-31uvpTaS_aL-Bi8mdFnORTev9qpnyk,6877 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_012_00_012_00_011_01_4_00_011_00_01half__t_9110caf9fa4e6fed12e73aa4912e9b01.html,sha256=LJOWlqkB3J-dz98Wy8Vop5ef1sZ_-ViT-BRS0z621z4,6862 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_012_00_012_00_011_01_4_00_011_00_01half__t_c07cc6439298fa5486a719e577be2538.html,sha256=PxDPvih3nBGbSUvszt7XVuGi-Y2vi2tsgySj321RK6Y,11306 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_012_00_012_00_011_01_4_00_011_00_01half__t_ccde11d1bbbdab3702772ce44eb9729a.html,sha256=yYMi3rGuiX9v1HUNvLYSvgVYtWCPr0puAkngdUE-y2c,11327 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_018_00_018_00_01128_01_4_00_0132_00_01uint15918972b95027764b3a849b03075ed2b.html,sha256=3eKba2UNwAYjx6vJL6TsRP6QHh5GjT214rWDeCET2NY,29835 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_018_00_018_00_01128_01_4_00_0132_00_01uint193e4529ff6509d9dffe61a902bae1f87.html,sha256=sSM0c8qDE6NeS0hA5AzSzO4K4LOOGXvzhU_iWlyshXs,12954 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_018_00_018_00_0116_01_4_00_0132_00_01int8__2b08bf7357f4869709a6071c15462437.html,sha256=UOgLDe3WpkzInSQ2ECNTbQWcBej-bBBBSAl0mKod5B4,13059 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_018_00_018_00_0116_01_4_00_0132_00_01int8__5299c9c90c8f2f521be0c8cec1c3eb08.html,sha256=z4QLw6H0-OsJw5zcktCgAUIQ6KDF0S7LybtTooxUPIQ,27256 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_018_00_018_00_0116_01_4_00_0132_00_01int8__7f429ceaeab349f61850839f58246c62.html,sha256=vsFMrqxxAIBt6H684U0p3dRXR-H0K3bEb0iNAQdbmBc,12954 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_018_00_018_00_0116_01_4_00_0132_00_01int8__8ebae0cbdf333fddfe5c24d35ebe8e02.html,sha256=wfMwdlVbpYACAnvwPXxs3bAuctl2VcHzoR--aXhRM2U,27371 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_018_00_018_00_0116_01_4_00_0132_00_01int8__927179f46017ea5f58f859f1196c4829.html,sha256=dhkwoZgMkUSdp1h58P3NLmzob6kCyFNrfp5tE-WglS8,27237 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_018_00_018_00_0116_01_4_00_0132_00_01int8__96070083128b01fff1ff03d9341232b2.html,sha256=gvONxoCNSkWYL031sIvGpHixegj4E3cnhD3mlcKtmpI,12939 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_018_00_018_00_0116_01_4_00_0132_00_01int8__a2362f92eed5bed99180572b30aba1e8.html,sha256=YtiplUz3XMNJ6HVqw0rWkbNJSAwzM_m7OfGfOfJJ-_s,13074 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_018_00_018_00_0116_01_4_00_0132_00_01int8__f083347e265b1e9eea5572d86ddb6bf9.html,sha256=PNTpFXPymHh31w-4MWmFKLn1YOZDiT0s9Z_wvTZuYkg,27390 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_018_00_018_00_0116_01_4_00_0132_00_01uint8_303afb481b5f876ceb31af6f80d5b554.html,sha256=bQH492PPd4ofh32DFaxopFfhKJznCW7tjogTnsfqoGA,12954 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_018_00_018_00_0116_01_4_00_0132_00_01uint8_5221708cec5828d35db1d1c47cb4964e.html,sha256=_ilv7xAfhaAjTIzZM1jdFpePbZeTdLEX3s5VFkAqVuM,27275 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_018_00_018_00_0116_01_4_00_0132_00_01uint8_5f42559672a849e95863771a68af69f1.html,sha256=bhBqNULI5CfTnrj03W4TZEYDCPpcTfxfBPi5wJomTU4,13074 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_018_00_018_00_0116_01_4_00_0132_00_01uint8_6479c01385ff06e7ae8b33a11f823c98.html,sha256=YUubsE05ntMrQr-x9qqA5xtppVAp5_hqILllCbisO3k,13089 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_018_00_018_00_0116_01_4_00_0132_00_01uint8_a62aa63a212985df306fb27e8a50aeae.html,sha256=BPCbXSSclGZDsLvVs9OS-2c0yjd2yZXoxEVnoB5HisA,27256 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_018_00_018_00_0116_01_4_00_0132_00_01uint8_ab741d81fdc991345cb9e43c29fca573.html,sha256=ckwByIUlUmIt7NyARGdeDKGV7n-jpMtBdFnz5QtEn-k,27390 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_018_00_018_00_0116_01_4_00_0132_00_01uint8_ba813b2739e79cfa98433a99a00eaf46.html,sha256=Wiwt1u-GefCtwJ6RJg5VG6LDka3zcYCrLI7OJFYEk58,12969 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_018_00_018_00_0116_01_4_00_0132_00_01uint8_bef0c048bc0f8ba2d875cb7ab26d363b.html,sha256=A6Fx5Mi0reezZ4JqMCEuxw8p34tIueYLubvmeg3Tevk,27409 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_018_00_018_00_0132_01_4_00_0132_00_01int4b_0ee08a4520882d24ba9026879265e892.html,sha256=dA16gsfLgv1wFUV2esDnDUfcSDIM9ZQXEYqDMpUjVdU,30001 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_018_00_018_00_0132_01_4_00_0132_00_01int4b_3c87ec4ca9f646f0bf0bead0e5cf262c.html,sha256=0aJJVHSNrlO5u3Va-oU-c1HjPXSMPojXLBi0vW3dyMU,12984 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_018_00_018_00_0132_01_4_00_0132_00_01int4b_4746fc55e614df0016c518d3fda2677e.html,sha256=U_ksnXZWdzHeSg0o_PkJMYAl0mPSmrGKfgmF9-judFA,29884 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_018_00_018_00_0132_01_4_00_0132_00_01int4b_546e9ec6de6a5970b326da6f6280f1d4.html,sha256=equGzCwdrgbB9wcrJf4X8lBp5NdfeCK5AuGQQLQNnF8,30020 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_018_00_018_00_0132_01_4_00_0132_00_01int4b_6e513ccbc44ae7909a60d93b9b5435b3.html,sha256=JVaRQsIJpsAdb1q4FWa443XYWxMv_O8D7RKzxpe7k0o,29865 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_018_00_018_00_0132_01_4_00_0132_00_01int4b_b4842cad42fe945980d6229487761771.html,sha256=x58rVSk_lQ2wSPUnWtE44yCpd3hKQT3TI8aO-w3kpnY,12969 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_018_00_018_00_0132_01_4_00_0132_00_01int4b_ba87b3ef93a089f45a272d916916236d.html,sha256=v17hXkECfVtZbmsHq-6RD-Wn2umAc8l2QqCKslbDLbs,13089 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_018_00_018_00_0132_01_4_00_0132_00_01int4b_fb9487231025d1903fd4f0dbf859e253.html,sha256=GDPEmGW0fUszW0EPWUWfAXcwku5R0PISQAnB0i11T3U,13104 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_018_00_018_00_0132_01_4_00_0132_00_01uint4b03e3b50dbcb30d0d1ac062f3a9d5abef.html,sha256=xcaSx2scjd9jkdVRk6nOZ4LgtEzPUidnIUxDVY2I6I8,29884 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_018_00_018_00_0132_01_4_00_0132_00_01uint4b0f8247022b39cc775caff7857c35b56d.html,sha256=9PvTw1tyntzT0jCT1vQAusuehFdMbwhamglb7i2b3B4,12984 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_018_00_018_00_0132_01_4_00_0132_00_01uint4b451d5cf5d7e8cbbe476afe3dab5c09b2.html,sha256=qfBJtrrNxn2_caflQYsJqwqTtjvC859Pho6pUSOJcbc,30039 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_018_00_018_00_0132_01_4_00_0132_00_01uint4b64e22ea4b915e39f2f60a70b62dcc673.html,sha256=8PP4hXrE0CngJ-uvlz261FKq4MzJigUbqqbGSOthsI8,12999 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_018_00_018_00_0132_01_4_00_0132_00_01uint4b6d968039dde5c9f062ab15f90a8049fe.html,sha256=VBnU6cWfwIPRwkucUFJ_3gf5Ibcmo26Yzegd5EPKoQU,30020 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_018_00_018_00_0132_01_4_00_0132_00_01uint4bc4b6ba004e25c44bfd9266c61f937dfb.html,sha256=gEBsGX5HrrO1TQ-GzEX7i0aiAiALMOlOhPbY5v2BPso,29903 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_018_00_018_00_0132_01_4_00_0132_00_01uint4bc68104664ee4c0c391c6df22b1ca8bba.html,sha256=gjYYWHPEZvbpv1muz4yN4Bf86TdpqeFYNZcxUUrySmk,13104 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_018_00_018_00_0132_01_4_00_0132_00_01uint4bdd617edb43bc65ebc3f680e48fe9a1d5.html,sha256=f9jt7ZqSY2mj-xfVG_D7tJSVMz8YdcHrZj9KyidQbFA,13119 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_018_00_018_00_014_01_4_00_018_00_01half__t_1bb2e5f77f790852abba777515da1b98.html,sha256=IHYcw5JMlyWviCwhCOukZrj1d9OmCqSBuY1WSawZ6QE,12992 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_018_00_018_00_014_01_4_00_018_00_01half__t_2d559ae99ed058d77e22f2d26b3dd474.html,sha256=fHDowd4e-50Na0CuMgLnel594la0ifxxWoGucVbH2Uc,12947 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_018_00_018_00_014_01_4_00_018_00_01half__t_31defda8ea2b7d855642ffd77da1a411.html,sha256=AIeoJaQAnbn1XKiRF0Vj0YwSsBZy16xIigjxxzrCWOE,29684 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_018_00_018_00_014_01_4_00_018_00_01half__t_44a3b2a8df88a2b067f1284515cb5371.html,sha256=5puUZuTo6KkwrK10znHXfFECAVJlXQEel6WW3kU1ecw,28983 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_018_00_018_00_014_01_4_00_018_00_01half__t_4b7308177b308a272c1889fbe9670275.html,sha256=9BgXeoglhuAxkqTdXEnM7dxEENCCJO7pBBxGTEI78To,29684 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_018_00_018_00_014_01_4_00_018_00_01half__t_5a9888862cebd333ecaf11f7262f77d4.html,sha256=KlN9i-D-him18FNLZ7rnGtNnJz1LemXn8hgECxFKuBc,28983 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_018_00_018_00_014_01_4_00_018_00_01half__t_5a993f7e52584c39076147af4505c439.html,sha256=QzFwpmNo6BBitEAediMReoXMUNHVTDPiZKRflQrHysg,12947 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_018_00_018_00_014_01_4_00_018_00_01half__t_73d9802d6b944a5299bc255887db6bbc.html,sha256=WCZXeWgQRYfRDbEdG8fgCk95x1B2VrHzXm1r1e-Zewg,29591 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_018_00_018_00_014_01_4_00_018_00_01half__t_7dfde6c9b18b9888b3900080f3bee151.html,sha256=bErgjFFEow4abVcngYh9K-5XQV9HxnSpp0RMuzAvz9E,12887 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_018_00_018_00_014_01_4_00_018_00_01half__t_839a7c8bb938d1661f4611e68f85d8cb.html,sha256=ia8ncqPK78XqX6LG3ZyeChXJG0o6nz4eB4gEVEv4-oA,28890 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_018_00_018_00_014_01_4_00_018_00_01half__t_8c75b568d2509e87b439a0eecc9b1656.html,sha256=UDjuVRS-2Ogz3l9CpuIHgd2B9PtWFt77tx5-CzLG-ak,12932 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_018_00_018_00_014_01_4_00_018_00_01half__t_a8a8547a07d55daa1da249db3ae19c34.html,sha256=KzgYyxy_LlThdgHGQJOmS174dH3gLmu-FGQ_GWP2qhY,12902 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_018_00_018_00_014_01_4_00_018_00_01half__t_b0242d7a01097510effbc4718040d3e5.html,sha256=Hi_OfS9mOaMAA7h7PWG4E41ikP9-9S18ltewEki9seo,29076 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_018_00_018_00_014_01_4_00_018_00_01half__t_c7f88bfd32a544fba8111d2dcadeab11.html,sha256=7wONMWLZf6GVz4s7y34bSERuSeGfNU4U0tyXqUZGYMM,29777 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_018_00_018_00_014_01_4_00_018_00_01half__t_dcd30e5a5680a0a5c8cff2896111c9eb.html,sha256=X29lw39Ls2Uh3BvHg7T4wkzDnfXHn8breb5JiwOj6A4,12932 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Mma_3_01gemm_1_1GemmShape_3_018_00_018_00_014_01_4_00_018_00_01half__t_fed5cb7f8411f56c4d17a6d4d9ab09cc.html,sha256=QzZZ07mYyZPyflksoaUrfeMa8YqmctbF9f6XglkxxR8,12977 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1PtxWmma.html,sha256=7RPA3IRZevA_Hoa76J4SaJiQusTaCyLY8_wmj2PbuBo,5185 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1PtxWmmaLoadA.html,sha256=AbnkEFdoO9SSB5E0rY5sQHL_dad9yMIC2wmHvr8A3kc,5577 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1PtxWmmaLoadB.html,sha256=bSyNGg02m2aCGeORqUZAV-ffqNmXbmT8Q475n3gqpsE,5066 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1PtxWmmaLoadC.html,sha256=WrdO_4Iz1vgJ5jYwtQSwb0Fc0NH9w5MI85lPVAgdg_4,5066 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1PtxWmmaStoreD.html,sha256=vUmlP-wiKXMIEoyEKqU-nd13krPYeYuCJV5xojUOARs,5106 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Sm50-members.html,sha256=njCuaFZihRj2Z_Lnnshu0GIbEPs0iTuf_aBoDPkx5rI,5162 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Sm50.html,sha256=zjc5OOLcuR-hFdmarlzFwgJO88j_bIPY--LMyevMBTE,6225 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Sm60-members.html,sha256=SVMkNFgGsdnLZRk4VH8-yLlxoaU8RqT9HDQaDXkmRWE,5162 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Sm60.html,sha256=liPKYkaXKMg9daJrMj6-TinH4Kt2_U8-ndlLVR95Ttk,6225 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Sm61-members.html,sha256=e4V-0DhO1bS39-0N2xlN99kKSIb9MGkr9xtSzWlajMY,5162 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Sm61.html,sha256=lpnUFRgKziCr49dTKZ3FBxml7C3IK7fm0VlESJjPckk,6225 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Sm70-members.html,sha256=dW51aaaDg64_TZR1J6XYn7BdZKXNU4QD4iQNmylVNIM,5162 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Sm70.html,sha256=AhmAHZWhUPBBKQSIpk4fo0oiBFUKg4eFgY5vcAj0blU,6225 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Sm72-members.html,sha256=t4mQuJwkfS3P0XMUupRlm8hmGfJg3m-5UJ75t2N9GGE,5162 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Sm72.html,sha256=SJc28ybdvTBXv-CG3XZDt5SAnZrddETN7SAyLOLhM_8,6225 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Sm75-members.html,sha256=3FyG_DVvaxMBgymJlviTjSL20BA7WdiIT4WDToJtDF0,5162 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Sm75.html,sha256=a40FFhXVtt26jyMrjt-pHPN-h6I2MEvJGzA14Ng8-mE,6225 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Wmma_3_01Shape___00_01cutlass_1_1half__t_00_01LayoutA___00_01cutlass_1_84e30c8cc93eeb7ca02f651bd16d4c38.html,sha256=_73FL_qLu5Rw1qAHtEO0OL80NuQkN4fpQZj1MnfPNwQ,5414 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Wmma_3_01Shape___00_01cutlass_1_1int4b__t_00_01LayoutA___00_01cutlass_16fd808a90b3cf9d7cfc99f30888ca3fe.html,sha256=CYdjvAgrMXIFmkXBoxhYx2VoPo9MeXF2Q-lzzsl-4Qs,5414 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Wmma_3_01Shape___00_01cutlass_1_1uint1b__t_00_01LayoutA___00_01cutlass_c80a7ea4d219cd9b13b560b493338028.html,sha256=1Uvt1lgppBDpv_SMKHuks0GPHzV2WHdto_igtr8loeQ,5408 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Wmma_3_01Shape___00_01int8__t_00_01LayoutA___00_01int8__t_00_01LayoutB_505c57bb6818a941dc16f00cf35a9ec0.html,sha256=oov4WaALauHecIxzqEl-RIpTcbgMJWSyF0Cb7feNdS8,5354 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1arch_1_1Wmma_3_01Shape___00_01uint8__t_00_01LayoutA___00_01uint8__t_00_01Layout219a464a1248ebfc37aa29bcb10cb1b0.html,sha256=OTuYIUIIP17-xvLBmZXymLFpoC1i3WpKUCyQn42cpLM,5360 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1device__memory_1_1allocation-members.html,sha256=PI3O-Uf-fvPhO-KlYAAXjDfRAbmCatLuIMuMsFROvTM,10070 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1device__memory_1_1allocation.html,sha256=gGhrmR1x6lrvf9zhVchGFCKciUHbOjKgnGuvDsotYtA,28033 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1device__memory_1_1allocation_1_1deleter-members.html,sha256=8NlYVXdbufO_UX-mFO-nzuYtQSyPyz2TA3_iNQ04TcM,5505 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1device__memory_1_1allocation_1_1deleter.html,sha256=3vt0_0nf9wqyFurqjPOS2UcQrcmhyzvVXwd7rpJDtn4,6865 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1device__memory_1_1allocation__coll__graph.md5,sha256=Pg5FfKSGoGCzfu4IzOr3ncBnLpaV4XJAjCnVyd7AXJs,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1divide__assert-members.html,sha256=qMlx83ORuTI6B6PxIZKKwnpMWNA9aYuWA2fHpHdifhA,5179 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1divide__assert.html,sha256=3Fi9V7gkxQ0NrV1jutemQDlRWyhixbogzTdY1Fd6uf8,6689 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1divides-members.html,sha256=JSLzjXQdPnnpvWVdTAXp-Q3TGXAEwvwROOUswu_W708,5106 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1divides.html,sha256=kmmGK5iK7uwL5JEpVbAQFqhm-VwCIX3QkwY4WqDkJwc,6885 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1divides_3_01Array_3_01T_00_01N_01_4_01_4-members.html,sha256=G_C5-0wE0cuJhrrg5fUvrc2zF3nGxULv-AFfLMmd_Pc,6269 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1divides_3_01Array_3_01T_00_01N_01_4_01_4.html,sha256=eQZ8SzPoBM2KFYrRoEe_inkDUyw-YAD-g82zzXmHCEw,10754 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1divides_3_01Array_3_01half__t_00_01N_01_4_01_4-members.html,sha256=Ug3hlWAha9TPd0pHzZDqTB67lHtKopTBrkjf0_TZp9c,6371 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1divides_3_01Array_3_01half__t_00_01N_01_4_01_4.html,sha256=zvCTeM2yNbEvMMS1rP5baD06bznoR7a8AHkJzN_sXyw,12008 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1EpilogueWorkspace_1_1Params-members.html,sha256=Hvmtf1biCNhdoz7hkd9DU6MJAb2Opt3Uwums4QFPoU0,6772 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1EpilogueWorkspace_1_1Params.html,sha256=iliTYtiNSBN1W7haswgFKkrCGx66ZW7gk0vJelczxyA,12478 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1EpilogueWorkspace_1_1SharedStorage.html,sha256=9ZxDobLvTT726-aN0bXFaYgzi-W5Oyp06dIrJO9x2uI,5342 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1thread_1_1Convert_1_1Params-members.html,sha256=Rps4Q9cSUOnzWvnC0F3SYZQchEtV30G_h2trVUZ27mU,5721 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1thread_1_1Convert_1_1Params.html,sha256=rrl6Q5DZqdKt9CRit6Csx2ZG8Ly0m0OKEJmsZt7bNeU,7345 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1thread_1_1LinearCombinationClamp_1_1Params-members.html,sha256=ZzKDHYhBzXgSHZnSj2sA_0oNFPzXHoJHafCYcAWiggw,8872 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1thread_1_1LinearCombinationClamp_1_1Params.html,sha256=aR4PgWj17uT58QaBiPj8BtsQ5tyiHfkNa9ittmcq5vg,20092 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1thread_1_1LinearCombinationRelu_1_1Params-members.html,sha256=PO_AvoTbKXRu-6a0B_yw7IImUJthC__3DE7F0HC4Ca0,9391 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1thread_1_1LinearCombinationRelu_1_1Params.html,sha256=dqibBlZfPYHz-1sMFst8DVNN27vLK4s2BP4Ze7nkzqg,23482 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1thread_1_1LinearCombinationRelu_3_01ElementOutput___00_01Count_00_00274a94522c46cd041d0b10d484e2ef3.html,sha256=NmQWemGI4WMl0IJ6xjTt7CFqr5foffzzPpxBw9QL1LM,24977 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1thread_1_1LinearCombinationRelu_3_01ElementOutput___00_01Count_00_0e626b08ab2558da5b9459d2466940481.html,sha256=sGynQhekhEDYnRCEpHeFn9838zoKxO_wxhdGf1CEjHc,10292 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1thread_1_1LinearCombination_1_1Params-members.html,sha256=NSiSVXStR2ht1amW0G2kaNsKEVgH0QJW0T6f2cCgIys,8737 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1thread_1_1LinearCombination_1_1Params.html,sha256=lN2gmzPdxulbb4-RYOKZn0vfTX4Uv03tWRFuvl65_WQ,19831 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1thread_1_1ReductionOpPlus_1_1Params.html,sha256=Vo1jaTaOWpO32QCEqDvpGzCHUggTJy-7V7VYEMFB20Q,5379 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1threadblock_1_1DefaultEpilogueComplexTensorOp-members.html,sha256=45K1KSKAdpB7bCldTjwOD1jX7r_bMMT_vrFCV462DRA,12759 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1threadblock_1_1DefaultEpilogueComplexTensorOp.html,sha256=0QNnjsZ6qK8tMcZfCKj94cveUUAzAOBAOZh6Bs3_Y2M,34412 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1threadblock_1_1DefaultEpilogueSimt-members.html,sha256=EigVV6tehijAAFL_0mO8rcZc7nz2UvR41L_dhBbFSuI,11916 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1threadblock_1_1DefaultEpilogueSimt.html,sha256=FGqcIeY-ilDYfSFI5vBAVfrKLs9z0sKf2fZW9LLmouU,32103 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1threadblock_1_1DefaultEpilogueTensorOp-members.html,sha256=7wTYx4dsW-5rsXAx-E8QyKpVDSZ2FjQYhc8ehlgaYIY,12409 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1threadblock_1_1DefaultEpilogueTensorOp.html,sha256=df3PLn36oVq24isRZt4rm4x-AlDryXQeNa6a54Cq7nQ,34130 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1threadblock_1_1DefaultEpilogueVoltaTensorOp-members.html,sha256=UEF8M724KjiUsdXsP0zNLWT5jIgVFfVGHmj2bmb1RiE,13170 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1threadblock_1_1DefaultEpilogueVoltaTensorOp.html,sha256=ZY4xhc-ec78rER9_E20XSt4LFRx1N3r0rzRt7EQEFDk,36933 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1threadblock_1_1DefaultEpilogueWmmaTensorOp-members.html,sha256=OUC_1EjRn51YgzmjTnL4as_KuzVxbjHs7Hb2n1fooLE,12609 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1threadblock_1_1DefaultEpilogueWmmaTensorOp.html,sha256=9vE9fzFmS-W0aDqlG2hN4-naEw186pTZAv5s5UnH9Ic,33906 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1threadblock_1_1DefaultInterleavedEpilogueTensorOp-members.html,sha256=INj0dX1AW9l-YEaeLUAm02n--B6jeran4KiDbDc68S0,11944 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1threadblock_1_1DefaultInterleavedEpilogueTensorOp.html,sha256=HSpgCvPdffLwGpYuOLbHFXPa6Gb4yQy0pMCOVq3APtU,29883 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1threadblock_1_1DefaultInterleavedThreadMapTensorOp-members.html,sha256=FW_gHrtYdNoDoS5I5f501hjT8VHg18D8Eamq2ckrhp8,9119 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1threadblock_1_1DefaultInterleavedThreadMapTensorOp.html,sha256=iWzcJEqpUSQz8n5F2NQj5AncYjtGp1szRb9rvaiv5qs,19366 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1threadblock_1_1DefaultInterleavedThreadMapTensorOp_1_1Detail-members.html,sha256=Wsz_dp-9CyqVbyxwbIfIwC_AGhA9l8644rUuQgEuwAs,7827 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1threadblock_1_1DefaultInterleavedThreadMapTensorOp_1_1Detail.html,sha256=a6rMrDSNhwJPFojzZvY4KUDLYxT-W7cy-zDWVB7ZI64,13743 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1threadblock_1_1DefaultThreadMapSimt-members.html,sha256=bmKsLKMR69kb5dkEAOGSlVkuZSHKWFPzL1t2KxrN-Jw,8721 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1threadblock_1_1DefaultThreadMapSimt.html,sha256=ntrvYa3kMNQVUwAEAtpYOTiGbEp95IRHIiLPqlPZGXI,19116 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1threadblock_1_1DefaultThreadMapSimt_1_1Detail-members.html,sha256=-vb-h58t2e41xS4HfvNA6JJePesAQnrxfQWVpP8ejM4,8107 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1threadblock_1_1DefaultThreadMapSimt_1_1Detail.html,sha256=8UuzdpvpDHqJAhkxWVXSOij2lzX_iLq9xrhf06lkwqY,15553 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1threadblock_1_1DefaultThreadMapTensorOp-members.html,sha256=whMagV7s2ydr7gsp59AOKcemQLAy6noIGofx7H9GVRk,8197 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1threadblock_1_1DefaultThreadMapTensorOp.html,sha256=pD9fcJ2ojVqz5LTafjz3cnCV_qxjoJBM5jzCXg6dROg,17989 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1threadblock_1_1DefaultThreadMapTensorOp_1_1Detail-members.html,sha256=DXRoKvaiM_bxnp1FyqL3PYadO9PvEXZwq-p1AFEfNNg,7545 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1threadblock_1_1DefaultThreadMapTensorOp_1_1Detail.html,sha256=Xwz_MD4ZZaEh2Uj5YYHHZSbxsYbU4JxwfvVd50gZ0m8,13336 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1threadblock_1_1DefaultThreadMapVoltaTensorOp.html,sha256=Tz0xQ6jR-LnXtiTCtUqYNpmwOJRK5JYA0lBV17qJD7M,5615 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1threadblock_1_1DefaultThreadMapVoltaTensorOp_3_01ThreadblockShape__364315d2ac90dbb16106f0356bdbccd6.html,sha256=cRPLggw38w8L6a4K6DWIJ3L-4qAWkNtBo5fanrQ5e6U,10204 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1threadblock_1_1DefaultThreadMapVoltaTensorOp_3_01ThreadblockShape__4433cc988100e98097a748d2670fb0fc.html,sha256=5MKhDqW52NeOz4SkNZSp1oJ_MjEdWZVNQxesV4hlHno,20185 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1threadblock_1_1DefaultThreadMapVoltaTensorOp_3_01ThreadblockShape__52116c60c62f0fd520071558e42b814f.html,sha256=qLJp-Enzb_4ykbJNMPra5u9kK5yUOnlBJ8VjureKCYw,19790 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1threadblock_1_1DefaultThreadMapVoltaTensorOp_3_01ThreadblockShape__955da2dc7e407f84277f5d1f97180cdf.html,sha256=_WOWG71IdsqNNlb2sqA-m14TDOfyCLU5WtEKiyKl8Tg,9913 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1threadblock_1_1DefaultThreadMapVoltaTensorOp_3_01ThreadblockShape__95db04b7b72e34283958bd7fbf851d16.html,sha256=Jm_RnNKjnvvh81_CoHiSG_7gDVU8T3mbZMuncVZvwY0,19911 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1threadblock_1_1DefaultThreadMapVoltaTensorOp_3_01ThreadblockShape__d293d298f2a882a1f0cd746a16f0e9e0.html,sha256=9NZigxGai__X5zUf0lRqB6XPll2D350pIIjWkznYnTo,10214 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1threadblock_1_1DefaultThreadMapVoltaTensorOp_3_01ThreadblockShape__d3d67c61c92960b2b5d6f66acb83afd8.html,sha256=BiDyUFfskUBUWXNiomMfVh2p7eo7xgviYCb0yabZ50E,9923 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1threadblock_1_1DefaultThreadMapVoltaTensorOp_3_01ThreadblockShape__d58c94abc36b7c5c109b55202c6992e7.html,sha256=NSQOR5iQSnDFcIMO1EYsb_WAMC503iMCqxOr_1VZgzM,20418 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1threadblock_1_1DefaultThreadMapWmmaTensorOp-members.html,sha256=fJjTFJ3sOzurANSFpVqZkqtYkAW4kPwG_lA_ajA7qFU,8959 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1threadblock_1_1DefaultThreadMapWmmaTensorOp.html,sha256=OKm9SELGTq3Zj6hAyN_Absmz5y6h5XPpaGDD8OHSBKQ,19848 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1threadblock_1_1DefaultThreadMapWmmaTensorOp_1_1Detail-members.html,sha256=f0HIfdvkZNOz3LHZZSFee3n5cjvmehyzhQYOyciOLf0,7731 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1threadblock_1_1DefaultThreadMapWmmaTensorOp_1_1Detail.html,sha256=fk3ogSugO13ROt4ygdc01o6ugMHPrSvBNsVOi06wAqg,13742 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1threadblock_1_1DirectEpilogueTensorOp_1_1Params-members.html,sha256=S-s_skaSdXkfmp295G5UTQVBXTSw4b52yvlydfJucaw,8594 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1threadblock_1_1DirectEpilogueTensorOp_1_1Params.html,sha256=V-Ng5pcAP4f7VX3LDtxcK3Wrl-KBG27pHeBaQmCpv9c,17790 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1threadblock_1_1DirectEpilogueTensorOp_1_1SharedStorage.html,sha256=VUmOp47IIMulI_LDywpqI7-vFyzZWhU1-HXOluHAtP4,5633 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1threadblock_1_1EpilogueBase_1_1SharedStorage-members.html,sha256=qTCJ5G-h2bsxTZmw2bQthfi0ZLQjdWdGHJBJSI5ro1w,10145 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1threadblock_1_1EpilogueBase_1_1SharedStorage.html,sha256=XdrgyYbZXeWyZtvMDMDrM7cC_jDbGlx0tHiOuoGC2MY,24430 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1threadblock_1_1EpilogueBase_1_1SharedStorage__coll__graph.md5,sha256=QDc5rKdiEbgxipWgETlemaBQB_8Cn0pOIL_vl9CECwk,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1threadblock_1_1InterleavedEpilogue_1_1SharedStorage.html,sha256=LInXd8lLlVJHSgzOGqLLF5a-lw3Te0k2LlhNKRJfNN0,5718 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1threadblock_1_1InterleavedOutputTileThreadMap-members.html,sha256=XMWHqe8pa5gZG_4UkOhhimgd0prQnF3PFr4Gpa8umP4,10348 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1threadblock_1_1InterleavedOutputTileThreadMap.html,sha256=TdmJfFQkDH3IKMJydgOxuQ_TpggRIAir64hT5MF5OlQ,22963 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1threadblock_1_1InterleavedOutputTileThreadMap_1_1Detail.html,sha256=jfSLJi4fUrLEwOeGp_tfI0tRhk-iMvesjb0fw7BP4r0,5571 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1threadblock_1_1InterleavedPredicatedTileIterator_1_1Mask-members.html,sha256=LKPA2JrvPeGMnd4_tE_NOwaFrkjEaARJeXUR5v7kTW8,7949 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1threadblock_1_1InterleavedPredicatedTileIterator_1_1Mask.html,sha256=3322VFNVNNtZEPXDzkiV5iX8S7h3LT8BwZ2HtDBdc74,14681 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1threadblock_1_1InterleavedPredicatedTileIterator_1_1Params-members.html,sha256=NaerszANcR1CY7k4hgIxsxOkJXZawQLHvlraouBz4Lk,8482 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1threadblock_1_1InterleavedPredicatedTileIterator_1_1Params.html,sha256=9JF3dfi8pkS_puvQ2g_dVOYnKe1lcU3n7XyS4FOevrg,16497 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1threadblock_1_1OutputTileOptimalThreadMap-members.html,sha256=OFiBf99iD43yJAdnXFSdOpUzxg82-3uD7D9cDjIWrdc,10117 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1threadblock_1_1OutputTileOptimalThreadMap.html,sha256=NH4uqNKhTWWuLWIh_K0yHOt4QApZGOtbaQhBB1fnFvo,24161 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1threadblock_1_1OutputTileOptimalThreadMap_1_1CompactedThreadMap-members.html,sha256=y8oxOZezdw9BTf6VCjCWwGEezK-UhdR9S3AnZNidNME,8797 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1threadblock_1_1OutputTileOptimalThreadMap_1_1CompactedThreadMap.html,sha256=xV9L_ao3mwxGjm6GAVMZ3fekhu5uBTS8tJVQtO4QWao,17834 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1threadblock_1_1OutputTileOptimalThreadMap_1_1Detail-members.html,sha256=ba5r9yzcxMvgsumB9GMtpJJKwRlCPxr09m9oat8N68M,12744 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1threadblock_1_1OutputTileOptimalThreadMap_1_1Detail.html,sha256=iaLgjwb-ge2wumgJuPPwSZxvMqDzbLLhPQu5scKitLY,33044 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1threadblock_1_1OutputTileShape-members.html,sha256=MXEEUZUvQn4WNjjVmWcRei5LNV57DV3FSIl82asO6u0,7760 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1threadblock_1_1OutputTileShape.html,sha256=4JqC35jV4oi8xDeE_otTe7PKNlmUgVuLgySGYc2_8uM,14194 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1threadblock_1_1OutputTileThreadMap-members.html,sha256=-pydgGsDsBkIY3HtQCnnqXJor3nF55axIi0HIRyZdio,8825 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1threadblock_1_1OutputTileThreadMap.html,sha256=0qXsOolg8DgVfqilhF_PebTTbDR74NBZc4DKgf85V_w,18420 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1threadblock_1_1PredicatedTileIterator_1_1Mask-members.html,sha256=1J6Hv-GvAVklscqoAPSJ5xeJL6M_60XTuH8xo9SdKY4,7620 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1threadblock_1_1PredicatedTileIterator_1_1Mask.html,sha256=CGPlDppTVgyFzvcxNPiszYSVdDqHPoTtJXA6T21n1cA,14005 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1threadblock_1_1PredicatedTileIterator_1_1Params-members.html,sha256=-wMiUDVqNz-Au1GZqeG7jWjMpmnYKhNChQh4TzLobc4,10321 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1threadblock_1_1PredicatedTileIterator_1_1Params.html,sha256=MdWU7Xww3WHQVO_jFXmxJMTN3nWdNVCJbp5yCcKKUuk,23400 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1threadblock_1_1detail_1_1RowArrangement.html,sha256=jtRgE6qa2beWEw_AtNVGHCYrFnjN4glhj5Rf3cN3aTc,5793 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1threadblock_1_1detail_1_1RowArrangement_3_01Shape_00_01WarpsRemaini6d8790249bf12cac580da73bb37eb791.html,sha256=Tp5ZbKWcLROTl_sk1-ItBDJ2FPB5_GXWUeYffibWw_U,29554 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1threadblock_1_1detail_1_1RowArrangement_3_01Shape_00_01WarpsRemaini91159e6f7e123d881e3ec45101fa4f81.html,sha256=488P1VoW3ZJdVcKUBAXeyCVDfBXGlEDPI6qg4m26Lys,23133 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1threadblock_1_1detail_1_1RowArrangement_3_01Shape_00_01WarpsRemaini9e2f7c245df80a4cc90efa6b3b50b22b.html,sha256=aiwKaw_lmebceueDWN0URu2WlaOeZJWEhoFYyPZROA4,12293 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1threadblock_1_1detail_1_1RowArrangement_3_01Shape_00_01WarpsRemainid5663e27f30dce1ea91bc27cfb40da6c.html,sha256=MCc2_6k8FtSZaSuwBcfFlqmVURNIyQMiw5do0wElm-8,8243 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1threadblock_1_1detail_1_1RowArrangement_3_01Shape_00_01WarpsRemainief28e98b3f284469f271d28aba73de2e.html,sha256=CKo94LWCOSiCyTdYvAo3uYQWPBjGtfsL7x2XtlADyE8,13749 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1threadblock_1_1detail_1_1RowArrangement_3_01Shape_00_01WarpsRemainifad5d578e4fccf2388350bc6b13bdf45.html,sha256=vWWJ_QDwFYM4PWm_sxlqJQmCUHct304yw73_8OcEa38,12886 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1warp_1_1SimtPolicy.html,sha256=RI2Q9JcCPKM9Dl3iqOLhgZordZItXAxdu_kOC6iEzFY,5224 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1warp_1_1SimtPolicy_3_01WarpShape___00_01Operator___00_01layout_1_1R7b839f068e1800884229b9f957f8e289.html,sha256=OxFsWxiLonbV5fmY8lqf89f9yKvEmmjcxRdq8zPIFe8,10607 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1warp_1_1SimtPolicy_3_01WarpShape___00_01Operator___00_01layout_1_1Rcef1c60e23e997017ae176c92931151d.html,sha256=cax6lNVGuqdw8Sdc-mtslSjgVcok5homl9PshE-7My4,21670 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1warp_1_1TensorOpPolicy.html,sha256=-cGnphCOvc_GML6ed7m6cPBT57WD6VBJa2LcVVWc8gc,5293 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1warp_1_1TensorOpPolicy_3_01WarpShape_00_01OperatorShape_00_01layout69549d10c3610d943987eb90e827bc05.html,sha256=nKIdbIvF8ejRpBKsCVvNdj8dpK7pbGFzCOZspuwM2mg,14523 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1warp_1_1TensorOpPolicy_3_01WarpShape_00_01OperatorShape_00_01layout78cabdb5254892450f7768363889ab34.html,sha256=TpKSJjRoOawz-JGtvBnpta4jRHd-gCtA9kFDx_5qiIM,8523 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1warp_1_1TensorOpPolicy_3_01WarpShape_00_01OperatorShape_00_01layout_1_1RowMajor_01_4-members.html,sha256=RxRiWDqKaYa8nEBh3JUaj3YXRyIE25ADt214xWBsCI4,9169 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1warp_1_1TensorOpPolicy_3_01WarpShape_00_01OperatorShape_00_01layout_1_1RowMajor_01_4.html,sha256=xzXjTUHkYSH-Xj6X9Qh7PIQ_EG_lKlVN-KiQHA2z6xs,17863 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1warp_1_1TileIteratorTensorOp_3_01WarpShape___00_01OperatorShape___05f11e023c9e6ee5f7a888fa4c5bbf6d1.html,sha256=yEwooToDBOpQaXSVqjEOojKqIRDxpC3Pf7MjyHED0vI,7512 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1warp_1_1TileIteratorTensorOp_3_01WarpShape___00_01OperatorShape___0c7c94d937906add757265a8e71852661.html,sha256=o_ppSdsuzGJaafMS2iKzgcuVejnjDWKrixoiaZtP_uQ,6217 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1warp_1_1TileIteratorVoltaTensorOp.html,sha256=xgJkT6hM-sEetQSQlJdyRDbkuHxDwoR1IGq2gSU6YGk,5460 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1warp_1_1TileIteratorVoltaTensorOp_3_01WarpShape___00_01gemm_1_1Gemm747fcabce4f700e79b702276a148156b.html,sha256=jXmoXKatsHbTdUNdLLNWUu-lwARHPkWRnIMLnHMYXa0,8814 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1warp_1_1TileIteratorVoltaTensorOp_3_01WarpShape___00_01gemm_1_1Gemm7500b0164b0b2d2b2a5293c157708b4b.html,sha256=P6EmVPsU3k22u_ARAGV6UF36Bc6cje_yKOlU00Sl37g,8822 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1warp_1_1TileIteratorVoltaTensorOp_3_01WarpShape___00_01gemm_1_1Gemm770cbca45441d295d5d7433e8222a700.html,sha256=skNdiTSOo6BrhKcqFX-H50SP1vLq07Yz31_tiSFK4uA,13763 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1warp_1_1TileIteratorVoltaTensorOp_3_01WarpShape___00_01gemm_1_1Gemmffcab2297c8de8d0013602a39c525b78.html,sha256=tYv_HPTKZTCj_Te_P8jHxfDP9dTYah2sAn3iDDWTo98,14046 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1warp_1_1VoltaTensorOpPolicy.html,sha256=SJ5mUezVtSvcjN-P5d69GTRrepEK2xHKnk6mD5xdyF8,5373 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1warp_1_1VoltaTensorOpPolicy_3_01WarpShape___00_01gemm_1_1GemmShape_017a2f40ef0604c52d3326997deaf4c6.html,sha256=dWypwuP-QAYwZtWMjUB5VusyLJtjOm7sYAF3c0KOsAU,14988 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1warp_1_1VoltaTensorOpPolicy_3_01WarpShape___00_01gemm_1_1GemmShape_136ce744d4c1c6e8707f5a9785196194.html,sha256=zcnpgpIzmlU3W5PmJI3wtEXU82aVApaMxjleyjw4xzA,35725 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1warp_1_1VoltaTensorOpPolicy_3_01WarpShape___00_01gemm_1_1GemmShape_1d48185f49e4d066f8e9327bf0856b7f.html,sha256=D95U4DoJIKsW2x8gLtlciu_OtESdBUDyDwvq-ye31co,35033 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1epilogue_1_1warp_1_1VoltaTensorOpPolicy_3_01WarpShape___00_01gemm_1_1GemmShape_4f8b41ecfdcf1ad5435c532fcfac762d.html,sha256=x8sbk7AhXG3DB3WrXRiwTQeh8A5oqb5IhQrW0jcka5U,14399 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1BatchedGemmCoord-members.html,sha256=TraSGTUjum1ZpPT8G59EWYsSJkM6KOT9shMtcugYpz4,25364 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1BatchedGemmCoord.html,sha256=gxqYRLfOg6_RK64gl3Ribfez__19xFr8OyYaRjeLdZY,85256 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1BatchedGemmCoord__coll__graph.md5,sha256=XzGOGvvXLNxTHY2HMOChzdyej_5-EY8xiNzv3eXgk1U,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1BatchedGemmCoord__inherit__graph.md5,sha256=XzGOGvvXLNxTHY2HMOChzdyej_5-EY8xiNzv3eXgk1U,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1GemmCoord-members.html,sha256=acZMPD739kGHamDzLpXYRJoNCe5topgLowaKZ8BG1UE,25711 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1GemmCoord.html,sha256=w-FEWhKXXb3WZ86vPDPYEVa4pN2az8O8vNdvyz02ap8,88962 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1GemmCoord__coll__graph.md5,sha256=ponziRM7vfToxO7rEioEVbawWXcTIxyTA320Yif79EU,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1GemmCoord__inherit__graph.md5,sha256=ponziRM7vfToxO7rEioEVbawWXcTIxyTA320Yif79EU,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1GemmShape-members.html,sha256=Seq9s7SiH4zGyRgkZPHs5nF-Eg7tg0sfni4JvfDVq14,7912 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1GemmShape.html,sha256=1G0lyt4wzKqhvL-kp-5AXx4mq75l26kG8WKeZhGqzS0,16258 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1device_1_1DefaultGemmConfiguration.html,sha256=hrkA0k2YmCLxPd1XxA3Po3P5Lp7ec_je8nRx96CosUc,5388 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1device_1_1DefaultGemmConfiguration_3_01arch_1_1OpClassSimt_00_01ArchTag286687c5e6abe22d241f789fe344a465.html,sha256=_DsBptvxkD-jJNrGtbWLs8mt-GWB9nNqKwCY3XlKZiE,18026 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1device_1_1DefaultGemmConfiguration_3_01arch_1_1OpClassSimt_00_01ArchTag3026e48abb8c905d1cc6d13d669700e4.html,sha256=WcoYnvBTlwOe6mqvI0vv6wl6qo7jXTa-Vtrxac0o_pE,17277 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1device_1_1DefaultGemmConfiguration_3_01arch_1_1OpClassSimt_00_01ArchTag60e462f4dabbff3b40f34af77a1d77d0.html,sha256=uDn2qTh9LFVyRkbVxpB-lwdSBv56FUCXh7bbfjBTGog,10119 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1device_1_1DefaultGemmConfiguration_3_01arch_1_1OpClassSimt_00_01ArchTagb4e575c8d29a260d1cbc7b03daaa7ad0.html,sha256=AcdxTvfI62uxznI2VdimwvJRaCMm7lpuKllCqb6a_ZU,10284 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1device_1_1DefaultGemmConfiguration_3_01arch_1_1OpClassTensorOp_00_01arc01dd6530520353d132c882fddd6320f9.html,sha256=xnVe52barMeETRLASWfpPhMARfe5QZiNOMtRfym2yAo,10207 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1device_1_1DefaultGemmConfiguration_3_01arch_1_1OpClassTensorOp_00_01arc3d01cda73224ab5ff3cc0fc61ead1cb9.html,sha256=wkd2KZTjO7kXBIJrYgP_-PkRkZLvIryOhiUNYJcd0g0,10361 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1device_1_1DefaultGemmConfiguration_3_01arch_1_1OpClassTensorOp_00_01arc485a4f0b5a7d2d4ab2c1a24da6328048.html,sha256=5CRdwCGlTSG8zR3T-uS-CGBIjXrd7tCWHv2sqyWEVdw,19935 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1device_1_1DefaultGemmConfiguration_3_01arch_1_1OpClassTensorOp_00_01arc4fada4957d463c80a2831e47f28157c4.html,sha256=uG60fVA65a6ESVET7Ny28oYBXxVi0xhXhlIyuHZrYA4,18285 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1device_1_1DefaultGemmConfiguration_3_01arch_1_1OpClassTensorOp_00_01arc567cad318a31d04b70ea615d6321decd.html,sha256=26mto2SWx68yxn3hYFZjoW30O9MNcxh_klRiyPqik-g,19033 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1device_1_1DefaultGemmConfiguration_3_01arch_1_1OpClassTensorOp_00_01arc5753ee9bd900740e1710b6d6a296e40e.html,sha256=7ugXExyPPQ3adYmmYISYjXxzhwZvLz4fzG0Ihd3HpEY,10207 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1device_1_1DefaultGemmConfiguration_3_01arch_1_1OpClassTensorOp_00_01arc59c58017beb945eede0abb1aa581b62a.html,sha256=uWOen6LBwab-NTVFNHi0gjnMQTUyD5KCpCqd5V5DzEY,10196 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1device_1_1DefaultGemmConfiguration_3_01arch_1_1OpClassTensorOp_00_01arc7291f9c01fb5d713dd4b081092756e21.html,sha256=jEcvDddo1reBFxeEHQ5o1x80ohjymH2NPIj8ZGDGepc,10229 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1device_1_1DefaultGemmConfiguration_3_01arch_1_1OpClassTensorOp_00_01arc7fd102a00f059761cd539b832b0ca84b.html,sha256=3YWqINzp-Nuc6sWqbZcUo_itRM52Z8Rzcz5olsTgmcM,10240 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1device_1_1DefaultGemmConfiguration_3_01arch_1_1OpClassTensorOp_00_01arc8ab5fd2693c6a6ec43e447acb07f784c.html,sha256=5cPnx351AHBG1g4sX8KwwcTwxAcqQQ49Ll32zjaG_mg,18298 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1device_1_1DefaultGemmConfiguration_3_01arch_1_1OpClassTensorOp_00_01arc8e2604a56dff3a7595da9ee0604ae55e.html,sha256=m5oxGGsaAHnE6NaXFTdQUl2keT1LikzAkOiV7DjMoMQ,19948 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1device_1_1DefaultGemmConfiguration_3_01arch_1_1OpClassTensorOp_00_01arcb27bf218007928652d5b803193eab473.html,sha256=eicM5Q1aNMfPK6_l0xVS6VlCN8GwqCnyfPPU-Yai320,18298 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1device_1_1DefaultGemmConfiguration_3_01arch_1_1OpClassTensorOp_00_01arcb2e258b7bd321c633dd65d3ebcf6414a.html,sha256=1vp3SlqCWxB2b6COtflzkYwyJASgbs60f-Q1mB-loBw,19961 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1device_1_1DefaultGemmConfiguration_3_01arch_1_1OpClassTensorOp_00_01arcb7fc3be2027b2868753a4aae14e98f75.html,sha256=9bkXHRn-J13TFaN0LHZ8FASDKCvfxiEjxXQQfXzgwIc,10229 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1device_1_1DefaultGemmConfiguration_3_01arch_1_1OpClassTensorOp_00_01arcbaa1784011abb8692923771e7fb21906.html,sha256=ctG-ku9oWAm8VJn4x1LpksgJZrdtwa0vzDZiokZ2N0E,10218 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1device_1_1DefaultGemmConfiguration_3_01arch_1_1OpClassTensorOp_00_01arcda5cf58c271179385af56bf89955e96e.html,sha256=Mqv-ck0B9VO1yq5RW5SzgUpJdf9JxiOZmhk1l-dXCQg,10361 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1device_1_1DefaultGemmConfiguration_3_01arch_1_1OpClassTensorOp_00_01arcde61af9be1337dac1fdb210e7e7a6e01.html,sha256=u_g6ORHYZvK6aL_vSxd3ceS4S41gCCfurQnHrm4DiNg,20616 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1device_1_1DefaultGemmConfiguration_3_01arch_1_1OpClassTensorOp_00_01arcdf8d33e0ed321027ffd1ff87dcf72241.html,sha256=kCgOqrmfK4rigtQlKxi59jC-LlLyv0bgfxaYY3A-vYA,10218 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1device_1_1DefaultGemmConfiguration_3_01arch_1_1OpClassTensorOp_00_01arcfea0f3503156e8e3fba6456f0cedafdd.html,sha256=VeSjWb4VjaAYphp7YUTUnCqcQO6hShPLbMECHqCuf_Y,18311 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1device_1_1DefaultGemmConfiguration_3_01arch_1_1OpClassTensorOp_00_01arcffcf31256aed23d4d8d0eab627bc0cad.html,sha256=weI_PvUH7lukkSjjW9-HR-tyLZVSTrOncCT8dqlkhuc,19948 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1device_1_1DefaultGemmConfiguration_3_01arch_1_1OpClassWmmaTensorOp_00_0884059ecad03bea3e86c4cf722226097.html,sha256=wQ6MxzymSaYvIqEN1qnAIifnD9H-Ok8cjAUfDdGYN-M,14087 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1device_1_1DefaultGemmConfiguration_3_01arch_1_1OpClassWmmaTensorOp_00_0eea80d814d67886a4fe2e1d10f3b344e.html,sha256=JJ_k8s8GoDHlNXR4OoY1M941uu0cZOKBPJnI_wU3mOI,8572 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1device_1_1GemmBatched_1_1Arguments-members.html,sha256=QDwfzRsekFki-xIjvtMXhAWSsDX5GGm4KjEFl9wjs7s,13974 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1device_1_1GemmBatched_1_1Arguments.html,sha256=X8uMC_Db4uxu3jMcEuA6xdb8vDMcRlkiJWiTlbLTw0M,54118 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1device_1_1GemmBatched_1_1Arguments__coll__graph.md5,sha256=OH6TN_hxJYJngwvmQ7nCRkfAVd273A2bbuHEDdmek1w,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1device_1_1GemmBatched_3_01ElementA___00_01LayoutA___00_01ElementB___00_213d78696663f4231cd52c6a277c60e5.html,sha256=iafcszG2ukoEyziyolkisg5AMJ21DLZZA2yV2QUQa8Y,42038 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1device_1_1GemmBatched_3_01ElementA___00_01LayoutA___00_01ElementB___00_6a0109475095b785e1093424570cec9f.html,sha256=v8yLlfYW5Py3isseZF9QHxVKx_r2Viq_IqwO2EUbG30,16416 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1device_1_1GemmBatched_3_01ElementA___00_01LayoutA___00_01ElementB___00_86011929b951a4386edd82c2df43071a.md5,sha256=M3_tqbGDrLQup3Pzk2YBAMhcDBEYd7HkdTyh7RiEmiA,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1device_1_1GemmComplex_1_1Arguments-members.html,sha256=CZZ2YOUUF-gXZw1EpIxP_aRIJfmTNOS1wm1r40TGnhI,11552 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1device_1_1GemmComplex_1_1Arguments.html,sha256=2awnJTW173BguzMXO4qzIWoa6LqHhVvx1H8M2hI7i_o,38841 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1device_1_1GemmComplex_1_1Arguments__coll__graph.md5,sha256=LMeIyP7MFc5VRF-pMxw5_zHMcIb675LJxeOYwZOQjh0,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1device_1_1GemmComplex_3_01ElementA___00_01LayoutA___00_01ElementB___00_80986bcc93ad447832731ffb6134212a.html,sha256=DeIzrVw-P3r-Jpr72GskKuwiV08V985eLBNvjL-_Fis,13401 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1device_1_1GemmComplex_3_01ElementA___00_01LayoutA___00_01ElementB___00_a3923967cafb5cb9774c320dc24baa77.html,sha256=zXDMp6hO27lBPwzkS_d-7DbzMkCKhkrJBJDu1PjzCNA,35254 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1device_1_1GemmComplex_3_01ElementA___00_01LayoutA___00_01ElementB___00_d3937603119c7a34faa6d59fb44eb1d3.md5,sha256=IZhvvjpjxT2iyUeJZA2czKTIyea77amQQJwLaSKfSy8,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1device_1_1GemmSplitKParallel_1_1Arguments-members.html,sha256=MmBwLa0fQHExDqioE4CU2VlyBQBHpRqA0Lj-GYBWBh0,13595 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1device_1_1GemmSplitKParallel_1_1Arguments.html,sha256=I89BaLL5LYa4DNswl-HBQWVt-3_6lUEZIuxsN_cGMmE,55606 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1device_1_1GemmSplitKParallel_1_1Arguments__coll__graph.md5,sha256=Hm0qsuUhtxh4bl8WeKKTo3F6xViXYbEqDWMkgw8ffaw,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1device_1_1GemmSplitKParallel_3_01ElementA___00_01LayoutA___00_01Element0b5460769dc2e29b8089dabe0dea7664.html,sha256=aw7_8stzsw1SYMJW3lsUkNoYGdMAXVJhtbmJrsv4hFg,15598 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1device_1_1GemmSplitKParallel_3_01ElementA___00_01LayoutA___00_01Element62751fd4d5e9e1aa595a1c59145b8f01.md5,sha256=Tl0whDE1LHoj-jXebGFXIv36rlv4HPAdnCn411QT06w,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1device_1_1GemmSplitKParallel_3_01ElementA___00_01LayoutA___00_01Elementafcb1aeaf2035a7ac769d7acc233423b.html,sha256=uGLefkfjAr8nko_uqoN0R6lWpb9eJiVpzqryxSwOVR4,40431 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1device_1_1Gemm_1_1Arguments-members.html,sha256=TOUm6kbJk0mZ0JV2XTMeW3FO7q5bld8xhKeJ5sB0Pzo,11574 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1device_1_1Gemm_1_1Arguments.html,sha256=Q4t_sB9OLnrswNeZvLm3L8JlFaaPbCbUTt-5MbsYEns,42545 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1device_1_1Gemm_1_1Arguments__coll__graph.md5,sha256=MgrY_3KNy8DCC80Uvi1eoTIZ9k7aPUYTwzVNoKS4v7I,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1device_1_1Gemm_3_01ElementA___00_01LayoutA___00_01ElementB___00_01Layou1b211cc9c97c022d8fe10f2dd32c8709.html,sha256=c0HzwIs7WevCocJJT9F8y_Th0_IxxesBJyoXn1Idl8M,35548 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1device_1_1Gemm_3_01ElementA___00_01LayoutA___00_01ElementB___00_01Layouc7bf8dfab285ca1d3f1fcdd3156f88fe.html,sha256=s91AOAomjRna5mzzxNoa2D5h--vmQ_ILx9t9ocCwP0I,13593 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1device_1_1Gemm_3_01ElementA___00_01LayoutA___00_01ElementB___00_01Layoude3eb4cc675179705362d51bb2b48c9e.md5,sha256=eeB5RlWeyUL6RDd2TUSBrOw7_djJo--dt_NeJSdkfWA,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1kernel_1_1DefaultGemm.html,sha256=lHTtHbaN-v1v7J9Vr9dLIRovAOxfr6rayy1NG4Yltkw,5654 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1kernel_1_1DefaultGemmSplitKParallel-members.html,sha256=j_sBYn9hINnnzO5ZBonrDPy9hy8iaXG-QQZwuBMheHs,8007 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1kernel_1_1DefaultGemmSplitKParallel.html,sha256=twCAbkER_1ea6u87nYKVW1VZAYecnxkkSgY2tmOl81I,15052 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1kernel_1_1DefaultGemm_3_01ElementA_00_01LayoutA_00_01kAlignmentA_00_01E044b039b2fe402f29b04a9f5feee5342.html,sha256=pTj-IFII-_LJwJ-e1u_DIv3G9GSNbO6qC9jfXXH7g00,18638 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1kernel_1_1DefaultGemm_3_01ElementA_00_01LayoutA_00_01kAlignmentA_00_01E0b527dea5015765e44fc234cadf35e29.html,sha256=5Sdl1oXYRT-geAK2Nr2rZTSTxjj1QHHII9ARDX_0kho,9025 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1kernel_1_1DefaultGemm_3_01ElementA_00_01LayoutA_00_01kAlignmentA_00_01E56da05ce184ecd9a73aa195e352f08b9.html,sha256=Hk0RUqpVufWLpelRlRKvoxPpVNIoKJ6NxLq5MFqnqN4,9095 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1kernel_1_1DefaultGemm_3_01ElementA_00_01LayoutA_00_01kAlignmentA_00_01E5d78d37a9ae2ec08d7d477d571df036e.html,sha256=whznNT97wAs_Qq1RfsQM5Atj50Vn_pbHHO1GrSacoP4,18253 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1kernel_1_1DefaultGemm_3_01ElementA_00_01LayoutA_00_01kAlignmentA_00_01Edd80343e6570718ed237122e4ebf7fb5.html,sha256=c5a-zYaplWV1SLA66o6po6e3bzftvT2LG7vVk0IscMA,18346 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1kernel_1_1DefaultGemm_3_01ElementA_00_01LayoutA_00_01kAlignmentA_00_01Efab1637593655fb8e409b7cbdcee4ba2.html,sha256=KO8FWe4jYeUOLQW4ayVB9AR6I8_zbOY_eWf1MObrSZE,9060 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1kernel_1_1DefaultGemm_3_01ElementA_00_01layout_1_1ColumnMajorInterleave661fe54d13cc2c9153dcdf31e4beaa30.html,sha256=DP4MPFistIo79eeGy-Y69EYPj_6LnrTlW0kpFENycok,30481 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1kernel_1_1DefaultGemm_3_01ElementA_00_01layout_1_1ColumnMajorInterleavecb3ad866c4f35a6c75b3b509fe6317ac.html,sha256=gCIQSTW-zwq4-tHdeO17Ti-_EvrrDCGtXa3cLZLD-8I,13422 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1kernel_1_1DefaultGemm_3_01int8__t_00_01LayoutA_00_01kAlignmentA_00_01in6cddcf78576aeaab7109f4b04ca21c26.html,sha256=NOaSX6yYi72Of_8AMrxf9KPoutOb0WWCQsFxH6EW4z4,12045 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1kernel_1_1DefaultGemm_3_01int8__t_00_01LayoutA_00_01kAlignmentA_00_01inf48440732c1c5f42ddbfaba179861815.html,sha256=OP8vsTuoUPIl8IiMEWW187XvqJ_1HlpHYtRXrIk867Q,26109 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1kernel_1_1DefaultGemv-members.html,sha256=J6RHMiW0WLO756XQXGE2Uhj3IBZZpKJDaL9x4yJYShk,13462 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1kernel_1_1DefaultGemv.html,sha256=Da0IMUq7N6cLbnFeuseYUvHKRoRtfjESb1NeQ3qGvYM,39991 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1kernel_1_1Gemm-members.html,sha256=5ipdKTfG7mjHXy3H3ifAvpAtrVo5IErBquT3BbPyDjo,9228 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1kernel_1_1Gemm.html,sha256=71GMerJbeCp-R-8qJVlLsNnqRfCxZDGz-bq0BtsbTNI,22872 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1kernel_1_1GemmBatched-members.html,sha256=lDjcElPFQwcw4bwGHVflDMRxaR7V7VbKuwRpTZzXe3I,8227 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1kernel_1_1GemmBatched.html,sha256=ni1-cPVjn7jJ71HQZbo0kf6Bygd63UhaNmX83tW7nTQ,18281 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1kernel_1_1GemmBatched_1_1Params-members.html,sha256=XyQvb6KnqgHEd0o2nN2R-Uc17KCn3Nqsi4zeywGYQvg,13203 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1kernel_1_1GemmBatched_1_1Params.html,sha256=NlezF09Tt3WwlAdZJuSn6cIvGsVinmkxx8gZJVJ5HRs,30097 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1kernel_1_1GemmBatched_1_1Params__coll__graph.md5,sha256=4aMCwSUKHZ9Q5DVNzq0fuu7q3YRoSOTW4sbey61K5hY,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1kernel_1_1GemmSplitKParallel-members.html,sha256=GjSbfywyU1EHzWSbAHEoDVbLYr_QCexGuEcfY9wVvsQ,8865 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1kernel_1_1GemmSplitKParallel.html,sha256=KBOtJjC5dCkmXuM5dFNJNwJCCRYty0Bzqy7VN-EJNXo,19858 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1kernel_1_1GemmSplitKParallel_1_1Params-members.html,sha256=FGq2Fy-0sf8bSFrgobytwmmOz0TSlJ4pXdLxHrbTuFs,11048 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1kernel_1_1GemmSplitKParallel_1_1Params.html,sha256=ohHd5J78Yxis3lgVRxEujg-z6GoWdjB3QPxbEJoDjGA,24331 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1kernel_1_1GemmSplitKParallel_1_1Params__coll__graph.md5,sha256=fqWuf0czydWufkc4zCWpkDvhisvvRHJ8RbWkc8HcVh0,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1kernel_1_1Gemm_1_1Params-members.html,sha256=B7fFVWAqIjjBpumyf03tQNOjOm4LdwsvYmv9Z2pMKO8,11850 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1kernel_1_1Gemm_1_1Params.html,sha256=9Oi3JF9XgJyB9wQ8d9CcXAk3sHxH7olH3e7IwFMkEO0,27740 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1kernel_1_1Gemm_1_1Params__coll__graph.md5,sha256=n3y-IjigAG8TrU117Bj3W3rs2YQHKM4QER9FMS7wGGQ,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1kernel_1_1detail_1_1GemvBatchedStridedEpilogueScaling-members.html,sha256=p6xu9bhQiNbmSsii2YStJbkZYBJ_ji5EsEn9rAihxgA,7388 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1kernel_1_1detail_1_1GemvBatchedStridedEpilogueScaling.html,sha256=LkvabkcRBbt8WhoC3U3AM1252uIl56C4Q39lCyxTXvc,12485 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1thread_1_1Mma.html,sha256=mTdXWjrmTTsx30lNwdEJ5MguUHfVP6JpM4n6A0pfqbE,5316 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1thread_1_1MmaGeneric-members.html,sha256=Tmtvy4Qq389V_0KoRFtOaX6j2pxyrsOrtd-zuFguQ28,10663 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1thread_1_1MmaGeneric.html,sha256=gs3ArHZKXhtQqwnM7aRlu55E99Bf6GtaoHjoWqV2qxY,29509 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1thread_1_1Mma_3_01Shape___00_01ElementA___00_01LayoutA___00_01ElementB_77330d7783270c0eb7aa2b24c543081f.html,sha256=MLAXhV43yv8QPdOoPqjAjTyPGE_MP8kydd1oMft7JbQ,12630 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1thread_1_1Mma_3_01Shape___00_01ElementA___00_01LayoutA___00_01ElementB_e41c1cd6078b6d1347fac239b0639d56.html,sha256=1cdUiGIExpOpMdLLUG6PKcGL4jeyp3AZhBG0eeadWIo,29249 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1thread_1_1Mma_3_01Shape___00_01half__t_00_01LayoutA_00_01half__t_00_01L066c9d2371712cdf0cac099ca9bcc578.html,sha256=xWIz_r4Y_KRKtm0naOjU-krABMDZ03XlSeP8QTumazs,25437 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1thread_1_1Mma_3_01Shape___00_01half__t_00_01LayoutA_00_01half__t_00_01L5349ba8a899653b0d5d0c23e9cf44a0c.html,sha256=HYL8Cc-CaiUEZdkV77PT4U4cdj9ujkdhMJ-uw6GfGlA,10661 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1thread_1_1Mma_3_01Shape___00_01half__t_00_01LayoutA___00_01half__t_00_0289b291e61fc11c6dd8f80a16a97bd46.html,sha256=whmoX4yI75YbQV9St1_9yGfywLxrwXVMy0ujDitX39g,14844 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1thread_1_1Mma_3_01Shape___00_01half__t_00_01LayoutA___00_01half__t_00_088f0e99e501b6012297eb30b4e89bcea.html,sha256=giWm2F2yi4_sXbpPejhRs2WhkUePERBnSxwqz5EnHtM,36814 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1thread_1_1Mma_3_01Shape___00_01int8__t_00_01layout_1_1ColumnMajor_00_013f3785e722edc6e9aab6f866309b8623.html,sha256=9gowhtfKlAxyOu7LEohI0buxCUgvN4apteu_foZuYIM,30136 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1thread_1_1Mma_3_01Shape___00_01int8__t_00_01layout_1_1ColumnMajor_00_01d50065ae476bfe25761aed2404fd85bf.html,sha256=nhQgF-o868xJknYIm5otdMhOJ7tZe0N3G0R7Zn1bg3s,12825 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1thread_1_1Mma_3_01Shape___00_01int8__t_00_01layout_1_1RowMajor_00_01int89c659e7faf47264972bdba6cd80f42b.html,sha256=CGpodZyNxmo8NLvni984rKynm2sg34lGoFYlNJLHT_M,30106 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1thread_1_1Mma_3_01Shape___00_01int8__t_00_01layout_1_1RowMajor_00_01intbfe74b44f9842985e186ee7faada0200.html,sha256=de-cFxu3OYocAVa_YomeIDA1XwkQHrtimZdquOHodhc,12795 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1thread_1_1detail_1_1EnableMma__Crow__SM60-members.html,sha256=NNPu9UdvxpptH01t89NM-tkXFz1pObhG7f7baW28-pQ,6122 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1thread_1_1detail_1_1EnableMma__Crow__SM60.html,sha256=i5SDnoLOEHDMfaM0Zv9Wh-0m4Jf72HNr1DokF6jH_IE,9459 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1thread_1_1detail_1_1Mma__HFMA2.html,sha256=MjoeuqzkdbBuxsxY_xnkAAiJ8ymwWtfJBQtywM2ThXo,5420 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1thread_1_1detail_1_1Mma__HFMA2_3_01Shape_00_01LayoutA_00_01LayoutB_00_05434f0c746fe7543e953c4f4e635b605.html,sha256=U8A_UFXEuUqTeNNLx4_c2SkRRAKG6jsZ3TUDLrWVCgM,7796 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1thread_1_1detail_1_1Mma__HFMA2_3_01Shape_00_01LayoutA_00_01LayoutB_00_07ac147cb320ee0d28ff8e78eb4cd330e.html,sha256=jYm15lsKumvYZcnfr29_PsGmZj86qOqKjFgpMoNY354,15573 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1thread_1_1detail_1_1Mma__HFMA2_3_01Shape_00_01LayoutA_00_01LayoutB_00_0e1104c65871c539155bd3a0c7631928b.html,sha256=Qh_HCF7f_29D0vsF3p1FdiV6KuAg3ilNcarABayqDds,15606 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1thread_1_1detail_1_1Mma__HFMA2_3_01Shape_00_01LayoutA_00_01LayoutB_00_0e5ac1f521c32478a4316b5a9ea84e939.html,sha256=TnN0bOtyNSRKpjDpSKOJVfa6-48rgzub_rm2PSoMyP0,7817 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1thread_1_1detail_1_1Mma__HFMA2_3_01Shape_00_01layout_1_1ColumnMajor_00_17070298bc4cced0a1b98aee2bb6b455.html,sha256=MdQqIxx_bISp4lR4zvJJwTmBvG8MP41Kufm4J2Ms5KY,16070 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1thread_1_1detail_1_1Mma__HFMA2_3_01Shape_00_01layout_1_1ColumnMajor_00_72621f7ab9ae4a4ba4fe9725cf8e89c1.html,sha256=2mQ9DGu6jresZkXi_Q_tpiX5NYLklh0mY06oySpSAKY,16159 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1thread_1_1detail_1_1Mma__HFMA2_3_01Shape_00_01layout_1_1ColumnMajor_00_94c813e3bbfb6f9857c155166f772687.html,sha256=Ete0whYOvpWc9-mMU6NSpuQIgdi1YOMjCDUBkiWGAeI,16126 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1thread_1_1detail_1_1Mma__HFMA2_3_01Shape_00_01layout_1_1ColumnMajor_00_9afa1e2f7fe8284e818c1409e0230fa2.html,sha256=6U2BeRO6h7fAQC-BRhPPuAT5ArO4deMhqoFbCedcmTs,7936 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1thread_1_1detail_1_1Mma__HFMA2_3_01Shape_00_01layout_1_1ColumnMajor_00_aded668311848cc9c73554accdb29b97.html,sha256=z0v9GEGvM-u2lv4OnayKnMdWfvKIfCbEWK_RefFNPSc,7978 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1thread_1_1detail_1_1Mma__HFMA2_3_01Shape_00_01layout_1_1ColumnMajor_00_bf6d29bb09a025e7b96942809743e28a.html,sha256=hilHgPYrbWEV-NoDdvEDReu2En8iHZIl_0zoA1LkBx0,16093 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1thread_1_1detail_1_1Mma__HFMA2_3_01Shape_00_01layout_1_1ColumnMajor_00_e91e59489e973164266ab8b55889a608.html,sha256=imk_X9nFvPjbAc8IQWXVL3o_zBvGuO77iIOR8mhnIIc,7957 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1thread_1_1detail_1_1Mma__HFMA2_3_01Shape_00_01layout_1_1ColumnMajor_00_f16629e5249aa6882f509571d2434832.html,sha256=2eytdtOe_MEKkIqD6GXCm7_a_rNdU5fr9YP2ktj_MOQ,7957 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1thread_1_1detail_1_1Mma__HFMA2_3_01Shape_00_01layout_1_1RowMajor_00_01l086c058a15d6c79558e4f3d9ff1dc148.html,sha256=ZW4WWeysqJxgh1vxBLMY2jTY_1IAtmyc44s6gbMNbrM,16060 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1thread_1_1detail_1_1Mma__HFMA2_3_01Shape_00_01layout_1_1RowMajor_00_01l26a133b13650c1d058273e3649f60f04.html,sha256=YPfW7KFhXCAeKje2EcXoIaRQZgcCTJGE5kYkursjvzM,16126 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1thread_1_1detail_1_1Mma__HFMA2_3_01Shape_00_01layout_1_1RowMajor_00_01l2aa4d2fd2e940e0d0cf7c47bc8f6017c.html,sha256=oEZfqwRW_Nl1oHpWe2teO-BK7ddQRMNihDPZVoxe_dw,16093 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1thread_1_1detail_1_1Mma__HFMA2_3_01Shape_00_01layout_1_1RowMajor_00_01l2d7c9369ee79d34a9ecd602986cfab0c.html,sha256=C2US7Dw_4VML3OgKfQDjhsEEwXPtrBzGtZH5LJjBOR4,7915 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1thread_1_1detail_1_1Mma__HFMA2_3_01Shape_00_01layout_1_1RowMajor_00_01l3aca9bdfbd9560dddf80c9e0b7775f8a.html,sha256=25yugtO2TNKvn1h-jX-6QvVvvDJ6pW6Biyu35NbM4fU,7957 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1thread_1_1detail_1_1Mma__HFMA2_3_01Shape_00_01layout_1_1RowMajor_00_01l931b11057bee5329b2f865f01881feb4.html,sha256=meWzPgu278NOi7zk01XRqYnMhJ9c2e6dcy_TpWiX964,7936 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1thread_1_1detail_1_1Mma__HFMA2_3_01Shape_00_01layout_1_1RowMajor_00_01lbba3a796be96a0276693ef6b259ecc4a.html,sha256=5-JaY2Nda98T2FKSU_yoEfOaoXXyBfLX6Yh2fHsQS8M,16093 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1thread_1_1detail_1_1Mma__HFMA2_3_01Shape_00_01layout_1_1RowMajor_00_01le301921af6f57a0bfbb3c3961e8be641.html,sha256=Kg5UsOuRA8NAPjdWvQT6md_ttCs5DqKQ8hL7RME7rws,7936 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1threadblock_1_1DefaultGemvCore-members.html,sha256=oiqBQCbxWFP2BrIEc3RhCjsny6l6KVSR_QEWBHyoGaM,12875 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1threadblock_1_1DefaultGemvCore.html,sha256=rKq7glR-0EMVuakV6QC5NAfXqH5uGV8lyTQnObX0ldE,42032 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1threadblock_1_1DefaultMma.html,sha256=PoMIkJq8UZlxVTaDiLZday8h_nanDpHmx7CTXeemcxA,5581 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1threadblock_1_1DefaultMmaCore.html,sha256=pIJCUf0qTBOTOVvOEO6zxbdVw50-oodCrAblnhJBxOo,6773 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1threadblock_1_1DefaultMmaCore_3_01Shape___00_01WarpShape___00_01GemmSha1552173080a33a19c634eb2f66813db1.html,sha256=9m46VR4TnOG1PamJYk6Yt3MYL5uCrWajDMVtI9rVDEs,30545 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1threadblock_1_1DefaultMmaCore_3_01Shape___00_01WarpShape___00_01GemmSha2c0d0b7cdb5c4bcb11e83c058eb65345.html,sha256=byfg3KCL921pGCUA5R9UJ0juBq9kAKxXd_xBAYuznqo,95613 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1threadblock_1_1DefaultMmaCore_3_01Shape___00_01WarpShape___00_01GemmSha2d7c0a561bbf8f59c22021f3182fdfd7.html,sha256=f9bL3DurSCppTv2YlpTSzTLnJi655omM6hLRxZKoYaw,31327 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1threadblock_1_1DefaultMmaCore_3_01Shape___00_01WarpShape___00_01GemmSha2f65fab287659088299cac7e3a7d1c73.html,sha256=DYApUb1o0iJ9ujY48zVSga5-FJ8rhdirD7SVSSH3qTk,19880 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1threadblock_1_1DefaultMmaCore_3_01Shape___00_01WarpShape___00_01GemmSha34a52cc7b2942e8c290f0032b6779b52.html,sha256=vljGhHkl9FSnxbz7e-x-hLpSjEG8UYfH0ZjcQz1vn-8,86422 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1threadblock_1_1DefaultMmaCore_3_01Shape___00_01WarpShape___00_01GemmSha3adf608332a8c9ee7014fced0da8a9ca.html,sha256=PyXWVyKsTdLmh__Wz7BJi6AlM-G_ukm_RF77Ot01eVg,68399 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1threadblock_1_1DefaultMmaCore_3_01Shape___00_01WarpShape___00_01GemmSha46446d1e3871e31d2e728f710d78c8c1.html,sha256=1bRkuPpBAF9D5-z4dE5rq5Vk7lqPHsL9c8THYF1ydrw,57677 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1threadblock_1_1DefaultMmaCore_3_01Shape___00_01WarpShape___00_01GemmSha4dc50bde4c2a3941f8f9807599cc52ef.html,sha256=X2n_p_GwDxIfeQdcO8RWTTPOudZeWKDApLqBB5YEerc,21919 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1threadblock_1_1DefaultMmaCore_3_01Shape___00_01WarpShape___00_01GemmSha5fdfbf65379c910a1c04ef3a46a549ed.html,sha256=3sgtGuJ9D_NLggvT5CPn1rAkXkHSI9oAexdV6O5RZdU,30794 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1threadblock_1_1DefaultMmaCore_3_01Shape___00_01WarpShape___00_01GemmSha69bef08ea63dd930f99d9788105873dd.html,sha256=NXqtjfb-jGTYIo5mCzdcSMEAmSmmubITe0eclA1M6-8,68356 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1threadblock_1_1DefaultMmaCore_3_01Shape___00_01WarpShape___00_01GemmSha84e9f8afb6a4ca9f5dcd219b182d16e7.html,sha256=Ye85ca83KFVhv9mIW0F5sRW9QsmGkuVIE1aN6Fn52so,95949 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1threadblock_1_1DefaultMmaCore_3_01Shape___00_01WarpShape___00_01GemmSha863d4139ccaa713bc4bde32c425f4067.html,sha256=YVTvP-0e7how1QNo2ylFERPsBqhaAtPQjZwO9O09_Ec,95115 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1threadblock_1_1DefaultMmaCore_3_01Shape___00_01WarpShape___00_01GemmSha8da7a0cfbbe859b701fdd9f2b8566aa7.html,sha256=YnNdtXsU6Booow1ymCPeMivnGEUbCwKMUTUL0FYNgKI,102139 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1threadblock_1_1DefaultMmaCore_3_01Shape___00_01WarpShape___00_01GemmSha903c12d1a6db57137118ba796bc8de3e.html,sha256=MCmEISFM8D_p1xJWeRdSKRBHORIVAw4w1TvMZL2pBHE,28611 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1threadblock_1_1DefaultMmaCore_3_01Shape___00_01WarpShape___00_01GemmSha99d686f7f39d14961f2f465b7d3f7026.html,sha256=GjQE6A9ijN9ErolejiKBmQrjYn0gEHllKX_ecQ71BDg,22000 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1threadblock_1_1DefaultMmaCore_3_01Shape___00_01WarpShape___00_01GemmShaa1477d8eaa363a2af9fe1b96cded5b28.html,sha256=iOqPb-H33eE-3iteOyP8BogYG4nQ9ZQsjzUh4FXjuk4,29544 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1threadblock_1_1DefaultMmaCore_3_01Shape___00_01WarpShape___00_01GemmShaa370fcd3431f7e4951b8c5eb885ce2fa.html,sha256=BztelPdCDD3vpbaEZbIoDrszudvFQ9PPOhyhm3_E-Hw,32284 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1threadblock_1_1DefaultMmaCore_3_01Shape___00_01WarpShape___00_01GemmShaa65fcc9419ddceacdfc43dd268adb852.html,sha256=h4gANO2ba4oXYHUtgtWf9PY3CfSWGlRnZjGezjT_hbw,22000 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1threadblock_1_1DefaultMmaCore_3_01Shape___00_01WarpShape___00_01GemmShaae2ea1baf1eb4cfec940a7655796b053.html,sha256=Cgq_c2R-teAyo0YkGvf8TyPbO73JBtScRq9l0Is1R9s,30785 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1threadblock_1_1DefaultMmaCore_3_01Shape___00_01WarpShape___00_01GemmShaaf312aafe9da92ea9d417bcc12a8e7dc.html,sha256=lOpqnUD5iaaCaskXlEHckoGAK6J82fPKo7SPMEcFkP8,98338 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1threadblock_1_1DefaultMmaCore_3_01Shape___00_01WarpShape___00_01GemmShab7edfba3cdf43a07e3c4d719d87565a4.html,sha256=489NXFl8wxVua0rUtJ0zj0kSNZxFKZhh-5waEzIxA5k,68195 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1threadblock_1_1DefaultMmaCore_3_01Shape___00_01WarpShape___00_01GemmShab94a11a77dd0565102710907089acee0.html,sha256=Xr-gd35R3RKaCVRllDXv28JC4BXsPfYF8qj5Bxtk_nE,96450 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1threadblock_1_1DefaultMmaCore_3_01Shape___00_01WarpShape___00_01GemmShaf03a122202ad10acdc96f280106d678b.html,sha256=X3XEimk8gOjqWTFhh_qLNy6FYGgHe08gGK1fhLAbXTE,68560 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1threadblock_1_1DefaultMmaCore_3_01Shape___00_01WarpShape___00_01GemmShaf9c49957c66a8ac51d686f0d22b8b0ea.html,sha256=LwhftvRTkhSQq_Xomyd6mEH4vJwsrqJafrV7g5_jzqU,31034 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1threadblock_1_1DefaultMmaCore_3_01Shape___00_01WarpShape___00_01GemmShafafd5c61db86cbfe90863578ddd11092.html,sha256=SvCABXJSGf5uElZj7wm42BxYV-1R6x-gGV_684R90UM,90300 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1threadblock_1_1DefaultMmaCore_3_01Shape___00_01WarpShape___00_01GemmShafd521c9baa327d4845a8f8f161b0cc97.html,sha256=pfduUW7SW_7RO1SjVzKmFjDnIVhgWRXcTUkTVlgQQvg,22081 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1threadblock_1_1DefaultMmaCore_3_01Shape___00_01WarpShape___00_01Instruc24092ddc01fc83dabb7db4c14880fe60.html,sha256=JE9TDtVfb8FFqWfGhHIS6VuFab56Am9pcvWbOlKC5N0,73366 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1threadblock_1_1DefaultMmaCore_3_01Shape___00_01WarpShape___00_01Instruc275197ad0505c12b07f1abc87ba9121c.html,sha256=nJfg_JETIO-Q_ikJCiRd2PqQ9tUyeKOQOtgTkJp8w2o,21102 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1threadblock_1_1DefaultMmaCore_3_01Shape___00_01WarpShape___00_01Instruc2bf00737f4ad0a9da9a8be6d3e66c152.html,sha256=HqJqlSMowP5Z3WTnQ3HzGtjtFl9MBodiWoeEf4X8JEc,84950 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1threadblock_1_1DefaultMmaCore_3_01Shape___00_01WarpShape___00_01Instruc4fee9f2965b8468bfb42b94a74527d22.html,sha256=mdgjlSNvbO33ik6S9zCkw0WT-_gs3iTHnNQxY5yoTGU,68367 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1threadblock_1_1DefaultMmaCore_3_01Shape___00_01WarpShape___00_01Instruc72e82df901305098cfe0dae3a1c52620.html,sha256=4Yg92uMAG6Jcli8ZEDIe2E0bpg_gRPtpBULD1EbNHBs,28139 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1threadblock_1_1DefaultMmaCore_3_01Shape___00_01WarpShape___00_01Instruc803d38bc1e4618c07c47f54c87ae2678.html,sha256=dcHz-ScZlxv8V_Nj48r0U_f-BhyDN79PDOlElYgpD0E,68738 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1threadblock_1_1DefaultMmaCore_3_01Shape___00_01WarpShape___00_01Instruca1d9a28a8480eb9edfb7c40780b136e6.html,sha256=nA2LyqysAhYMU27_IiR2um6KQIoMP5kbQ42aTa7hWCY,22444 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1threadblock_1_1DefaultMmaCore_3_01Shape___00_01WarpShape___00_01Instruccda7d350d3e2bd640227b690e127afe5.html,sha256=xYs7QaEhiDKlYNKpJ3CDvXqcC66ynt2s6xChCZUj5dk,23954 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1threadblock_1_1DefaultMmaCore_3_01Shape___00_01WarpShape___00_01Instrucf60fe02fcdd80d28b7fd419133465dcc.html,sha256=weTBNpiCZzkE_DymWqjUKrcFUnjZTv4TNS9EB8RttNw,63746 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1threadblock_1_1DefaultMmaCore_3_01Shape___00_01WarpShape___00_01Instrucfd34bebfcb8bb444b55e46bcd7ea6fb0.html,sha256=a2ZCaT7DIqmxiUIIqPo59dYbBHAXNRmkIy8WxmEGoqc,22612 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1threadblock_1_1DefaultMma_3_01ElementA_00_01LayoutA_00_01kAlignmentA_0010764e1fd5a3251a57eddafbd83eab8e.html,sha256=wXwMSrzTezOp62UVoJ9eNaRjE-5k-Qk_8uM4m2iO5o4,17253 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1threadblock_1_1DefaultMma_3_01ElementA_00_01LayoutA_00_01kAlignmentA_007182ba7df2fd06bf603976d8711bfcb9.html,sha256=-a1oTCuyHK92_bZj-Bj0zmYC2ock_FdTNU5IMUkii3Q,8632 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1threadblock_1_1DefaultMma_3_01ElementA_00_01LayoutA_00_01kAlignmentA_00a5ddf5dbb058f0e0fc5808d9dfe594c9.html,sha256=gzvWRsO2SOJwgHbPEsw1fdufCwZwQ0nLNnKBEXpgqIo,8821 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1threadblock_1_1DefaultMma_3_01ElementA_00_01LayoutA_00_01kAlignmentA_00c67c16f9881e4f2fda76d8ed83ebabd6.html,sha256=hinz6-T0FZ_6JlYaAEW8BqqT5bYZTbmuLoR-kyWuaF4,16657 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1threadblock_1_1DefaultMma_3_01ElementA_00_01LayoutA_00_01kAlignmentA_00ce36642cae579bce6605ff8edde3c6ab.html,sha256=TylM6fQxiQOpdxTv_IjEZspuSR3HeE3FrHPC4dmVOQk,16693 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1threadblock_1_1DefaultMma_3_01ElementA_00_01LayoutA_00_01kAlignmentA_00da4cf9ab35f8ffca5adfef751b4184c4.html,sha256=vWCyQd58it1uE2ixt8ElQLGtshWC80u0B_YhRoraJxs,8604 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1threadblock_1_1DefaultMma_3_01int8__t_00_01LayoutA_00_01kAlignmentA_00_07e7230d4011ada5e22cfcb29103b696.html,sha256=zcJ6eG0qob6ff6U66ooXpH7ldetQdk_6kA_y2m0tnaw,31745 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1threadblock_1_1DefaultMma_3_01int8__t_00_01LayoutA_00_01kAlignmentA_00_30934a4e911d342b2afe462e21e8268a.html,sha256=2GcBR3wT3cFGda2At_eoLieEm5mgP4bnBD4z35XD8X0,12942 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1threadblock_1_1GemmBatchedIdentityThreadblockSwizzle-members.html,sha256=f5ONv3tGRQVzoEOzMsfZRKG0yxRWKcf-fI22flm52zU,7087 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1threadblock_1_1GemmBatchedIdentityThreadblockSwizzle.html,sha256=PZmItcHH26gEFNdbXLQzPtvNQytpTztVnswp_rSX9C0,12845 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1threadblock_1_1GemmHorizontalThreadblockSwizzle-members.html,sha256=4E_tIt77-llPs03VGUszU53TSHMcJe6gNdd99Vs3yFY,7017 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1threadblock_1_1GemmHorizontalThreadblockSwizzle.html,sha256=EsM7Iank2Pw8lq_XV4h4D-9P2croQ-r-93_cNY3W14s,12821 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1threadblock_1_1GemmIdentityThreadblockSwizzle-members.html,sha256=ETJFNNFgsOEtUPgCV4_wUmL_huR8uUsPylQfFGL-6Zs,7374 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1threadblock_1_1GemmIdentityThreadblockSwizzle.html,sha256=Ycct0z7G_66JwSzDjqYXLBObhgf_PeaJ4N-ZB6LLgzA,13821 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1threadblock_1_1GemmSplitKHorizontalThreadblockSwizzle-members.html,sha256=nWRz0eyMhVqnEz1IoCY-eSUx1FtHAMMKSdYK4FTsCxY,6648 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1threadblock_1_1GemmSplitKHorizontalThreadblockSwizzle.html,sha256=BelSWDSL5vlJ7EkhwrE5Ois4zlDvuCufS7m4GMZ4Z9o,11551 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1threadblock_1_1GemmSplitKIdentityThreadblockSwizzle-members.html,sha256=Zi4OJQ9RAcqN1ey5Uy6hu0uSTKNvXuZTicMgEDkCvEc,6620 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1threadblock_1_1GemmSplitKIdentityThreadblockSwizzle.html,sha256=xtrjSim54Tn2WV_p0z2ViQYqSywOeq_FQfehNa3iAcc,11529 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1threadblock_1_1GemvBatchedStridedThreadblockDefaultSwizzle-members.html,sha256=aZIl4E4ilaAK82XfWu12_A2aCWSHyDJ-fOZwSBLkVAU,7681 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1threadblock_1_1GemvBatchedStridedThreadblockDefaultSwizzle.html,sha256=F9qC3cGvo-DJ0wawYLsJR091lnvf1XTkaZq0IfjbygY,14194 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1threadblock_1_1MmaPolicy-members.html,sha256=ArqbWtcTRNTD2LeMtCFvk1aGLAe-V6IcGAHMqXNloBg,6775 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1threadblock_1_1MmaPolicy.html,sha256=lncSvShxH-rVBbR7qmWhPF8CinyX96u1_mejbifN7ok,11919 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1warp_1_1DefaultMmaTensorOp-members.html,sha256=ivYitoK9ZYPinE5uEux6ST8FFwm-pVvFalQDptyCVmw,6333 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1warp_1_1DefaultMmaTensorOp.html,sha256=qudOWc47AdUtVTZzZfFfSwTBb-yTYM-JeM_RpEfRkHg,10695 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1warp_1_1MmaSimtPolicy-members.html,sha256=sirT2ALDdew9HAoeLTEjah_Yjm7VvIT9Jl1OQH8mWpw,7051 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1warp_1_1MmaSimtPolicy.html,sha256=wluPbJK5juy6wEVpm08xtI7RgU0t2yDrywdFdapoXW0,12595 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1warp_1_1MmaTensorOpAccumulatorTileIterator_3_01Shape___00_01Element___02100c8adad47cbe03be37d64b9a26478.html,sha256=1Tg_0I_DzJa025RcbySdoZeKghHxJk_DIpfA9W9s3ss,6296 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1warp_1_1MmaTensorOpAccumulatorTileIterator_3_01Shape___00_01Element___03822d9be37f3725022005a5434441f22.html,sha256=wJv09GxC4BtQcwa7ldm4trD0u-9fwp3wQY4v6cktBvs,8397 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1warp_1_1MmaTensorOpAccumulatorTileIterator_3_01Shape___00_01Element___093b5d2838ac5a742704ef62b5c8688f0.html,sha256=iyyRGjjc1UNRYqqUUfxX-mSxsqyW2koUM1OwutBYt4s,8220 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1warp_1_1MmaTensorOpAccumulatorTileIterator_3_01Shape___00_01Element___0d35fa5dc4e4b4f72784c943fd857fc1d.html,sha256=bfyTiUH1ZqBiHUa00-WuiZgFq-AZaRQPHBaPMJFvR3w,8235 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1warp_1_1MmaTensorOpAccumulatorTileIterator_3_01Shape___00_01Element___0e7cf8dbcdec1b98ecc43cbc7fd404caa.html,sha256=aFMZFTStCMrmKLrXNy274HtpXc1vi88ajj68pge_-oQ,6440 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1warp_1_1MmaTensorOpAccumulatorTileIterator_3_01Shape___00_01Element___0ef23ad16881f43f6f15b3fa7d1c44a0a.html,sha256=focRLN23-sKa2cdqkhjJ_SQ74T24RkYzdaRCtKGCaPM,6308 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1warp_1_1MmaTensorOpMultiplicandTileIterator_3_01Shape___00_01Operand___07638f8b7761f6e2e2e6918e2c05e739.html,sha256=oGLNsiF75mX2ckR1Zcd-xslssn91I1rVOk2MTiwydj8,21737 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1warp_1_1MmaTensorOpMultiplicandTileIterator_3_01Shape___00_01Operand___0784c74bd670999ec23ad8ef9dc55777.html,sha256=uQMMtq-Enk2T499gY4q3RDaX7NfeqlPcxxEwnA4uKrw,22390 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1warp_1_1MmaTensorOpMultiplicandTileIterator_3_01Shape___00_01Operand___7981e68facdb9c437cbc67ef4cc006db.html,sha256=ZCe9JUoBOcbuoO4aJTiWDQCNcN82n9UqHbKaNPAAkDU,11134 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1warp_1_1MmaTensorOpMultiplicandTileIterator_3_01Shape___00_01Operand___d8b3878197b6208162024299927d355a.html,sha256=Ka6V69tsmJZe1MAEPvRwJ4yeT-ZXMFebk_vE3xsLvVY,11064 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1warp_1_1MmaTensorOpPolicy-members.html,sha256=aK_P2MhlQabhbRatO3k-NXgmTBRUWpbSEtkadSyI2GA,6188 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1warp_1_1MmaTensorOpPolicy.html,sha256=qCmq0KqKEJSEiFJBxZozzfCRMf9wxJjPD6MpHb4AndY,9506 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1warp_1_1MmaVoltaTensorOpAccumulatorTileIterator_1_1Policy-members.html,sha256=MlwQRj0qfcte8NSUTcp-dHhmdudKkvcqx6MVxrZYgDA,6943 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1warp_1_1MmaVoltaTensorOpAccumulatorTileIterator_1_1Policy.html,sha256=4XYZZ3Si4JiA2Zigla3ySxo5puuK4OBXZZ_ORI59kAI,11879 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1warp_1_1MmaVoltaTensorOpMultiplicandTileIterator_3_01Shape___00_01Opera33cdf53848564e894d4407637dc86caf.html,sha256=Y3vASFuK5pKH7XEHsfUfSQ_KeoYqb3elQVCvAhyJbgM,10634 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1warp_1_1MmaVoltaTensorOpMultiplicandTileIterator_3_01Shape___00_01Opera4c86200f22934f3a3ec95b229ae65545.html,sha256=WV9xVxjJ7OjITOHLFhLGFgCzuUYKzsCe61ko11RtBF0,7370 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1warp_1_1MmaVoltaTensorOpMultiplicandTileIterator_3_01Shape___00_01Opera5da07caa645948ad891c884c71a4e5f2.html,sha256=_BRyGOYsEjWiKl9J8IKSZ6_LT-SSDClK05lssTsbN1Q,7365 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1warp_1_1MmaVoltaTensorOpMultiplicandTileIterator_3_01Shape___00_01Opera6fa6d2d3725bb3ec613d5c527ea3ffe7.html,sha256=3oBsuElHS0jtlmspZc1HcToRRr7gPwXkPquHuhJDG3Y,10641 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1warp_1_1MmaVoltaTensorOpMultiplicandTileIterator_3_01Shape___00_01Operae16326b7ce6ad841541903bbbfdc32dc.html,sha256=SAA77Kw6Kw9s_-cQ3Eq1V02V0mbF2q5Fhb2o0Jd8QZc,8871 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1warp_1_1MmaVoltaTensorOpMultiplicandTileIterator_3_01Shape___00_01Operafa294175b280756dd8388f9ffe7b72c4.html,sha256=mmmdFw8yblNzSZvlCgHxhzEZLEYKmQfWhbjtRM6dwFA,14797 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1warp_1_1WarpSize-members.html,sha256=YJ5J4_t5Z2seKvmmVeIDBOsBucvGxyBKNLZ_XLksep0,5389 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1gemm_1_1warp_1_1WarpSize.html,sha256=CmGJVrx39YcfmPLO6ZdL-TNrmDqzMmFLdGKVnixEq_o,6666 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1half__t-members.html,sha256=0Dw4ux-8pY8YPOxjU3G5ySN7QZRbdLI2xbb1ddigRPQ,12282 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1half__t.html,sha256=27xV5uLOj9gJDCxuRJQNpWhahtuzWU5c5Xx6Tc5996Q,39811 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1integer__subbyte-members.html,sha256=aVHMSCCxU7si3Jo68GfXv63-0-JfRpK6LqShZvyuAJU,10809 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1integer__subbyte.html,sha256=oyXp7Zd9VCXK3tsRjkmQjLeJlvnqqSNwsHchJrE3Q8I,32939 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1is__pow2-members.html,sha256=grT2_DW1aLEcBcqSensfxHiQAXxdAvshqyWJU3vvbIU,5073 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1is__pow2.html,sha256=B9E8kLSIc6f1HyW4s358RlwQRGLC11t_6d1itoZSuNM,6560 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1layout_1_1ColumnMajorBlockLinear-members.html,sha256=eVBnn1anWWmEbBc05iA8OofCZXkCNBPDf5C7a2ClkWY,11859 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1layout_1_1ColumnMajorBlockLinear.html,sha256=QJGtmVam3wSomQhmTO4zDoCApUUX0O8UW2IpdVTP5_8,35604 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1layout_1_1ColumnMajorInterleaved-members.html,sha256=D9n8MnmVCyFTP7B7IoC8YA5m0Xy6ftZXXNMzhMS0coQ,11637 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1layout_1_1ColumnMajorInterleaved.html,sha256=kwpa9vdwfSeA682_pP7v5rO6-wz4WaiIFGJzI_Epdbo,35750 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1layout_1_1ColumnMajorTensorOpMultiplicandCongruous-members.html,sha256=vqaBBAv0Q2YiojNtAyiXmZVJp82oBQgjp-pUyJqzZHk,15020 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1layout_1_1ColumnMajorTensorOpMultiplicandCongruous.html,sha256=3192xX97d9_lYEfuUyn_TitPIk_ufL8mL9xXj8YD0mA,44482 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1layout_1_1ColumnMajorTensorOpMultiplicandCrosswise-members.html,sha256=VpA66hP1zbZrTvui8pJROCqHh75APG8RUfskaIUdjtI,15020 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1layout_1_1ColumnMajorTensorOpMultiplicandCrosswise.html,sha256=VOM8-iX77jMZbm6GxDlcLlNVui407LmUeHLOtDETRvU,44323 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1layout_1_1ColumnMajorVoltaTensorOpMultiplicandBCongruous-members.html,sha256=T925wux7HV9L0TsjKwCWTtJj3dGfCaMlJgPN7Ih_oFc,15194 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1layout_1_1ColumnMajorVoltaTensorOpMultiplicandBCongruous.html,sha256=UqLixUTHiQLL4rhZrHorAJfRaRwq32lAAovodcOKCEo,44503 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1layout_1_1ColumnMajorVoltaTensorOpMultiplicandCongruous-members.html,sha256=R-q281iC2AE49s32FYTi4fH6ZPlHqYIPRSC52ugWZqk,15121 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1layout_1_1ColumnMajorVoltaTensorOpMultiplicandCongruous.html,sha256=RO2H4cXOlcrC_NyFWkBQC_ZQYs_z9W3CbMJcew75JCY,44372 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1layout_1_1ColumnMajorVoltaTensorOpMultiplicandCrosswise-members.html,sha256=mkQgPwd_D8LX6m21GECSb16vZ7NjkoPhfoBidt6phY4,13559 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1layout_1_1ColumnMajorVoltaTensorOpMultiplicandCrosswise.html,sha256=FopTHSAdEF0kKPWI1aGskgvawECP3puNSE7qAjwanm8,39122 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1layout_1_1ContiguousMatrix-members.html,sha256=TT4w1o3sJvrYfJctXlJ-cHR9RnpNUeq9BJ-rdkm8B9s,10266 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1layout_1_1ContiguousMatrix.html,sha256=-mNPMXTrKW_glf0bgeQIVY16zZCMpaX9tBNavcRbWZ4,30811 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1layout_1_1GeneralMatrix-members.html,sha256=2QjoUOXGS_12duVQCqab49L9_bUz3GJfWPvncdMSsaI,10819 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1layout_1_1GeneralMatrix.html,sha256=gGtbOLsMd3CQ9zhm5pHJS1KpkfYLPLRQ6LEsa7BYl3I,33329 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1layout_1_1LayoutTranspose.html,sha256=UJKcIMyLvcXzokOlJc9lhnLKBNJMn2OWmIDtOGA84bI,5096 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1layout_1_1LayoutTranspose_3_01layout_1_1ColumnMajor_01_4-members.html,sha256=ipNMYjs-TfkuMU0rOCHwiNmivFVKkcRehOVI0NJyo8M,5465 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1layout_1_1LayoutTranspose_3_01layout_1_1ColumnMajor_01_4.html,sha256=z3bYqOsoAqtxbdn6XEIM3-uzyIX7XsfR7hJSTn_JlOo,6793 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1layout_1_1LayoutTranspose_3_01layout_1_1RowMajor_01_4-members.html,sha256=SSu2njJUfh3wya8x804vhPUrlpkTuBg8Lq51_Nxeghw,5441 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1layout_1_1LayoutTranspose_3_01layout_1_1RowMajor_01_4.html,sha256=DMnCXZnmPpRLAq-ZBgy9DDcVVsutduTKy8VBtx-doIc,6778 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1layout_1_1PitchLinearCoord-members.html,sha256=wnYDSaVIe_myCS7R7Aob4oyhSoxmoJxdt9vJudrgbYI,22150 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1layout_1_1PitchLinearCoord.html,sha256=jasWVgVHC6GlpKQ7HJqvVpop3CIFfhDfCsa0PTSOy-Q,69657 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1layout_1_1PitchLinearCoord__coll__graph.md5,sha256=Lgp1qU4s9_Agt_ZsUZ1x7liTjdvYV9qKXeBDae-Qc1Q,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1layout_1_1PitchLinearCoord__inherit__graph.md5,sha256=Lgp1qU4s9_Agt_ZsUZ1x7liTjdvYV9qKXeBDae-Qc1Q,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1layout_1_1PitchLinearShape-members.html,sha256=u8a-67mTQ24oj_3Pn4Yfy4l3G_Njo6euVvC8l9sZBZI,6098 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1layout_1_1PitchLinearShape.html,sha256=eC4IOenedNqRM4rrRfxifPmTGxd0dfRpbj3YPc-42fM,8910 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1layout_1_1RowMajorBlockLinear-members.html,sha256=WQNy_eVgnarThkEcgKGptMWH67Ol85bhhQmR2GJllzg,11688 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1layout_1_1RowMajorBlockLinear.html,sha256=1ZI0GCCoDB9HigsX_hlzP8c0-2ZxDVJ33wI3shBiRlA,35333 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1layout_1_1RowMajorInterleaved-members.html,sha256=MLfI6w0SxHm8ld8CmCRfGIxCpItNGaXUxwsG44Zudk0,11463 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1layout_1_1RowMajorInterleaved.html,sha256=Tf8QNIdNFe39o2kYCGZ8VY4bVrcdyBrKZoHJposuanc,35468 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1layout_1_1RowMajorTensorOpMultiplicandCongruous-members.html,sha256=v2wDulyXLHKDERHZRPFDFXviYLAMy1flOk3DDaSYilc,14801 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1layout_1_1RowMajorTensorOpMultiplicandCongruous.html,sha256=h1dnZ4DhHQQ_u9zPIYhycZs-TmpFEaGpt90JKnrJO98,44119 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1layout_1_1RowMajorTensorOpMultiplicandCrosswise-members.html,sha256=EDH_MZ3GnVD4t0bf1AcNSFGbsQWTRn-uLsfc0y3PjWA,14801 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1layout_1_1RowMajorTensorOpMultiplicandCrosswise.html,sha256=ltqgYP1UsoYQONh66XWpu5an4cvLL_ZgYLrGO6LEu-4,43960 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1layout_1_1RowMajorVoltaTensorOpMultiplicandBCongruous-members.html,sha256=SQetQdcmy8_ss49zZcOoqu9ruBXW_8C_0zKNzlno2Ko,14975 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1layout_1_1RowMajorVoltaTensorOpMultiplicandBCongruous.html,sha256=w8Kj9-DQdGGcNLS4ePTk6MdrfT5k3d8jRbyhdrWFcmU,44143 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1layout_1_1RowMajorVoltaTensorOpMultiplicandCongruous-members.html,sha256=s3VYkRG6vWqCr6tC2vFSewoHY58WpHj3m8Q2mwLTnvM,14902 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1layout_1_1RowMajorVoltaTensorOpMultiplicandCongruous.html,sha256=6QZWVGcWJ61KG9XHLvnMIkOZf7yCb0mPnabQlYLJCQc,44012 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1layout_1_1RowMajorVoltaTensorOpMultiplicandCrosswise-members.html,sha256=OXKHnIuONmW1LXmddRaJECOFHSZe5hj-z8wtaX-YWaI,13376 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1layout_1_1RowMajorVoltaTensorOpMultiplicandCrosswise.html,sha256=kW-t3F_efuNma-LSAUZQUYTjIwnRWRdNIaG2yWgwgf8,38797 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1layout_1_1TensorOpMultiplicand-members.html,sha256=OQ2X0FGrk2YZuU4w8fjU17TMKxXuPi-IL1Y3YIMWWlI,14364 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1layout_1_1TensorOpMultiplicand.html,sha256=q_0r0npv-AW5iUI-Hd7hdDxuQhaj99dlsJqEVBarsCM,47915 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1layout_1_1TensorOpMultiplicandColumnMajorInterleaved-members.html,sha256=qtj5ylYgtu7Efk091zFVxwPK1mvo1_JHLfBDpbO-I24,13056 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1layout_1_1TensorOpMultiplicandColumnMajorInterleaved.html,sha256=rpj2tbz5jefJBUeNDMlGFvfot4HGZSPU068FWT79K0I,36837 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1layout_1_1TensorOpMultiplicandCongruous-members.html,sha256=WGkTdTF4v-sHvFGPRPuPvE2ew-KAdxJJmsqAS5C8YQ8,14217 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1layout_1_1TensorOpMultiplicandCongruous.html,sha256=LT4iyBQbPywCMKWwphEbqLCsfLWcUkR23mtfITf0HnQ,42872 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1layout_1_1TensorOpMultiplicandCongruous_3_0132_00_01Crosswise_01_4-members.html,sha256=GHQ21JXA7OaMAXBS0YpsYEoqQCMyEq9un0OOwsQjS2o,14351 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1layout_1_1TensorOpMultiplicandCongruous_3_0132_00_01Crosswise_01_4.html,sha256=tQ_XTujBTySbGoH2CcUshUWTF2WuwGYfcpOIlywqzGQ,41266 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1layout_1_1TensorOpMultiplicandCrosswise-members.html,sha256=XGx9Ls1A9arYOZp3Zt-t_uoNxYiuNl1lLKx9TaVs17U,15049 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1layout_1_1TensorOpMultiplicandCrosswise.html,sha256=WYElUTLgmlk7iLYLQVrqOQ4qY_0yjOtS7_S1qoPP62g,45202 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1layout_1_1TensorOpMultiplicandRowMajorInterleaved-members.html,sha256=mHpYNAlOQHmZdAMLJmzOMRysO3EYLSqGL-Zr7BtY3Ws,12882 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1layout_1_1TensorOpMultiplicandRowMajorInterleaved.html,sha256=YYeE8jhYnIugdC0sXhmUoJWayzxyyR0FSXaW8ehCTik,36540 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1layout_1_1VoltaTensorOpMultiplicandBCongruous-members.html,sha256=HS3_2N3qMLB95v-niJ6gsw_5ceFhvZO1raL1pe9N6U4,13552 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1layout_1_1VoltaTensorOpMultiplicandBCongruous.html,sha256=K-lW6dwAtR-Hjo4bDnQV8DDvNiZDiZDjTpA3799g-N0,41538 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1layout_1_1VoltaTensorOpMultiplicandCongruous-members.html,sha256=7vJ4e-C8BIH22myVh6ucuH8KKOKq7xaAejXjPnUuGqk,13485 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1layout_1_1VoltaTensorOpMultiplicandCongruous.html,sha256=JGoQaTjkjAjJdtbY7LkLW5kZeZQLwvsyKzNzRtna4oA,41426 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1layout_1_1VoltaTensorOpMultiplicandCrosswise-members.html,sha256=FbUjxamK_iCGpSKXfrqSNKQb5Qcs_NzFCKuAuBm0B5I,12472 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1layout_1_1VoltaTensorOpMultiplicandCrosswise.html,sha256=cWDjXWcrOu-WajMaPyREtkIT6WAKbYxXms_jCH0IsQM,35914 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1library_1_1GemmArguments-members.html,sha256=6_rjyfGQHpZ07pspUJ-CZ1gn5kgyRycSFiQDc4Oa1uI,7010 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1library_1_1GemmArguments.html,sha256=_BBjayp7MtGH7eIFEZoOoCW45EWZ5dIZ6yvpl6gGoKE,12033 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1library_1_1GemmArrayArguments-members.html,sha256=1ZI_kYsHTE5qHkHgBKcnQQpDoD7XBqeU4c-e9-Ouf34,7140 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1library_1_1GemmArrayArguments.html,sha256=QYcC2SzGdoaieqK0LIGU_OaT8GxizyCMZJTRGG2jSFc,10695 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1library_1_1GemmArrayConfiguration-members.html,sha256=DsNtodI1x_l-tN05YawuRfK8MMqWstcODF073AEfoKU,6924 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1library_1_1GemmArrayConfiguration.html,sha256=etD1yKh-Ns6t25UMe6DhMF8sk-38_XDKM6UoQzZ-dz0,10564 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1library_1_1GemmArrayConfiguration__coll__graph.md5,sha256=WxPCMbg-kEFIKfGRbBo41X6Xi3zaGMgBlqqAFKsWs80,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1library_1_1GemmBatchedConfiguration-members.html,sha256=EkUsstZTyhrB00Q7KmkRnAxD8qqqfqKGNvQRAjLgr-Y,8344 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1library_1_1GemmBatchedConfiguration.html,sha256=j3jdTUh1mTRNp7jQvmu-k4CYy8965ZcZWj9timnAdTQ,15721 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1library_1_1GemmBatchedConfiguration__coll__graph.md5,sha256=W5e69WVArtshLikcIlyXJXgd_vIbZajiJUd__5fO5FQ,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1library_1_1GemmConfiguration-members.html,sha256=ptttojCl5-1a7ys5gMWRL7lPDkkP6UWA4tXckgQlllk,6812 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1library_1_1GemmConfiguration.html,sha256=Fh6HQZSKbfQhMr0M-mq_ylfyrIU9tyxvF3QuVz1L3PA,11646 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1library_1_1GemmConfiguration__coll__graph.md5,sha256=QHlmRTr7H21BXJB5lp5Nj1F4sTsyUecUCFPBGeZzYRs,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1library_1_1GemmDescription-members.html,sha256=tbhKHFaCva8dMHYjh9F32O7FU97tx1aIUFWdSZsDXDc,9645 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1library_1_1GemmDescription.html,sha256=zBP9krJOtsndnBHUHgYsmXW2TxyErSjjrMDXJVUK58I,27706 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1library_1_1GemmDescription__coll__graph.md5,sha256=fKpdAQS1mJTtMn_fUpenLeAdhoyjd_05d__iFm6dDPQ,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1library_1_1GemmDescription__inherit__graph.md5,sha256=P69q7x67eRKYYx5m3Ao6avhlIPq2MuZflKISEBhlQEs,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1library_1_1GemmPlanarComplexBatchedConfiguration-members.html,sha256=y1QDmLjRJeYBmTMobgzr7dDQE6p7vASRv1melrwT5IM,9960 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1library_1_1GemmPlanarComplexBatchedConfiguration.html,sha256=zaB0_C1qfAnf73alswHMayf5wcfW6Y7ItHcaL9-Dc3c,16221 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1library_1_1GemmPlanarComplexBatchedConfiguration__coll__graph.md5,sha256=UWJBFYNxnGOZxSib7VR09Z2DlbneAJHMiJ600fAVIvQ,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1library_1_1GemmPlanarComplexConfiguration-members.html,sha256=ym0iB6GpdiwAVvwbddD43mwY1y2p45vM6x5LvBNb4xA,8198 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1library_1_1GemmPlanarComplexConfiguration.html,sha256=y8EodfQzRA7geEZisqoHUERJGzKO_xlu-6wUYYMURyM,12941 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1library_1_1GemmPlanarComplexConfiguration__coll__graph.md5,sha256=3a2ALq3xU0Dc-O_dVp9VOCdAch319dpdMUx6jBUCby8,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1library_1_1MathInstructionDescription-members.html,sha256=CYSAPAXhw2_f8NtBNA46kj9C2_IeyDfHT4CrCh2JHAw,6600 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1library_1_1MathInstructionDescription.html,sha256=8TQbQTWmCRNYFi_YE7JcRdfPKg1kfkR8IitjP-hlPko,13164 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1library_1_1MathInstructionDescription__coll__graph.md5,sha256=qZDYI4i7pnMCW1xF7qwnNZlkY4E8M-gmzpYvMo1DFlU,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1library_1_1OperationDescription-members.html,sha256=cX0wwoIByMDZSMx31G78eaYQg2gyfHCMXPj3nf-nePA,6431 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1library_1_1OperationDescription.html,sha256=eu3WyaZlohXgnHsBUbaB7xaPt2h6T7x3dTql7J05s6o,12831 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1library_1_1OperationDescription__coll__graph.md5,sha256=k1wYeJk3wzXxDNP43YK-NdHxM8WM3CzB6KD8zacpFqg,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1library_1_1OperationDescription__inherit__graph.md5,sha256=Doe_tlW12IOZ760rj6S1JDhTTSDtm3_jI0BDxWQynY4,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1library_1_1TensorDescription-members.html,sha256=ceoT1Qzv_s4w8jhHi90P28JSgySnaIa5jnSmxX1Eiko,7037 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1library_1_1TensorDescription.html,sha256=_XGRqtB3g2u4eyHirJk4lADfwlT1hlo2EtNMjI_Wt80,14489 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1library_1_1TileDescription-members.html,sha256=iaIYdeVEKyLLHAgX8xcT14KD7Aa0RatAuDSY_JnTeqA,7502 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1library_1_1TileDescription.html,sha256=2gz8wTLS9dZufTkGS5Cxu9AuJeRjKoNRX1nwYF3jWWI,16807 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1library_1_1TileDescription__coll__graph.md5,sha256=pkBa4F0igZ6XVgJp91YHU0Bv-7La76TYnK3aNPTy7EM,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1log2__down-members.html,sha256=YnVSQJmsK4fesqgPKrFTmpTHsqbf-qto6MUgc7EFBYA,5156 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1log2__down.html,sha256=-vzs8qNHJgA9YZYgqhbjly8_KlGMilAGvnjAPppaxIY,6915 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1log2__down_3_01N_00_011_00_01Count_01_4-members.html,sha256=jUhfp4MgyPeFXvTNXca51PzovVRGa9v4rD2oQFlP1L4,5266 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1log2__down_3_01N_00_011_00_01Count_01_4.html,sha256=5j6wcPsoAGTkArakVe9YiDWOQgdGzWyaJXOYL4xjURU,6391 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1log2__up-members.html,sha256=xCcyGxaDLKkqprx96JeWpIPZWjV3QFVQCkD-DmS6Zpo,5140 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1log2__up.html,sha256=YWMRHRdTbVJal4wBpH_aPKRI1M3wYMD0Kn9BlAVagu0,6895 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1log2__up_3_01N_00_011_00_01Count_01_4-members.html,sha256=t2_-HJCaRY2hTAp41CsHuenHmUagPQh7uqeMcxhmJDg,5250 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1log2__up_3_01N_00_011_00_01Count_01_4.html,sha256=UZN2xrYlsHuLSQo-4FLwd7VWnpJjKCXEA2lSp-PPHqg,6421 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1maximum-members.html,sha256=_tpq6GBfb46HqKOK98s2GJrZ1BE5b2VJ-WfAW_JrPv4,5117 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1maximum.html,sha256=7-QM99sEFDDVXX_PQq0XCyDhA0bk8Op-fR3RbCmDuwU,6908 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1maximum_3_01Array_3_01T_00_01N_01_4_01_4-members.html,sha256=QSys1k919DPOMa0j0ZyzvoYczS_koNtzYYZ6M-EW3n8,6269 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1maximum_3_01Array_3_01T_00_01N_01_4_01_4.html,sha256=6O2ArIL0u2agU5zmupuWdkeugVTOYf3H9coIhjsCx9Y,10754 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1maximum_3_01float_01_4-members.html,sha256=AIAvHwiKCeo3jvfG0O8ykxi9Q_spdWCMwk_JiqRUYSg,5212 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1maximum_3_01float_01_4.html,sha256=A7M9FBnmozvaiwmzNIijiDqHI6fxgOyiQB1YcSnlUW8,6944 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1minimum-members.html,sha256=mQmrwAw7DKNQrixyNVBQ0bq64dNqLbtYiP8zUaeeM_w,5117 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1minimum.html,sha256=98_DomTm0rs4lJ0X9B65ivNzH5Yw_-frhdtocJK8D3g,6908 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1minimum_3_01Array_3_01T_00_01N_01_4_01_4-members.html,sha256=rafDCddcTEq8jpKTXz8xVgXc51DKs3B7ur2SqZOy7Pc,6718 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1minimum_3_01Array_3_01T_00_01N_01_4_01_4.html,sha256=WIYg8ARcXA0T13jeunzxyIvn6a8O-zDRBCRHot0APS8,12734 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1minimum_3_01float_01_4-members.html,sha256=z8HG90aS_he9FdoD0HKulOrDj8O6uIXOlHvk7Sg9tno,5212 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1minimum_3_01float_01_4.html,sha256=vFygu1XNzo0E4oQehbcXgimNIRVHzsEC0K20J2VB9IY,6944 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1minus-members.html,sha256=U-OxQ7zm8G-oPcwgmL5RFve9wvaPpi4IN_fR_KmuoaM,5090 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1minus.html,sha256=tnAMvVvaAPTXSfGjwIw0AwDciAGRd1JiO-HjhKM0X38,6869 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1minus_3_01Array_3_01T_00_01N_01_4_01_4-members.html,sha256=SFMbs0rwSO8AQVAGD-R11nRhUwZWxXTu9e0JRUIP0iU,6241 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1minus_3_01Array_3_01T_00_01N_01_4_01_4.html,sha256=SD0NYFKpI_DgqvpDLcTyAlhaRrzg08CIxSW6ij0H5s8,10726 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1minus_3_01Array_3_01half__t_00_01N_01_4_01_4-members.html,sha256=c0d3uI2UZ5xNJlerjFHS12cRYL_bVTnyXMGPXBkghUM,6343 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1minus_3_01Array_3_01half__t_00_01N_01_4_01_4.html,sha256=_BmD1TsHWneIqND4whHGLt7ptkd8RqD1Ffvu2DTn6e8,11980 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1multiplies-members.html,sha256=KXkcMPyTD7b9xa983aCorWIMYpXaCA5DhF-_AjBbJ0Y,5130 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1multiplies.html,sha256=-T8SZ53R93jZJ84HoJfpnUBEL_9q4jKg-F9awG9pK7g,6909 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1multiplies_3_01Array_3_01T_00_01N_01_4_01_4-members.html,sha256=ASXJ2MYHi1Jrc1nu20X2WPnaWgURfo2HUGu1MKQBTS8,6311 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1multiplies_3_01Array_3_01T_00_01N_01_4_01_4.html,sha256=xKL3iFk5tSoJgyqCn8FP3dIWNofWWmlJpP7VYRxkwCk,10796 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1multiplies_3_01Array_3_01half__t_00_01N_01_4_01_4-members.html,sha256=5Oc6Uq1oLm2AFlWyuMEMImlQWEh073Haw3kj-vVjYfs,6413 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1multiplies_3_01Array_3_01half__t_00_01N_01_4_01_4.html,sha256=JNVbAoGVF1LxOvVM2j30IHEPOBZyttZa5VRdPjYz3ms,12050 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1multiply__add-members.html,sha256=IRc2YG_4We39ZczYz1m_fGpy04Z21heEbMpZ_mJI1lo,5191 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1multiply__add.html,sha256=pqRfo3WcADZSTyo9QLnsNWre4SoIhiZtN_zsbisiQCU,7232 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1multiply__add_3_01Array_3_01T_00_01N_01_4_00_01Array_3_01T_00_01N_01_4_00_01Array_3_01T_00_01N_01_4_01_4.html,sha256=vXkybKBeHeA7IERcgYjNlfVNpy_7TqmWNReUDCc9fuU,12117 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1multiply__add_3_01Array_3_01T_00_01N_01_4_00_01Array_3_01T_00_01N_01_4_00_01Arrc22976a5dc70dc30cb0b8cb0caf7ab47.html,sha256=HAtK4CpHeUHxMuwVrPnBHvw5FmI5CJsWVmpVCPRNUn8,7157 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1multiply__add_3_01Array_3_01half__t_00_01N_01_4_00_01Array_3_01half__t_00_01N_01adaeadb27c0e4439444709c0eb30963.html,sha256=giAlYNG_zAqM5I3vUNeG-QOVA9dsPdf8qc6MlGPmK64,16886 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1multiply__add_3_01Array_3_01half__t_00_01N_01_4_00_01Array_3_01half__t_00_01N_04badf8da5e654ee1d0a3e7ed231f3e77.html,sha256=363vqteS8aJu5EcVqSfQ3SKsOkd8zNQi1IPZ7GklOco,8028 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1multiply__add_3_01T_00_01complex_3_01T_01_4_00_01complex_3_01T_01_4_01_4-members.html,sha256=K6zU5KpFpq_NqYjzkRdMEj9fEwye4M86Ap-X3oVSEFk,5614 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1multiply__add_3_01T_00_01complex_3_01T_01_4_00_01complex_3_01T_01_4_01_4.html,sha256=XqoIEXGtGcs5DSFaqLpFdm378T7_hsXxToAuW1oVbHw,8063 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1multiply__add_3_01complex_3_01T_01_4_00_01T_00_01complex_3_01T_01_4_01_4-members.html,sha256=OykvkIh5ZVoyd3YLS08y-n-xIo7q_u-Jr6MOlcKUOv8,5614 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1multiply__add_3_01complex_3_01T_01_4_00_01T_00_01complex_3_01T_01_4_01_4.html,sha256=brQaiIHjK11ROBWVx-y_CUR5mJWFh7rCEycBrhLKzuk,8063 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1multiply__add_3_01complex_3_01T_01_4_00_01complex_3_01T_01_4_00_01complex_3_01T_01_4_01_4-members.html,sha256=8qHjD7PXUZUFZK6PCSPtOsP4Tcj-dKLUfhbZT30e__w,5767 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1multiply__add_3_01complex_3_01T_01_4_00_01complex_3_01T_01_4_00_01complex_3_01T_01_4_01_4.html,sha256=1nPxEEnrWm0hTPgcMXm8aUHRL8pSsvoUy8J2SQnhu5Y,8378 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1negate-members.html,sha256=9fvHZ0pzIDZbh77BbUABiz9oVllPjoVKn5F1HLuYLCs,5080 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1negate.html,sha256=WHdncDXu52wpQZexv8Cs2DlvVV6JKxpDnpL79YQhAOY,6593 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1negate_3_01Array_3_01T_00_01N_01_4_01_4-members.html,sha256=_dsBj72uVpR70M3EDwApaF1QG95oJd9YQMC1i5SMGI0,5324 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1negate_3_01Array_3_01T_00_01N_01_4_01_4.html,sha256=j7kClkh1AtmMWEU3UOtot-WXrBYLA-kYZAalDs5Bqig,6876 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1negate_3_01Array_3_01half__t_00_01N_01_4_01_4-members.html,sha256=TwHNJDf55kZtEHaDzlqp20x2SY7duAgRpGZ6EfQW_EM,5373 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1negate_3_01Array_3_01half__t_00_01N_01_4_01_4.html,sha256=kq17M0dqSvcIhZQkOsNzGBrXw8afWAf7y6oImhcI82U,7196 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1aligned__chunk.html,sha256=Q1JrOd22hk4qT3MwtS7qtc2vY-DX_rJSAIE2lM1eMFY,5033 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1aligned__storage-members.html,sha256=gb7CUsQLayd4IDX53vG7XQPJ-0nX13vFlhVA3qY99Dw,5307 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1aligned__storage.html,sha256=AQGtBRpPRKkAB3Fsr33RI6Fsl9RTYLIAg3d3w_Gc8Fc,6771 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1alignment__of-members.html,sha256=G_FRsnmuGk2bSVlGvtvPguNSOOS602eotw0mTleJC3M,5311 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1alignment__of.html,sha256=wHwS2jt-EXhgejlP_GccjpXdCLjBrSXvZBOVUaZuSN8,7582 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1alignment__of_1_1pad-members.html,sha256=ngdJUxTgNYhdkv9wUHMxlSnAqQGkMMptSWxtgXTDT_Y,5741 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1alignment__of_1_1pad.html,sha256=0wW3gVqZJXvAhfDBeP5_5ife3tfnO-HUS57ZyULGp94,7874 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1alignment__of_1_1pad__coll__graph.md5,sha256=FE_v42nn0_RRloZpeP0ZD5LBk4Z-akalKDIJFvWfiGk,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1alignment__of_3_01const_01value__t_01_4-members.html,sha256=3bIpxxvi41mPw7KNKf0J82JScBI9dzNO_eTAO02S7Q8,5398 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1alignment__of_3_01const_01value__t_01_4.html,sha256=kGQTiylkliltaWubFTVo8h5f8ddZcDOtzGuMqX4GVsw,7677 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1alignment__of_3_01const_01value__t_01_4__coll__graph.md5,sha256=o3TiBIAFDFLgRXEYi9FpqoWyq-Ei9Eru5Rr5mwZa_p0,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1alignment__of_3_01const_01value__t_01_4__inherit__graph.md5,sha256=o3TiBIAFDFLgRXEYi9FpqoWyq-Ei9Eru5Rr5mwZa_p0,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1alignment__of_3_01const_01volatile_01value__t_01_4-members.html,sha256=GiC-an9noJwdJt7ujRlDmmkEwSnYlYLyHRuKMQgrlrg,5447 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1alignment__of_3_01const_01volatile_01value__t_01_4.html,sha256=SsVd6lE7o6sGHxIFA11TpGpjWV5QPAZU3fqwC36_D8o,7832 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1alignment__of_3_01const_01volatile_01value__t_01_4__coll__graph.md5,sha256=wwkbuS2dDr_V4p199KhJKdvFB_mO2NLyiPFvuoI6ocE,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1alignment__of_3_01const_01volatile_01value__t_01_4__inherit__graph.md5,sha256=wwkbuS2dDr_V4p199KhJKdvFB_mO2NLyiPFvuoI6ocE,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1alignment__of_3_01double2_01_4-members.html,sha256=N-2kf1ZWH6rECCiiHovfnRPwIAczKyswkT8JcuGJR5U,5396 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1alignment__of_3_01double2_01_4.html,sha256=AyePODmbEwKz5OXrXUM5Zp9tjK3XKBQs_QUDRQ_itcI,6434 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1alignment__of_3_01double4_01_4-members.html,sha256=c-Y9auyBCemgg2ADI5NruzWUy_dJC7-tVB1E33lxKMo,5396 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1alignment__of_3_01double4_01_4.html,sha256=dtGuGEbvkAOxs2yUoP6n5P_fVCo5moGkhI0KxxWihDo,6434 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1alignment__of_3_01float4_01_4-members.html,sha256=MrYcSNCOLoNYOVtB3r9MKDObJmbihk4pWTM7-sC4RRc,5388 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1alignment__of_3_01float4_01_4.html,sha256=kTu1a3ZrO0U-jbcpp55yxrc8eC-i84gCb9UoPRdb0t4,6428 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1alignment__of_3_01int4_01_4-members.html,sha256=RaxLI6YlUC6Y9AeGE0o5qgwNa2DArTnQ7BuOBXvYj40,5372 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1alignment__of_3_01int4_01_4.html,sha256=uruN9B5ypNBN0J9Om99qf-q0v8zwcCsKGeczXY7BFuE,6416 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1alignment__of_3_01long4_01_4-members.html,sha256=_1YTH9Ga872ybFqd8MwD62n8jEjokkO2VepWa56p7w0,5380 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1alignment__of_3_01long4_01_4.html,sha256=3TNQXX6hfSCa3sEMPcvxkJaT7OrwCJfdPGppSwOoYzk,6422 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1alignment__of_3_01longlong2_01_4-members.html,sha256=JiSW1FIfxflzR65ZXoLY0tSUEhmTEki_qknu0kQo0ps,5412 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1alignment__of_3_01longlong2_01_4.html,sha256=XA6Wz3jF62R_TLw253q3OTiuVxOrRDJcd6ZiaZMmW9Q,6446 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1alignment__of_3_01longlong4_01_4-members.html,sha256=26utGLvndkyFwmZDpFbG85Xat0u5ADQxdAPpouaiQL4,5412 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1alignment__of_3_01longlong4_01_4.html,sha256=cyEtX-BsFYH89bkOsz7-S-VhfPqYALKe0Tt5T-IeZMY,6446 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1alignment__of_3_01uint4_01_4-members.html,sha256=IwWyz948_pVSYWBTDniRrA56bV_ru4TRwDrAgJ0zNGo,5380 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1alignment__of_3_01uint4_01_4.html,sha256=swhNqOIuVaMlgRzyIBodUjEtxr9jPm-njRixxqjFvWs,6422 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1alignment__of_3_01ulong4_01_4-members.html,sha256=5uCERdScFcJRhrFLEKLASo4oXoCtH8CD7cD2QFgQcvs,5388 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1alignment__of_3_01ulong4_01_4.html,sha256=jlqawktawJiS9vZS08a1HGuyA4qGSDvhvnB8LQOHW6w,6428 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1alignment__of_3_01ulonglong2_01_4-members.html,sha256=ZlRw-bt_9d8GoO0E8BajvncgZ_lybygKGbPoi84hcSs,5420 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1alignment__of_3_01ulonglong2_01_4.html,sha256=C0mjZpMFLWf74k5-3Awh4trcCleZn9bMuPXA81DEdjs,6452 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1alignment__of_3_01ulonglong4_01_4-members.html,sha256=qSfghc1pvVSBpO8Wn2UoOJB_qAEusdm-FbFcTOsNt-o,5420 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1alignment__of_3_01ulonglong4_01_4.html,sha256=3E3x345X3VM3U_AL476jtD4KyKYk7atOGE7wn6xgUT8,6452 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1alignment__of_3_01volatile_01value__t_01_4-members.html,sha256=pv1fhSRmTn2rSmhQcDLn0xjJ5FsyHImveAXbvOLvhZg,5413 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1alignment__of_3_01volatile_01value__t_01_4.html,sha256=siXp5Gr7qc-FajwHpR4fOqeoTtXK9-OaAeU-2exnnOU,7722 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1alignment__of_3_01volatile_01value__t_01_4__coll__graph.md5,sha256=9wfZKdMPUfKm6fxMjks4QxaUduE5Ab9Q5ii1ZJtwj0g,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1alignment__of_3_01volatile_01value__t_01_4__inherit__graph.md5,sha256=9wfZKdMPUfKm6fxMjks4QxaUduE5Ab9Q5ii1ZJtwj0g,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1alignment__of__inherit__graph.md5,sha256=RF-DMictTSRbE9YxL8DOIMkzV-M66TneZ9SqCHmbqZk,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1bool__constant-members.html,sha256=XRuveCvoKdN2LMDaCz7pV1UXqGUBoyaudfLSWtXAwE4,6774 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1bool__constant.html,sha256=fQTpbi386fI2UGTryWvvHRZU1juzCUwbAZuOX8MCU9I,10911 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1bool__constant__coll__graph.md5,sha256=hSK51VAXRiMuY0siPzs5xqK23QR1iORWh7YEBXiXxDo,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1bool__constant__inherit__graph.md5,sha256=hSK51VAXRiMuY0siPzs5xqK23QR1iORWh7YEBXiXxDo,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1conditional-members.html,sha256=meSIvohqNKI4JpDczpC8aDrfbmAlHQdDeMVgkg1lYM8,5262 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1conditional.html,sha256=pyVQEGvJ4SCjS9nsTGNk5ns1r9wsI5mjYgXHsJS4TTo,6417 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1conditional_3_01false_00_01T_00_01F_01_4-members.html,sha256=LYQVzaJIT-G7CHwHXrnKiCHkbnwf_JVqP76o4xNCFxE,5411 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1conditional_3_01false_00_01T_00_01F_01_4.html,sha256=10zR41E91yM7eWocTouPfH_lrJ4UV8rbfJvDKUmzB60,6561 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1default__delete-members.html,sha256=Mfyt7xr57mIv4gKznkwx241hvl8WT3bo7vNsiwj9SSs,5319 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1default__delete.html,sha256=we1gQhh8G8GimmnlevJc_-oHY1a3U2i0sdabkuH9hn4,6671 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1default__delete_3_01T[]_4-members.html,sha256=f2dfH1M-P9ZvbwENUP-ada8jbvle0JBMYiDM-35XLg0,5374 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1default__delete_3_01T[]_4.html,sha256=UlX3gKp8WdfbL9cvit5PXJA6WrTksv1LehJLDrLvNZc,6748 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1enable__if-members.html,sha256=8N_1gw8GSojEFJw-2vtlx-Utrnizq7s6f8ssTjSOnc4,5241 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1enable__if.html,sha256=AGNCsJiMPp0Gr-GdEfyWKTsX4AfuXEbyhgNoPaV54Sc,6395 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1enable__if_3_01false_00_01T_01_4.html,sha256=FZ0L-F2N3FkVBg_bLbnQd9L_sjMcT6MuCgeMzZA3kmk,5112 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1integral__constant-members.html,sha256=Ntbq9ZsIEq3MFHfVAH009hb19JPXktwsP3talqjfDSI,6829 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1integral__constant.html,sha256=DEe8DvtpY1Lv2OQULsM_Ylwa2YDwSohn1K3Pn7nPf7o,13777 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1integral__constant__coll__graph.md5,sha256=Xm3iiTUZDYUtU1OJQBRUE882lLMWqSRLQic-RXTbiUE,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1integral__constant__inherit__graph.md5,sha256=5n-X4CInDVRItkTqsvj55mewVhFnUE6KI_a8oZ-8kZ4,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__arithmetic-members.html,sha256=9XrJg3PDy5SMP9oTMn9QHYSDW7F6KWcFBKWdHhfD2b8,7099 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__arithmetic.html,sha256=96R9dytny4l9a2wVkXiIqLo58Ep3c33TNawxyFTbubw,11106 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__arithmetic__coll__graph.md5,sha256=VnHiTsY8lzO_e2CMrEHoMk9ieRAJTdqzGXqOl50zW2Q,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__arithmetic__inherit__graph.md5,sha256=VnHiTsY8lzO_e2CMrEHoMk9ieRAJTdqzGXqOl50zW2Q,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__base__of-members.html,sha256=h-HV2kMnjc2e8DAQrNqhUQK5Yqhx_mO6tm_gNwmSLcU,7744 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__base__of.html,sha256=6iPiqKtNh2MWUEld3dzHhiPJMCyQiK-1LUXmebAaSi4,11610 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__base__of__coll__graph.md5,sha256=dLN9badn5Tllf9NLrSZHoOuUe1qjcOWFKY1cs0YJGSI,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__base__of__helper-members.html,sha256=odmBhpOpp0t9noltctO8UkSe4i95PI83qDz4h81DICI,6871 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__base__of__helper.html,sha256=uWVWQyoksMg_UwxD3dRNLpOy6nnaeXCjzG2SLOiZAgg,14347 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__base__of__helper_1_1dummy-members.html,sha256=F6dPq_h4_m3OxiPWrLHQKW5PdfbJIJZjH-CiH4tpr6w,5953 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__base__of__helper_1_1dummy.html,sha256=bu2gz65IRjFWdG8FwLu_MrvxLR4qspVL1-NxRtMw8lQ,8415 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__base__of__inherit__graph.md5,sha256=dLN9badn5Tllf9NLrSZHoOuUe1qjcOWFKY1cs0YJGSI,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__floating__point-members.html,sha256=RMW95xu2S_544VX3cYzfNj6_IJ9G2tqRMnwlz7pKE5o,7376 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__floating__point.html,sha256=8FSlhA18RNhj_2Q5AImRtgmLivVvBDP8Z7LNu_MkzJw,11333 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__floating__point__coll__graph.md5,sha256=XqDTNELk6HAtXBpqd3h9rBT7MV-PYmn3cfVUDe_gaJ8,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__floating__point__inherit__graph.md5,sha256=XqDTNELk6HAtXBpqd3h9rBT7MV-PYmn3cfVUDe_gaJ8,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__fundamental-members.html,sha256=OeBBuYTdr09fxrRfu4LAhtxnRPmvOVQl2mQ2A0VJ2h4,7379 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__fundamental.html,sha256=QLcSBEUmlpCY4pZOaDwk9QZmJv5X-6z3p47S06JO5xM,11287 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__fundamental__coll__graph.md5,sha256=kENvcdDz2FnAdSHG18FIBcYThX_kbZ5v_PmfLr8dOZM,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__fundamental__inherit__graph.md5,sha256=kENvcdDz2FnAdSHG18FIBcYThX_kbZ5v_PmfLr8dOZM,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__integral-members.html,sha256=o6rWlv7-DzJyqz66keMHp69neGEigDK_Qxd3VPRAsEQ,6781 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__integral.html,sha256=krb7t0JU3NEZLsZy7RV-ixhtuFwiEscK_vUM9j5YJf8,10903 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__integral_3_01char_01_4-members.html,sha256=_Zc8JBF2K9txdb6VnRKbxfYM45u5dM5-7c4HzsGNaSo,6829 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__integral_3_01char_01_4.html,sha256=8TQe8i7uqijmPZoHUsfwxLk8ZlwmmsPIOXDy_nGKxiE,10975 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__integral_3_01char_01_4__coll__graph.md5,sha256=EpXKjIMNQxuH2LuGBsArgtkkqRMy6l0diES2V5L2WU8,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__integral_3_01char_01_4__inherit__graph.md5,sha256=Lnbt2NNpREf9D-9T1VlbfuZdkb5Ow7HIaK1aC5aRcWk,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__integral_3_01const_01T_01_4-members.html,sha256=l32DSKFTT9xZqfjbjRwD9ajsNFL-NRLljNNhHr8iIa4,6848 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__integral_3_01const_01T_01_4.html,sha256=kHbO3yN7nrSGvIsnqxSiNjyNMM3vnEqgWFY9j3sL9YM,11040 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__integral_3_01const_01T_01_4__coll__graph.md5,sha256=o7WRyveWk0Te6_q3ZAXp9sqEl2xt3oXiQ3ZYwIlfLO0,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__integral_3_01const_01T_01_4__inherit__graph.md5,sha256=mUyFcTmQAlUu4Ek5AQQeQozzJCpa_GI90VAWAWN1ccE,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__integral_3_01const_01volatile_01T_01_4-members.html,sha256=gXJl8kUuxLmKY_8vNLDEFKbf7sXdocanSDDyxgVA1j8,6897 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__integral_3_01const_01volatile_01T_01_4.html,sha256=DvJHxAXgCe_wbS1m_kQ4YiCSsOADd6i_wuEU3rrZ8JI,11195 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__integral_3_01const_01volatile_01T_01_4__coll__graph.md5,sha256=AEpo2AzzROTLFVv6KS9LZX6acKG5DMgLY_hiSJL47jk,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__integral_3_01const_01volatile_01T_01_4__inherit__graph.md5,sha256=-bPd_g_677HNikHJlmRo4D4WEH74f4cBiMxlilBKzT0,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__integral_3_01int_01_4-members.html,sha256=siEiIX9_tK_erUCWjEgYn_hX5gmQVmoGJnaLJBNGgL8,6824 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__integral_3_01int_01_4.html,sha256=P4v-1rfyWvZlcVX7MzLlS7JzqdjBcXC2IN1TBFlmX7M,10960 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__integral_3_01int_01_4__coll__graph.md5,sha256=YcSoQn92IMgdofNsqBYiBEIAp34Z3p6f2n981m3VujY,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__integral_3_01int_01_4__inherit__graph.md5,sha256=ggixYTLDqNSJ38AamsRgD9Cw1pFEfMO2KLzKsVuYkJI,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__integral_3_01long_01_4-members.html,sha256=9Rt7ZVe6uaOAAJvZakyj2hK0iUGNyNAnVAdTxKbDfcs,6829 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__integral_3_01long_01_4.html,sha256=Z1S6fT1M5nF-gY0nOpJElrdtcAxLOQoHP9vLDT6-djg,10975 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__integral_3_01long_01_4__coll__graph.md5,sha256=QdtohFAI8oj9DbmD-QDG-kQfGrhnMvT1uZLXQ5uUTZ4,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__integral_3_01long_01_4__inherit__graph.md5,sha256=VqiM7ROzASQHsx0M4GbVfkFjF6WE_AueP4TY1FQX6Sw,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__integral_3_01long_01long_01_4-members.html,sha256=sKHG7FMx3NGgFT_G2YGioeFT2ZGJU-2wH3J6hva1a9s,6858 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__integral_3_01long_01long_01_4.html,sha256=T9zlx4DEsbrQoFq31AVcqRWByFBUjAlnXtSeR3cAxk8,11070 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__integral_3_01long_01long_01_4__coll__graph.md5,sha256=TcFddadTtMFrcfoN1BLuL_gZt3sbzMBjL0wbQzzP6ys,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__integral_3_01long_01long_01_4__inherit__graph.md5,sha256=1mCx0W0Qbmv0Bl3t4mW7ArhnIDnzIWZU0eZOGeuJFsc,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__integral_3_01short_01_4-members.html,sha256=MeUCxYhSfdgFZ31fRYPw-8R1tk31QqkzNtBg9jbQzsY,6834 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__integral_3_01short_01_4.html,sha256=wtmF5onERCt83AUj6GCLdYiiPkbM0R2Pu7VHXuaq9Rk,10990 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__integral_3_01short_01_4__coll__graph.md5,sha256=IJTuxBFWSpEucNxLHMCShR5pCKk5tAPy9iAFmVGICDc,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__integral_3_01short_01_4__inherit__graph.md5,sha256=PPWsbmf5bl0CKUAEiZCyDWgNSIDiPbJKca6xetdzJts,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__integral_3_01signed_01char_01_4-members.html,sha256=BKcgYGFrIcsbKt3EGG4kJiy_4dQtqS3SX33VwQaaS64,6868 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__integral_3_01signed_01char_01_4.html,sha256=1VMIMtMfU8pbV8rTQinfwPgghnVdyRW-y6dxgOam4OU,11100 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__integral_3_01signed_01char_01_4__coll__graph.md5,sha256=sI3abdGynojqXybPSFnx0vqTMfeXefB14pNTVzqPICY,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__integral_3_01signed_01char_01_4__inherit__graph.md5,sha256=BBiMoq4WEC1DVobzL_yGzdfs-tWYAZrXlW4W5VtplJc,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__integral_3_01unsigned_01char_01_4-members.html,sha256=FrrRbwTSMhhF65esRaQGLP78Bk2Div_hTEyY6a5aGrY,6878 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__integral_3_01unsigned_01char_01_4.html,sha256=_NSWhJtHKI3bH_T1Y8Yrd0mGvgZmDdAQTZu2FcOyrVw,11130 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__integral_3_01unsigned_01char_01_4__coll__graph.md5,sha256=E7ERv2sQZC6XN7XJVVfcCbY0RNmtw1BtCIwm9rGf0Mw,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__integral_3_01unsigned_01char_01_4__inherit__graph.md5,sha256=3R3fUpXLNuwewOcIhkjIwCfDJvLiqrOVLgyKvob-vC4,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__integral_3_01unsigned_01int_01_4-members.html,sha256=7mzIYcsBNkCQBzin6qu3SUpp4rC5ww1Bth2QdxDfY1U,6873 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__integral_3_01unsigned_01int_01_4.html,sha256=0vU0D1LOF5WUOhQ7SAAs4ebZnuGXU5qyYGt_zstGnm8,11115 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__integral_3_01unsigned_01int_01_4__coll__graph.md5,sha256=i3oKN0TlSQTWmX9gaakUU-8NNSj_I50DIFSwNIeAh9Y,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__integral_3_01unsigned_01int_01_4__inherit__graph.md5,sha256=-v3Kcse-E1shWIeDo90aBzv2g3N1Z_aPxfX_L5EzmzU,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__integral_3_01unsigned_01long_01_4-members.html,sha256=0fElGUC_3RoPhe2jy7rrdZ590kRvX0nltVSLFmx1dQc,6878 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__integral_3_01unsigned_01long_01_4.html,sha256=K9kbjSTBkfuEjb-v0oyyCb9k92926O72ed7nVSgffNw,11130 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__integral_3_01unsigned_01long_01_4__coll__graph.md5,sha256=91EIcZTU0_w1Glim1alBg8U-AaNsbeGFyRAE0RLPxiY,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__integral_3_01unsigned_01long_01_4__inherit__graph.md5,sha256=t8m_xMv7LTP7F8mANrexh4Rsi4lvu8dg6ICwlsJS6cs,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__integral_3_01unsigned_01long_01long_01_4-members.html,sha256=UfR41qm4BvixL9iStkwKp0jYx1--7xrQI6s2WMlRwN0,6907 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__integral_3_01unsigned_01long_01long_01_4.html,sha256=HS6HP4LrSYilbgCH9u7lxheEy1i9ik7n41m5vVIk6oU,11225 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__integral_3_01unsigned_01long_01long_01_4__coll__graph.md5,sha256=KvUFDq0SK4WzJrHIE8MZea1bOg3ixdwxqkQOC4HwbJA,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__integral_3_01unsigned_01long_01long_01_4__inherit__graph.md5,sha256=FFVjcQ4B0iFKNOShyRBAQbPZpFPIFWcYkv7BUQD3ZXE,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__integral_3_01unsigned_01short_01_4-members.html,sha256=SslZfDeWAp8XOeWdeLSeeWwXSnZCwHzQvI6eiUqLRYY,6883 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__integral_3_01unsigned_01short_01_4.html,sha256=WmDLqjYm9--QBQKlHFq7ZcyACGwHpnZxG207h0p-E0g,11145 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__integral_3_01unsigned_01short_01_4__coll__graph.md5,sha256=4wfrTiX0mOmT2JZydyUwxS9B8J0EHwTy1UH5GGG12VI,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__integral_3_01unsigned_01short_01_4__inherit__graph.md5,sha256=JK8NhS2BYRBFco-2VXytl0JhdyLOxactNyItf1Is0oA,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__integral_3_01volatile_01T_01_4-members.html,sha256=d3v-tJjHgF7G_0_ZFAEIegFQIReLb3wW6YIW-jWiTvU,6863 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__integral_3_01volatile_01T_01_4.html,sha256=jDzuGRosbGRLmOw_VaFFxXHSSkoRVYyDJl-SedW4lIY,11085 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__integral_3_01volatile_01T_01_4__coll__graph.md5,sha256=pBRzY7TumYQdMpYLi5nBmY2IwtPQd_DyUrWGVg6pb4c,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__integral_3_01volatile_01T_01_4__inherit__graph.md5,sha256=PNO0lWtPOtiLLVB1gNpiRBplWUZBd8rrfUHUEolSFwU,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__integral__coll__graph.md5,sha256=GdyJbYMXVJ60P4RHlgrHduqpQ7P1EEyB0qtpSmUDSPc,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__integral__inherit__graph.md5,sha256=FJwqrAeLVpMm30cClHa7ZtLOOHsG1hZXYNeaYLroY9Y,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__pointer-members.html,sha256=YyHKbdd-NFTZw6Te4hjc8l_r3C-bVGZJLRhMFl0GB50,6776 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__pointer.html,sha256=nNWANDw0c7MpJg_N_Spn02t8qxBf5gKyel0TWVb3YCc,10887 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__pointer__coll__graph.md5,sha256=dpKbaEnPIsjMdRyRnqlVMdKejQOQBFbDa-UeSfG8dWM,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__pointer__helper-members.html,sha256=U7I16lWaTh6-5uqm-vhqbMBsoppd2FeoY_wB43Hwpq0,6813 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__pointer__helper.html,sha256=pHPgIIadWU3BgLg-1-pFlSIfoXlv7A_qKLcN02uySvw,11036 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__pointer__helper_3_01T_01_5_01_4-members.html,sha256=cWJohHAzXaEYolTSAlqvMYY5GAGOILB35xUpTstLmm0,6862 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__pointer__helper_3_01T_01_5_01_4.html,sha256=6HahLKXHMvOjujxief-buVCBJBFNeVnjh1XcrY-Du2U,11150 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__pointer__helper_3_01T_01_5_01_4__coll__graph.md5,sha256=kaQTUMAs4q5iNG44uLsIu0D375ZMqnKDFl2A8I09Zi8,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__pointer__helper_3_01T_01_5_01_4__inherit__graph.md5,sha256=T1ovNvAwXRCYR07InI_7YDCUlz0YZ_6UcHJXJF3K73c,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__pointer__helper__coll__graph.md5,sha256=ZY1A7krnyq6_Klnqt736PICtj1EArod76fWiZ3Rp8IA,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__pointer__helper__inherit__graph.md5,sha256=vR5yGcWzuknG5m6Ee5kfJc597UIVg7TFLco9ff1JSaM,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__pointer__inherit__graph.md5,sha256=j718YxJWygD-Kfszcbq5ZxrxEHUnwBgJF3MBJhBk_38,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__same-members.html,sha256=w5MZP9Ksj0EHfUKIF4ZLblWQR8717QXop70ld4Nyy7g,6767 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__same.html,sha256=IJasy8V5ubN6y80ewnCIq-kfQ4L7J1ilpNpp99hNPL0,10916 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__same_3_01A_00_01A_01_4-members.html,sha256=8vPAVceiqdtmiJs00Zwo0Qf3d5xB679GS-VB3dCzhzY,6817 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__same_3_01A_00_01A_01_4.html,sha256=d-fhmsZqHklZYqQUIjOnszP9jbhBbqDrv9i5TbuKy9A,11001 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__same_3_01A_00_01A_01_4__coll__graph.md5,sha256=hiJOIOeIIfZ6-uVLI4iobkrcJD6YRed2hQWxveTf3qM,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__same_3_01A_00_01A_01_4__inherit__graph.md5,sha256=TQSVNrr2tG0my44ots3WoMnCtB4KikM_6C9Kj3iHpbw,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__same__coll__graph.md5,sha256=3tDNrRTUgJMXaO5RelolhKDbiOaCEFt-dQ7KcmHa8CE,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__same__inherit__graph.md5,sha256=JnGLMPdrQj4IxKkVcnUbtkZ1T54Qx7-k8TSuirGM5z0,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__trivially__copyable-members.html,sha256=y_7ZIYRmdV5r46mVha8YmMoTJjidjI_LAUbQIiYFtoU,7121 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__trivially__copyable.html,sha256=PubEYCfqNlbEc5YAqnM9QXNKqxUaBti-KVZiWwK9IDY,11768 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__trivially__copyable__coll__graph.md5,sha256=TSJT9LvAaMiAvE5QYtjOHR0kkYnn4rwmnJIIUBmkPtg,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__trivially__copyable__inherit__graph.md5,sha256=TSJT9LvAaMiAvE5QYtjOHR0kkYnn4rwmnJIIUBmkPtg,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__void-members.html,sha256=LN5HPa8b4rQJ49FqBDA8PCdPydYGXzvQWlZF9cvt9Kc,6761 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__void.html,sha256=h1bXOwxKQ0XS6k9_zWaSUB8RaeIythdMxGKhuWP_YSQ,10839 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__void__coll__graph.md5,sha256=lyXWHXjJHXZm91f6Qk58SXSGoWVsSyzgO_0HsUtoNvE,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__void__inherit__graph.md5,sha256=-_Y-0OXUPehcWP1vMW21BC8X-1kt73kRdQ9vjLJp6Zo,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__volatile-members.html,sha256=p7n_ii8-CcGQOu6gukC2kZ7z2BgDZtTyNe01yfcdyIM,6781 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__volatile.html,sha256=dvurtsKCitrH_TTYeS909kZY6SozNzLEuwhx63jW4tU,10903 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__volatile_3_01volatile_01T_01_4-members.html,sha256=o54mZ8GLcat_2l6EZMEQpg9dnW-gi8zcfH2Cfy257Ck,6863 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__volatile_3_01volatile_01T_01_4.html,sha256=Aa4FZKh48rkx3nYn0D74osjybBvnueQG10IkVYUFfgw,11085 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__volatile_3_01volatile_01T_01_4__coll__graph.md5,sha256=HMBvL7A_E4bU8fu4ylJ1JzZpIYdWv7H1yDHF4uu3YZ0,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__volatile_3_01volatile_01T_01_4__inherit__graph.md5,sha256=m5keqG36yIwWEvNFQeDYHa-Ef8t07Z1zQaCL9Cq15dc,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__volatile__coll__graph.md5,sha256=kuEcYJnSPIeRzt_7dWZQMGzFmf3U4lX5Q5ety2zQ254,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1is__volatile__inherit__graph.md5,sha256=EM5v-6hEcAjcDx8lL9miIR0fjEYBbwGq5GJWhMQ_Llo,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1nullptr__t.html,sha256=UQ22IoXnSUy0WtSyjjL-K7WnBIsKY0JHIO94ZJuVVyk,4995 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1remove__const-members.html,sha256=KbWJ8loL5o7OkZiy2IP2bvR44G7PSIgh3C5K3PF-1f4,5256 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1remove__const.html,sha256=alKLkOVIuFw46ejhhfiFzZmHYy6d-EDCfKUuV3aTaUc,6405 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1remove__const_3_01const_01T_01_4-members.html,sha256=h11R1G6khWPUM_85FtDSgfmIJ-nHFapQ0JNpzDz82tc,5367 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1remove__const_3_01const_01T_01_4.html,sha256=Vpv1C64OfQ5Vr2Rqt3X0MGkIqObpLbTHMswYmyIyGVs,6513 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1remove__cv-members.html,sha256=b_-cZpDbtHA-FFPiaTmMm223PAQtyLXcHJQE5kEki-M,5232 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1remove__cv.html,sha256=YeTAJLUbv9CFVrdFXvBzwI9mo_ujQ2Kg10IffHEgJ8Q,7195 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1remove__volatile-members.html,sha256=QwNAJ_Oh322hqJHHCYdTRhRc4eXz7UMOk3ikH99lcOo,5280 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1remove__volatile.html,sha256=8kypSvP5k32MwUrnwMcEKxrvDcb_82h20Rr3lI5FcWQ,6438 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1remove__volatile_3_01volatile_01T_01_4-members.html,sha256=Pa89IgPyFw_pPO4EgFkQzArpKyBIPyD5EgoORNW39uU,5415 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1platform_1_1remove__volatile_3_01volatile_01T_01_4.html,sha256=4phywViwZRbhYE5-Vzf64SF8ubIsYD3GwaplRp2jUV8,6570 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1plus-members.html,sha256=dLJa71HfE3AfKtKWXvv0L2rDrNY-QX8lNxoeLisxUGQ,5082 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1plus.html,sha256=9xqPofazOdhxmQpJpWkHc2PQE8ajxo2MXnHr3890DJ4,6861 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1plus_3_01Array_3_01T_00_01N_01_4_01_4-members.html,sha256=-dCPaG1tOKgB6ZBze6dwE1bbKS5HMcAf5OzNVBYNxz0,6227 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1plus_3_01Array_3_01T_00_01N_01_4_01_4.html,sha256=mvwsxGzuLzaDIoBkJUJ2n_pNZ9NNr_hcW-QCwK1IT-k,10712 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1plus_3_01Array_3_01half__t_00_01N_01_4_01_4-members.html,sha256=OG6IJYdCMoDAt9PgUWsz-6jMq0IHDk3PS_0XyvsSGG8,6329 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1plus_3_01Array_3_01half__t_00_01N_01_4_01_4.html,sha256=eG_E8p52-gdwSKbCvWcRdt4JPmmeR94aKqmOKYMtwvI,11966 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reduction_1_1BatchedReduction-members.html,sha256=IodleM4iFuXdPZcq11du_24EEboBW_4IwoBqGQRBU4Q,8935 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reduction_1_1BatchedReduction.html,sha256=ulViyZss2zt_18sE6pTTjKm3OpuGk6gD2h5hNfAarHw,21504 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reduction_1_1BatchedReductionTraits-members.html,sha256=YI0pxyAuoZ2dfGgzK7wZ2KunLwq7SzAthZ2CV_uodl0,14918 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reduction_1_1BatchedReductionTraits.html,sha256=xvChq20eC1OV5KWuhqeWzbmxOvBptA6Z6tQsC_HI188,41706 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reduction_1_1BatchedReductionTraits_1_1Params-members.html,sha256=x8RmQPcjv7KuQ7usDgPTOiThmboGTdPXRid3KYpbFK4,12211 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reduction_1_1BatchedReductionTraits_1_1Params.html,sha256=Taw3uD3YVTb5ctW3KT5gFh1OynvK51M0-0JTc_RPL4E,35846 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reduction_1_1BatchedReductionTraits_1_1Params__coll__graph.md5,sha256=Se1jDK9Jn-60n073j3-y_DrOFcaGKDAb2dc7hGLZl0Y,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reduction_1_1DefaultBlockSwizzle-members.html,sha256=bb_QprM4QST_RNnih8UgCwb6EJ97wxqzyR5RgO1BYXE,6549 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reduction_1_1DefaultBlockSwizzle.html,sha256=w0BSBC6_xpXRimykURkE1zO_MqR6v-Y7NcHvZUEi9Qg,11461 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reduction_1_1kernel_1_1ReduceSplitK_1_1Params-members.html,sha256=RdYLX77nhcNvRwgzJM8sKZWuUeo6NJHFtAJ3W9pEUJE,9935 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reduction_1_1kernel_1_1ReduceSplitK_1_1Params.html,sha256=lTlfWBdP1wH5SDtJOglvkr2LFcjNA96xSFpnlEoce9w,22009 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reduction_1_1kernel_1_1ReduceSplitK_1_1Params__coll__graph.md5,sha256=mVA0wCgRq97j5odeohHMR7a-TEOdsbtTPwVmbCILdJA,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reduction_1_1kernel_1_1ReduceSplitK_1_1SharedStorage.html,sha256=HcOskpZlIe8aKkV4XS3JbHuSFLI_7wM1z3HIIGbdUX0,5429 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reduction_1_1thread_1_1Reduce.html,sha256=27vBRDi_hty9cAy7F8MgPKhlwD0egxk7wyVqY_aMNGM,5188 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reduction_1_1thread_1_1ReduceAdd-members.html,sha256=Ttc1zOHF5jKiPryRRc9NTXcBaongqzNvxLrSLmgdFbM,8354 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reduction_1_1thread_1_1ReduceAdd.html,sha256=LQriO6uYRGQxKgaTKBpgrjwGl3sdNS-CFvR-6nGtyWY,20719 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reduction_1_1thread_1_1ReduceAdd_1_1Params.html,sha256=JUIA18ILlwyyY5AoLosVU0WX3qDPKOHic6TNwFdtZ-k,5375 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reduction_1_1thread_1_1ReduceAdd__coll__graph.md5,sha256=_y5pKE_ptwd-CkZg_xgVBbdBe76O1aj8PS1EaxqY6AI,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reduction_1_1thread_1_1Reduce_3_01plus_3_01T_01_4_00_01Array_3_01T_00_01N_01_4_01_4-members.html,sha256=52aptgGZX6XpCeGIRu9M_hLvpKC3q4CXICG4-CEg59o,5819 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reduction_1_1thread_1_1Reduce_3_01plus_3_01T_01_4_00_01Array_3_01T_00_01N_01_4_01_4.html,sha256=3MfYyf-0v6v6iY4cNXfhRqbfrRZ9uISzb0DgEPyLUFw,7586 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reduction_1_1thread_1_1Reduce_3_01plus_3_01T_01_4_00_01T_01_4-members.html,sha256=u2I9P8ZYU4txnArmsnASUAMxe2qleQx_1JBtf_AFaqI,5649 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reduction_1_1thread_1_1Reduce_3_01plus_3_01T_01_4_00_01T_01_4.html,sha256=q9z-17cpqhnaTdjxCYm1HRSMgCkanoGt6Tl8SMuaCi4,7647 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reduction_1_1thread_1_1Reduce_3_01plus_3_01half__t_01_4_00_01AlignedArray_3_01half__t_00_01N_01_4_01_4-members.html,sha256=l94Nebru2EpAOQso3xeEQ1yeld9KALi0TPcZgnSfwa0,5971 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reduction_1_1thread_1_1Reduce_3_01plus_3_01half__t_01_4_00_01AlignedArray_3_01half__t_00_01N_01_4_01_4.html,sha256=sDwc8KC8Zs6Wqp4xyzPlXHWHGixTIH2oH4XNi-QW5Ts,8245 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reduction_1_1thread_1_1Reduce_3_01plus_3_01half__t_01_4_00_01Array_3_01half__t_00_01N_01_4_01_4-members.html,sha256=CIFE1g7DY05KrKG0YVLy4RMt05mQ5X3UgtXdrINSpRI,5908 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reduction_1_1thread_1_1Reduce_3_01plus_3_01half__t_01_4_00_01Array_3_01half__t_00_01N_01_4_01_4.html,sha256=4Iq4w-3yjNv94iKiswKIWcUFDWZN7mJ3LBJqj5HMoqg,7998 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1detail_1_1Cast-members.html,sha256=x8vVu5TO7WkV5si9Hxau6ReISRVEclwQtHIPOl2Sc6A,5481 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1detail_1_1Cast.html,sha256=HB86nn3XyVQMpqTAqOYQfiajtBcJuR3Pzn7n5waoXYE,7083 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1detail_1_1Cast_3_01float_00_01int8__t_01_4-members.html,sha256=rmHG4bkvGkllA0q3f-S5VhTsimfCrzXe_b53Vmz6voM,5605 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1detail_1_1Cast_3_01float_00_01int8__t_01_4.html,sha256=MmusftdDHg7i8lGZEAFm1oDqeBGZJY28FPzbs4B4zq0,7089 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1detail_1_1Cast_3_01float_00_01uint8__t_01_4-members.html,sha256=Wbv1t3p7tGwh3hhxu2wEPUIihvSCVTHaUrOOXbxZOmM,5613 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1detail_1_1Cast_3_01float_00_01uint8__t_01_4.html,sha256=56H0s0FQYB4zPWOC8if2i--ut4BaQzWAqO1fUbUul4M,7098 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1device_1_1BlockForEach-members.html,sha256=ksn4gZNtrBU6mvuH76s0TQQuRL9I430_x0NAh2EknSA,5616 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1device_1_1BlockForEach.html,sha256=nqX_MMOVbt_6J0k6Exzzmo0cdrXlez5bKhLyMPz9GNc,8243 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1device_1_1Gemm.html,sha256=PGpxypUGlZNngnmPEPjPJ5Q1OIzge7wo8AgLzKyOMXY,5463 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1device_1_1Gemm_3_01ElementA_00_01LayoutA_00_01ElementB_00_01Layout30b72addd464a2ca4a26785cbfd77a8e.html,sha256=Y7TWPv5B2nL2C53FImVg24YQMgKKe2bDS17CqEDCIP0,13893 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1device_1_1Gemm_3_01ElementA_00_01LayoutA_00_01ElementB_00_01Layout369ab66cb5af61d94815b1554b7ffdd3.html,sha256=EDbIFNYkVpMok9nBAKih8O62oT54MdbU4EcX4a619_g,7320 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1device_1_1Gemm_3_01ElementA_00_01LayoutA_00_01ElementB_00_01Layout4e016ab7cfc644acd7cb4ae770339773.html,sha256=bX41dsko_UtgWP49Ll9vhhtaMKjEqRGG2CRO9HCpl98,13844 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1device_1_1Gemm_3_01ElementA_00_01LayoutA_00_01ElementB_00_01Layout54e3f4e44d8c1c659de062425d47747b.html,sha256=b-_165X5PPuHka7TCRbJkygDNPq2rth_7SB1InpRFqU,7340 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1device_1_1Gemm_3_01ElementA_00_01LayoutA_00_01ElementB_00_01Layout660562b232f408218828ca5915b7e73a.html,sha256=xywA8IdRuQ33McAhul6264pW_eO4f6DyTQL-rpfAF68,13818 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1device_1_1Gemm_3_01ElementA_00_01LayoutA_00_01ElementB_00_01Layout8f9867405e8781f535ae5882a63e49d7.html,sha256=d5VJ8lt-yGspCsUX02O4_UUjrGADESoZ7hgY9R9KV_E,7380 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1device_1_1TensorDiagonalForEach-members.html,sha256=Y1s5kCi4nkjAJmacwzW0Sl3ocZQ_Webpa3a5SOZFrJw,5687 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1device_1_1TensorDiagonalForEach.html,sha256=ICfdx8hJ7qer5o0dLtxzxs9xIh7kYfard6FIjbpiKRU,8524 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1device_1_1TensorForEach-members.html,sha256=VSzgsDzjj306BUg1f9q82VLL9AnYadbYPJvIoD-hTX8,5605 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1device_1_1TensorForEach.html,sha256=EWPL3lywZJ3WtbShnTrsttYnhFyeRS0yeJJg_R_zKF8,8225 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1device_1_1detail_1_1RandomGaussianFunc-members.html,sha256=nvSKpWS7xmP_aDfZFFbZZm95DIikzQaLrAJyko98Cig,7772 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1device_1_1detail_1_1RandomGaussianFunc.html,sha256=dbOswstbmg5YWVCJNnKzi2hgSb8L8GjjflreBvwkfcs,16310 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1device_1_1detail_1_1RandomGaussianFunc_1_1Params-members.html,sha256=l4Z_T9jSrwwuAvn_4pb_LDckvHgRnD-erEOqA1-IGuY,7659 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1device_1_1detail_1_1RandomGaussianFunc_1_1Params.html,sha256=z76Iv6MUiDX1irmMpWu7S6KIV8smCJMLVoOR6MdyCrA,12872 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1device_1_1detail_1_1RandomGaussianFunc__coll__graph.md5,sha256=8pJr2srCzKME5Cjbr6dGf3EuG9XFdah0tY6qXqooBJ8,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1device_1_1detail_1_1RandomUniformFunc-members.html,sha256=F5pTUNcuo_Qm_L_G_HWi8HXo-0J85XEO7cwUxMhiWzY,7748 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1device_1_1detail_1_1RandomUniformFunc.html,sha256=B0RCn7Un0TFdHJIWIRQZsR3lMGjl47MzOY8w-aCbAjE,16699 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1device_1_1detail_1_1RandomUniformFunc_1_1Params-members.html,sha256=NS_3z38dF2gMceK2Y6WzhMmA7Vf4n9fvcUwnrpxbY_o,8082 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1device_1_1detail_1_1RandomUniformFunc_1_1Params.html,sha256=_b5Arh0NsyCrFRzzV45AvGlmBs710GzN6GEV5J5SUBQ,14431 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1device_1_1detail_1_1RandomUniformFunc__coll__graph.md5,sha256=WZG947zbsOJ--W0mUxScxO1_EkJYt2qxXr_0sTdfkx4,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1device_1_1detail_1_1TensorCopyDiagonalInFunc-members.html,sha256=vwwQy-NeDDEXJ4wmWjWQq54jt39LtAMj1-T9WUvHqWg,8013 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1device_1_1detail_1_1TensorCopyDiagonalInFunc.html,sha256=-c6__twwmML6Sk6ROV-3tm8zAGuB-Tsq-pwGlT_smlE,18616 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1device_1_1detail_1_1TensorCopyDiagonalInFunc_1_1Params-members.html,sha256=O_XDuDQWcgFakhOW6AbQtwG8x2IFt5sNuq2cBW3cRDc,7382 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1device_1_1detail_1_1TensorCopyDiagonalInFunc_1_1Params.html,sha256=pXbKCdmzO3GQIVuQ-KNlU031u5TgtUoJeZjv6kznbCg,13359 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1device_1_1detail_1_1TensorCopyDiagonalInFunc_1_1Params__coll__graph.md5,sha256=ud_qYNhaicC0nTTq_LSlSVcE7u8ZAjcvnToGzQAx8Z0,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1device_1_1detail_1_1TensorCopyDiagonalInFunc__coll__graph.md5,sha256=m9VAuNhzt4Qa_0x5GECpD5QnRchFPjvxKe7LlS4BPg8,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1device_1_1detail_1_1TensorCopyDiagonalOutFunc-members.html,sha256=WhhltzJZHW5WOyWRWOuibhpZm-qNJVFN8-ReymDr4ck,8037 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1device_1_1detail_1_1TensorCopyDiagonalOutFunc.html,sha256=BZ8re7lPVpx3IV8ut0DbyMgAQ9SoUV543lXyhO1FBIk,18672 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1device_1_1detail_1_1TensorCopyDiagonalOutFunc_1_1Params-members.html,sha256=HQDzeniYEUWkxZOIvUGN-ztrxm84fGbwWWddVR5iYTw,7394 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1device_1_1detail_1_1TensorCopyDiagonalOutFunc_1_1Params.html,sha256=1NNX61hIsnpwjN4xvo-NFBKeIIUXoV2ljmLfVNx4bLE,13362 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1device_1_1detail_1_1TensorCopyDiagonalOutFunc_1_1Params__coll__graph.md5,sha256=PTjjEwjmADNq723YzemvzGyL-xTT3sBjwhQb6bDdyJs,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1device_1_1detail_1_1TensorCopyDiagonalOutFunc__coll__graph.md5,sha256=FTL-022lK-0t-EMlwE7zt086kogJuPBbJPYKbtu90xM,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1device_1_1detail_1_1TensorFillDiagonalFunc-members.html,sha256=Fe489KSj9W1M0ndP09l0cDQ2Vsy-EemI3ccfKihLSnI,7965 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1device_1_1detail_1_1TensorFillDiagonalFunc.html,sha256=gn-6xC3mUZlyxjtu_y7HSpAymL_xvsuYkLLadP4Xwio,18531 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1device_1_1detail_1_1TensorFillDiagonalFunc_1_1Params-members.html,sha256=QP7kMAK2zp6mL_C3eZ_tnnw44wHIotZioCZZBqXdn0k,7842 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1device_1_1detail_1_1TensorFillDiagonalFunc_1_1Params.html,sha256=Q8ZIdFwbEUAXK1cgP-S2bD1dpEOZoIw1_9WEFUIc0ng,14695 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1device_1_1detail_1_1TensorFillDiagonalFunc_1_1Params__coll__graph.md5,sha256=XSXYsx7lNHIePjUjFLpwwaryEkX3El8-mv5rf6H1tyQ,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1device_1_1detail_1_1TensorFillDiagonalFunc__coll__graph.md5,sha256=E8mDZrtulEuYP_7KjzPK7P1qKymps2ae5DfW6v-Ynpo,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1device_1_1detail_1_1TensorFillLinearFunc-members.html,sha256=vmVTIDpxKQtbwgi5etbtQi5qcalo6XKcRymfVMzX108,7917 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1device_1_1detail_1_1TensorFillLinearFunc.html,sha256=jkGOTRbok1qUEy2rEVbRhMRdjC4UTJmybZMKJuoE078,18437 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1device_1_1detail_1_1TensorFillLinearFunc_1_1Params-members.html,sha256=SNCM20oGHrm46b4xep3QDytJ1GWI0lfJUDTKpNeISMA,7803 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1device_1_1detail_1_1TensorFillLinearFunc_1_1Params.html,sha256=1t5NLokbiiGorhlPaW8E59jLmrHNaTq3eHW8dUXvNXU,14563 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1device_1_1detail_1_1TensorFillLinearFunc_1_1Params__coll__graph.md5,sha256=ze6wAIlLndW-WEYmGKEBGHDtRAVAYGOfnnQm-MECjnk,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1device_1_1detail_1_1TensorFillLinearFunc__coll__graph.md5,sha256=hXm3uyusxF1_zT0JH4TtH55pe0XTIdxWXn6APBN3o3I,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1device_1_1detail_1_1TensorFillRandomGaussianFunc-members.html,sha256=fV398oWrjVp32YYUFFcnE-Vbe8JtFZLz00dkcQsg-xk,8990 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1device_1_1detail_1_1TensorFillRandomGaussianFunc.html,sha256=kjse0kyuTx0Ln72Rc0S_hsYtNUbvmflWtwbO6pSu4V0,21302 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1device_1_1detail_1_1TensorFillRandomGaussianFunc_1_1Params-members.html,sha256=7ycwpDAqxjAwmHnzpEnKPb-Hh-5pC7ezzUb783JNQn0,7024 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1device_1_1detail_1_1TensorFillRandomGaussianFunc_1_1Params.html,sha256=cWsr7JM02m9BpD1lHnloCkAJ3bqGfL2H3kPbEmAnCFA,12748 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1device_1_1detail_1_1TensorFillRandomGaussianFunc_1_1Params__coll__graph.md5,sha256=gl3ACnyoWF_HAeZJhm2IDHRsyXYb9-MQhtujX4WvhaM,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1device_1_1detail_1_1TensorFillRandomGaussianFunc__coll__graph.md5,sha256=0BOi3a8vQ5uLzoznwVI2nZL2XCpQFqjAPt0vCs7Zrj4,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1device_1_1detail_1_1TensorFillRandomUniformFunc-members.html,sha256=M4TaU_jrVIO1ZvQeh0QGcuILTLmxTsrbDCUO2IVh0FU,8960 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1device_1_1detail_1_1TensorFillRandomUniformFunc.html,sha256=kxjdEmzZw8IMD6QEM-eHzeQvahQv5_DSGki7ACPossE,21242 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1device_1_1detail_1_1TensorFillRandomUniformFunc_1_1Params-members.html,sha256=YYAJhSc9q889gNbJUDbRfY_O7cRXu1pUAc7HKr5NbEM,7489 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1device_1_1detail_1_1TensorFillRandomUniformFunc_1_1Params.html,sha256=nupRvS0qNyWlhD4KO5NqIDouKVkzK2pv6kfnpsajwzo,14347 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1device_1_1detail_1_1TensorFillRandomUniformFunc_1_1Params__coll__graph.md5,sha256=1nMuwQ_wco9485jcl0YAGr_vczc0ifvpAiOog4kdWBs,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1device_1_1detail_1_1TensorFillRandomUniformFunc__coll__graph.md5,sha256=w8_s5xAHf0k4yZ0Idy7uIUSdVjQBAEIfhjSfjitQWso,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1device_1_1detail_1_1TensorUpdateDiagonalFunc-members.html,sha256=xoO1oHNCiJKgq9s9S--bBM60jhbHnqB8WiVHjCGeP7w,8013 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1device_1_1detail_1_1TensorUpdateDiagonalFunc.html,sha256=ozpi48gACIcd3dlZqV34uUSF0U9a3s3DlRAm7OhG16Y,18625 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1device_1_1detail_1_1TensorUpdateDiagonalFunc_1_1Params-members.html,sha256=ajQtC9ba_aSAeYdsnSC1QZZBbcd9sDcK-YQc29f_ur4,7401 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1device_1_1detail_1_1TensorUpdateDiagonalFunc_1_1Params.html,sha256=_ICPuhT42yVqSGvVd8NKsqxfeDWnYamvz67YemLRnE4,13522 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1device_1_1detail_1_1TensorUpdateDiagonalFunc_1_1Params__coll__graph.md5,sha256=STvUd3TpQYhW60nquOmVgk4HktbWfHa0ueN_uCpoXi0,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1device_1_1detail_1_1TensorUpdateDiagonalFunc__coll__graph.md5,sha256=jcBM1S8XNoIV_x4IZae1a41ChyVi8ngKI5fNVQcEjlg,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1device_1_1detail_1_1TensorUpdateOffDiagonalFunc-members.html,sha256=0B3QNqRxBzlYG2qNbMdBHT9yWUcrXOn2VSwyobkto4w,8085 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1device_1_1detail_1_1TensorUpdateOffDiagonalFunc.html,sha256=pq_1vbiwSCMpiLdYKPOIUniWAHiO3CQsfSzi6xp0pxg,18766 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1device_1_1detail_1_1TensorUpdateOffDiagonalFunc_1_1Params-members.html,sha256=ucZ3KI_Ywx238kta2Ykk9zHuGXrDunq5P3hwKJOi3ag,7457 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1device_1_1detail_1_1TensorUpdateOffDiagonalFunc_1_1Params.html,sha256=mE4cLF7OQcQ07I4IrNOxxEa8nwgG5TlusWyVuKRo2Uc,13613 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1device_1_1detail_1_1TensorUpdateOffDiagonalFunc_1_1Params__coll__graph.md5,sha256=jvUAiKkf3HHHf0aRbLIyCi0aSjzPMZ9EhBsXCLLWU7E,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1device_1_1detail_1_1TensorUpdateOffDiagonalFunc__coll__graph.md5,sha256=ZTkwhtJIwTU7YJns6DKJPJeT8hyp_84DMSiHiCPoMkk,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1device_1_1kernel_1_1detail_1_1TensorForEachHelper-members.html,sha256=b7fSDzhYUvnYZ1pDLioTQp8jmVa6ePf4Q5UjzAOFQao,6055 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1device_1_1kernel_1_1detail_1_1TensorForEachHelper.html,sha256=VH7Zzm0aCpmnmOvMCkXM_D0gLJBaD7EqXX3igOPqCa0,8807 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1device_1_1kernel_1_1detail_1_1TensorForEachHelper_3_01Func_00_01Rank_00_010_01_4-members.html,sha256=_0jyT63tcb5YIBNiJGVI6UX0KIezpF3Kmh2fC-6bngs,6166 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1device_1_1kernel_1_1detail_1_1TensorForEachHelper_3_01Func_00_01Rank_00_010_01_4.html,sha256=u2P7CHBa0QekJ4hYb0ht-KAVJRiXc7UtMCJYTWjAoBU,8877 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1device_1_1thread_1_1Gemm-members.html,sha256=ZX0b819ojifr6kq4utoKt_EwFjl27N6eGlSIO6qeA7M,9876 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1device_1_1thread_1_1Gemm.html,sha256=7X2t29ldIn431gL7G6BOXal4koBowgs6n-cJV34foGA,25441 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1host_1_1BlockForEach-members.html,sha256=rexKcrLjg5Ubfq9yLpUsMVKRl9XnbIo3z1J4teqdWzw,5563 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1host_1_1BlockForEach.html,sha256=gqS5NhF_Lfzr8nh9n8hveEfQjKpH-cKfFRHEeu_rwDw,7771 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1host_1_1Gemm.html,sha256=4pW8G_cA3zl8ma6TrsEDdpLZNp1WA-sTTorene_KkFk,5439 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1host_1_1Gemm_3_01ElementA_00_01LayoutA_00_01ElementB_00_01LayoutB_193dd3a37f00deff1e5dcd7c310afb1f.html,sha256=M_EGo2BENml1gsndUft5Z7VQHVQZoGXB-hBmV6Q3Rm8,13762 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1host_1_1Gemm_3_01ElementA_00_01LayoutA_00_01ElementB_00_01LayoutB_400beb827a8b62c34dc8a76365caabf4.html,sha256=TpYlgqy0N_ZGKRh9Cwa2QGzothxUFIcqsB-qln3Mr_8,7332 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1host_1_1Gemm_3_01ElementA_00_01LayoutA_00_01ElementB_00_01LayoutB_4f3f32c4b336238abfd741e87bfced46.html,sha256=xUdjFGBXEsjoNsgvSCqYT0fTKuu7gH9ziCA_mO3W5kY,13736 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1host_1_1Gemm_3_01ElementA_00_01LayoutA_00_01ElementB_00_01LayoutB_55729eac7dbd6bf311ea36f680e83e93.html,sha256=JjODCq6LYKJM64zRu5XlGJqt6oHH3oBfqLWANvfjQbc,13811 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1host_1_1Gemm_3_01ElementA_00_01LayoutA_00_01ElementB_00_01LayoutB_6b5c19f719ffef4036bef6a40e90c4a0.html,sha256=Fkq45qfknTfXDxe35SdmJEjIUdtCkfJhqhe7Rbed7-o,7272 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1host_1_1Gemm_3_01ElementA_00_01LayoutA_00_01ElementB_00_01LayoutB_f990b0b9b6b1ff6a6232b5d24c22d64c.html,sha256=HyKJ_8ROqyhxnkUPyUL6FhuyzvEGUWS4_AZvcyjVpOg,7292 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1host_1_1detail_1_1RandomGaussianFunc-members.html,sha256=hXSfq9W8exIDB9xVSv9a7hQlcFpCjhvRpsIDC0iRkrs,8143 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1host_1_1detail_1_1RandomGaussianFunc.html,sha256=WzOIq0YgtctiUT1DUmizNB-_xtyVjEHFOKVtAXfuCRA,14325 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1host_1_1detail_1_1RandomGaussianFunc_3_01complex_3_01Element_01_4_01_4-members.html,sha256=j7svXh1sWQmdlzQLG0c5oNXOGT0OQ_OQ-pn_ll5c58E,8874 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1host_1_1detail_1_1RandomGaussianFunc_3_01complex_3_01Element_01_4_01_4.html,sha256=0bEu9u-zg_kKurwprqdxCK7aVmFlRDsfipTSum9Cg5c,15411 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1host_1_1detail_1_1RandomUniformFunc-members.html,sha256=yvLdRsEBtf7ArojWDl8uQA79lVNKeW-FHocDBsYHl7M,8119 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1host_1_1detail_1_1RandomUniformFunc.html,sha256=8yhZiYI21KFMamyxb5yARU-nJ3MsaL-BwjVtBUdlYEo,14863 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1host_1_1detail_1_1RandomUniformFunc_3_01complex_3_01Element_01_4_01_4-members.html,sha256=c7ZErMziq5__UzrKiIei54J6-8fKBeMN0KwTNTZTcAY,8850 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1host_1_1detail_1_1RandomUniformFunc_3_01complex_3_01Element_01_4_01_4.html,sha256=vfjzf8EHoEFTEywkZVEhX8F1L1O9ubq7CYbFBL4-eAI,15983 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1host_1_1detail_1_1TensorContainsFunc-members.html,sha256=f27rNsZoin6dJFvfejlQTh1GvWydPjd-RFt3OeinVrc,8748 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1host_1_1detail_1_1TensorContainsFunc.html,sha256=VOqImjbghDKWw5ZTjS5F0xYauwDUGmgvKduSL63xkuE,17763 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1host_1_1detail_1_1TensorContainsFunc__coll__graph.md5,sha256=NljCc_31udVyc2pgHESxk4x87ZTaK6G4Is7Ll3_NuJg,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1host_1_1detail_1_1TensorCopyIf-members.html,sha256=MNVUFEiMmSxt2xzwFj_OGSXR98LI1_5xdvrI0i3U56I,8874 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1host_1_1detail_1_1TensorCopyIf.html,sha256=vHocFNr77AK3PPa4YDjV79kAA230ZnIoMJ-xeLqqp9U,19384 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1host_1_1detail_1_1TensorCopyIf__coll__graph.md5,sha256=GdJ4Sqfbpq0pHxGsoa6IDeieKiMh07EVOEcjnmdL6pI,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1host_1_1detail_1_1TensorEqualsFunc-members.html,sha256=7G7TyfNeYPPthUboL1taLWlk4rEJsdprkIDrZ9f24FQ,8329 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1host_1_1detail_1_1TensorEqualsFunc.html,sha256=UH8e2wBcLQ6hbgVMkLQF9JUIwA3U_K6gW0Oij9UpyBU,16932 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1host_1_1detail_1_1TensorEqualsFunc__coll__graph.md5,sha256=-WkrajWFxIF6N0zAhN5fjSSTlEJcTwOYtxwxljNECrI,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1host_1_1detail_1_1TensorFillDiagonalFunc-members.html,sha256=LIkMU03KLpZWYGI5GIB8PkYB0Bei5TMHGZ54LTPI--w,7987 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1host_1_1detail_1_1TensorFillDiagonalFunc.html,sha256=8-TTHljdJK45RhpIgV9CPm-y2phq8Mexj8k9yQh8csk,15907 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1host_1_1detail_1_1TensorFillDiagonalFunc__coll__graph.md5,sha256=jrtJmiagDPg-l1ArkfL_7ihOzDAspAWZsp9vE7xAl4E,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1host_1_1detail_1_1TensorFillFunc-members.html,sha256=YWB7F8i8G82RxZHi_AHhtfGq376RJMF9dJCZX87dQLQ,7391 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1host_1_1detail_1_1TensorFillFunc.html,sha256=vO2qz2eMp15b04WhEQasrZiEg_42j6l8BtnO6qyLoFQ,14410 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1host_1_1detail_1_1TensorFillFunc__coll__graph.md5,sha256=LHBkG4SRpHHEodebAsyVau77HaCj3Dq5m31DVkbM9Jg,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1host_1_1detail_1_1TensorFillGaussianFunc-members.html,sha256=L5diQ5V7YwxC6CefMbfReWD5rMcVJVjBHyBvrsng60s,7601 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1host_1_1detail_1_1TensorFillGaussianFunc.html,sha256=fE_jP1kk-HZ7dnVGC3wEnw-Mn79er2khkyrLnfi0K_Y,16296 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1host_1_1detail_1_1TensorFillGaussianFunc__coll__graph.md5,sha256=wVe31xkyT7EtUnJVjnyP2mCyIiWix-n8EGIDE3_93lE,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1host_1_1detail_1_1TensorFillLinearFunc-members.html,sha256=szFP1nQ_mB-yDnJIgrPHp8v_PJeg6SgztK5ONpJ4tt4,8403 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1host_1_1detail_1_1TensorFillLinearFunc.html,sha256=X1QW6wdKkvWN1yvijKAvhkLW2UTNy967dWFk-uuwQDA,17351 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1host_1_1detail_1_1TensorFillLinearFunc__coll__graph.md5,sha256=szMmjuMcggZ92SZzIZJlic4RTRA7taMCBn7AmduoY90,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1host_1_1detail_1_1TensorFillRandomUniformFunc-members.html,sha256=hAZzK7HGSOTgY_5LYWOCnG8s7TtsaYrRfP0cGUOPHPo,7704 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1host_1_1detail_1_1TensorFillRandomUniformFunc.html,sha256=k7yrfBfow_TwwtOgkc1rqXYSVGUUDM2xKBGPpIOOONU,16479 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1host_1_1detail_1_1TensorFillRandomUniformFunc__coll__graph.md5,sha256=Y3GkrYYzKWio2jcAhawt-04-948p_gm-Zmz6_fR3dQQ,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1host_1_1detail_1_1TensorForEachHelper-members.html,sha256=70bLcPmSQ3dymUrR9HxfoTy_F4NjnA9pktZ87GwQjy0,6281 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1host_1_1detail_1_1TensorForEachHelper.html,sha256=Qohj29MJNHAcv0gYHv_QqiB0G-KXrUfzC1TgTC5vfRY,10053 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1host_1_1detail_1_1TensorForEachHelper_3_01Func_00_01Rank_00_010_01_4-members.html,sha256=W5TgUAKdQFONoVS_jqjrG6eoPn5A3ICFauFyzstISgI,6442 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1host_1_1detail_1_1TensorForEachHelper_3_01Func_00_01Rank_00_010_01_4.html,sha256=ZN9yjmqtvLMJ6vPDQpVFlp5pH75x6G2z6puKlk_ipYw,10091 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1host_1_1detail_1_1TensorFuncBinaryOp-members.html,sha256=JmEOPPgXPlWjtyYFb-d3pqRoEzf4hLM8w1MNV6gIbjw,8907 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1host_1_1detail_1_1TensorFuncBinaryOp.html,sha256=mWYRzouhshM9hv8YQvwCSGFAAhbTmF8TOi2RhEk6eW8,19233 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1host_1_1detail_1_1TensorFuncBinaryOp__coll__graph.md5,sha256=ibD_mFFrfJKQUyYNRcTDZxnhBhCr5lgAlo1d_o0d7TA,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1host_1_1detail_1_1TensorUpdateOffDiagonalFunc-members.html,sha256=RT4MiminOUHEsXGujZJTaHt_-Yg9FIN2JMeoNNvO7yw,7664 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1host_1_1detail_1_1TensorUpdateOffDiagonalFunc.html,sha256=6kjo4jmAB3mqgGEKkvItWlQVIOH1F71oQOb_5-UVvqc,14891 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1host_1_1detail_1_1TensorUpdateOffDiagonalFunc__coll__graph.md5,sha256=3RIiWZVJ8s-5ap9jpjSbAcPfRTWRruEZeW1Hav9wm-s,32 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1host_1_1detail_1_1TrivialConvert-members.html,sha256=iL54pVcs7Jh356G4LzIIX1UH0bHJmtbURss2jKLO42w,6146 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1reference_1_1host_1_1detail_1_1TrivialConvert.html,sha256=Xj88_sI6jpr_I2YOpBfAAh4Jam8tl8-SMxF6OWlZJbk,8542 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1sizeof__bits-members.html,sha256=kGeP31IH3Ndp_Bs1UoCpr8UjWpGSnFI78DxGXxjBA3I,5105 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1sizeof__bits.html,sha256=_X8Pr-5Vht1YwmlLJiEuUNZLxRLEtyYx5tuYSlqG10M,6401 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1sizeof__bits_3_01Array_3_01T_00_01N_00_01RegisterSized_01_4_01_4-members.html,sha256=7UuGysAQAJjDwVKAcp9wC8kblzPu4HL02WxtYe5cLVg,5456 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1sizeof__bits_3_01Array_3_01T_00_01N_00_01RegisterSized_01_4_01_4.html,sha256=UuS1uxPADpZ8qMgF7wpgWxp2Vte-5mKPgblevP0P3r0,7442 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1sizeof__bits_3_01bin1__t_01_4-members.html,sha256=sQSMs6Eksy1lJLD9SXRJ3dNc442yzvyYrAjYaCB1LIU,5204 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1sizeof__bits_3_01bin1__t_01_4.html,sha256=mDEq5UgeY7luvImBfyoDt0txviWR_dpA1Y3G0zvY6GE,6505 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1sizeof__bits_3_01int4b__t_01_4-members.html,sha256=FGr180T58JyRaoRJmJ0sy7BJ1yzKQYbIsjQEhpcAh8A,5212 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1sizeof__bits_3_01int4b__t_01_4.html,sha256=GjoaS78iDXhhjQzcZikpn25mCI7teGCCf4opT3Ml_2Q,6521 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1sizeof__bits_3_01uint1b__t_01_4-members.html,sha256=_sxB4mhvWTBGtkpXuSWfykTfke6E5ddBxdnTsYELmyA,5220 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1sizeof__bits_3_01uint1b__t_01_4.html,sha256=jVuCzwsvB4fR-CThFJ7OLSjkY7JdlAo9r1bl4z9lB0U,6529 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1sizeof__bits_3_01uint4b__t_01_4-members.html,sha256=tmYtL11JjOPKR9kPxAJYnqPI-No79AZZ_WknLGBzMn0,5220 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1sizeof__bits_3_01uint4b__t_01_4.html,sha256=eKDwKml66b0GGi5dOF5DgpqJXQKL3SMMLlZvJ4Z048U,6529 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1sqrt__est-members.html,sha256=8QDUXhBk-SMEQ2Bpb7msdPDCfcMkufK-ZsEqUZVsZeg,5091 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1sqrt__est.html,sha256=FdoCRLBvBmKo52R5ThsshwnpX90_7XcF5GE17C9Ztmw,6533 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1transform_1_1PitchLinear2DThreadTileStripminedThreadMap.html,sha256=K4MUnnmlWS-tTSpL1FtkF6_mBA-9c1ofW2kKoMDsrRw,6007 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1transform_1_1PitchLinear2DThreadTileStripminedThreadMap_3_01Shape___00_01Thread0082c3467229b12cc9dd996283ee7160.html,sha256=CMFNLcyOLp8U3X2aT2k7HPDpck2K0VtiZjwdHs1jJuw,24754 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1transform_1_1PitchLinear2DThreadTileStripminedThreadMap_3_01Shape___00_01Thread48bfab8a2d7359e0aa1522180ca66ba4.html,sha256=NwbsSqBtIPBO_wJXyGXU_d5EqJ3sCjIlmniQABikDjQ,10277 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1transform_1_1PitchLinear2DThreadTileStripminedThreadMap_3_01Shape___00_01Thread896c01a3c466da1bf392e0cdfced4d53.html,sha256=ry2TsF9nETg9cE-1thGlWbucVwQJR51DdS3YbNg5K3k,8140 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1transform_1_1PitchLinear2DThreadTileStripminedThreadMap_3_01Shape___00_01Threade2f443f064d1208138831a4b5669221c.html,sha256=lP9Dq7jGZoNqcd8rnuKl0W3HC8piwkwNw8kQ9a7W1Mo,6206 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1transform_1_1PitchLinearStripminedThreadMap-members.html,sha256=MXHv_Zrdt0Oo8iiOJV8bYHuHpT8T5wcm3TnuCm5P-lU,8547 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1transform_1_1PitchLinearStripminedThreadMap.html,sha256=dHBgAOiQUi4xjZjZXZFptSl43ugfY2yT6NMjV0MWrSg,24746 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1transform_1_1PitchLinearStripminedThreadMap_1_1Detail-members.html,sha256=yagNl-_MSzE6kETenkBBNYiNW1x7LN8jxhViGFLDmHw,5694 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1transform_1_1PitchLinearStripminedThreadMap_1_1Detail.html,sha256=D9YSw2kFT4_pk-oP8Y2-l1pRwYEbb__qkPYUZrpt2XA,7745 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1transform_1_1PitchLinearTilePolicyStripminedThreadContiguous-members.html,sha256=uO0f7LOJMtLf_t-S2WOX7xNLslgwA0W-cIeunU7tXNU,8097 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1transform_1_1PitchLinearTilePolicyStripminedThreadContiguous.html,sha256=DqX0CoZ6qj1YCYSdMpYk3JyXzh48-Mtb2qdVGhMXJF8,15643 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1transform_1_1PitchLinearTilePolicyStripminedThreadStrided-members.html,sha256=tB4w0kgxrTs4W7dUilS2B8l3WF0hMDcqj_g-E1NGIvA,8489 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1transform_1_1PitchLinearTilePolicyStripminedThreadStrided.html,sha256=Ob2vVggoFf3YXmSWBo-_EEO7S46J20APk_7GnZbEFaI,16718 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1transform_1_1PitchLinearWarpRakedThreadMap-members.html,sha256=YZ1a64CJ6Ub4MaXtsHD2m8_HEwqqoHjLhRdcKn5YOdg,8758 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1transform_1_1PitchLinearWarpRakedThreadMap.html,sha256=UyQcsaEtrejYeFYoy_sTHaCwAU3xCQg2xRTYL5co_zI,22252 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1transform_1_1PitchLinearWarpRakedThreadMap_1_1Detail-members.html,sha256=ZayRNH_T4FWdtXIffw5BqrN5zEIkE1n6TsZHSARARU8,9147 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1transform_1_1PitchLinearWarpRakedThreadMap_1_1Detail.html,sha256=ltHGZF8lqk9kiYxHUkYx0ATV4mOpQPus9VSUxhKid8s,21805 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1transform_1_1PitchLinearWarpStripedThreadMap-members.html,sha256=-XF5aCZzOtema9jikQ_XkPJCB7qx4blQPeN5mBD7vX0,8816 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1transform_1_1PitchLinearWarpStripedThreadMap.html,sha256=SwiogCpd3CwCsdkgl1DuuUXrbzLn6OujTUALnTfl1RU,22778 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1transform_1_1PitchLinearWarpStripedThreadMap_1_1Detail-members.html,sha256=ahV4007ucrMxsK1bA5tdfbSwUXAqmpPPahCJj74IZM0,9207 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1transform_1_1PitchLinearWarpStripedThreadMap_1_1Detail.html,sha256=OovCX23Npz9QvbDL3TOdEsn-j_zqLEi_Ygu_tLf18xs,21969 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1transform_1_1TransposePitchLinearThreadMap-members.html,sha256=7iUs4gC7fQIsUx0cr_kET9oMG-WuAJmxgAQbeAluua4,8936 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1transform_1_1TransposePitchLinearThreadMap.html,sha256=I29CzgQ8lv3KXNzTyDuNYZupn-AK_PWipMKzk9c_Hgc,21936 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1transform_1_1TransposePitchLinearThreadMap2DThreadTile-members.html,sha256=r8v3mFXuDJxlYHFtnbWonbf6Db14REfAURgvWL9HBRc,9056 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1transform_1_1TransposePitchLinearThreadMap2DThreadTile.html,sha256=MKucVLIj8MRnA_-vmR1g8fGCKL8fiCS5VJUapjIIC00,19867 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1transform_1_1TransposePitchLinearThreadMapSimt-members.html,sha256=loxbT8_F5WzURHsojvCF3J006ks6kNOOT4LcdPqIicU,8800 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1transform_1_1TransposePitchLinearThreadMapSimt.html,sha256=KZMpA8YXR-18T9X6l9SDKvePOV0e2clPCOjRm94YMok,19449 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1transform_1_1TransposePitchLinearThreadMap_1_1Detail-members.html,sha256=lW9xe6OlE8ERZ0L3mkA4MH9g4ROEfew-achg6GQlhV8,7069 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1transform_1_1TransposePitchLinearThreadMap_1_1Detail.html,sha256=SQBlguIcqGR-M7tL3QMENIVE6HIc0RzvGJIfLdRQrlk,12808 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1transform_1_1thread_1_1Transpose_3_01ElementCount___00_01layout_1_1PitchLinearS337c4bfbdb4aa0b08021c6d28539409f.html,sha256=C7HjWFvKsuFfjtvd8FD57KRbLULK1JuCYeOpuhJXcB4,8328 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1transform_1_1thread_1_1Transpose_3_01ElementCount___00_01layout_1_1PitchLinearS99f8e05faf0bb5ed48a0154afe740d81.html,sha256=j5_eLROZONs8caouMDdp7jKe58nOgoEgnGxKR8lGW2I,15312 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1transform_1_1threadblock_1_1PredicatedTileIterator2dThreadTile_3_01Shape___00_090679c8ce9f0df00227bd9bd4aaff279.html,sha256=_2migNrMWLrTEoXtawMpvVb4uQyQqELV1N4rkgFqpKg,7010 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1transform_1_1threadblock_1_1PredicatedTileIterator2dThreadTile_3_01Shape___00_0b878062cc0cd214bf7e17d74ff17e246.html,sha256=z8OXMU30f-gFLydEOSbkdQ7WTJNQwfAEAqJMLzG8VOI,10292 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1transform_1_1threadblock_1_1RegularTileAccessIterator_3_01Shape___00_01Element_0a9491607d11be8e1780e79ad711aa42.html,sha256=IiV_rFnQzrzsOywft-3EwtXYBMppjBCCmw8Mowd3svk,10326 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1transform_1_1threadblock_1_1RegularTileAccessIterator_3_01Shape___00_01Element_159afb0a42935c95137b94a812a0c347.html,sha256=irYV_tRXhFkkllS-7VmqXRr5w0UiBvBzQ3NlmwAgZeo,7363 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1transform_1_1threadblock_1_1RegularTileAccessIterator_3_01Shape___00_01Element_3be8b96d170d886f39b6b30acab65e7a.html,sha256=TEOFUpOXk0_AwoEd1d0d6saJ_4We1KUvruQ1-DV8YxY,10213 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1transform_1_1threadblock_1_1RegularTileAccessIterator_3_01Shape___00_01Element_7fe4ae214b926456132d144640afba71.html,sha256=FeQ3BfivuOnzRp5JhKHVO-HQ8DY7UFJHXcX6TODdTvE,7438 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1transform_1_1threadblock_1_1RegularTileIterator_3_01Shape___00_01Element___00_0156743786c2e07a4e523ad410e291265.html,sha256=MzPcV32W_yAnpyTGUFBp0zI0Y-IkeQBEPTQweljAD8g,8150 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1transform_1_1threadblock_1_1RegularTileIterator_3_01Shape___00_01Element___00_02d305cfb0b55c6fb236a52cf2240651e.html,sha256=IYHGZA3QA0XbY_7kqFrkQ6xZ5MIUoRTHhqzrP6sG4BQ,10295 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1transform_1_1threadblock_1_1RegularTileIterator_3_01Shape___00_01Element___00_032f88d1be8b209e44a4815c707ba35bb.html,sha256=vNhQsekL_q6nuH1MeBI3S_9eZo6YPD8y2zsGy1tCq9A,10288 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1transform_1_1threadblock_1_1RegularTileIterator_3_01Shape___00_01Element___00_0390833403016f5d817416e20828845df.html,sha256=GvzTsc3oPcVQ15I7XxXoa89pPnY5S_0A5C8gsFP_RM0,12381 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1transform_1_1threadblock_1_1RegularTileIterator_3_01Shape___00_01Element___00_039093927f4b1ee61538c569bf1ae4efd.html,sha256=lKZPmKAKugdOlEnNQEd_Oi1-vuxqIomN9o6YxjMBBpk,8254 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1transform_1_1threadblock_1_1RegularTileIterator_3_01Shape___00_01Element___00_05192e46ead3e35a0208870cfc60f5da5.html,sha256=iBBlm8CLjJae1BYUuuYTn4VmWJGX8LmqJNKBxsxJEbc,7303 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1transform_1_1threadblock_1_1RegularTileIterator_3_01Shape___00_01Element___00_052caec9d5bceeb59b9a13cb3338ce64d.html,sha256=kcBg1k94PG2PEIwpEWZKdIvwVZYqSIRevBpydX59Ekg,8475 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1transform_1_1threadblock_1_1RegularTileIterator_3_01Shape___00_01Element___00_06b6dd3317cd1748fb948900df8beec57.html,sha256=p3LQocHBqTQt7hQOEedz2yq38Wsr35dk6efFIOgVICU,6635 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1transform_1_1threadblock_1_1RegularTileIterator_3_01Shape___00_01Element___00_078e1f4b2964afcce5387420c9c8eaea8.html,sha256=L5b0hG56quXsN5pQuzlvwHh6lNFnaWrw_3pbJFfc-9s,7308 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1transform_1_1threadblock_1_1RegularTileIterator_3_01Shape___00_01Element___00_0bc37beaa523707a55987f4ffcc372fcd.html,sha256=YGLYn5EubzpNwhm5CKYWXAdkmeL8n3PStMfM91Gkfk0,6695 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1xor__add-members.html,sha256=OgC30hdSr4RqrpT0t4nKnjZmmV4CES1BihDNo_s6tU0,5133 +bitblas/3rdparty/cutlass/docs/structcutlass_1_1xor__add.html,sha256=72VwO6auK_qhGrZ1Ari6VmwBtmVzx3zzdo3PJfH5-QQ,7143 +bitblas/3rdparty/cutlass/docs/structstd_1_1numeric__limits_3_01cutlass_1_1half__t_01_4-members.html,sha256=MwFq5SKqZkx5A_5Ar6kf8eIXn_GONOp6vDAXVX_9N84,13995 +bitblas/3rdparty/cutlass/docs/structstd_1_1numeric__limits_3_01cutlass_1_1half__t_01_4.html,sha256=qmMwEvAOR7t0NC8DFZfUUE4DVPRl3K3_JSiFsBL2MfY,32939 +bitblas/3rdparty/cutlass/docs/subbyte__reference_8h.html,sha256=qXY_cJkRjcEw16uZ-4aZuyEn6W5omETRR0Uup3Q_8Ts,7940 +bitblas/3rdparty/cutlass/docs/subbyte__reference_8h__dep__incl.md5,sha256=BpslvwGClRDzZ6ftFrbG-jLSgh6yjaPFB1B0q1kdS-A,32 +bitblas/3rdparty/cutlass/docs/subbyte__reference_8h__incl.md5,sha256=WSicBQ6X2nqsncYNd5j5Kbh0c91OZpKUiIbc-2-Sbpg,32 +bitblas/3rdparty/cutlass/docs/subbyte__reference_8h_source.html,sha256=KQMMEromn2mrBRzNPPs2pcPa4Rpe60FYli8d8blpAPg,111466 +bitblas/3rdparty/cutlass/docs/sync_off.png,sha256=fw5vcZxexReYzFDFNsETnMvpSbSHuIGCq9QTPcLKI0w,859 +bitblas/3rdparty/cutlass/docs/sync_on.png,sha256=QTk0L3OMT9DCLlo30AH47w17AXnW-lshV1C3FzMWJaA,847 +bitblas/3rdparty/cutlass/docs/tab_a.png,sha256=0zTgmu0-RPYVrDtPLrNr26lAzWMgUbZgRZkgGodGAd4,142 +bitblas/3rdparty/cutlass/docs/tab_b.png,sha256=ukbfMRiyCTTQ5Z1khrjvSlrOj-5rzpSXUITfzpTZdvQ,169 +bitblas/3rdparty/cutlass/docs/tab_h.png,sha256=clEaer2nVM8NdlKwpEaTFSXeViKvVabqzp0qMyhNuDs,176 +bitblas/3rdparty/cutlass/docs/tab_s.png,sha256=21Xuo5bMVxHf1KtVwZWed_SIz9aobsyNnouhpD9JriI,180 +bitblas/3rdparty/cutlass/docs/tabs.css,sha256=TjMRbR8hh_l87kbSTRMNIPT_bAAn2-KjavLrcNS9e8U,1163 +bitblas/3rdparty/cutlass/docs/tensor_8h.html,sha256=dnjK-rGHxsB1T51Wp7a85g5zGBcbbRnfvn4Zc7Xoy20,9637 +bitblas/3rdparty/cutlass/docs/tensor_8h__dep__incl.md5,sha256=J091R5MH2O1Bhh6YyuveMjJMZVlkz27Px8Bsiqf9u04,32 +bitblas/3rdparty/cutlass/docs/tensor_8h__incl.md5,sha256=hhi2xplNyNHeGq5dkjbv-4h8T_KyhQoSveOoMmLYwdA,32 +bitblas/3rdparty/cutlass/docs/tensor_8h_source.html,sha256=coPpCoq3ROsM2lgwl6M9EFGERjfe51ZSP2exviFaoYM,100256 +bitblas/3rdparty/cutlass/docs/tensor__coord_8h.html,sha256=3Ioz9ac6injj0nMBbgQ_qtcFJzRBmqBq3sw78somLfk,6757 +bitblas/3rdparty/cutlass/docs/tensor__coord_8h__dep__incl.md5,sha256=q305nF4bEnqjAkN1AntB-tVZtjkEETbRjxk-7LHj_1s,32 +bitblas/3rdparty/cutlass/docs/tensor__coord_8h__incl.md5,sha256=XSQjaqya9MtJX9KTvygDhN4kgfPtroMP7XjJM3U5Kk4,32 +bitblas/3rdparty/cutlass/docs/tensor__coord_8h_source.html,sha256=GSXG3ziiEtZPT-7TgPHmJz_Uqv9j3n7VQoYRp0vFLkc,49314 +bitblas/3rdparty/cutlass/docs/tensor__copy_8h.html,sha256=NjPuEtDukwFuc6HgGMsWE9iCSIpZaYr_A2kbSwTbcx8,13786 +bitblas/3rdparty/cutlass/docs/tensor__copy_8h__incl.md5,sha256=heEXQtwB2st22yVNkl9SitY_Kg_hZsiU5O31eMnUKjU,32 +bitblas/3rdparty/cutlass/docs/tensor__copy_8h_source.html,sha256=h6kditctpJlTObUyea3_Q2dSIQk730qyNifoLQIkwnA,48860 +bitblas/3rdparty/cutlass/docs/tensor__norm_8h.html,sha256=1qa3b56dLntzazhzFbVi6tH7pn86rpORLgIj5DGsJUE,9138 +bitblas/3rdparty/cutlass/docs/tensor__norm_8h__incl.md5,sha256=jF1WG7Y3J1NZY8BnMbwPusgFbpC9gMVFL3Jq8N38fyc,32 +bitblas/3rdparty/cutlass/docs/tensor__norm_8h_source.html,sha256=4kcsdCfgQ24ReZKF6QZNJagXR0rOY4FDAMWVYl_3UgM,20255 +bitblas/3rdparty/cutlass/docs/tensor__op__multiplicand__sm70_8h.html,sha256=FwmwUeDx7ac1P8AYeASwrk6GJRwwv2M97awLydxf5po,12926 +bitblas/3rdparty/cutlass/docs/tensor__op__multiplicand__sm70_8h__dep__incl.md5,sha256=rJfC0H_Xrm9ad6ht0ci2oYsBu9UyoRcQgP9244Tj-Bw,32 +bitblas/3rdparty/cutlass/docs/tensor__op__multiplicand__sm70_8h__incl.md5,sha256=Fr1sKPCyCTmWZCdkbyTLLkSbDhctKtRA5Ju6dB2TP6o,32 +bitblas/3rdparty/cutlass/docs/tensor__op__multiplicand__sm70_8h_source.html,sha256=I4HDQf50Uvf1WkSw17Ggk_L6VzsWZqMHwtjQYEgFzb4,267964 +bitblas/3rdparty/cutlass/docs/tensor__op__multiplicand__sm75_8h.html,sha256=nwOgQa-iFuWAa1sLVI_S2eQ31q5TlH1fvQBy32Bbt_o,11498 +bitblas/3rdparty/cutlass/docs/tensor__op__multiplicand__sm75_8h__dep__incl.md5,sha256=NJDu35Je0W2Y7pdiBwEDGQtLMXmoGp3ncys0-E1lZQ0,32 +bitblas/3rdparty/cutlass/docs/tensor__op__multiplicand__sm75_8h__incl.md5,sha256=oqEqX_qgk3GOT_VGId-93Wj5ZTi1q2SSa0-_3x9OuG0,32 +bitblas/3rdparty/cutlass/docs/tensor__op__multiplicand__sm75_8h_source.html,sha256=F5uG6a1IcSNqj4BeJtd-NeP4shCQTOmS2pczfCce6V8,287124 +bitblas/3rdparty/cutlass/docs/tensor__op__policy_8h.html,sha256=mEyCIw1hYs4Br-GLaKPHHzrXB1yXCgmLhzOIMf2RehQ,9474 +bitblas/3rdparty/cutlass/docs/tensor__op__policy_8h__dep__incl.md5,sha256=UeLNpVkwCz9FOoZZyWYaOTTLk4yCyX-qzkZw2R6GZgk,32 +bitblas/3rdparty/cutlass/docs/tensor__op__policy_8h__incl.md5,sha256=HYoq8by7uo65f-IB_LAs7feq1uthKg2DMcOvHJ-PW7Y,32 +bitblas/3rdparty/cutlass/docs/tensor__op__policy_8h_source.html,sha256=dITzZzOPr0cLgjQ80D_1JsG0rSID_xQTQmVzByMHeL8,25431 +bitblas/3rdparty/cutlass/docs/tensor__ref_8h.html,sha256=X8JmkhJFyx6pPfLj1aVOSUb2hiy7cek2AwtTl3Dfduk,8955 +bitblas/3rdparty/cutlass/docs/tensor__ref_8h__dep__incl.md5,sha256=Ue62H1c4sMTPcx81YIueFiCFp6eMNMOILd-vMQjhwkA,32 +bitblas/3rdparty/cutlass/docs/tensor__ref_8h__incl.md5,sha256=AMxZnyoHxNY7znvct0t_YZdP3MzReD0uLbEiqKfiZsg,32 +bitblas/3rdparty/cutlass/docs/tensor__ref_8h_source.html,sha256=8wMbz-NGli7MXewIUSQ-qN1H0HJO7RQJTjoFXsD3mlM,89989 +bitblas/3rdparty/cutlass/docs/tensor__view_8h.html,sha256=smcJqyt1pY0PQGoZp8kTe9Lsibn2V3Ew7WM35xN59dw,8542 +bitblas/3rdparty/cutlass/docs/tensor__view_8h__dep__incl.md5,sha256=YX3GVS9ZD6MiaEPxpVJKNyOx6hrcftA3V8GOlTgDkno,32 +bitblas/3rdparty/cutlass/docs/tensor__view_8h__incl.md5,sha256=O40wNtH06vYUS9liKtLMRrAHf_HZxrFLW3SXQjoxpFc,32 +bitblas/3rdparty/cutlass/docs/tensor__view_8h_source.html,sha256=xRCvmOXqOL-ce4ZdgJJx0hfKCj4FnNJ6ut2a7fmROdQ,68383 +bitblas/3rdparty/cutlass/docs/tensor__view__io_8h.html,sha256=aTddtRp-zdPq8mO0le7E-TOUw4MRq4BG7vqcyRj86Os,10881 +bitblas/3rdparty/cutlass/docs/tensor__view__io_8h__dep__incl.md5,sha256=IswXtT3xF6Ihod-_p_jj7nUceNfGnV5ToOxwyrlrlK4,32 +bitblas/3rdparty/cutlass/docs/tensor__view__io_8h__incl.md5,sha256=z7YxIWVVqFtYMuKBjT5qmMM08YF6XVHEO4urF9b0CCY,32 +bitblas/3rdparty/cutlass/docs/tensor__view__io_8h_source.html,sha256=3MT2eyzJ9_Is2yFKMp9hCCdI0e6gqNuQRgLc2E8D7Y4,29886 +bitblas/3rdparty/cutlass/docs/thread_2matrix_8h.html,sha256=S7CaeI6w43RvJczSLOLLCdsDwn6vScZjRea70ZEAJb8,9001 +bitblas/3rdparty/cutlass/docs/thread_2matrix_8h__incl.md5,sha256=oyURL-Yyl2EBuD_5OnBe_JQBw1i2yHkUt_O3X5tM0jY,32 +bitblas/3rdparty/cutlass/docs/thread_2matrix_8h_source.html,sha256=g1EMqlVbRKg5Wif5hIOqH6GArO04zKw-i6jqZ3QbYjI,49681 +bitblas/3rdparty/cutlass/docs/tile__iterator__simt_8h.html,sha256=_nL8Wj9KvwNUalFGlOdSWa2X4UjVDuz-tdWBt79856M,9806 +bitblas/3rdparty/cutlass/docs/tile__iterator__simt_8h__dep__incl.md5,sha256=BhaIs5mbzjBXubSG3rtmHt5dIaVM_42venili23bEC8,32 +bitblas/3rdparty/cutlass/docs/tile__iterator__simt_8h__incl.md5,sha256=K2VwRSwxxdWey7ZiW13kIgAGbXEg7n3dEt97xg8JB34,32 +bitblas/3rdparty/cutlass/docs/tile__iterator__simt_8h_source.html,sha256=W1sBXpO5dsgc4hj98psTabq1v4jWLUja24pM6re3THA,59865 +bitblas/3rdparty/cutlass/docs/tile__iterator__tensor__op_8h.html,sha256=9mB9B6iRFz6dDPnJxUUDOZY-HwZAIW4W7TsYwa6hQpg,9370 +bitblas/3rdparty/cutlass/docs/tile__iterator__tensor__op_8h__dep__incl.md5,sha256=J7Jp3goP4OvREjFc_RaDRs9hUZg5VVPHW2dLbdcJk7c,32 +bitblas/3rdparty/cutlass/docs/tile__iterator__tensor__op_8h__incl.md5,sha256=5j-zsZTRRSJcJ-Ak8o-ox0pL4UWAY9qkSMEkTMk3iqc,32 +bitblas/3rdparty/cutlass/docs/tile__iterator__tensor__op_8h_source.html,sha256=hztUYSXzwrPHjiHiuxBQ7G2D50qQjxPuygtbuMERY0E,56381 +bitblas/3rdparty/cutlass/docs/tile__iterator__volta__tensor__op_8h.html,sha256=r_pSO-5Sy4iQPhnd4FL0gKpiQIZtTOluFS7p794gKEE,10879 +bitblas/3rdparty/cutlass/docs/tile__iterator__volta__tensor__op_8h__dep__incl.md5,sha256=nMPoePV0e7xeZAO2eVJyiq3qhgemA_eSx6ViGBt8fXU,32 +bitblas/3rdparty/cutlass/docs/tile__iterator__volta__tensor__op_8h__incl.md5,sha256=hk4iFm1ftWQMEBhY8Oq3fJV5ypmFBzxKWYYMJZKoV0s,32 +bitblas/3rdparty/cutlass/docs/tile__iterator__volta__tensor__op_8h_source.html,sha256=OphzYj07joEa6EgSexo5NTjK4ICebOnKE_wJoc9htcU,113878 +bitblas/3rdparty/cutlass/docs/tile__iterator__wmma__tensor__op_8h.html,sha256=9XZVUkqFbFI_7LhdxA8xKlN2zsdIqeZMQ61CojPCdU0,9219 +bitblas/3rdparty/cutlass/docs/tile__iterator__wmma__tensor__op_8h__dep__incl.md5,sha256=96ZPZNHIa0fvwYwvAz7F-u36tToRbYY80XzllmLyjnY,32 +bitblas/3rdparty/cutlass/docs/tile__iterator__wmma__tensor__op_8h__incl.md5,sha256=FbCuOIdMCJcyPajIjlyDujWQpapZrV6qyY3gUNF3m6w,32 +bitblas/3rdparty/cutlass/docs/tile__iterator__wmma__tensor__op_8h_source.html,sha256=4iGW8TvuHgp-HpWOc2bchhQfiHCKi08gvxKsOdtz3DE,62739 +bitblas/3rdparty/cutlass/docs/tools_2util_2include_2cutlass_2util_2debug_8h.html,sha256=truIw_dDKzgAbVb86Y0IUJsodwGu4Y0ExN6trRUO77s,16512 +bitblas/3rdparty/cutlass/docs/tools_2util_2include_2cutlass_2util_2debug_8h__incl.md5,sha256=py2VtmXmmD_BHIjOmM84FEyugbeJzPavEBTqAQjrJCM,32 +bitblas/3rdparty/cutlass/docs/tools_2util_2include_2cutlass_2util_2debug_8h_source.html,sha256=gFd1izJ9TBJuvpU6pEHEGghXpr6BMbxsOeEYrSrM5-8,23972 +bitblas/3rdparty/cutlass/docs/tools_2util_2include_2cutlass_2util_2reference_2device_2gemm_8h.html,sha256=2FcJrwG-Sp6pyX_Hk1A2LjTgWRQGe62krmouj-D_WV0,15496 +bitblas/3rdparty/cutlass/docs/tools_2util_2include_2cutlass_2util_2reference_2device_2gemm_8h__incl.md5,sha256=l7xfUAZGmEVP9lF-kpsQIFvGH6gmDR8KNH5zB4IqKso,32 +bitblas/3rdparty/cutlass/docs/tools_2util_2include_2cutlass_2util_2reference_2device_2gemm_8h_source.html,sha256=wVkfEerw0ZKeYIKPBtnVwMCzDqvVC4LZKDVELJslXJ4,76237 +bitblas/3rdparty/cutlass/docs/tools_2util_2include_2cutlass_2util_2reference_2device_2kernel_2gemm_8h.html,sha256=kYb4phYRDaV-s9U7iRZYArQrHsbuuzEIP-eCX5dZRDE,10453 +bitblas/3rdparty/cutlass/docs/tools_2util_2include_2cutlass_2util_2reference_2device_2kernel_2gemm_8h__dep__incl.md5,sha256=-iETl4LHi5cXvI8VGVB-qR7YB4FOQZQZ4-bjse9IGO8,32 +bitblas/3rdparty/cutlass/docs/tools_2util_2include_2cutlass_2util_2reference_2device_2kernel_2gemm_8h__incl.md5,sha256=v3zMmZQa6Wdy6TcznVlDXGsTlkr2thZ0hfyisQeYJUM,32 +bitblas/3rdparty/cutlass/docs/tools_2util_2include_2cutlass_2util_2reference_2device_2kernel_2gemm_8h_source.html,sha256=T2Ry3y_1lI95X_c6kSFR1mDXF729Kw8-KODzUGJ3M38,29137 +bitblas/3rdparty/cutlass/docs/tools_2util_2include_2cutlass_2util_2reference_2device_2thread_2gemm_8h.html,sha256=iZ7jZIPJ42ydxFwOHhBa5fXUuSgBkVd8QopEMOss9KQ,8984 +bitblas/3rdparty/cutlass/docs/tools_2util_2include_2cutlass_2util_2reference_2device_2thread_2gemm_8h__dep__incl.md5,sha256=fI5Vyv7dT1taQPpy7ScQa9dmWnq9P4DfpxCZVjZPlrI,32 +bitblas/3rdparty/cutlass/docs/tools_2util_2include_2cutlass_2util_2reference_2device_2thread_2gemm_8h__incl.md5,sha256=Io1AsfJV98DiN2J18wKsstCxvRfNJImRhcA7QlTFVlA,32 +bitblas/3rdparty/cutlass/docs/tools_2util_2include_2cutlass_2util_2reference_2device_2thread_2gemm_8h_source.html,sha256=grVqYvrqOe5FyPVeTS_WlwGpvB_etHkcRnARPPC0C68,44119 +bitblas/3rdparty/cutlass/docs/tools_2util_2include_2cutlass_2util_2reference_2host_2gemm_8h.html,sha256=LWccQ4_WhVdUfeoRgXYqQ6uUj12upNiKhpqSW3gmvHQ,15643 +bitblas/3rdparty/cutlass/docs/tools_2util_2include_2cutlass_2util_2reference_2host_2gemm_8h__dep__incl.md5,sha256=oBAqy7eDSOq9tqRSlRCBNO8Yc1yHJ3JSTjyQWFiDm3k,32 +bitblas/3rdparty/cutlass/docs/tools_2util_2include_2cutlass_2util_2reference_2host_2gemm_8h__incl.md5,sha256=5dERJ1QROmwBiO90VVSiA4kZbXc8S21TVwKrdeZRZMw,32 +bitblas/3rdparty/cutlass/docs/tools_2util_2include_2cutlass_2util_2reference_2host_2gemm_8h_source.html,sha256=MJxcxcio_eBbj4Jk8i0ExTj1dgtdTlxCygWVOW4SSDM,77014 +bitblas/3rdparty/cutlass/docs/tools_2util_2include_2cutlass_2util_2reference_2host_2gemm__complex_8h.html,sha256=zSBQfdR8KtxF15lEVL4zdyIMrG_AQoDovGBKHUNiVO8,10045 +bitblas/3rdparty/cutlass/docs/tools_2util_2include_2cutlass_2util_2reference_2host_2gemm__complex_8h__incl.md5,sha256=lsr0j_UycGC57y_jxaiSBUqmMZ2Gk3Ao-Eg7DZ2IsMk,32 +bitblas/3rdparty/cutlass/docs/tools_2util_2include_2cutlass_2util_2reference_2host_2gemm__complex_8h_source.html,sha256=NidQEiVodoAeQtfE_zDbHEYAshYjC5OpbGnkwlmGKL4,37047 +bitblas/3rdparty/cutlass/docs/transform_2threadblock_2predicated__tile__iterator_8h.html,sha256=V0EA-RJ2tCo9DTQKviRW7f8ypLD_FBDHCyxqfWzm64s,15325 +bitblas/3rdparty/cutlass/docs/transform_2threadblock_2predicated__tile__iterator_8h__dep__incl.md5,sha256=8mmVsIgDcbf4WWIG5-neHBIxYT-7RbaM3ggQsozCtrE,32 +bitblas/3rdparty/cutlass/docs/transform_2threadblock_2predicated__tile__iterator_8h__incl.md5,sha256=Qx-Ke5pwehi5BosuJ0O1yAp6qRr80466aPk7YQ7XV9M,32 +bitblas/3rdparty/cutlass/docs/transform_2threadblock_2predicated__tile__iterator_8h_source.html,sha256=80_5y3rUhzP8UKuEuIRdbtnllq-7fkcL4t_5Bhq-aho,304982 +bitblas/3rdparty/cutlass/docs/transpose_8h.html,sha256=9vWDyzjDfjUgVXYQJiW9onqeFVQNKNFe7AKhPvQsYxM,7884 +bitblas/3rdparty/cutlass/docs/transpose_8h__dep__incl.md5,sha256=2ga8TJR3hc56e9POqhCIrd_sWixMLFQ6FJfMM-jNj3A,32 +bitblas/3rdparty/cutlass/docs/transpose_8h_source.html,sha256=lXsy1SCBy_eD6GtlCJcWh9TrffkmDVzLMxF-sXjvY6U,27762 +bitblas/3rdparty/cutlass/docs/type__traits_8h.html,sha256=r1KL2vx4FvP4mr_LT80oQDHQTNiXOGhe6lhHwcP6OFg,11787 +bitblas/3rdparty/cutlass/docs/type__traits_8h__incl.md5,sha256=W6wNR7_kkQgUXj35_B6UwdDdUsfnCU1qK2yS73O4Yso,32 +bitblas/3rdparty/cutlass/docs/type__traits_8h_source.html,sha256=y-NDJtmo4-WsGjSbUHovtJiYs_dxQgm7Hsac-FMYp_k,111911 +bitblas/3rdparty/cutlass/docs/unioncutlass_1_1gemm_1_1kernel_1_1GemmBatched_1_1SharedStorage-members.html,sha256=KpYm7aIRPbn3hNyUWUjDHVe8Z6UQ4mlH_LNiRzqlIjc,6098 +bitblas/3rdparty/cutlass/docs/unioncutlass_1_1gemm_1_1kernel_1_1GemmBatched_1_1SharedStorage.html,sha256=TxqSvtsfYlwVm75-IVir45fkQ6YztjZwjQOLZfjVKHw,7841 +bitblas/3rdparty/cutlass/docs/unioncutlass_1_1gemm_1_1kernel_1_1GemmSplitKParallel_1_1SharedStorage-members.html,sha256=jGcMTiiTGVtyIEPBtxRZ9fMtDScwG4Gjr00zdwCgINo,6182 +bitblas/3rdparty/cutlass/docs/unioncutlass_1_1gemm_1_1kernel_1_1GemmSplitKParallel_1_1SharedStorage.html,sha256=faZr62LdH6T0OcePztRpIQzuIgb30NwpkuKlC4DWGPI,7959 +bitblas/3rdparty/cutlass/docs/unioncutlass_1_1gemm_1_1kernel_1_1Gemm_1_1SharedStorage-members.html,sha256=KcPeZ1AQM05kXdF42w0dRHFj_zAreRKT5y-X2auN2MQ,6070 +bitblas/3rdparty/cutlass/docs/unioncutlass_1_1gemm_1_1kernel_1_1Gemm_1_1SharedStorage.html,sha256=d8PK4QKvtt97uOdX1WqJxsu2Pm5sCcFE0NqYm9tx0DM,7886 +bitblas/3rdparty/cutlass/docs/vector_8h.html,sha256=A6Q3SpE6AKEGX4bGg5g7Y2lGlAJygM0YfcSMjVYD3U8,7082 +bitblas/3rdparty/cutlass/docs/vector_8h__dep__incl.md5,sha256=fH_VPJqxHrjyrmzrOiBOG62GERfsc7EXJgJfXOTF7g4,32 +bitblas/3rdparty/cutlass/docs/vector_8h__incl.md5,sha256=UcEyFRBloHPPDssLLnEwQHl25-y_x1c3jtw57Z9SJiU,32 +bitblas/3rdparty/cutlass/docs/vector_8h_source.html,sha256=W_Mv1UgR_UzPxm7XtvkS4aeVEfDfzHaKg7Hpi4NQPr8,26099 +bitblas/3rdparty/cutlass/docs/volta__tensor__op__policy_8h.html,sha256=mUfg7MyfxM6zH5uBKtWYH_3HgdU2OUsnGds76fDvYPg,9764 +bitblas/3rdparty/cutlass/docs/volta__tensor__op__policy_8h__dep__incl.md5,sha256=uEY6WzeueUF9k3czw9MEijXLR_QiEGvtEsEwny0EiXc,32 +bitblas/3rdparty/cutlass/docs/volta__tensor__op__policy_8h__incl.md5,sha256=xgYe12m1CqpO5SYCIO5icTku0N88RSsJbHLoSmt0HgI,32 +bitblas/3rdparty/cutlass/docs/volta__tensor__op__policy_8h_source.html,sha256=7ftJmqWIPOyggveLVzF5sXgCUhXwy0bbIQkrv46YkyE,42763 +bitblas/3rdparty/cutlass/docs/wmma_8h.html,sha256=Kt7eWarCo24TBvJ4-X5Xh9vCGvX4cqLnYa67uFajAnY,5045 +bitblas/3rdparty/cutlass/docs/wmma_8h__dep__incl.md5,sha256=09yDkRJB5U44Fear8jZY1SZNkZ14gtihrv6CZpnLu14,32 +bitblas/3rdparty/cutlass/docs/wmma_8h_source.html,sha256=9jQ8oa6_wJq7u1gmiYBRU7HJB50zVgHMf5pv0hXUL5I,33877 +bitblas/3rdparty/cutlass/docs/wmma__array_8h.html,sha256=qbhpr7ISpcIFprHcK3jpqkglPvH-00mfZ-MB7570MIs,5458 +bitblas/3rdparty/cutlass/docs/wmma__array_8h__dep__incl.md5,sha256=FOK3qZUoZ2fXQuZbNM8HAPqImTo1l5HE3vRyv6OX_pA,32 +bitblas/3rdparty/cutlass/docs/wmma__array_8h__incl.md5,sha256=73BiHxfraP06KDXmGRblsTxFH6Am9otiycPX-7CvPQA,32 +bitblas/3rdparty/cutlass/docs/wmma__array_8h_source.html,sha256=lZQURr_U7RaensGtt4vL-ofyJEsGDd2JFQcJiGqU6Rw,14520 +bitblas/3rdparty/cutlass/docs/wmma__ptx_8h.html,sha256=GZh6-YZenp7GjeRcX0fOBD3CY4OK7oUCzofZaLH92I4,8571 +bitblas/3rdparty/cutlass/docs/wmma__ptx_8h__incl.md5,sha256=7gL5ESRjYEKpg40RpmVWj-dvptajuBewK36UrKCyfV4,32 +bitblas/3rdparty/cutlass/docs/wmma__ptx_8h_source.html,sha256=j5Slvys6xqADwMepP9AI8SvP7TlGFYcdWGBtiSOXba8,18944 +bitblas/3rdparty/cutlass/docs/wmma__sm70_8h.html,sha256=I_Hw1hs4dfn9sy205FDXpBLY_wKC2MCLMzQEqkpFoqU,6682 +bitblas/3rdparty/cutlass/docs/wmma__sm70_8h__incl.md5,sha256=Ro_ibqupXnaGYI4RiVV4wa1TRY19xZUAklk_goMysqE,32 +bitblas/3rdparty/cutlass/docs/wmma__sm70_8h_source.html,sha256=Knhus_tL32AjkBYLlzR1f0UZ4BwhFycawDlmgLeukAM,24243 +bitblas/3rdparty/cutlass/docs/wmma__sm72_8h.html,sha256=lNODnmruZCoEvM3uaQN_wZwBy4BWYgUTuKIY7msdX_Y,7162 +bitblas/3rdparty/cutlass/docs/wmma__sm72_8h__incl.md5,sha256=eOCAH1yoRSX5VX0S-BEToy3bQXbk9_8N2VNs6GFQtzc,32 +bitblas/3rdparty/cutlass/docs/wmma__sm72_8h_source.html,sha256=-Uj1YZ0eH5NGIoX-ALQAX1qW6fb18LSsMvPBHl1S0xA,33365 +bitblas/3rdparty/cutlass/docs/wmma__sm75_8h.html,sha256=SABgjSwlL3rM3ZgYTvBjjlKPKHefKSZWgwverqitPxI,7198 +bitblas/3rdparty/cutlass/docs/wmma__sm75_8h__incl.md5,sha256=lW_OdXngjI9Um-cwocS6RxsP83gR6dtc8q8qXKDpg5w,32 +bitblas/3rdparty/cutlass/docs/wmma__sm75_8h_source.html,sha256=2QmBd04KgbT7KWECQMUYspqwSdFaHnJgx_J5I_L5H1k,34187 +bitblas/3rdparty/cutlass/docs/wmma__tensor__op__policy_8h.html,sha256=6yAgUgvDwYGylKzTKMrzYczc4yL1JZYSJ_Vad_npG3g,6143 +bitblas/3rdparty/cutlass/docs/wmma__tensor__op__policy_8h__dep__incl.md5,sha256=fQhbr3jxZt-UlgKwjNk_RRdDZ0e5mg4maD2Pi0mvMSk,32 +bitblas/3rdparty/cutlass/docs/wmma__tensor__op__policy_8h__incl.md5,sha256=DaqjcnZgcfYlPOXX-pFWp-hir4p1jKc-0371DnyqoJQ,32 +bitblas/3rdparty/cutlass/docs/wmma__tensor__op__policy_8h_source.html,sha256=-eKeU_s9FENSyDUkv7c52tIvJQPdslkp3xxY_Dtx1mU,17307 +bitblas/3rdparty/cutlass/examples/00_basic_gemm/CMakeLists.txt,sha256=VDnAzZ48aNGrY74t-AUdw-aAEwubaK-ihtgM4qbC04I,1668 +bitblas/3rdparty/cutlass/examples/00_basic_gemm/basic_gemm.cu,sha256=rDDHzx43NA-Nfbm00PuOzdWwm7tnu9EUgcuSptn5_o4,14698 +bitblas/3rdparty/cutlass/examples/01_cutlass_utilities/CMakeLists.txt,sha256=NCOhDUTQCCQiPBW_SqgUUbi_pzIVTY5rLWSZM00cm8o,1681 +bitblas/3rdparty/cutlass/examples/01_cutlass_utilities/cutlass_utilities.cu,sha256=EF8hTZYijmC2X5HjSum7a21bK2Pz_-8H-blJQMyzknA,13255 +bitblas/3rdparty/cutlass/examples/02_dump_reg_shmem/CMakeLists.txt,sha256=CsBUR2m7YqrhgTpFNrFoCTiUuc1EOBQIbh3_IQvYSp4,1674 +bitblas/3rdparty/cutlass/examples/02_dump_reg_shmem/dump_reg_shmem.cu,sha256=LY6WWGS4p8o6G4arMnI9AIp7jYvqYDmi0ndV-VhmUFc,7157 +bitblas/3rdparty/cutlass/examples/03_visualize_layout/CMakeLists.txt,sha256=WIEjJ6B3GtWtliD8Ahc0eI5GsZyfUgRJ56PenLUEFqA,1789 +bitblas/3rdparty/cutlass/examples/03_visualize_layout/options.h,sha256=IUw6gfJdWCBIHNHiOoc3b8EA_FbNrrJrXF7NBM-3Nvc,4478 +bitblas/3rdparty/cutlass/examples/03_visualize_layout/register_layout.cu,sha256=86lULW7FlDrq4peuuD4MNico3QSmzhP1FPAeffz6L48,7081 +bitblas/3rdparty/cutlass/examples/03_visualize_layout/register_layout.h,sha256=es3_Wz1YUdUVIIalIkgqcILZ_AdHdwr_MBnDmkUjVyM,2691 +bitblas/3rdparty/cutlass/examples/03_visualize_layout/visualize_layout.cpp,sha256=mypDqhfDSykHJnTt-ArkdssEvCWuBbuM197C8DaVWao,5819 +bitblas/3rdparty/cutlass/examples/03_visualize_layout/visualize_layout.h,sha256=u-Y0qB3cxnoHtgCnOmPy2a1GWpdIpoeWy-hqt7PfY9c,11415 +bitblas/3rdparty/cutlass/examples/04_tile_iterator/CMakeLists.txt,sha256=AjQoM3E4JyDGX9RhWhxysY8ZPdSLzV5Ppzzrr0TEFxU,1673 +bitblas/3rdparty/cutlass/examples/04_tile_iterator/tile_iterator.cu,sha256=-1EPlHoCxDbREqR1XaGdg5y-TQQ4A4GfSlqOoxZRQ9c,8226 +bitblas/3rdparty/cutlass/examples/05_batched_gemm/CMakeLists.txt,sha256=ac0a02CUHKTIGZQBX_x49giYggeabJeCd1H1R6lkak4,1672 +bitblas/3rdparty/cutlass/examples/05_batched_gemm/batched_gemm.cu,sha256=FAXk21kCbPmbzqww8uUsIYULh1Vy5i05pZy5Eggjotk,15161 +bitblas/3rdparty/cutlass/examples/06_splitK_gemm/CMakeLists.txt,sha256=myEX76r7nMV4oA6NJ2h_oAPsT2AULMG_U2QP6GflIPY,1670 +bitblas/3rdparty/cutlass/examples/06_splitK_gemm/splitk_gemm.cu,sha256=uQXwhiU-kPy4u8-n_3OCSdQWgi5vv1xpBsYd_izRezA,17570 +bitblas/3rdparty/cutlass/examples/07_volta_tensorop_gemm/CMakeLists.txt,sha256=JH2MCJJZrc-Yhfr6ZKloeo2sybcYes8N5yLAzascXZk,1686 +bitblas/3rdparty/cutlass/examples/07_volta_tensorop_gemm/volta_tensorop_gemm.cu,sha256=2qi-vaFLs4CpoCmrslDmlHyUB8edw1_XSiGiP8L43dw,18283 +bitblas/3rdparty/cutlass/examples/08_turing_tensorop_gemm/CMakeLists.txt,sha256=7ATMbFYuSsjpCGNytgohcdpcExw2esLSpAQ1XLd3vME,1688 +bitblas/3rdparty/cutlass/examples/08_turing_tensorop_gemm/turing_tensorop_gemm.cu,sha256=_hjhxm5eCU_IKCJOscxn7bfxXMZDeNyJ4jqyNWL1ZDE,18198 +bitblas/3rdparty/cutlass/examples/09_turing_tensorop_conv2dfprop/CMakeLists.txt,sha256=xcc9c7LSSKo0hv-IKWypXMkGZeJLaapBbtVPkE3ryIo,1703 +bitblas/3rdparty/cutlass/examples/09_turing_tensorop_conv2dfprop/turing_tensorop_conv2dfprop.cu,sha256=mm_e2Z15kD9qrzXU9xuxHKKBLQ6ecjGwjwO-4i_fzxY,28142 +bitblas/3rdparty/cutlass/examples/10_planar_complex/CMakeLists.txt,sha256=vU7f6OIWmLOLf8h7koyLs0Kvw0XWj_Tzb-NtNCauaag,1897 +bitblas/3rdparty/cutlass/examples/10_planar_complex/planar_complex.cu,sha256=vH9n4tb7xUDq6xJ6NJbF9O7vz31CBaePUxQV4SUoCvE,21947 +bitblas/3rdparty/cutlass/examples/11_planar_complex_array/CMakeLists.txt,sha256=ch8vGD0XPFoIueWSeMH-luNPFc_G5z8MMI1h8kvsXB4,1921 +bitblas/3rdparty/cutlass/examples/11_planar_complex_array/planar_complex_array.cu,sha256=lcI8lN36sa9s_qraw8wb0_XoYN-gysxDYpSk2GvUduU,23244 +bitblas/3rdparty/cutlass/examples/12_gemm_bias_relu/CMakeLists.txt,sha256=1teM0jV01KcwWaU2pYXGsUYZejAaNFsd_GBe3DdpYbc,1676 +bitblas/3rdparty/cutlass/examples/12_gemm_bias_relu/gemm_bias_relu.cu,sha256=ccLWeMYxfgnA9ON9C0aVs3b67rFH3USkJNSw_gutG0Q,13151 +bitblas/3rdparty/cutlass/examples/13_two_tensor_op_fusion/CMakeLists.txt,sha256=Pywo4aFS8UWnM9A4_pOYoLCBgYWr42v9-TotXeGHUdc,2757 +bitblas/3rdparty/cutlass/examples/13_two_tensor_op_fusion/README.md,sha256=6H21z2laBENwubu3JSYqGodHScox7vASSdGE5vgsWMM,5893 +bitblas/3rdparty/cutlass/examples/13_two_tensor_op_fusion/b2b_conv2d_run.h,sha256=xSDIEWoKF_jvK0v6Id65xwlAZ8hH7PwHY8OoNNcFMZs,26102 +bitblas/3rdparty/cutlass/examples/13_two_tensor_op_fusion/b2b_gemm_run.h,sha256=pvtNIUcNexBqVL-685UB3qNpE4IAX9GRw1lEqO9sFug,24557 +bitblas/3rdparty/cutlass/examples/13_two_tensor_op_fusion/b2b_grouped_gemm_run.h,sha256=ZLO1YGUigZsdeo5cqTksVOD56S-upJnIW0MfcMS1VvI,18662 +bitblas/3rdparty/cutlass/examples/13_two_tensor_op_fusion/b2b_interleaved_conv2d_run.h,sha256=yW1U4TWaYiZfkIaE4u666GYu7okzTcRa0H6RkeWfgKA,28268 +bitblas/3rdparty/cutlass/examples/13_two_tensor_op_fusion/b2b_interleaved_gemm_run.h,sha256=zL66qK9xGi4hffHG0Vp62RKqchuzgqQb4g0peu7gAmk,26174 +bitblas/3rdparty/cutlass/examples/13_two_tensor_op_fusion/device/b2b_gemm.h,sha256=iIN3GLnfNI5kCAcjbnD0_tHkUvaqCXWbVTYcp8wgJM0,12711 +bitblas/3rdparty/cutlass/examples/13_two_tensor_op_fusion/device/b2b_implicit_gemm_convolution.h,sha256=Q8ydEofEGpkmYDYcpmd-c0XXsznopvOQSjwZIioIQCw,11520 +bitblas/3rdparty/cutlass/examples/13_two_tensor_op_fusion/fused_two_convs_f16_sm75_rf.cu,sha256=E3RrSy5yJ9qn6Ssz4CFzmwk2m2qec_B7AUHpi-_IGRQ,8756 +bitblas/3rdparty/cutlass/examples/13_two_tensor_op_fusion/fused_two_convs_f16_sm75_shmem.cu,sha256=3U8eVeXsgeNp5a3qhrXzWDoY3u4RTYY0mNoozED76Pw,8759 +bitblas/3rdparty/cutlass/examples/13_two_tensor_op_fusion/fused_two_convs_f16_sm80_rf.cu,sha256=Sxk6EMyVOXN73gJXI12a0AvsXd3hyzRevzpCsw0fFpU,8712 +bitblas/3rdparty/cutlass/examples/13_two_tensor_op_fusion/fused_two_convs_f16_sm80_shmem.cu,sha256=Z_sS7iAMpXHtdxWzBrzGCnBi2g2G1I5IHSSCQN8PK2Y,8762 +bitblas/3rdparty/cutlass/examples/13_two_tensor_op_fusion/fused_two_convs_s8_sm75_rf.cu,sha256=K31CTmhQSKrPlB0m8B6Nl-17diDJk6FnWqiSEizwXMQ,8782 +bitblas/3rdparty/cutlass/examples/13_two_tensor_op_fusion/fused_two_convs_s8_sm75_shmem.cu,sha256=EMlkYGqererIa7Bp422cqLtojK2qMjiA4cHn93NUYJQ,8785 +bitblas/3rdparty/cutlass/examples/13_two_tensor_op_fusion/fused_two_convs_s8_sm80_rf.cu,sha256=QQR5m8lLs4aTz18LwYu_Pw_8psjV8Df8k9h2w0wLnSs,8711 +bitblas/3rdparty/cutlass/examples/13_two_tensor_op_fusion/fused_two_convs_s8_sm80_shmem.cu,sha256=SRCKZY4CvbFSMJEwuiB0psRShgXwlghEjNwpClM97rA,8775 +bitblas/3rdparty/cutlass/examples/13_two_tensor_op_fusion/fused_two_gemms_f16_sm75_rf.cu,sha256=QjZ3vsiuO-g_jKn_mWBis2F1ZpS0oge0Q2wK9eaKeHg,7269 +bitblas/3rdparty/cutlass/examples/13_two_tensor_op_fusion/fused_two_gemms_f16_sm75_shmem.cu,sha256=t_BHdxl7ukRy-A-CtDwruFwImMiNqza4geGt1Ty4hX4,7338 +bitblas/3rdparty/cutlass/examples/13_two_tensor_op_fusion/fused_two_gemms_f16_sm80_rf.cu,sha256=taDqcXUshibHtO3dlEQ7posiRIO46TQivc8Uw_RB6v4,7294 +bitblas/3rdparty/cutlass/examples/13_two_tensor_op_fusion/fused_two_gemms_f16_sm80_shmem.cu,sha256=e1tMmobUiIhTP-avoBiYQ8wnxXhFz1ZAyA2zMW8mOIA,7359 +bitblas/3rdparty/cutlass/examples/13_two_tensor_op_fusion/fused_two_gemms_grouped_f16_sm80_rf.cu,sha256=qpBvvxtuDhbO52buhd8s_bQBAXrFruiRZFTasXOcNhU,10064 +bitblas/3rdparty/cutlass/examples/13_two_tensor_op_fusion/fused_two_gemms_s8_sm75_rf.cu,sha256=USWLoVGlhvOz1RMQ6J95jzkiJA7NxVSGaIlcDKZBlpE,7358 +bitblas/3rdparty/cutlass/examples/13_two_tensor_op_fusion/fused_two_gemms_s8_sm75_shmem.cu,sha256=pP_ofAoCIj9-ee92vFC7ze6Prnr38t6O9W-Dn92qLV0,7424 +bitblas/3rdparty/cutlass/examples/13_two_tensor_op_fusion/fused_two_gemms_s8_sm80_rf.cu,sha256=A9TFusLd09Uhn7UhpmKDVTxz5UP8qccBoI-zRxLFZu4,11029 +bitblas/3rdparty/cutlass/examples/13_two_tensor_op_fusion/fused_two_gemms_s8_sm80_shmem.cu,sha256=kn9JqEcGE_ddS1Gzgs1nBlcgWUrq_CxiYSJU0kOnZXc,7619 +bitblas/3rdparty/cutlass/examples/13_two_tensor_op_fusion/kernel/b2b_gemm.h,sha256=oGEdtvot8fwUfGu82b4WsA21VVeIZsxfqhfTgLW7se0,30457 +bitblas/3rdparty/cutlass/examples/13_two_tensor_op_fusion/kernel/b2b_gemm_grouped_problem_visitor.h,sha256=Epuz6bDKSM9i0MVvSvj68bl1T0dqJwPYpPuaxthIXaE,6120 +bitblas/3rdparty/cutlass/examples/13_two_tensor_op_fusion/kernel/b2b_implicit_gemm_convolution.h,sha256=DhOxwfH0AXmFL43ylZDWX2brCVHuy24jfiBZXhdaNjA,18151 +bitblas/3rdparty/cutlass/examples/13_two_tensor_op_fusion/kernel/default_b2b_conv2d_fprop.h,sha256=G_CJYCOJQu8w2vThM6x47QjcLD-eS8YkatAXg0TeON8,3973 +bitblas/3rdparty/cutlass/examples/13_two_tensor_op_fusion/kernel/default_b2b_conv2d_fprop_sm75.h,sha256=-5e34JrCF-MMglInEkKSg1tgABsMFlpCWusmU443eA8,26762 +bitblas/3rdparty/cutlass/examples/13_two_tensor_op_fusion/kernel/default_b2b_conv2d_fprop_sm80.h,sha256=ky5XYdjEEwjLkqeBsQbVwZs0P2ovRWMtfx5_pKQpMKM,26775 +bitblas/3rdparty/cutlass/examples/13_two_tensor_op_fusion/kernel/default_b2b_conv2d_fprop_smem_accumulator_sm75.h,sha256=E0rD11fGlw9O64I08rLWHWS0VZUZQpBFxdFYKLdRVdw,28422 +bitblas/3rdparty/cutlass/examples/13_two_tensor_op_fusion/kernel/default_b2b_conv2d_fprop_smem_accumulator_sm80.h,sha256=mAg8lI48arPv5cgUcCOVY-dNm5Kn2uvamIjZPprYFsw,28073 +bitblas/3rdparty/cutlass/examples/13_two_tensor_op_fusion/kernel/default_b2b_gemm.h,sha256=lLeKGOnzNShEjxdx2b6CI4YWManEbpo9e4F03WZ-9Dg,19973 +bitblas/3rdparty/cutlass/examples/13_two_tensor_op_fusion/kernel/default_b2b_gemm_smem_accumulator.h,sha256=iNVcV0YTGTy97Ww97S7xVClLdgR784GTyW57pSgpugQ,15092 +bitblas/3rdparty/cutlass/examples/13_two_tensor_op_fusion/kernel/grouped.h,sha256=iScQfXVtl_lhrJ4qekK0ybC4WJ_vdHaFgnu5LRzXMVo,6380 +bitblas/3rdparty/cutlass/examples/13_two_tensor_op_fusion/reference/device/tensor_scale_bias.h,sha256=j-Uw5tXMSSHqMAMwy6dHNKkLSpPWAmVZrL8Wtxe23vQ,14663 +bitblas/3rdparty/cutlass/examples/13_two_tensor_op_fusion/test_run.h,sha256=8af30l6Pc45bntwRzO2RLP1F2HZ92a31pBqXZk0U5BI,3577 +bitblas/3rdparty/cutlass/examples/13_two_tensor_op_fusion/threadblock/b2b_implicit_gemm_multistage.h,sha256=Eua3Q0vx_W3C901TkWOB1jbtMGdBs8HMO17PwNt07s8,31616 +bitblas/3rdparty/cutlass/examples/13_two_tensor_op_fusion/threadblock/b2b_implicit_gemm_multistage_smem_accumulator.h,sha256=_cd1CnEdxo-t8C4H76ph45YSlVlavIyZx3uH2TsMpbk,31443 +bitblas/3rdparty/cutlass/examples/13_two_tensor_op_fusion/threadblock/b2b_implicit_gemm_pipelined.h,sha256=nPw9X0cNOHZy7lw8XdxKhENWMdBRGhztKNgEre4U3fw,21012 +bitblas/3rdparty/cutlass/examples/13_two_tensor_op_fusion/threadblock/b2b_implicit_gemm_pipelined_smem_accumulator.h,sha256=L0BD3A50SM70SmE1tlAEzjbM50U9KEyQM2tfVN0njkU,20494 +bitblas/3rdparty/cutlass/examples/13_two_tensor_op_fusion/threadblock/b2b_mma_base.h,sha256=sY52i8wIF95JbEz_ZvEvndMt9ZCqWJTsiwUyBVOMBPg,7983 +bitblas/3rdparty/cutlass/examples/13_two_tensor_op_fusion/threadblock/b2b_mma_base_smem_accumulator.h,sha256=yXoOQK37F0rkaEoLYrZp77V12OJVGra2zXUEvVOglWI,6047 +bitblas/3rdparty/cutlass/examples/13_two_tensor_op_fusion/threadblock/b2b_mma_multistage.h,sha256=vxm3TlRrZQ5MKTedTbE0OMyPt2xHcyzLQ_3toDjQF2c,34515 +bitblas/3rdparty/cutlass/examples/13_two_tensor_op_fusion/threadblock/b2b_mma_multistage_smem_accumulator.h,sha256=m-78au6Uj30RvxdNFEMo1FXNmIsRCi8oTYtx4s8xuFQ,34226 +bitblas/3rdparty/cutlass/examples/13_two_tensor_op_fusion/threadblock/b2b_mma_pipelined.h,sha256=tUaslP_gS2lrtvbJccQpNGXQn98vHsr0Z0fwCI1vT30,21820 +bitblas/3rdparty/cutlass/examples/13_two_tensor_op_fusion/threadblock/b2b_mma_pipelined_smem_accumulator.h,sha256=MLTUxkTGElj04pyl8VaOzX1BLYF4bIxBTM_uTREkYxY,21434 +bitblas/3rdparty/cutlass/examples/13_two_tensor_op_fusion/threadblock/default_b2b_mma.h,sha256=4qjEDQjCL1L9WSdefESBz3lvP-oGuGL5TT7AxHJJ3aI,27144 +bitblas/3rdparty/cutlass/examples/13_two_tensor_op_fusion/threadblock/default_b2b_mma_smem_accumulator.h,sha256=wK2Ux8wEzJs_7S-QQaDEc6Wno_SCICHJluSLrC4fvQs,27400 +bitblas/3rdparty/cutlass/examples/13_two_tensor_op_fusion/threadblock/grouped_threadblock_swizzle.h,sha256=6kdpjCaiIu44ZTCqj_FaUGLHeFU2krB6pV-2JFPZrDk,5719 +bitblas/3rdparty/cutlass/examples/14_ampere_tf32_tensorop_gemm/CMakeLists.txt,sha256=26pUwlhUv91apsE25Jh6NA0cfNowqDqaGvun4cTtqqI,1698 +bitblas/3rdparty/cutlass/examples/14_ampere_tf32_tensorop_gemm/ampere_tf32_tensorop_gemm.cu,sha256=_dEYg44CORXAmILNi9W6dA6nXqBhJBYu3ii885c1mTQ,18020 +bitblas/3rdparty/cutlass/examples/15_ampere_sparse_tensorop_gemm/CMakeLists.txt,sha256=BRNMYgEWpu_FbrhvYL_Sd8jRLzIni0irkTP27xYt49c,1702 +bitblas/3rdparty/cutlass/examples/15_ampere_sparse_tensorop_gemm/ampere_sparse_tensorop_gemm.cu,sha256=sjfvk2g28cpshfgvbz5gQqqUSNEkgQTagPECr2XxUKw,15042 +bitblas/3rdparty/cutlass/examples/16_ampere_tensorop_conv2dfprop/CMakeLists.txt,sha256=VvIR_5jG28urwi29k8Lo1ZHvNs4VwrvDLk7VLF11THA,1703 +bitblas/3rdparty/cutlass/examples/16_ampere_tensorop_conv2dfprop/ampere_tensorop_conv2dfprop.cu,sha256=HBTetCwMRhrfjURrcdF_yk5uIsVdDNRSd3lGJ8wPb6c,27844 +bitblas/3rdparty/cutlass/examples/17_fprop_per_channel_bias/CMakeLists.txt,sha256=HSN_YGc9w1KQZ08f90i_PmjDf05J3iruGA-dV7v1LSo,1694 +bitblas/3rdparty/cutlass/examples/17_fprop_per_channel_bias/fprop_per_channel_bias.cu,sha256=OxEfAiXoq--W6EHemIcjh8MRnZctGIknyhrpk7XqmdQ,12580 +bitblas/3rdparty/cutlass/examples/18_ampere_fp64_tensorop_affine2_gemm/CMakeLists.txt,sha256=bu_ctcXDEZRk7-pscSAPoy6MhdulSD8HZkNZuMt72sw,1715 +bitblas/3rdparty/cutlass/examples/18_ampere_fp64_tensorop_affine2_gemm/ampere_fp64_tensorop_affine2_gemm.cu,sha256=4RaWIue4oV1Ox4DUCPO2yOfrYegmS5yyvkJOhk0XdmI,14007 +bitblas/3rdparty/cutlass/examples/19_tensorop_canonical/CMakeLists.txt,sha256=TAHNMB7rCiRfdd_-1QZr4WRvAPEUZSOueoe8-aWLaG8,1682 +bitblas/3rdparty/cutlass/examples/19_tensorop_canonical/tensorop_canonical.cu,sha256=isNqfC85em1Ro0n_qqYDA6PSGCfy6josNfROMWCfSvI,13401 +bitblas/3rdparty/cutlass/examples/20_simt_canonical/CMakeLists.txt,sha256=mPSEqACJ2rQCbggbduTHt9KyoBqEvvoSsLM8TiEZJcE,1674 +bitblas/3rdparty/cutlass/examples/20_simt_canonical/simt_canonical.cu,sha256=qDVO5KWj8eDjQdjm0gvh_lcH9HBNyuUYfHPgIh4AQvk,12556 +bitblas/3rdparty/cutlass/examples/21_quaternion_gemm/CMakeLists.txt,sha256=CqpLgcIfVp_ttex29VRMleqQ51JSwcdKbqMdyQ4mw5o,1678 +bitblas/3rdparty/cutlass/examples/21_quaternion_gemm/quaternion_gemm.cu,sha256=XwCpsd0f1nxIFqi9E1q4j97OU-Ib183lI80FsibqEWc,17319 +bitblas/3rdparty/cutlass/examples/22_quaternion_conv/CMakeLists.txt,sha256=bknSKZrqYZDQ0aqSHEMD8vMe3SrOivTC11SaFkEr-v0,1680 +bitblas/3rdparty/cutlass/examples/22_quaternion_conv/quaternion_conv.cu,sha256=tlla3c5v2hhQl6utvH3lylXG_AZh6T5pG0JhQHOZYbE,21423 +bitblas/3rdparty/cutlass/examples/23_ampere_gemm_operand_reduction_fusion/CMakeLists.txt,sha256=D204hpS4dHz5IGEJ-Vqc_LzDZeZU0-XOY9Zs3NME-H0,1721 +bitblas/3rdparty/cutlass/examples/23_ampere_gemm_operand_reduction_fusion/ampere_gemm_operand_reduction_fusion.cu,sha256=UYbnw5H2TlBtjQPblzJeP_b6a9U43-cf7D7TIeFFT8c,27530 +bitblas/3rdparty/cutlass/examples/24_gemm_grouped/CMakeLists.txt,sha256=b_8mKn9zrws6R_m04F5bwr0kGXfXHdPdz9d25rVrz2c,1674 +bitblas/3rdparty/cutlass/examples/24_gemm_grouped/gemm_grouped.cu,sha256=GMDYUvKYG7p9xVS89fS_CUL3W2UoClW1asSgb4ANjN0,50890 +bitblas/3rdparty/cutlass/examples/25_ampere_fprop_mainloop_fusion/CMakeLists.txt,sha256=_Xj72vrY85SX7pLo_BczQWs70u0AEsAicV0enQY3vMY,1816 +bitblas/3rdparty/cutlass/examples/25_ampere_fprop_mainloop_fusion/ampere_3d_fprop_mainloop_fusion.cu,sha256=U5UiGmERZQDiwJuj9wRIcKh4BwPAB1vc9tyvkSNqLag,26547 +bitblas/3rdparty/cutlass/examples/25_ampere_fprop_mainloop_fusion/ampere_fprop_mainloop_fusion.cu,sha256=G7NLglwIsbAa0pzxxOVE4HOfG3bErAw5y-UKE5raYEs,25628 +bitblas/3rdparty/cutlass/examples/26_ampere_wgrad_mainloop_fusion/CMakeLists.txt,sha256=iG-Cb7sUL41RpNlXJm_iNv19dsZUz7DYK2lIoP8eCsY,1705 +bitblas/3rdparty/cutlass/examples/26_ampere_wgrad_mainloop_fusion/ampere_wgrad_mainloop_fusion.cu,sha256=j0WEF3BdJXktDmmKD5StXKFAQ2sjv_DB-Kur8sSmUJs,25538 +bitblas/3rdparty/cutlass/examples/27_ampere_3xtf32_fast_accurate_tensorop_gemm/27_ampere_3xtf32_fast_accurate_tensorop_gemm.cu,sha256=wy5dWAtev2cCRrC1MBViSaS2DCrgCyefKqKTG47NP4k,30446 +bitblas/3rdparty/cutlass/examples/27_ampere_3xtf32_fast_accurate_tensorop_gemm/CMakeLists.txt,sha256=rWj_o-DcTqEb52XaJGrjZ8HV3IoK9JlnWJW79steZL4,1733 +bitblas/3rdparty/cutlass/examples/28_ampere_3xtf32_fast_accurate_tensorop_fprop/CMakeLists.txt,sha256=hMZjQQBSNA_axSOp0gQZUvr-a-JAHO5imPvfSJnw0bc,1732 +bitblas/3rdparty/cutlass/examples/28_ampere_3xtf32_fast_accurate_tensorop_fprop/ampere_3xtf32_fast_accurate_tensorop_fprop.cu,sha256=d9Zh3wtMfq3zoVx2YxPeoMTEH_dAWDHi76LOPHIhuJM,28159 +bitblas/3rdparty/cutlass/examples/29_ampere_3xtf32_fast_accurate_tensorop_complex_gemm/29_3xtf32_complex_gemm.cu,sha256=atQY6Jm4_CJUoefSgdNi78Tkj92MYzc8w0vqF6Brbfk,28382 +bitblas/3rdparty/cutlass/examples/29_ampere_3xtf32_fast_accurate_tensorop_complex_gemm/CMakeLists.txt,sha256=9b7qUVfbnmYPnyn8IwJzeqqD6on-D6elXy9W_0d1PT8,1754 +bitblas/3rdparty/cutlass/examples/30_wgrad_split_k/30_wgrad_split_k.cu,sha256=Go_GMYK6dzpifan9EIX0nHwhjmaDr_sL74FY1sfUeQA,27329 +bitblas/3rdparty/cutlass/examples/30_wgrad_split_k/CMakeLists.txt,sha256=Gb_sHADvVjJz0LLvH4nI5aNECMDCEXjraEdkfqlyzrE,1677 +bitblas/3rdparty/cutlass/examples/31_basic_syrk/CMakeLists.txt,sha256=z2hMJhDS0X7PwyK_MF2Oza97m6THiROb4zyQxJGKmgY,1668 +bitblas/3rdparty/cutlass/examples/31_basic_syrk/basic_syrk.cu,sha256=m8mKNTB-ARf7eD4J2ZXNpC_rh_4GnlsjfEd1_Ba-_q0,15205 +bitblas/3rdparty/cutlass/examples/32_basic_trmm/CMakeLists.txt,sha256=VcVGuk62tmngDnj91KlMeK8hEbQwIQmkjN7WzH6gQTc,1668 +bitblas/3rdparty/cutlass/examples/32_basic_trmm/basic_trmm.cu,sha256=YGYmn7tIvSKHwzj_U_LyeUnU15V3jmc7fOuLdT47FJ8,15906 +bitblas/3rdparty/cutlass/examples/33_ampere_3xtf32_tensorop_symm/CMakeLists.txt,sha256=Gkxu-XX4W5aNE2lOurLkeEVXkw-HVWIBF4V5GebwtFQ,1702 +bitblas/3rdparty/cutlass/examples/33_ampere_3xtf32_tensorop_symm/ampere_3xtf32_tensorop_symm.cu,sha256=dTpFCdRmhoZDjSrRWHtEdCU8fGtJSF3uNSQJFUKXAAM,31803 +bitblas/3rdparty/cutlass/examples/34_transposed_conv2d/34_transposed_conv2d.cu,sha256=730Lx57mRM93T3rHT7mS5S6CoI4rovoVv3r0auIK6qQ,22378 +bitblas/3rdparty/cutlass/examples/34_transposed_conv2d/CMakeLists.txt,sha256=uXSeJqpJF-06z8HK5Bkl2glBnE5rFqasD5BfXclcfD8,1684 +bitblas/3rdparty/cutlass/examples/35_gemm_softmax/CMakeLists.txt,sha256=WzHOsifANs7XMKJNDlqEUR1rU4e2xovCFLw0a2yiNf4,1673 +bitblas/3rdparty/cutlass/examples/35_gemm_softmax/gemm_softmax.cu,sha256=inl6uNRUbGKFko_2KxhG_p9oxqam_xZW1N5W0w8ht-E,23114 +bitblas/3rdparty/cutlass/examples/35_gemm_softmax/gemm_with_epilogue_visitor.h,sha256=U7yI2gVEI-3pjHSeyuMGbenDHkSK720DFfl8HZyYrok,16723 +bitblas/3rdparty/cutlass/examples/35_gemm_softmax/gemm_with_softmax.h,sha256=cZAtVlyaig4orVeOkptuMfOMFz56fzlNP5GielSYFxU,19055 +bitblas/3rdparty/cutlass/examples/36_gather_scatter_fusion/CMakeLists.txt,sha256=eT5iVZ8wD8LtLyOFqEikVCdbPG338rFHfEh1AMvC0oM,1687 +bitblas/3rdparty/cutlass/examples/36_gather_scatter_fusion/gather_scatter_fusion.cu,sha256=x_vD-akHmI4wwld8ATB0IxCNRzbGcTgUYLa5aPpp-Uc,20974 +bitblas/3rdparty/cutlass/examples/37_gemm_layernorm_gemm_fusion/CMakeLists.txt,sha256=zQKF9T7BRtMy7FbSRa4YhGpk2OcATla8mqdVr0hMPLs,1689 +bitblas/3rdparty/cutlass/examples/37_gemm_layernorm_gemm_fusion/gemm_layernorm.cu,sha256=dYoP-MzEDS-GsiaCEXuCj1MDuLrmzG_1Da-EiZAlf8U,31111 +bitblas/3rdparty/cutlass/examples/37_gemm_layernorm_gemm_fusion/gemm_with_epilogue_visitor.h,sha256=R-BMvfa0cQpIuU1wG7KttErpwVdfJQUzcDnr_EfY1sM,13982 +bitblas/3rdparty/cutlass/examples/37_gemm_layernorm_gemm_fusion/gemm_with_layernorm.h,sha256=MfWxrLhwUXjMeSaGKoXY3bQRonLTNqo0PbtUZUL7PRw,33905 +bitblas/3rdparty/cutlass/examples/38_syr2k_grouped/CMakeLists.txt,sha256=NqE_M9v8TYXRK79-UpjP9SM1nfMvZKzRRiwYmz6nobQ,1675 +bitblas/3rdparty/cutlass/examples/38_syr2k_grouped/syr2k_grouped.cu,sha256=Oft_1LMZ56i3fCfU0tHdkAWooUEP5sNSaIRsNPrdqxg,47455 +bitblas/3rdparty/cutlass/examples/39_gemm_permute/CMakeLists.txt,sha256=ZT5_oiXKP5MHt7vsLCj2MHMSg2sNNLPZ_GH9FWjH-js,1674 +bitblas/3rdparty/cutlass/examples/39_gemm_permute/gemm_permute.cu,sha256=vpv3AwOdmCIR22r2OcNmMCRXKNBri4V87pIGcFKvad8,48551 +bitblas/3rdparty/cutlass/examples/39_gemm_permute/layouts.h,sha256=xCPCbE4mbXDjjLAvY59aMLWrhr2kJi2YpUqBkI914AQ,15309 +bitblas/3rdparty/cutlass/examples/39_gemm_permute/permute_info.h,sha256=6FAzbGPPaPlOsqM-eV_W3YLqZJvpmVy1Oh2V-Aklm6I,11985 +bitblas/3rdparty/cutlass/examples/40_cutlass_py/README.md,sha256=ldwEmscgdcq25t_nyIg0jkaxEdvxBqy7Un4Ru3wrmP0,253 +bitblas/3rdparty/cutlass/examples/40_cutlass_py/__pycache__/conv2d.cpython-310.pyc,, +bitblas/3rdparty/cutlass/examples/40_cutlass_py/__pycache__/gemm.cpython-310.pyc,, +bitblas/3rdparty/cutlass/examples/40_cutlass_py/__pycache__/gemm_grouped.cpython-310.pyc,, +bitblas/3rdparty/cutlass/examples/40_cutlass_py/conv2d.py,sha256=UdIhCq3hcN7EW_uL5yoXPOrqHs3-xthAqUpvTDyhlxk,7305 +bitblas/3rdparty/cutlass/examples/40_cutlass_py/customizable/README.md,sha256=X5y74GFjW0Zdmv9vMnF_gxIcU9lldb5XD7WNEorAXog,15590 +bitblas/3rdparty/cutlass/examples/40_cutlass_py/customizable/__pycache__/conv2d.cpython-310.pyc,, +bitblas/3rdparty/cutlass/examples/40_cutlass_py/customizable/__pycache__/gemm.cpython-310.pyc,, +bitblas/3rdparty/cutlass/examples/40_cutlass_py/customizable/__pycache__/gemm_grouped.cpython-310.pyc,, +bitblas/3rdparty/cutlass/examples/40_cutlass_py/customizable/conv2d.py,sha256=NA2MbchFBdBqi04E7aTjYR6F18NVDWaxb2jehBzPXns,16073 +bitblas/3rdparty/cutlass/examples/40_cutlass_py/customizable/gemm.py,sha256=DqcxcCBAAGsH3G66FH-ZlePCtPdSbcrngU_NEA7tPlc,14899 +bitblas/3rdparty/cutlass/examples/40_cutlass_py/customizable/gemm_grouped.py,sha256=vx0HkNjZr4Se9gflP4kpKXo2R2SGO8BDBtx_lzQR7Nw,14023 +bitblas/3rdparty/cutlass/examples/40_cutlass_py/customizable/grouped_gemm_problem_size.csv,sha256=k_EdKnOiWmQBu0zBbj6J4MautnOID7fXNPJDuaJP1ZQ,36 +bitblas/3rdparty/cutlass/examples/40_cutlass_py/gemm.py,sha256=mVxXElKHBaxGkkySuHyT77M-4mKrX7ccre2PK0uqs6A,6047 +bitblas/3rdparty/cutlass/examples/40_cutlass_py/gemm_grouped.py,sha256=SJjICaMRMSqLXwm0uGrTggfI81iRtZ2jSPZw0-X70N4,6028 +bitblas/3rdparty/cutlass/examples/41_fused_multi_head_attention/CMakeLists.txt,sha256=JIJNHMTbfvdXTNtBZ956T8giCSuLdrkmt_G3GWdabOs,2390 +bitblas/3rdparty/cutlass/examples/41_fused_multi_head_attention/__pycache__/fmha_backward_test.cpython-310.pyc,, +bitblas/3rdparty/cutlass/examples/41_fused_multi_head_attention/__pycache__/piped_subprocess.cpython-310.pyc,, +bitblas/3rdparty/cutlass/examples/41_fused_multi_head_attention/debug_utils.h,sha256=lAMnMPn0SS3cR8wmaG2wHIzAuYM6oiudLDiQ0C3DinA,11865 +bitblas/3rdparty/cutlass/examples/41_fused_multi_head_attention/default_fmha_grouped.h,sha256=W-SJ0etVV4ZfCTcN5qvvudvu9fIlpIjY0ldTUkgJMBY,10832 +bitblas/3rdparty/cutlass/examples/41_fused_multi_head_attention/epilogue/epilogue_pipelined.h,sha256=EIfX1bUG1AhLpP1cxxgqGAfp9GVmSXjPaO3ENxZIRjs,22349 +bitblas/3rdparty/cutlass/examples/41_fused_multi_head_attention/epilogue/epilogue_rescale_output.h,sha256=TGIJ9f2RIF1V5vafI5iYRG3JNL_nAXwM7xcrWTbrnbQ,9162 +bitblas/3rdparty/cutlass/examples/41_fused_multi_head_attention/epilogue/epilogue_thread_apply_logsumexp.h,sha256=gPhF3aotXTvm1keWyiuP6uDK3Y9cVpTpUcDB6MMOSF4,6111 +bitblas/3rdparty/cutlass/examples/41_fused_multi_head_attention/fmha_backward_test.py,sha256=OoBCjpLJyK6vYImOBUfK24y3OTZ1TQds13y1FhhQEao,6797 +bitblas/3rdparty/cutlass/examples/41_fused_multi_head_attention/fmha_grouped.h,sha256=Hc8GisxaRO_OPtrCw0uzlVFCDcAaNJgVEKn-i05t09I,37522 +bitblas/3rdparty/cutlass/examples/41_fused_multi_head_attention/fmha_grouped_problem_visitor.h,sha256=A8yQI38XHSPyb_-jxQZH556Jbg6btu2I1UghQ5y87WA,6666 +bitblas/3rdparty/cutlass/examples/41_fused_multi_head_attention/fused_multi_head_attention_backward.cu,sha256=nTqATBJsUYYtOvDO5tbf5dlkE-lVDmRfAtRxJpo7R10,11208 +bitblas/3rdparty/cutlass/examples/41_fused_multi_head_attention/fused_multihead_attention_fixed_seqlen.cu,sha256=PucXmxUym97wX_pRpRjU64Hs6mxVHyZwijdIADJqOPc,38218 +bitblas/3rdparty/cutlass/examples/41_fused_multi_head_attention/fused_multihead_attention_variable_seqlen.cu,sha256=62WliC0RUCrrUoQx2YTN0Ctd_Gr-74NB5TnzUmRI_jA,40003 +bitblas/3rdparty/cutlass/examples/41_fused_multi_head_attention/gemm/custom_mma.h,sha256=JWKhnFM8XAmtuJ33h5BioZgV70kVrJoQ5P_Bel3nQVk,3994 +bitblas/3rdparty/cutlass/examples/41_fused_multi_head_attention/gemm/custom_mma_base.h,sha256=a-U6bupgGfA8ct_uApXPiujKygQMj06IbcbGjFIr72M,6241 +bitblas/3rdparty/cutlass/examples/41_fused_multi_head_attention/gemm/custom_mma_multistage.h,sha256=ebarLiE7ssmMixylnBKqDwYxE6N3TiSJpN7vaaOH0ss,26926 +bitblas/3rdparty/cutlass/examples/41_fused_multi_head_attention/gemm/custom_mma_pipelined.h,sha256=O6lUB6j3oqSgu7BWKTY_YZq4jEKFxbJbaIChcMGKC9g,14098 +bitblas/3rdparty/cutlass/examples/41_fused_multi_head_attention/gemm/find_default_mma.h,sha256=5xVlU7OaVyqM-6lSGSH4XerI6owS-lLdIxpyIbWpuT4,6782 +bitblas/3rdparty/cutlass/examples/41_fused_multi_head_attention/gemm/mma_accum_lambda_iterator.h,sha256=0Qts6YdGrMSTAyJhDZauCJ9hp9wD8M0d4MjLFyWzyso,13959 +bitblas/3rdparty/cutlass/examples/41_fused_multi_head_attention/gemm/mma_from_smem.h,sha256=03tjmj4NeIFJyICUx8Qe9ZWkwijFFxsKJj-0rhWYBvY,68646 +bitblas/3rdparty/cutlass/examples/41_fused_multi_head_attention/gemm_kernel_utils.h,sha256=rovYj0qFDdpUEs_Pp6jK6mGSV40fdQXzUE6uduvq1vc,11075 +bitblas/3rdparty/cutlass/examples/41_fused_multi_head_attention/iterators/default_warp_iterator_from_smem.h,sha256=EVIlOGpjvVKMYbRQCaIwL20W1rCNDUkjGUxY59Tjws4,5769 +bitblas/3rdparty/cutlass/examples/41_fused_multi_head_attention/iterators/epilogue_predicated_tile_iterator.h,sha256=Lp554LqKg5uDYfS1H1s5o3e4JuN20-eh6zhIpBjkmcU,23855 +bitblas/3rdparty/cutlass/examples/41_fused_multi_head_attention/iterators/make_residual_last.h,sha256=vnH6n5GzVM8O86tWn304APFEGOiWYuMa6bUVxUIPdfI,3142 +bitblas/3rdparty/cutlass/examples/41_fused_multi_head_attention/iterators/predicated_tile_access_iterator_residual_last.h,sha256=QVUI2qFw42Az_glZJJmeGniPtT3MIDN8g6kPgr1jeO8,64466 +bitblas/3rdparty/cutlass/examples/41_fused_multi_head_attention/iterators/predicated_tile_iterator_residual_last.h,sha256=EkxDJE5L-wMRATRzLr0M26Bj1_MW8vIccYrmVAW7q0g,64500 +bitblas/3rdparty/cutlass/examples/41_fused_multi_head_attention/iterators/transpose_warp_iterator.h,sha256=b3wATx3AH3e7LISa_kEGO3nweEZfJzbobOXp0WdsU44,2512 +bitblas/3rdparty/cutlass/examples/41_fused_multi_head_attention/iterators/warp_iterator_from_smem.h,sha256=PRtSFnIE5yYmW4dWjVK5pX_JG9on1TjYMyeA8_4YbuI,10056 +bitblas/3rdparty/cutlass/examples/41_fused_multi_head_attention/kernel_backward.h,sha256=iQLN9x0COLsbBpKJCddoMbL-rmifct9zP3LICP4hlho,97621 +bitblas/3rdparty/cutlass/examples/41_fused_multi_head_attention/kernel_forward.h,sha256=RTkS1_noMUO99xmlBbSOhvnbdmdKu2KY_IddyeRRA2s,52597 +bitblas/3rdparty/cutlass/examples/41_fused_multi_head_attention/piped_subprocess.py,sha256=Xf0UrRPB16kgcZsJNcx8myGV-TnCN4BIlKYrQ0gLcys,3871 +bitblas/3rdparty/cutlass/examples/41_fused_multi_head_attention/transform/tile_smem_loader.h,sha256=0X9zsIJz1n7y2_g5wbhFhue-K6886ZNaLMYyQDnSSAY,3761 +bitblas/3rdparty/cutlass/examples/42_ampere_tensorop_group_conv/CMakeLists.txt,sha256=9Mot_n1Od1FCjNXjwww_rSgeNKdWqd-PB1pcFAeOVv8,1701 +bitblas/3rdparty/cutlass/examples/42_ampere_tensorop_group_conv/ampere_tensorop_group_conv.cu,sha256=oJXUTaHZf8pUKqiX8OG92nF7CaRUkbIcgKNYZ4naePE,23901 +bitblas/3rdparty/cutlass/examples/43_ell_block_sparse_gemm/CMakeLists.txt,sha256=6H5AkaOx_OE1bdQvoNtfapfyxzQ10LMI08dGWFXdoB4,1690 +bitblas/3rdparty/cutlass/examples/43_ell_block_sparse_gemm/ell_block_sparse_gemm.cu,sha256=-gk3usmIqvrI598TDP0Qi2KDZr-WnYtUMGhBBFoXJrM,23867 +bitblas/3rdparty/cutlass/examples/44_multi_gemm_ir_and_codegen/README.md,sha256=ezC-E5EQ1h0fCgoOKhfiqpPpNszjYkPtAsgw7ndHm1c,2589 +bitblas/3rdparty/cutlass/examples/44_multi_gemm_ir_and_codegen/config.json,sha256=ejjHm3L8Jqx9EV2K8PD8PKQZgQ7KiCqGdmW3x_qRpTU,1105 +bitblas/3rdparty/cutlass/examples/44_multi_gemm_ir_and_codegen/fixed_impl/epilogue/threadblock/default_bias_act_epilogue_tensor_op.h,sha256=LrRvH9sl_8aMPi1MnrRxKYUepvo5V32j38gXBsCy0sU,6370 +bitblas/3rdparty/cutlass/examples/44_multi_gemm_ir_and_codegen/fixed_impl/epilogue/threadblock/default_thread_map_tensor_op_for_fused_bias.h,sha256=6XpR9OKwpE_l29Wc9LKwawFuHm-eqbgT43OfO-ysUsU,4099 +bitblas/3rdparty/cutlass/examples/44_multi_gemm_ir_and_codegen/fixed_impl/epilogue/threadblock/fused_bias_act_epilogue.h,sha256=4Ssy4WAKMR3MJk3pBT5mibJjcHYKxBG_T5PWCgnm-00,8285 +bitblas/3rdparty/cutlass/examples/44_multi_gemm_ir_and_codegen/fixed_impl/epilogue/threadblock/output_tile_thread_map_for_fused_bias.h,sha256=IKpRXN8-oCyMMf-THzx0JxPCQTLZHEnDfub8oduPqXA,10439 +bitblas/3rdparty/cutlass/examples/44_multi_gemm_ir_and_codegen/fixed_impl/epilogue/warp/fused_bias_act_fragment_iterator_tensor_op.h,sha256=_Y470J0leGMBTxVJvaFt9nGPezgdKpHtsPz76k3J15I,6848 +bitblas/3rdparty/cutlass/examples/44_multi_gemm_ir_and_codegen/fixed_impl/gemm/warp/mma_tensor_op_fragment_iterator_without_output_op.h,sha256=6SEUhAc6XL-L2LlphFHTVdgSZvWzfBhcVZeLG6yDeaA,14747 +bitblas/3rdparty/cutlass/examples/44_multi_gemm_ir_and_codegen/ir_gen/__pycache__/gen_all_code.cpython-310.pyc,, +bitblas/3rdparty/cutlass/examples/44_multi_gemm_ir_and_codegen/ir_gen/__pycache__/gen_cmake.cpython-310.pyc,, +bitblas/3rdparty/cutlass/examples/44_multi_gemm_ir_and_codegen/ir_gen/__pycache__/gen_customized_epilogue.cpython-310.pyc,, +bitblas/3rdparty/cutlass/examples/44_multi_gemm_ir_and_codegen/ir_gen/__pycache__/gen_device.cpython-310.pyc,, +bitblas/3rdparty/cutlass/examples/44_multi_gemm_ir_and_codegen/ir_gen/__pycache__/gen_ir.cpython-310.pyc,, +bitblas/3rdparty/cutlass/examples/44_multi_gemm_ir_and_codegen/ir_gen/__pycache__/gen_kernel.cpython-310.pyc,, +bitblas/3rdparty/cutlass/examples/44_multi_gemm_ir_and_codegen/ir_gen/__pycache__/gen_sample.cpython-310.pyc,, +bitblas/3rdparty/cutlass/examples/44_multi_gemm_ir_and_codegen/ir_gen/__pycache__/gen_threadblock.cpython-310.pyc,, +bitblas/3rdparty/cutlass/examples/44_multi_gemm_ir_and_codegen/ir_gen/__pycache__/gen_turing_and_volta.cpython-310.pyc,, +bitblas/3rdparty/cutlass/examples/44_multi_gemm_ir_and_codegen/ir_gen/__pycache__/gen_verify.cpython-310.pyc,, +bitblas/3rdparty/cutlass/examples/44_multi_gemm_ir_and_codegen/ir_gen/__pycache__/helper.cpython-310.pyc,, +bitblas/3rdparty/cutlass/examples/44_multi_gemm_ir_and_codegen/ir_gen/__pycache__/replace_fix_impl_header.cpython-310.pyc,, +bitblas/3rdparty/cutlass/examples/44_multi_gemm_ir_and_codegen/ir_gen/gen_all_code.py,sha256=hmmnT-kpd5ZKdcWw3V6hGrdwxwh2Vh_vk5NXe06atdY,5538 +bitblas/3rdparty/cutlass/examples/44_multi_gemm_ir_and_codegen/ir_gen/gen_cmake.py,sha256=1nXcQO4R_QvdE-X_XW4ReuGKUvKaSsxeaR9IUM9Jkmk,4658 +bitblas/3rdparty/cutlass/examples/44_multi_gemm_ir_and_codegen/ir_gen/gen_customized_epilogue.py,sha256=SkFFvovOXHJk35iRDKrGxjUBCrEAUJDa05RecRMYBKk,4236 +bitblas/3rdparty/cutlass/examples/44_multi_gemm_ir_and_codegen/ir_gen/gen_device.py,sha256=v5qfOEWzAJpTJYHL9IO8PVeD_X5I5XtNFvRvK6qoRrs,19627 +bitblas/3rdparty/cutlass/examples/44_multi_gemm_ir_and_codegen/ir_gen/gen_ir.py,sha256=8cb2AXVOxb1gW3QYydN-TJeLLvbfLJIOQ2H2_pYnqP0,7374 +bitblas/3rdparty/cutlass/examples/44_multi_gemm_ir_and_codegen/ir_gen/gen_kernel.py,sha256=sm9ltHmnqafLOwV_I7i3BzxGLqqSkdRBM2XMLyldmTI,24634 +bitblas/3rdparty/cutlass/examples/44_multi_gemm_ir_and_codegen/ir_gen/gen_sample.py,sha256=S-Ff-qlL7D-y_VpmYUwBPb3-F3_YwCBEJx3kHb0oq5I,11836 +bitblas/3rdparty/cutlass/examples/44_multi_gemm_ir_and_codegen/ir_gen/gen_threadblock.py,sha256=lGM9qvkejNC7bAgOGVMtii0jFAZOkIHrn8DzS0aWwtA,47632 +bitblas/3rdparty/cutlass/examples/44_multi_gemm_ir_and_codegen/ir_gen/gen_turing_and_volta.py,sha256=BTk36b5v5lEdlkktyPx-T1okYx3H9NEAxK0vb2xKECU,21490 +bitblas/3rdparty/cutlass/examples/44_multi_gemm_ir_and_codegen/ir_gen/gen_verify.py,sha256=akvtcLZkMI0b6FV3xe3UnnVe-4uDhQzt7Zm3R_3q-0A,3780 +bitblas/3rdparty/cutlass/examples/44_multi_gemm_ir_and_codegen/ir_gen/generate.sh,sha256=5j662aGD93B6EBG4S_QjCxpI07FE6krWkQN3beA2sPk,2346 +bitblas/3rdparty/cutlass/examples/44_multi_gemm_ir_and_codegen/ir_gen/helper.py,sha256=oznBxB2QhYKjlzVxBVZ_dPQRkVE5aj4SJXZBNPN0jHw,4533 +bitblas/3rdparty/cutlass/examples/44_multi_gemm_ir_and_codegen/ir_gen/replace_fix_impl_header.py,sha256=qq2CQMuU1EDcSUE8MX8unO6_9aM-9MR41furZiPQitM,3112 +bitblas/3rdparty/cutlass/examples/44_multi_gemm_ir_and_codegen/leaky_bias.h,sha256=TBgNAhQq_Reo8ZQ2-KJsQ1xz8RBFDCIIRYBVoKD3cd4,10231 +bitblas/3rdparty/cutlass/examples/44_multi_gemm_ir_and_codegen/utils.h,sha256=1B5fxFotgkLyi6wrVoNTy0W-oJp4NCspEi8VHz6Ocwo,3745 +bitblas/3rdparty/cutlass/examples/45_dual_gemm/CMakeLists.txt,sha256=-TRfO2cDqaq90zaO395OgZIPAGx2lldBCswjWRnDE6s,1668 +bitblas/3rdparty/cutlass/examples/45_dual_gemm/device/dual_gemm.h,sha256=05R02eYoPUusy-00r_0dA05HfNdTk00nTj40PZ0vE7o,16953 +bitblas/3rdparty/cutlass/examples/45_dual_gemm/dual_gemm.cu,sha256=5BvvGgImll5zuFLTR6dEPXAUvv57VRcUwHBCbATqHnQ,12642 +bitblas/3rdparty/cutlass/examples/45_dual_gemm/dual_gemm_common.h,sha256=8qY7dWHIKBU11Ckwu4EDhRagDKNGe2GFYsQTft3zfXg,2366 +bitblas/3rdparty/cutlass/examples/45_dual_gemm/dual_gemm_run.h,sha256=Pu_WGWJjxjFVcZkF5bTDHqy7coYHf4Ne_Rt_BC15CGM,31509 +bitblas/3rdparty/cutlass/examples/45_dual_gemm/kernel/dual_gemm.h,sha256=9ZxtWFwpxowL1mvY_Koq9yqojwO90tJW4EeIAIhoThY,18413 +bitblas/3rdparty/cutlass/examples/45_dual_gemm/test_run.h,sha256=8af30l6Pc45bntwRzO2RLP1F2HZ92a31pBqXZk0U5BI,3577 +bitblas/3rdparty/cutlass/examples/45_dual_gemm/thread/left_silu_and_mul.h,sha256=QsDnKDrPhg78GePs9Nw-Qj1gnACdEK4hSdLLFiylkSg,5818 +bitblas/3rdparty/cutlass/examples/45_dual_gemm/threadblock/dual_epilogue.h,sha256=WINe4ZPVKnIwhsGbnih9DEZOV3aCGarVhlMwslgxHzk,15613 +bitblas/3rdparty/cutlass/examples/45_dual_gemm/threadblock/dual_mma_base.h,sha256=Ltyi6dkYwgIjGwPuzBg17FaNe0y5AltMT3y199RPZW8,7920 +bitblas/3rdparty/cutlass/examples/45_dual_gemm/threadblock/dual_mma_multistage.h,sha256=qRPGkzrthqZeVJX9qs1Z4z0J-q0WJyYB8m_9sjkyKmk,29897 +bitblas/3rdparty/cutlass/examples/46_depthwise_simt_conv2dfprop/CMakeLists.txt,sha256=tzWxSHXY7ZX01ldzcCxWMf8l9XDVwaTk_TktHmEcLrs,1701 +bitblas/3rdparty/cutlass/examples/46_depthwise_simt_conv2dfprop/depthwise_simt_conv2dfprop.cu,sha256=OzWn3o6Xrn0m0Ue-cS6RQD91fGmsYG5hDzycHICKMYw,24772 +bitblas/3rdparty/cutlass/examples/47_ampere_gemm_universal_streamk/CMakeLists.txt,sha256=Yqhj3s_ncOz5ddRzxB4ceABShZ86vfyHPRAIcwEGUZo,1832 +bitblas/3rdparty/cutlass/examples/47_ampere_gemm_universal_streamk/ampere_gemm_universal_streamk.cu,sha256=FYQOYbaZn6h-lMl99ZVT0aiJWFI2-5d6lw1-YNtnqW8,22676 +bitblas/3rdparty/cutlass/examples/47_ampere_gemm_universal_streamk/ampere_gemm_universal_streamk_broadcast.cu,sha256=9gB7l5YtPJzBY2VtsjttA_X0b3jqyx60fvR_X_YQ9dk,30694 +bitblas/3rdparty/cutlass/examples/48_hopper_warp_specialized_gemm/48_hopper_warp_specialized_gemm.cu,sha256=bTpJmwB6rRCOG0OJH3bcCf9x07Q-C1Svo-RzMG6ZpU4,17135 +bitblas/3rdparty/cutlass/examples/48_hopper_warp_specialized_gemm/CMakeLists.txt,sha256=NePFB9LE7X4IXQtmRI-cC3esTvgKxDWuEHUMjTRyQB4,1707 +bitblas/3rdparty/cutlass/examples/49_hopper_gemm_with_collective_builder/49_collective_builder.cu,sha256=OjVboaPgebmhEbcdU5HsEXz6RkHT0N5cRDDIVkAWXvg,30403 +bitblas/3rdparty/cutlass/examples/49_hopper_gemm_with_collective_builder/CMakeLists.txt,sha256=upguZSmIdMgVOiVWX8P3pT4Ksl6QPfW2KKTqGn2dHWc,1751 +bitblas/3rdparty/cutlass/examples/50_hopper_gemm_with_epilogue_swizzle/50_hopper_gemm_with_epilogue_swizzle.cu,sha256=Y3FeLRgX8x4bzTSAopU-z7ZmM8REs4WWIyZSUTtG6Pw,18806 +bitblas/3rdparty/cutlass/examples/50_hopper_gemm_with_epilogue_swizzle/CMakeLists.txt,sha256=jRhesdDmJy--kiP-gghPk6cQB9sV0u_Nm7eJLA2hu50,1717 +bitblas/3rdparty/cutlass/examples/51_hopper_gett/51_hopper_gett.cu,sha256=F5COhyOkDZOcXj90yS3miSNeaiUb2JvKssvsQPXsyOQ,17256 +bitblas/3rdparty/cutlass/examples/51_hopper_gett/CMakeLists.txt,sha256=hPjocXjMOYMk05WjKzZBTMMfrdBwjbEo_n044PJrfQ8,1668 +bitblas/3rdparty/cutlass/examples/51_hopper_gett/gett_kernel.cuh,sha256=wbIL9lcQjKBtAIPORxZwUFzfBzSqLvqXyZCDtNJrtRM,5572 +bitblas/3rdparty/cutlass/examples/52_hopper_gather_scatter_fusion/52_hopper_gather_scatter_fusion.cu,sha256=LVPacyya0YBIv0H-PeJKaEnPeoyjYCxxtxXm8RXq9KE,27371 +bitblas/3rdparty/cutlass/examples/52_hopper_gather_scatter_fusion/CMakeLists.txt,sha256=OGc-0Bb-6z_R2rlS58yxco6NUmkfEXHcRIDU8A6jHUA,1704 +bitblas/3rdparty/cutlass/examples/52_hopper_gather_scatter_fusion/gather_gemm.hpp,sha256=C9SufV6JpmZmHWTbHiaQpoZpt58O1rWNxcHj94a4h7s,10218 +bitblas/3rdparty/cutlass/examples/52_hopper_gather_scatter_fusion/gather_kernel.cuh,sha256=rJ_mEiM9PICeapttq0msywKaAJNqLO_XbZisUjTI-Gs,5606 +bitblas/3rdparty/cutlass/examples/52_hopper_gather_scatter_fusion/gather_tensor.hpp,sha256=tdsaW1F8x1lsLzftasgoMN1vHG1oNiWLJkVmJYORN8c,6878 +bitblas/3rdparty/cutlass/examples/52_hopper_gather_scatter_fusion/scatter_epilogue.hpp,sha256=EzN5fzHraMAiXLm6LtZBO-lBcX2kIaV9HrG1vQUxclU,8503 +bitblas/3rdparty/cutlass/examples/53_hopper_gemm_permute/53_hopper_gemm_permute.cu,sha256=iYxipecMj_nEhoJ-RUPmncxNQrQdvLhPYZoqdkvvP4U,45142 +bitblas/3rdparty/cutlass/examples/53_hopper_gemm_permute/CMakeLists.txt,sha256=xASmGsgootsbz0eIOyP8cBxMtxNQFWmLCI1t-JrktM8,1690 +bitblas/3rdparty/cutlass/examples/53_hopper_gemm_permute/permute_kernel.cuh,sha256=TYsqHOs273qMpCsFl6S6JOLbBCGU0H9tvMDQNYQD6Bc,4078 +bitblas/3rdparty/cutlass/examples/53_hopper_gemm_permute/permute_traits.hpp,sha256=8pKTtwlZYiMMr82N5TOGQCQFeCNxyUV9vTvFqV-v-HM,11429 +bitblas/3rdparty/cutlass/examples/54_hopper_fp8_warp_specialized_gemm/54_hopper_fp8_warp_specialized_gemm.cu,sha256=Q_uzYYlMe5Yhd-0V5TFCzF-yy-wFTa9E3r8v038Tg6o,21934 +bitblas/3rdparty/cutlass/examples/54_hopper_fp8_warp_specialized_gemm/CMakeLists.txt,sha256=5GKVJVMu-7j1Zaq7WRoaaqqu8jkpeSr5kjHWVd9sPjg,1712 +bitblas/3rdparty/cutlass/examples/54_hopper_fp8_warp_specialized_gemm/hopper_fp8_commandline.hpp,sha256=aIz9D2AnGa0C81R9xcqLUbMdkJXXGZrzQlZBhqHxWuI,5157 +bitblas/3rdparty/cutlass/examples/60_cutlass_import/CMakeLists.txt,sha256=VflWVpUWtrL0MSiHE98MOEO6p3ozW_w-nhENxzf2tjs,2683 +bitblas/3rdparty/cutlass/examples/60_cutlass_import/main.cpp,sha256=XuTdl68LAl_EY7WeF3OCpnAGr6VpildT6-6GZbMgG3w,2849 +bitblas/3rdparty/cutlass/examples/CMakeLists.txt,sha256=QlPaIrT4Ia704XX_X_jkCfJMtl0tWa1lCYy1zB3Kn90,4370 +bitblas/3rdparty/cutlass/examples/common/helper.h,sha256=P9gtrCtjMnFCGLpTMISnYUPHzARYMMJ1e2N-mB_eMr0,4469 +bitblas/3rdparty/cutlass/examples/cute/CMakeLists.txt,sha256=XVR4yDXPA8W3SW47zOb8O5sUHM0cemh32U9QKRuyCSQ,1625 +bitblas/3rdparty/cutlass/examples/cute/tutorial/CMakeLists.txt,sha256=DGfkYd6u23a_Nqsa5oQfpfPNycltV8IlThZS3toValQ,1661 +bitblas/3rdparty/cutlass/examples/cute/tutorial/sgemm_nt_1.cu,sha256=yz6FShJ9AheZtv0aF39JUW13hxiiGnorRSgmDrtq_bg,14342 +bitblas/3rdparty/cutlass/examples/python/00_basic_gemm.ipynb,sha256=tkcizMMk21MAU9V3JQHx64HmTk2uN-tOjK-AERORRKg,12130 +bitblas/3rdparty/cutlass/examples/python/01_epilogue.ipynb,sha256=4CaLJ9XzYKQKhP0-gKtdzgxrIhkmWTEflh49S9kG0xk,6234 +bitblas/3rdparty/cutlass/examples/python/02_pytorch_extension_grouped_gemm.ipynb,sha256=FK0zZTn2BjnDDmJCKil4cQNYl_kpNCKL8pPOUbYpTyg,8780 +bitblas/3rdparty/cutlass/examples/python/03_basic_conv2d.ipynb,sha256=wzBFx9tRzu7Zstdf5P06ZT-X0WZC44rmqn0je0qJFd8,17022 +bitblas/3rdparty/cutlass/examples/python/04_epilogue_visitor.ipynb,sha256=KaDN9Izlm7i1gHgjHpiqb-kAdrqVmnCRsQgJqPHzMgk,7856 +bitblas/3rdparty/cutlass/examples/python/README.md,sha256=c9sxxBDR5VTwpA717YYxRb5YKW_kr1QwL9S8i78rTT4,961 +bitblas/3rdparty/cutlass/include/cute/algorithm/axpby.hpp,sha256=levq1xQdSdp-__4psvwvnYoWBEtuyckGmfy8zrzfJ4E,2999 +bitblas/3rdparty/cutlass/include/cute/algorithm/clear.hpp,sha256=R94777XI6DVb0rATEoMw3Ogzy7qlLxk2UrhCVcYTTXA,2351 +bitblas/3rdparty/cutlass/include/cute/algorithm/copy.hpp,sha256=b5MuZP9kiv9Aah-ZCIhlFHwsvQathoEgAx_1XUH9Iuw,10086 +bitblas/3rdparty/cutlass/include/cute/algorithm/fill.hpp,sha256=l7kg-ZA9jlLbrQfMBwibn_waltV9sFqbJxIVos4LbI8,2906 +bitblas/3rdparty/cutlass/include/cute/algorithm/functional.hpp,sha256=-lv3rsHPop0TO3YXUZ1lYR5S4xuc-1oHIQjAn-1DC-Q,7224 +bitblas/3rdparty/cutlass/include/cute/algorithm/gemm.hpp,sha256=TnIlQBg9jxYg8uFP16rpHmn41SDObwH-OjbcreRfWqs,26851 +bitblas/3rdparty/cutlass/include/cute/algorithm/prefer.hpp,sha256=90zyfDx-ABWqHlFJaZtjTTOkmLQmwULaG1YZxROgooQ,2124 +bitblas/3rdparty/cutlass/include/cute/algorithm/tensor_algorithms.hpp,sha256=EDoP8i1A8MPBoa_M2gN-EANEf9lOc1uTbHP-x1vezq0,5252 +bitblas/3rdparty/cutlass/include/cute/algorithm/tuple_algorithms.hpp,sha256=L-okcBXfKulBQmoVMPJOkI2q2aRwNUOJWFlzjlnXcNE,27691 +bitblas/3rdparty/cutlass/include/cute/arch/cluster_sm90.hpp,sha256=6M-QrmdAOnSx_du83IN0Y0fyDInd7hGt2QxMx8drXKk,7541 +bitblas/3rdparty/cutlass/include/cute/arch/copy.hpp,sha256=Ch2dzPbFJd3L54xlXX-1w7T07ZmScqK8Rlinnp7iM2Y,2453 +bitblas/3rdparty/cutlass/include/cute/arch/copy_sm75.hpp,sha256=R7BPRcUlN8GXj_D1kKXjWzPD8xGJ5vm8KES29VKKqFY,7703 +bitblas/3rdparty/cutlass/include/cute/arch/copy_sm80.hpp,sha256=cGCOfwp3he3DaqOcmRGmVvtFve7F3NefGBNAf7BmNFY,4812 +bitblas/3rdparty/cutlass/include/cute/arch/copy_sm90.hpp,sha256=e-HX_fOqudDalA3F6Ivu5fH-nBikK0-zFkb014OUBTo,7325 +bitblas/3rdparty/cutlass/include/cute/arch/copy_sm90_desc.hpp,sha256=sUKJynBkvFrvOa1DCyJHPzsuB_zQBdSUVPRYRqrX0ZA,8312 +bitblas/3rdparty/cutlass/include/cute/arch/copy_sm90_tma.hpp,sha256=_kv6p88MWt1efb6l4XJzXk6zt5UuiN_C-rxDtnEQLbw,32479 +bitblas/3rdparty/cutlass/include/cute/arch/mma.hpp,sha256=-NXdlS5QCjbYY3ZukzF88Jr1kt1OO-JBWa0ltNyStSU,2393 +bitblas/3rdparty/cutlass/include/cute/arch/mma_sm61.hpp,sha256=ovKF68J-fwSdGK_9gRPnfWAZDZtt1kIjFDUX3vrtas8,3160 +bitblas/3rdparty/cutlass/include/cute/arch/mma_sm70.hpp,sha256=D90aMLsPoCpJyv6ClgVD8g3EojDfYD2SwZDiwnrGhVM,12452 +bitblas/3rdparty/cutlass/include/cute/arch/mma_sm75.hpp,sha256=obk-bMt3UMy6a-Og0L8lf_X0fTDrSJsL-JEMzuqGf28,4262 +bitblas/3rdparty/cutlass/include/cute/arch/mma_sm80.hpp,sha256=MKYvLqlHSf9tsFMgHhthVeVGj_KqbibUo72WUBRXEFg,68426 +bitblas/3rdparty/cutlass/include/cute/arch/mma_sm90.hpp,sha256=Hk4VWBZ7-MMkmdk7GzCDiQk7SVFwKbzasoAYFo3Xo_I,48530 +bitblas/3rdparty/cutlass/include/cute/arch/mma_sm90_desc.hpp,sha256=eTldEpuD7L2NnIuR_qXbmHWE-ePFxC9FNECM8v2zTDs,6172 +bitblas/3rdparty/cutlass/include/cute/arch/mma_sm90_gmma.hpp,sha256=GSDd0SudmUeckcgFZYZWVUHs6aWfCeaOi8eQcoUVc0c,983542 +bitblas/3rdparty/cutlass/include/cute/arch/util.hpp,sha256=5gKxRHRTTd2PNyckxjv64sbDxqwNmNiusOLNBTf9xW0,8212 +bitblas/3rdparty/cutlass/include/cute/atom/copy_atom.hpp,sha256=yRSdWWbsOi2e83X2YL_pg6HSMr6SF2mOZJZaxKa1hhY,27964 +bitblas/3rdparty/cutlass/include/cute/atom/copy_traits.hpp,sha256=aouyc0O3pKBAJrLZ8OZMtFmoBbcGdK9xfCMS_JORYNc,5605 +bitblas/3rdparty/cutlass/include/cute/atom/copy_traits_sm75.hpp,sha256=NOGga4pteaO_sHO3HCB6hv1fAfBWAAWfJ8mzfFl0rig,5087 +bitblas/3rdparty/cutlass/include/cute/atom/copy_traits_sm80.hpp,sha256=QkLTYTmKBKC8ZyqyPPnEy_2C2CA4RDw1DTL7xIQqwDE,3689 +bitblas/3rdparty/cutlass/include/cute/atom/copy_traits_sm90.hpp,sha256=w9UiEjxUKYHOuCrTWgA3Koqh7aORuseMyfjZhvfDbEI,4589 +bitblas/3rdparty/cutlass/include/cute/atom/copy_traits_sm90_tma.hpp,sha256=nYOQO5PAWy1oLYjKQg2Ex5LlD3UkdZOOLKLmKjN-Bow,42538 +bitblas/3rdparty/cutlass/include/cute/atom/copy_traits_sm90_tma_swizzle.hpp,sha256=19rBZRq-UvNwryByf8jBrKQ8p823IWKkvxXL41r5vos,2833 +bitblas/3rdparty/cutlass/include/cute/atom/mma_atom.hpp,sha256=-pH7MBumKMkTHo--j_wp_E5ZJWsluAOCo7Yb1dOp1WQ,37762 +bitblas/3rdparty/cutlass/include/cute/atom/mma_traits.hpp,sha256=d9rb4tHxqArLnfW9eVK7aoWysesd8fI2FjuABgxhWTU,8749 +bitblas/3rdparty/cutlass/include/cute/atom/mma_traits_sm61.hpp,sha256=Y0px8tYj3EMMCeCKwJN1sEGsrWyOIeHtS2P-6jExiwc,2797 +bitblas/3rdparty/cutlass/include/cute/atom/mma_traits_sm70.hpp,sha256=RYIvRkHmbKM7ErBdxkhaRn666Y4y6cHsePiEnZT7kBk,6188 +bitblas/3rdparty/cutlass/include/cute/atom/mma_traits_sm75.hpp,sha256=-ZaDRnIxCwlAxr15zP4gJx7ZjmaPlItv_9ZSJATaIE0,3327 +bitblas/3rdparty/cutlass/include/cute/atom/mma_traits_sm80.hpp,sha256=jfgbgLrZal3tPchT-Zze_1pOCRdQUc5YHyLKT50WqXQ,14416 +bitblas/3rdparty/cutlass/include/cute/atom/mma_traits_sm90.hpp,sha256=fdeyieRrV6NUV6vNFw8ArrxY3uPODQHit2Jj98GgwZc,5121 +bitblas/3rdparty/cutlass/include/cute/atom/mma_traits_sm90_gmma.hpp,sha256=qPWHf7AnJND1IwN3Sm0Pt7nmDwzJ9mk6y0HNk2LSEGw,201904 +bitblas/3rdparty/cutlass/include/cute/config.hpp,sha256=0RMOBI_KWyHzytXSgZRozO0JQTr5aA9-vKS1sy9kh2k,5317 +bitblas/3rdparty/cutlass/include/cute/container/alignment.hpp,sha256=BXxdDLczDpaN2PiqfnwikUwtVOPTiKFxGhegTnLXqR4,2982 +bitblas/3rdparty/cutlass/include/cute/container/array.hpp,sha256=IId7owDXQjwSh-I5Zk8cfbMFg_8Y5vBQ5k_KGGlCBWE,9480 +bitblas/3rdparty/cutlass/include/cute/container/array_aligned.hpp,sha256=FhOKwFInj2S5rKCaFDw4WwC_8MoR5HYh3_5eifWF_fw,2082 +bitblas/3rdparty/cutlass/include/cute/container/array_subbyte.hpp,sha256=j_AEDdH8_zwFJxeEJZ4eZm2-pd0VbqqqJb_ijf3nsPU,15103 +bitblas/3rdparty/cutlass/include/cute/container/bit_field.hpp,sha256=f3JfxZrWbxpYusqYoS9Y39ipkdAaLEecn-9IPPgkRNY,5889 +bitblas/3rdparty/cutlass/include/cute/container/cuda_types.hpp,sha256=ymBGHmRB82qCk1jCa9o_QTb0BVBFD99Wec8wCTmcWuQ,4609 +bitblas/3rdparty/cutlass/include/cute/container/tuple.hpp,sha256=m7zc4lX3666i93VqjhExpAmiEMo87-0NdTHarJtsvz4,21136 +bitblas/3rdparty/cutlass/include/cute/container/type_list.hpp,sha256=Jz6G6LFh8lhpUd2iQZOL9KscMq8AuEtYMpWN2DvkVAo,4224 +bitblas/3rdparty/cutlass/include/cute/int_tuple.hpp,sha256=8enAn-OfbeZXSj7Qse2TMHB7Vi1kquXqVmbufEnDHJU,26907 +bitblas/3rdparty/cutlass/include/cute/layout.hpp,sha256=X76egU9ZeL7Z7djKFBvhznPiGbOaJjY1btc8wnEs2o8,56125 +bitblas/3rdparty/cutlass/include/cute/layout_composed.hpp,sha256=T-A69bZRwioL6rRn1wK7BxV_EdttAwjvmU4FPRMRP50,17165 +bitblas/3rdparty/cutlass/include/cute/numeric/arithmetic_tuple.hpp,sha256=fVFE1CyCo5qgKQBwhNOgpgB-7gEPqFfm9QQ-C-OgiWk,15119 +bitblas/3rdparty/cutlass/include/cute/numeric/bfloat.hpp,sha256=XbduWLgvxGXxFv9DUhwE3YUo4eyv1MaRiDk8KVcFE_s,2170 +bitblas/3rdparty/cutlass/include/cute/numeric/complex.hpp,sha256=_Qq2uDigW7jWNFVMvaRUfIke_fr0c7ufri7mnASD8GY,2694 +bitblas/3rdparty/cutlass/include/cute/numeric/float8.hpp,sha256=ivQH7QRlq7-mbFmq2zVcVXeK1RQrv6CUg7ywfL9HdH8,2033 +bitblas/3rdparty/cutlass/include/cute/numeric/half.hpp,sha256=RkYq--xNoBJSe0MLdb9XWuBsq0EiVxrk97MekqNJQyI,1997 +bitblas/3rdparty/cutlass/include/cute/numeric/int.hpp,sha256=4S2dtSMkAn0vvEGeISs3SfPBpDbZ-CikmZgIl6wJ3OM,4734 +bitblas/3rdparty/cutlass/include/cute/numeric/integer_sequence.hpp,sha256=VXTBYfmbllqDdhCCUoSzWHwijVHG5vz3n008sq794bc,4671 +bitblas/3rdparty/cutlass/include/cute/numeric/integer_subbyte.hpp,sha256=xfPp0Cv5L2KwuPLj1YgkBq9Ic_J3itJWZuHk6r4nHdE,7178 +bitblas/3rdparty/cutlass/include/cute/numeric/integral_constant.hpp,sha256=6Wm6Obt4JIkhysEM5kuswcEZTFk5-XncZwvqEBCZ0pE,12698 +bitblas/3rdparty/cutlass/include/cute/numeric/integral_ratio.hpp,sha256=tQwU9a_8sgUB_2hiie42OsLya-iDMRFZivsOJDC9gdU,5418 +bitblas/3rdparty/cutlass/include/cute/numeric/math.hpp,sha256=h_kAg0RKAnbkrLDqgumPpqRPP0OCqlL157oItdk3yic,8640 +bitblas/3rdparty/cutlass/include/cute/numeric/real.hpp,sha256=qJBkBVMkxu4M_EXZjZNyorCv9d_SXFG-qvb7OGhI8Lc,2259 +bitblas/3rdparty/cutlass/include/cute/numeric/tfloat.hpp,sha256=UnwQW7onFvEo3ULNvFu87L6pK0pz2txyqi4jV17-7PE,2170 +bitblas/3rdparty/cutlass/include/cute/numeric/uint128.hpp,sha256=201eJy3VnqxmL7s0Jc0-tbGy-0zSjB7zIvZSfaGrre8,7531 +bitblas/3rdparty/cutlass/include/cute/pointer.hpp,sha256=XE_kdm3nU4gKYdM3N67F0VeCDlXE2mWPmqmOQ258SeY,9220 +bitblas/3rdparty/cutlass/include/cute/stride.hpp,sha256=vwJYBOrnnkkpSVxA7odjp33DCNpTqoFHxEPzD53y5IU,15535 +bitblas/3rdparty/cutlass/include/cute/swizzle.hpp,sha256=qkOXnl2yRe8Md3tt_v4QK_iQI6zHJkAzUMzHw-nQfgY,17550 +bitblas/3rdparty/cutlass/include/cute/swizzle_layout.hpp,sha256=aPyRL_7Bhl8_rGuZ0r1oJXVKWA9pdQwudip8CKT2c5s,18485 +bitblas/3rdparty/cutlass/include/cute/swizzle_ptr.hpp,sha256=u2ziufebLKCQkxS5LBJvGMkoFqkMZGL2vFQBWyOsWPc,9898 +bitblas/3rdparty/cutlass/include/cute/tensor.hpp,sha256=UWNAkf5vJHA_4FdLrJ5bn_ruKUbaCAtXoZZT0cau3T4,29217 +bitblas/3rdparty/cutlass/include/cute/tensor_predicate.hpp,sha256=1Gp1UsSuLwFeIe1Swh3XLe9371tgrBupxZ-x6_TWKiI,2305 +bitblas/3rdparty/cutlass/include/cute/tile.hpp,sha256=On_SdMp-mhqF9C8BTOaeS06b4rwZEidKgyy2PfPZmcY,2279 +bitblas/3rdparty/cutlass/include/cute/underscore.hpp,sha256=nZqqtqEbg_B58d4NHPmsfdJcJ414GrTg1TKM_06WKeU,5068 +bitblas/3rdparty/cutlass/include/cute/util/debug.hpp,sha256=tQ0C6cvlF6E8gJHGtcbj5r_T7wNHAEnek9ZtvOy0x4M,5010 +bitblas/3rdparty/cutlass/include/cute/util/print.hpp,sha256=Wa2vee7CzAvNUfwRShn4fa_09C58W5-MWJNEwk9LxxM,4101 +bitblas/3rdparty/cutlass/include/cute/util/type_traits.hpp,sha256=CsPhw0gbPdjqYmhNcCWf9csh28-zpDBjicnFpkSG-aQ,7453 +bitblas/3rdparty/cutlass/include/cutlass/aligned_buffer.h,sha256=wdH-YXyQh2NWSZs2biFLEdExk5pXv60kYSu2GRAlpMQ,3793 +bitblas/3rdparty/cutlass/include/cutlass/arch/arch.h,sha256=k47SAVpPGotkeloogf9a_ecrApU3hM5isdGVfNd2UQM,3537 +bitblas/3rdparty/cutlass/include/cutlass/arch/barrier.h,sha256=LuYu39d0NWtqhE-PiuiK0McWjm81oFAFTH26Lik3lOg,16466 +bitblas/3rdparty/cutlass/include/cutlass/arch/cache_operation.h,sha256=5x1Vj3pPeFHt_XUbhAGrTP_ZcgwQ8aq-QJdLE2h5KJQ,2691 +bitblas/3rdparty/cutlass/include/cutlass/arch/memory.h,sha256=uEaVc53lZUGCPJ3LlS2Is_rYANHg_fihU_Mijhd0YFQ,18266 +bitblas/3rdparty/cutlass/include/cutlass/arch/memory_sm75.h,sha256=UL_xli77L2C24DvEXdliQsj9OjCBVLL7xiyIUsg-Q6Q,8260 +bitblas/3rdparty/cutlass/include/cutlass/arch/memory_sm80.h,sha256=CjQ9DAY1arCF5M0s7gNBETm8Qx8QoHQS-_dH7kjt2AA,15163 +bitblas/3rdparty/cutlass/include/cutlass/arch/mma.h,sha256=9E1Sm4BD-fA2mx7ZgkeTFLAP-iraQma2iYzU-W5QgeU,8804 +bitblas/3rdparty/cutlass/include/cutlass/arch/mma_sm50.h,sha256=pjEqChsc6J15KUCZPSROC1QSn4IBcfbtP0L1i1HnjOI,11096 +bitblas/3rdparty/cutlass/include/cutlass/arch/mma_sm60.h,sha256=CmG4ose57_cuZXjBJcdoqL8VldbeOUhdc9JlhD1TBko,7040 +bitblas/3rdparty/cutlass/include/cutlass/arch/mma_sm61.h,sha256=ACpR7cg84eSGl3EaUSTQJYVO11dpdptfjFTNLQyKvX8,4193 +bitblas/3rdparty/cutlass/include/cutlass/arch/mma_sm70.h,sha256=9nCkX_xUtblIcQTRc7NpX4Iuv_MxGwDzV64SAP3nmQM,16554 +bitblas/3rdparty/cutlass/include/cutlass/arch/mma_sm75.h,sha256=9BDphjxR26RoLe6zWyFbfKb8-RIFgXFuF8UiFhK7fAI,31990 +bitblas/3rdparty/cutlass/include/cutlass/arch/mma_sm80.h,sha256=D7ctRLgN0MDYLtrbMM3y1PokpTNVAZ9lUlX605nHvIo,57636 +bitblas/3rdparty/cutlass/include/cutlass/arch/mma_sm90.h,sha256=jlO5wSQK-0Tv7HpwvwjmDl-eSqK_KBrFzrQy8iZfnw0,8255 +bitblas/3rdparty/cutlass/include/cutlass/arch/mma_sparse_sm80.h,sha256=uuM_TVg0z4YphqbR5BRGOBzZJ5qEFWj5vqTZ8DSJ47g,43978 +bitblas/3rdparty/cutlass/include/cutlass/arch/reg_reconfig.h,sha256=UxMi3gs5lIwhdKg2WdQsLulXe7IE2go79s-mpAFzUF0,2622 +bitblas/3rdparty/cutlass/include/cutlass/arch/simd.h,sha256=wGoI5izll8Y07-PBzwGxhYgKcMyoOexC05j8F2_Eu3c,3998 +bitblas/3rdparty/cutlass/include/cutlass/arch/simd_sm60.h,sha256=OBHXqf0sS9sIhbtvlqrVEu7uW9s9vfrjZn0u9q5yLsw,3590 +bitblas/3rdparty/cutlass/include/cutlass/arch/simd_sm61.h,sha256=7xmgUinL1Q1z_EZ_aqeEqEYthYjY8ZUH567ySk_0WvE,5102 +bitblas/3rdparty/cutlass/include/cutlass/arch/wmma.h,sha256=F4v8wFV2-BgLWhiOCLiEeqslxRAH12R7L_-yJrozfwM,8473 +bitblas/3rdparty/cutlass/include/cutlass/arch/wmma_sm70.h,sha256=W6fPSOqq3vLIltjG78DTgxIB4DDXnzd0Jqc4Va27bhs,5286 +bitblas/3rdparty/cutlass/include/cutlass/arch/wmma_sm72.h,sha256=fdvlnDdhzFPpNtxyFGYVvsOBuN_yCb82ZhrGyJYGlRU,7746 +bitblas/3rdparty/cutlass/include/cutlass/arch/wmma_sm75.h,sha256=M5CN8oRbjF6ILjhs2VsqhQ666nkpjWNgvSK9qxoAKTw,7616 +bitblas/3rdparty/cutlass/include/cutlass/array.h,sha256=e0uYMyMFVoBNY01dEcxcpAcEhB5mB8wmZM1gqeOo6Os,66025 +bitblas/3rdparty/cutlass/include/cutlass/array_planar_complex.h,sha256=wKNY7qajhBZJqbe7geTciHFTh92lqWMJuIzV581Alxs,3662 +bitblas/3rdparty/cutlass/include/cutlass/array_subbyte.h,sha256=tCvLDlNoz3T5FL30KYYx0uosWtV1o7P0OtupkqtbxAY,13521 +bitblas/3rdparty/cutlass/include/cutlass/barrier.h,sha256=ErvWwZdoL2ktIi0uClwhZPLobA-0XEuBsjPcu7036So,12238 +bitblas/3rdparty/cutlass/include/cutlass/bfloat16.h,sha256=xgaZxUfF9IuJnEJ7F1SHPHQh7EKlWKUvmJW3Fs3qMAM,13766 +bitblas/3rdparty/cutlass/include/cutlass/blas3.h,sha256=7n_CC6r2_3-oBy35AXdxcHF6pzXSdm-xHiVQOhgLpn4,5294 +bitblas/3rdparty/cutlass/include/cutlass/blas3_types.h,sha256=HkRbwgYn2aAM8pL5_3cnRYkE9RBs3lJDRzOcVezAqp8,3256 +bitblas/3rdparty/cutlass/include/cutlass/block_striped.h,sha256=kHYj-XgiVZCrYZ4zsSUtgMfzT-Z4cYRZR2ymF78ymyI,9386 +bitblas/3rdparty/cutlass/include/cutlass/cluster_launch.hpp,sha256=szP8GQkrXvaqxXTaPwhPH20OcFgkfw-305fBWJI-9yM,8819 +bitblas/3rdparty/cutlass/include/cutlass/complex.h,sha256=nr-9pYuB5S8_8D8S8W7TpMEs7A8x7xd3NI1Aba-k03M,19492 +bitblas/3rdparty/cutlass/include/cutlass/constants.h,sha256=v3Sjq0wLzd7nW251eBNYzoxiN9ZoB5MLXxcrDaE2w5I,47943 +bitblas/3rdparty/cutlass/include/cutlass/conv/conv2d_problem_size.h,sha256=Swa_Xjy9XvT70Fi678PTyC6DMskjcelbElWQiovHCT0,23019 +bitblas/3rdparty/cutlass/include/cutlass/conv/conv3d_problem_size.h,sha256=nyeCXV_dYuFvbAtRePjvyJK4M69dGR3Fd4zAP8bJ4-c,16660 +bitblas/3rdparty/cutlass/include/cutlass/conv/convolution.h,sha256=HvFTO4mrd6VrQYqy8x1M6gEuRFAUqooR6PN1JO-T_SE,7140 +bitblas/3rdparty/cutlass/include/cutlass/conv/device/direct_convolution.h,sha256=q8yXGVZLAzqaLWwzGyJ2bHHDiDOuwlroDWNapWet4gQ,9743 +bitblas/3rdparty/cutlass/include/cutlass/conv/device/implicit_gemm_convolution.h,sha256=oyXiFhxQmPxjVcPIhTtN4f_4O7Wn2g5GIm6PTszZ-40,12078 +bitblas/3rdparty/cutlass/include/cutlass/conv/device/implicit_gemm_convolution_fusion.h,sha256=oGKG10A6mzKkBMTThjLyeVk59oWjtS4fAfApNxWDR04,10044 +bitblas/3rdparty/cutlass/include/cutlass/conv/kernel/default_conv2d.h,sha256=vB_KoaUQY_MRCLaBQW1YwCXmGnZ5TwG6yqqk7XrpJLI,7671 +bitblas/3rdparty/cutlass/include/cutlass/conv/kernel/default_conv2d_dgrad.h,sha256=qerAv8YeEZvCtznBd1dRMCIqG0cfcVbFT38CKOQVlDc,53546 +bitblas/3rdparty/cutlass/include/cutlass/conv/kernel/default_conv2d_fprop.h,sha256=Dmv2nD-x-qR257i4D6iTzwJY2j8t4e-RPGfhD7rn8SQ,56838 +bitblas/3rdparty/cutlass/include/cutlass/conv/kernel/default_conv2d_fprop_fusion.h,sha256=O1fSnT-DDeT7IZYGXGygcuG26iRQ2u3-E_XJONePtv0,11953 +bitblas/3rdparty/cutlass/include/cutlass/conv/kernel/default_conv2d_fprop_with_broadcast.h,sha256=c3G9TXjQaMHh5869DUSCn9zGtuwvUqIqM-FT96BIEGY,4689 +bitblas/3rdparty/cutlass/include/cutlass/conv/kernel/default_conv2d_fprop_with_reduction.h,sha256=XwsRFX0DYxun7MdYeT5TkOdEgSz52nnVun-zaiLrToQ,4659 +bitblas/3rdparty/cutlass/include/cutlass/conv/kernel/default_conv2d_group_fprop.h,sha256=dpda--2EXchv1gOKOrATN3I6cJ3O-NajUqqA9IBQYLk,19603 +bitblas/3rdparty/cutlass/include/cutlass/conv/kernel/default_conv2d_wgrad.h,sha256=WRjKZEED_yM95yoLXDAFN3l4FgJdE6i6vlpLsTzCCY4,28745 +bitblas/3rdparty/cutlass/include/cutlass/conv/kernel/default_conv2d_wgrad_fusion.h,sha256=Z6rCWWncaaWiaLr2TxO8GE46wf8TGa2ld84Mv-xLa_g,10459 +bitblas/3rdparty/cutlass/include/cutlass/conv/kernel/default_conv3d_dgrad.h,sha256=XqtOCIqU8_taz1LHt9QvT5-omeHYh-dT6c1QJ214IUE,9324 +bitblas/3rdparty/cutlass/include/cutlass/conv/kernel/default_conv3d_fprop.h,sha256=bYv5Tqyzc5VVxMPMeJl_iEK1rf7YSfpQoSHZTs3GZAs,14864 +bitblas/3rdparty/cutlass/include/cutlass/conv/kernel/default_conv3d_fprop_fusion.h,sha256=EfR4CxBXrdV32L8ABxqWib5Bd54bJ16pNanGKniPWpA,11980 +bitblas/3rdparty/cutlass/include/cutlass/conv/kernel/default_conv3d_wgrad.h,sha256=CATjTLizXhRMq4Poho2hnPi5QARS_zFNSCZlJacr_5I,14883 +bitblas/3rdparty/cutlass/include/cutlass/conv/kernel/default_depthwise_fprop.h,sha256=DtWUbW88V5Zn4QxIWTKHLkds5S91kS6wCrP0Ki0puro,19293 +bitblas/3rdparty/cutlass/include/cutlass/conv/kernel/direct_convolution.h,sha256=XPyvEyXxIddP5oRO8h-zjlZaWjOI5q2i0N67b1THy_8,18026 +bitblas/3rdparty/cutlass/include/cutlass/conv/kernel/implicit_gemm_convolution.h,sha256=9PwnBECVhR175nWkC5thpLG7IMHmi1XHGG385tT0Ars,15413 +bitblas/3rdparty/cutlass/include/cutlass/conv/kernel/implicit_gemm_convolution_fusion.h,sha256=cTwxssd2S1-e_cNgoFt3xm8yPdL0JCkdNFGOv5FfCi8,15690 +bitblas/3rdparty/cutlass/include/cutlass/conv/kernel/implicit_gemm_convolution_strided_dgrad.h,sha256=Dx_cVS4s-r8q1OrABbjtKMPXeDObWviokvqYpBVbhe4,17222 +bitblas/3rdparty/cutlass/include/cutlass/conv/kernel/implicit_gemm_convolution_with_fused_epilogue.h,sha256=NGHbDuGwxXoYknEELVu83RpqbkTvHaCuXVgXNDqFWgI,16730 +bitblas/3rdparty/cutlass/include/cutlass/conv/thread/depthwise_mma.h,sha256=ONlyGswJ0nUMFKISTUxGZJt10-IqrpbWk4FqppSi-Gw,9689 +bitblas/3rdparty/cutlass/include/cutlass/conv/threadblock/conv2d_dgrad_filter_tile_access_iterator_analytic.h,sha256=fQiVcrx0mB8bxWDiovgpq1_E2ZKi5Lobt1139x-ZndM,15306 +bitblas/3rdparty/cutlass/include/cutlass/conv/threadblock/conv2d_dgrad_filter_tile_access_iterator_optimized.h,sha256=NOSv65pgRkV-4cHDSykpLPcMYGH86pjNsXCfxqnWGTE,19735 +bitblas/3rdparty/cutlass/include/cutlass/conv/threadblock/conv2d_dgrad_output_gradient_tile_access_iterator_analytic.h,sha256=cT8j9eM5iIzRMHfMaEkIU3qt47aKgyliC_qjogs69Rs,18940 +bitblas/3rdparty/cutlass/include/cutlass/conv/threadblock/conv2d_dgrad_output_gradient_tile_access_iterator_optimized.h,sha256=TVLtqUNrb7zPRmrDTfSs9NMTRrsR843hpHL50UQRi70,26136 +bitblas/3rdparty/cutlass/include/cutlass/conv/threadblock/conv2d_fprop_activation_tile_access_iterator_analytic.h,sha256=AfvSqb-Nfj0ZNmfneYIWZYowAG5HmhXtv6gi6g-Rum0,10977 +bitblas/3rdparty/cutlass/include/cutlass/conv/threadblock/conv2d_fprop_activation_tile_access_iterator_few_channels.h,sha256=uXHix9fY08mChzMGC5_3El9VV4UOsxqslYEL4IG3Yr0,11529 +bitblas/3rdparty/cutlass/include/cutlass/conv/threadblock/conv2d_fprop_activation_tile_access_iterator_fixed_channels.h,sha256=TWmC0ZSORa3bNfIZpwLUS1_4IWxuHE092jGZVpPz85U,11333 +bitblas/3rdparty/cutlass/include/cutlass/conv/threadblock/conv2d_fprop_activation_tile_access_iterator_optimized.h,sha256=9UTw-ACTb4iXuswOusoz7cK5i_O0tDv9jw8F9a6SO00,13688 +bitblas/3rdparty/cutlass/include/cutlass/conv/threadblock/conv2d_fprop_filter_tile_access_iterator_analytic.h,sha256=JCnym0MpHNOzj_yCrwadYS6F2zh1HMYbkxDrIE8Wmg8,10651 +bitblas/3rdparty/cutlass/include/cutlass/conv/threadblock/conv2d_fprop_filter_tile_access_iterator_few_channels.h,sha256=68kQJnicK0dcHu8Q6Y2rI5_W3F2rb4k4eaeuMawOd3I,9314 +bitblas/3rdparty/cutlass/include/cutlass/conv/threadblock/conv2d_fprop_filter_tile_access_iterator_fixed_channels.h,sha256=7DUc9SG7tmgkuKCWxhxejqfZ461cEoPHItCGa2FoSp8,9018 +bitblas/3rdparty/cutlass/include/cutlass/conv/threadblock/conv2d_fprop_filter_tile_access_iterator_optimized.h,sha256=j3iqHj8gnz0EopUpyadJcP1lOP7W7S8J7V2tTEyk_Wc,10411 +bitblas/3rdparty/cutlass/include/cutlass/conv/threadblock/conv2d_params.h,sha256=MtTvp1vLidxTJjxDotbApfvytxYhdV7hQGKF5M9zIjE,30197 +bitblas/3rdparty/cutlass/include/cutlass/conv/threadblock/conv2d_tile_iterator.h,sha256=qQZsCUnpglrsxjaa1ela1dTQmlM4ZYp9TFSdRybyKTM,11202 +bitblas/3rdparty/cutlass/include/cutlass/conv/threadblock/conv2d_wgrad_activation_tile_access_iterator_analytic.h,sha256=-qXsNcOkFUDyS-hVTl9786EJwoplF8W4h9e1SKocRkc,10349 +bitblas/3rdparty/cutlass/include/cutlass/conv/threadblock/conv2d_wgrad_activation_tile_access_iterator_optimized.h,sha256=h1qsOWjLID4ec54yGRkm5BmIR2qAaNJpBcaC31_jukA,11519 +bitblas/3rdparty/cutlass/include/cutlass/conv/threadblock/conv2d_wgrad_output_gradient_tile_access_iterator_analytic.h,sha256=GFHj02td8xTZBMbzMrZgVYQLOmN-hV5-rsIxskXHn8M,9043 +bitblas/3rdparty/cutlass/include/cutlass/conv/threadblock/conv2d_wgrad_output_gradient_tile_access_iterator_optimized.h,sha256=YcZ-pkqgcCIoplQW2jCtwRCy_ITukAzMwfTyFHd2PDI,10832 +bitblas/3rdparty/cutlass/include/cutlass/conv/threadblock/conv3d_dgrad_filter_tile_access_iterator_analytic.h,sha256=hor6ztsHTmzLJc__sJV1dtrbsODcvJIhLkBWQNv5a4Q,8450 +bitblas/3rdparty/cutlass/include/cutlass/conv/threadblock/conv3d_dgrad_filter_tile_access_iterator_optimized.h,sha256=aCl5baowU1vYgaLGQR3BCZYN1n_rZoon9qVHTjNuZyU,9569 +bitblas/3rdparty/cutlass/include/cutlass/conv/threadblock/conv3d_dgrad_output_gradient_tile_access_iterator_analytic.h,sha256=UyfHi5FKmD1h8hH53sxCEkr8z1E87JmuMsHLKziHKbQ,11020 +bitblas/3rdparty/cutlass/include/cutlass/conv/threadblock/conv3d_dgrad_output_gradient_tile_access_iterator_optimized.h,sha256=YhO2xJxaZIdqj_yjn9-SeVStXM1a5qbY3Sa6uLk0rok,15014 +bitblas/3rdparty/cutlass/include/cutlass/conv/threadblock/conv3d_fprop_activation_tile_access_iterator_analytic.h,sha256=Cw8raxOqOM6upiiLuCDVU6OAew0eZQYwIk3ho794IgY,9634 +bitblas/3rdparty/cutlass/include/cutlass/conv/threadblock/conv3d_fprop_activation_tile_access_iterator_optimized.h,sha256=aW6IJxFYzG77DqUt_elab3C-GYOvk0j-18BPdjPbUPA,15132 +bitblas/3rdparty/cutlass/include/cutlass/conv/threadblock/conv3d_fprop_filter_tile_access_iterator_analytic.h,sha256=1ZuiXkmsaFMLlhWpVa1pZtHhkdbki8K_R88tTKH3C_g,7945 +bitblas/3rdparty/cutlass/include/cutlass/conv/threadblock/conv3d_fprop_filter_tile_access_iterator_optimized.h,sha256=Tz7tMcAVI5n-99o30rLSKgPUMGve16dJvil_24ndG7U,8891 +bitblas/3rdparty/cutlass/include/cutlass/conv/threadblock/conv3d_params.h,sha256=u0fmeuuAnQuS3K-V790-RAofi25s2tVq0xRUrP0rYPU,18249 +bitblas/3rdparty/cutlass/include/cutlass/conv/threadblock/conv3d_wgrad_activation_tile_access_iterator_analytic.h,sha256=4EXbQwlB9GzAHuZabyqeGWcOnf6gfB9obQSMSAjeOM8,9971 +bitblas/3rdparty/cutlass/include/cutlass/conv/threadblock/conv3d_wgrad_activation_tile_access_iterator_optimized.h,sha256=LRCFZbQhoYK3Pl6sIeiE6L1dytjBYxa5WRp0w7FBMok,12024 +bitblas/3rdparty/cutlass/include/cutlass/conv/threadblock/conv3d_wgrad_output_gradient_tile_access_iterator_analytic.h,sha256=kZyVAYJf-WObPYaLlxoQMyVUyoog_M-dOi7-tSa0fXM,8821 +bitblas/3rdparty/cutlass/include/cutlass/conv/threadblock/conv3d_wgrad_output_gradient_tile_access_iterator_optimized.h,sha256=bebqTfBlRRzn4luxGjCYrCx_x0kVl8PQEtN9ofT0Dl8,10744 +bitblas/3rdparty/cutlass/include/cutlass/conv/threadblock/depthwise_direct_conv_params.h,sha256=MdVmk5F2jConXUovYkNCJUxgLKVRgsrtXqLDIf0NuNs,8871 +bitblas/3rdparty/cutlass/include/cutlass/conv/threadblock/depthwise_fprop_activation_tile_access_iterator_direct_conv_fixed_stride_dilation.h,sha256=azqDbE892BQ-fA5SR7C6gfgscCVeNKmtINlU0uhoY-Y,10747 +bitblas/3rdparty/cutlass/include/cutlass/conv/threadblock/depthwise_fprop_activation_tile_access_iterator_direct_conv_optimized.h,sha256=kmBbu1i-rTCBMKmUYHY4DkZiRpf49KtM152JrvyZS3I,9899 +bitblas/3rdparty/cutlass/include/cutlass/conv/threadblock/depthwise_fprop_direct_conv_multistage.h,sha256=mSHARh9AJXZtkIHWPj0DOVKuw-jHHmPQbJZSY_ZG9wg,20899 +bitblas/3rdparty/cutlass/include/cutlass/conv/threadblock/depthwise_fprop_filter_tile_access_iterator_direct_conv_optimized.h,sha256=uJoQcgqSbYj9bx005gHjjFqbKKQSEKrxIKdJCgE0_Kk,8921 +bitblas/3rdparty/cutlass/include/cutlass/conv/threadblock/depthwise_fprop_pipelined.h,sha256=91XNU7EIywP9JSxaKoiXFicuv_vTcRa2Wk-PHQKAhP8,12745 +bitblas/3rdparty/cutlass/include/cutlass/conv/threadblock/depthwise_mma_base.h,sha256=jQznZ1uLEU0ZuwXPSO844rZsEahNHxyAXpLm1Ri70Qg,8097 +bitblas/3rdparty/cutlass/include/cutlass/conv/threadblock/depthwise_mma_core_with_lane_access_size.h,sha256=gN_F32CWhNhHQZdFdZZC9G9BmRMSO7jpXh1oikh2Zyc,36697 +bitblas/3rdparty/cutlass/include/cutlass/conv/threadblock/implicit_gemm_fprop_fusion_multistage.h,sha256=wiuBY4nWbxrY-Igg3r7fhNGL4b2FG530D2Kvlejk3_U,30106 +bitblas/3rdparty/cutlass/include/cutlass/conv/threadblock/implicit_gemm_multistage.h,sha256=Z03wLpJe_JrXEXIUFXMNXFRJYpEogaXc0uEq3Ag-eH0,19823 +bitblas/3rdparty/cutlass/include/cutlass/conv/threadblock/implicit_gemm_pipelined.h,sha256=t3X70P0y-ccGVGLJyGEpw9NhyeyHCXKPC5xvyV5QoYo,12175 +bitblas/3rdparty/cutlass/include/cutlass/conv/threadblock/implicit_gemm_wgrad_fusion_multistage.h,sha256=onkAqmowuxcnvfTt1k-g3RCxI9mUn8yQZrpHwl--Fao,26320 +bitblas/3rdparty/cutlass/include/cutlass/conv/threadblock/predicated_scale_bias_vector_access_iterator.h,sha256=5H9Nz3pKAayqmi6jOFWn66c5HP9sk40zfoEmHXNG2ok,16915 +bitblas/3rdparty/cutlass/include/cutlass/conv/threadblock/predicated_scale_bias_vector_iterator.h,sha256=gi2ZmFgIptNO8I4GFuNsql0R_oWsxzZ-Le28821xyOE,12476 +bitblas/3rdparty/cutlass/include/cutlass/conv/threadblock/threadblock_swizzle.h,sha256=hMnJed2byeJ6rCJThm3olDgCYmkOLUoR-t7nGHtPwpw,8050 +bitblas/3rdparty/cutlass/include/cutlass/conv/warp/mma_depthwise_simt.h,sha256=iX58m5Xa8TKYj1C3qzLcVvCFZyMstroMLWeYKeHFUfU,12392 +bitblas/3rdparty/cutlass/include/cutlass/conv/warp/mma_depthwise_simt_tile_iterator.h,sha256=hzn2nIS-jvCrmd29CEuYaODZuz5gmw0liU9Jf7A89KU,30655 +bitblas/3rdparty/cutlass/include/cutlass/conv/warp/scale_bias_relu_transform.h,sha256=zSP9is_fYAKfvaRoDQBR36vf8s3JpktqVzVOZrXMR5w,8704 +bitblas/3rdparty/cutlass/include/cutlass/coord.h,sha256=h7lTS9oX-vFgNOL5IIHQzMh1loOK0rrUu1nNBtpq6to,12221 +bitblas/3rdparty/cutlass/include/cutlass/core_io.h,sha256=JA9lZAcKz1x7VVUe93Mq-xyAgbM2tDeQGNSd4MvHNas,11384 +bitblas/3rdparty/cutlass/include/cutlass/cutlass.h,sha256=xkzd16GSup0sTKngYMLi0BsFBFL8C5JGZuH3X0RqWMk,6872 +bitblas/3rdparty/cutlass/include/cutlass/detail/dependent_false.hpp,sha256=sxIz-vOojMN7NH29VNu5sKXyj3_fRoh5W-l7dEr8iPk,3710 +bitblas/3rdparty/cutlass/include/cutlass/detail/helper_macros.hpp,sha256=HnZuUXpNCWU2veJuGTSaaQUj_saD7fr21wHTuUG1fnI,5666 +bitblas/3rdparty/cutlass/include/cutlass/detail/layout.hpp,sha256=UDKRvVR7QlH5rJxKyyyGmxtP2C_gsiL7FDRbsn-Kqbk,8448 +bitblas/3rdparty/cutlass/include/cutlass/device_kernel.h,sha256=Gt-iCIOaBnzXKBhjxep28BvGjeUh1WqW074OoDqv-S4,4309 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/collective/builders/sm90_builder.inl,sha256=v1EOFRbPKnzRdsWkCMZWAfX3E41EYXkNzUXwrgm2QB4,25249 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/collective/collective_builder.hpp,sha256=9CsiTq9YVoQ__aAKCbojNvBdYFXdsTBbkXYo-hrwDjY,4383 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/collective/collective_epilogue.hpp,sha256=3u-fJ-Jz8SRJMRnI2RgTxI6wEsFE0hCFJ0_S4TDu3kU,2919 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/collective/default_epilogue.hpp,sha256=fBfQhKY5pDQygBc0GS7n6NIUxoU_YVnypmZl6FxtDDc,8556 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/collective/detail.hpp,sha256=ULVT_rlzY2VOtThG4aWXgCut7fQRd15nbfwAYL91hNk,8153 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/collective/epilogue_tensor_broadcast.hpp,sha256=uq35ZqrLGO1fwXTXqPinWw20rr5KRdgnLPNMvaRwQ68,10714 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/collective/sm70_epilogue_vectorized.hpp,sha256=1JTXU18Z2PGNEkBr_CnWI-Iob3syWFZO_g53xgf6VaA,13533 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/collective/sm90_epilogue_tma_warpspecialized.hpp,sha256=X0tTuvpEboHx1TqUOaCHXWWYk5b-TscUwCKQk2VwyGc,28669 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/collective/sm90_epilogue_tma_warpspecialized_bias_elementwise.hpp,sha256=qwssHLmr6s1C-Vy6MPICa8g5MfxC06QKbna7Hw3buUo,5369 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/dispatch_policy.hpp,sha256=OAVfKpiT0z5ER5_79JPOdCEVN1LfXwMD9XAH3Llo9CI,6013 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/fusion/callbacks.hpp,sha256=BwQQeTWwLTijdboYCeqU4tvg22mz3vFTKAmsICLSn_A,4128 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/fusion/operations.hpp,sha256=m_LD_RVxNhP2M8BDSxPYd09kYZq2z2gVJOVv5x5ej14,9643 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/fusion/sm90_callbacks_tma_warpspecialized.hpp,sha256=nmrzsbkjTkm5ytlkRAs9hEllDc3cZbF_KEPu2mkYMeY,38706 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/fusion/sm90_visitor_compute_tma_warpspecialized.hpp,sha256=pLv-DXAQ-9DGPauxp-FSMaJ07D3dZrcKPy5jHfyvU4g,12739 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/fusion/sm90_visitor_load_tma_warpspecialized.hpp,sha256=68_1flfliUKKgEsQLPOANKH8NJOs1d3rKJd0b3BoUbo,32077 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/fusion/sm90_visitor_store_tma_warpspecialized.hpp,sha256=PCRmbPmf5yT2DFDIM4XmUwoTxATKIvBvn1XVJZaaSMg,30849 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/fusion/sm90_visitor_tma_warpspecialized.hpp,sha256=BbK07OCP6kMRsyNLIqePZvNZphd9k5GgQdExYOaWum0,27806 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/thread/activation.h,sha256=8zjlmPmolcomPSiGWSqBEndz189lu9PvT-lLkm8dxY0,15398 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/thread/conversion_op.h,sha256=06kVoXhfhaXrftFLEDNIa4Orie8z8hXlJtEScc3CKJU,4691 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/thread/detail.hpp,sha256=L38wU-sHHyH5t8FKwSz5V1pRBpXtfx7ZjjBa6ODAkcY,2281 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/thread/linear_combination.h,sha256=qUeL3ApU8Mkqf5zt5z_7thiTsEXZ__RBia4ICa5P1FA,17463 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/thread/linear_combination_bias_elementwise.h,sha256=ypGNM_Q1CBT892hm2eFvIDhs276zooapRUiE_9frs1c,9245 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/thread/linear_combination_bias_relu.h,sha256=vwEkg5RJcqgW_QNKbQ0oH14J6pOqseb3zWiJe72Xm14,13571 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/thread/linear_combination_clamp.h,sha256=wF6S5Bnlh-lVzTO7YZnY9wBWHP1-J2Eu4i__XVB1CCA,23752 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/thread/linear_combination_dgelu.h,sha256=-iQPSaqkRp5lIqTdzVr9aXucYWZmnoGPlIVn2uq9pL4,9067 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/thread/linear_combination_drelu.h,sha256=C1Q1JFrZnUeX-EoSTtqZL_OchL2myiPE8xkPY2sTE_c,15195 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/thread/linear_combination_gelu.h,sha256=Sft9won8C34vZxKJ7NAmHgIPNzbXmscy40MEBnhLlYQ,3669 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/thread/linear_combination_generic.h,sha256=TcoJ4iftGGxHljTaRNQ8sXgPWxoaysJzcbRb7pL7qbw,10056 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/thread/linear_combination_hardswish.h,sha256=s1MXwlUxsMzDKv75_p1wyiO-A8mWcK_FoQ6248K5VX0,3693 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/thread/linear_combination_leaky_relu.h,sha256=t6zFGkhNsqdtHEaiA3RZDheKH1h_7FePYFO4EZvCwrA,8399 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/thread/linear_combination_params.h,sha256=II0xBu62sKmaX2FpBjTHir18t5YnxXn7pTyAPsp0SeM,3046 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/thread/linear_combination_planar_complex.h,sha256=Y7at1fB0k9toQaUachpSJFEqKMm8BC3GSJwH1XtcLBY,9351 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/thread/linear_combination_relu.h,sha256=RzQENn1i0NTJozLSox4tYp525p9oE2UQqB2jZMAetiQ,20596 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/thread/linear_combination_relu0.h,sha256=2AV0jBw60Fp5ce1-Fvwe1zdCjUQguNok146EWZQSnJw,19458 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/thread/linear_combination_residual_block.h,sha256=zA86UYR6ROITxaYH44BxDyF_R6WnnomFv1QFeJ_R4sA,11995 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/thread/linear_combination_sigmoid.h,sha256=6Yumsvzz66zS_od-tTuMqWM_oRUEe3045ZCmqpZys7U,3688 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/thread/linear_combination_silu.h,sha256=wbtDjrrzRb02ZtFaNpvCLn4ayxPGwGnXLN9ssVS9e3o,3669 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/thread/linear_combination_tensor_broadcast.hpp,sha256=E07r-QRmW7HQPalsWIp2Vq0y9wscRA_ApT6Sg54CkqU,9786 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/thread/linear_combination_with_elementwise.h,sha256=VC5obOH30TY3rNuRsljjkZvugNm_WF4BvzK33VF7GDM,8662 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/thread/reduction_op.h,sha256=xbZ2vgd4fbS70mLKNKgdxk04qIqTziGihUbaR07jgyI,3416 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/thread/scale_type.h,sha256=EKK-JaUXgE5t3LtbGHGAAu3L6bjJcYk8vUgO1-pJLNM,3048 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/threadblock/default_epilogue_complex_tensor_op.h,sha256=DEWsbB9O4nqZUE6TWemG2I2y8mvpZucnmdovo4yxUj4,9142 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/threadblock/default_epilogue_complex_tensor_op_blas3.h,sha256=bbnin4NzkvozDpyYtS9sPUUQaxsViZK-llh0w0B5pWE,9441 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/threadblock/default_epilogue_direct_store.h,sha256=iLYRf2Pe0t6Um4FnObq38eDayjx4HSzpQVJF4hi8mi4,3234 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/threadblock/default_epilogue_planar_complex.h,sha256=1j5GocEvGydwSqjS6N-QRx_eOC_lDO4yEnvTKZFP1O8,7209 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/threadblock/default_epilogue_simt.h,sha256=WtNSis-JYAQugGC_7I4OXiHMdYHacS01BkwN8xzT72c,13385 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/threadblock/default_epilogue_tensor_op.h,sha256=Rtccm3qGyTHe5uLCjaSOBNYm1vRJS4yTDaO03fpDYos,28290 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/threadblock/default_epilogue_tensor_op_blas3.h,sha256=n-81D7xCAFo9uRCdPFtAAmfNF6f1xOWIS_2kvV16gB4,7129 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/threadblock/default_epilogue_tensor_op_row_broadcast.h,sha256=NsO0ZJ9VtjUmWB3v1k8tqRlK8YApVFfZ9-WTc-3UlKE,7506 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/threadblock/default_epilogue_volta_tensor_op.h,sha256=FrFKxvIbstej5tdXKIgsgfjLOQfFZDp0cymtlfQZuKo,10846 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/threadblock/default_epilogue_with_broadcast.h,sha256=rFnDQ-gFCAwGYoJi3ECNe0mHAS4iyRaiGuBsz_8V47w,7424 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/threadblock/default_epilogue_with_reduction.h,sha256=XsWtQpVYpT8bWy1pcu13DtW19BObDeppE9lAuDzZGp4,5763 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/threadblock/default_epilogue_wmma_tensor_op.h,sha256=o1UJwjmG2kEPM1AyYdJ11-7JOpH8IT3iwkmCcyQbU1o,5947 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/threadblock/default_thread_map_simt.h,sha256=ESlYEE6rA73eNsDll7AoF-KwsMUO3Q9mnE3HIJUUgtQ,4409 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/threadblock/default_thread_map_tensor_op.h,sha256=Uzc2n6SkPRumeeW69MtAIMsPnRoYvIVH5Qu5DaMUz98,7398 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/threadblock/default_thread_map_volta_tensor_op.h,sha256=8rZQUMp2N3opKV9vnW2cTGHfK5Zd9_TOe1IQAM3YS68,7303 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/threadblock/default_thread_map_wmma_tensor_op.h,sha256=h7tMBFueo1V-G3zuDc7TCgdqKzPJ5ZQKXT8CUfqUBPQ,4098 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/threadblock/direct_store_epilogue_iterator.h,sha256=H8Z7PIH1fnxoIMZXZAbAWkAvNrLEs2h8lZPBtxoX34A,4678 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/threadblock/epilogue.h,sha256=4UCHyKLsxKSoOcxY3QVFTs4k8ALZttwxthkcOLPD5zA,19249 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/threadblock/epilogue_base.h,sha256=E4TsRXprl6zXnBGUYxY3hImPHOz40Qg5F8DTwi4x6rc,8279 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/threadblock/epilogue_base_streamk.h,sha256=-hqPGX61sJcfy4kPdA-dLf8j3B9ZXoNgo9Hf6KENObU,7455 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/threadblock/epilogue_depthwise.h,sha256=0b7ILihkUj_w-fYBVkILir7a9jTaSyCjisPEpygkCU8,13424 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/threadblock/epilogue_direct_store.h,sha256=9NO7ginqHxX7NtTKoi_wepl-WaHNXHFi1Aonj9SEGv8,13933 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/threadblock/epilogue_gemm_k_reduction.h,sha256=MS8WmxQTuV3mEfOUGsDpb1lZ9V4QXrLCX9kQz6hmE5s,7401 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/threadblock/epilogue_planar_complex.h,sha256=KOrwiq0d8yEPNKUiVSvmKnyGfd6L8bJjwK01o6BgAPU,14610 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/threadblock/epilogue_smem_accumulator.h,sha256=zix9lB2bNZAKbo8LeMPlYnto0Umbt-JIkZtyzOKtd9Q,9073 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/threadblock/epilogue_streamk_with_broadcast.h,sha256=GlwZTyMFX0hb19ACH-ZgYdyzFSbyE0yza3iIdq2C1d0,15321 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/threadblock/epilogue_visitor_with_softmax.h,sha256=8lxKwgraHKvDWnOleFGJ7EM6KYkOSjDUjQ96Fw9PQCI,16804 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/threadblock/epilogue_with_broadcast.h,sha256=xlbgAM4byqnShBSYBo9SZZYaxwjR83flzi08dzsyW1s,58685 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/threadblock/epilogue_with_reduction.h,sha256=FiHm-511Vt4jgWUpQZIzildifYVdkTmhq6no9HyOnZk,29199 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/threadblock/epilogue_with_visitor.h,sha256=PolxajZaoNzhkWSivJU4ZSHVg5akeMCTzMH-wI4OiG0,13454 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/threadblock/epilogue_with_visitor_callbacks.h,sha256=TjbYAVO8_44zlIjcjd5vkzK9L6uTYLWc5xY7Z___ugU,16977 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/threadblock/epilogue_workspace.h,sha256=wY00rtyFaNACryLoB2epcq4cL9NwbGlAJmHBRu4ayNk,7308 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/threadblock/fusion/visitor_2x.hpp,sha256=8S1VyRUdfQsHk0yh9S1MA_JkYMTpqOjXtVEAHCyBXuE,14536 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/threadblock/fusion/visitor_compute.hpp,sha256=WsGIhMWLosd9cpYbtTqimxRkPFst9iqmyY5KSoNOjLI,4387 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/threadblock/fusion/visitor_load.hpp,sha256=_BKMBwCnGWg_1VvEla91M93WyiicVZvjOFRhnVUaMuU,17202 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/threadblock/fusion/visitor_store.hpp,sha256=fiNsTMAj4QQA9VgDsp1eiaK8dIqc3kS2xLOfhhyvlyo,24993 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/threadblock/fusion/visitors.hpp,sha256=0VwkSbd6TLdacSw9MIyrkM0AAKFKPyr6BGLxKtLeFOs,2171 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/threadblock/interleaved_epilogue.h,sha256=uCIRHL6WsfMNw6JhpLYUBg8yh3uWTIbMyfMvHFpQw-E,14359 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/threadblock/output_iterator_parameter.h,sha256=D1WfoULKmh0DpR2LrE9NTfXoljSKVI7lUhv-VIhQmao,2912 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/threadblock/output_tile_thread_map.h,sha256=DUJbHGhu1kqNbc4ZZ26y3bhn6Mbog8es2ZSCmubQAYQ,19842 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/threadblock/predicated_tile_iterator.h,sha256=9ZbJwJ4wKbMKOIWtjwVO7l3gzYhT89vVGOx6skcXaNQ,40972 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/threadblock/predicated_tile_iterator_affine.h,sha256=MbAaFk3TXjjI_Mp87m0p5YT1KbCIbaY1veTSxdGwPM8,18821 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/threadblock/predicated_tile_iterator_affine_layout_params.h,sha256=sTLf1apmARFW2uFs_Rw5lOa-9cVIDU2QLwrznLcb3y4,5636 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/threadblock/predicated_tile_iterator_blas3.h,sha256=D5dTY6atIFVCGqEwzzy1Qz0gNyexuEZhMy1BN9kGYjY,21249 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/threadblock/predicated_tile_iterator_direct_conv.h,sha256=LiR8x6tyQjkEKn06g90A1fx9hDsX39u5hsvwB-Bjnx4,13873 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/threadblock/predicated_tile_iterator_params.h,sha256=Lff7uA_U4zfoG0DGsAxHCOEySpousZ4TO1JCqBR82LQ,15397 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/threadblock/predicated_tile_iterator_predicates.h,sha256=ady0ky64xBK6GPnxXzTfq8o_iq9RXp4kSc9VAA3zsFY,9146 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/threadblock/predicated_tile_iterator_row_broadcast.h,sha256=DLJVIyld1bVHVTeHbLTr-PFzhnz06TPrvkafjU2y-R8,16037 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/threadblock/predicated_tile_iterator_strided_dgrad.h,sha256=PiSEksVxqpo_gp7gIlPqUti-XVF76jbQyB-gU0ZPDds,15534 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/threadblock/shared_load_iterator.h,sha256=EiDnfQ0J1K8zC-KlMyZBpmjYaA_xCAXBz63r9DUs2mg,7487 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/threadblock/shared_load_iterator_mixed.h,sha256=uWrT4EQQDA2bW6AGjvpakeQmPrNSzSQ40U3qSKM9CeQ,18100 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/threadblock/shared_load_iterator_pitch_liner.h,sha256=W7qeWPqC5M3My3TWp9ZsCV_6EiiXyLg_izu32mbDx8c,7394 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/warp/fragment_iterator_complex_tensor_op.h,sha256=4scHnb9_XEwrWxTU-z6Q6SoAzI1Z0PRnw8sXE0DTI1c,7055 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/warp/fragment_iterator_gaussian_complex_tensor_op.h,sha256=7n3IxGiyCQCXUzHS0Qsa0bEh8Ls-m7IyaJnDN21ZOAQ,7736 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/warp/fragment_iterator_simt.h,sha256=-n6AeH8UU_riWj5kJ5vsUlY73PB4ET8Tx2gNLhDMdPc,5880 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/warp/fragment_iterator_tensor_op.h,sha256=nlBAhtkXz9J8jSMTyCs_YfyP44eHQKea0vSh5DCoWlA,9883 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/warp/fragment_iterator_volta_tensor_op.h,sha256=8pxmjZH79edh_U44UuIAz-zUgFGRBIRyrJyd4rI0hzQ,8924 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/warp/fragment_iterator_wmma_tensor_op.h,sha256=hXyzGth1uFUgbbT97M3qE1ZkBPShbeegH-lK29XCr-M,6045 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/warp/simt_policy.h,sha256=FrgyTg-1N_jumiROE-rPe6uWJbyHVNmusDXSV9Le0J4,4864 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/warp/tensor_op_policy.h,sha256=d6PBVsZnnSfJRmsW5g8rCzJse-YOwe5uybZIVIryClA,5979 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/warp/tile_iterator_simt.h,sha256=TlLRyOgwAOnAL_oXy4WEFGQrXrz4_TKXcCTqu6IC1Vk,25658 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/warp/tile_iterator_tensor_op.h,sha256=taUoUEv7THwwLou0V2uo29dT_A_dA06r9Qsao7n4p8s,20290 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/warp/tile_iterator_tensor_op_mixed.h,sha256=cotyKFJC19jH4_aLZpjKGtMK4jrBUttLYJba4yqgzz8,22921 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/warp/tile_iterator_volta_tensor_op.h,sha256=S7r2b-DAcwwlwcQRWVz0bsezvwqy9uDiZUM_jBWgmls,14250 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/warp/tile_iterator_wmma_tensor_op.h,sha256=GHXUK4mExRm4A_9y8h5eMEQ7FC67-N4oBcXQ4qKkx5w,7704 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/warp/volta_tensor_op_policy.h,sha256=JDANmq-4MN1rn7GA8NhOWxaXAp6FegeCOMH2jIrz7A8,7485 +bitblas/3rdparty/cutlass/include/cutlass/epilogue/warp/wmma_tensor_op_policy.h,sha256=PoFFL6ItV_Lq-OzgOPs4EkK0MZbESusdDVrf9VUmXq8,3916 +bitblas/3rdparty/cutlass/include/cutlass/fast_math.h,sha256=kABByniOzYDS52L6w2xHouugpInHF9An3f7KmlpYJ5g,27129 +bitblas/3rdparty/cutlass/include/cutlass/float8.h,sha256=k15dNkZtuUZzUHKlMSTu4AZzNKp_owXRil7O5bLLIC4,35979 +bitblas/3rdparty/cutlass/include/cutlass/floating_point_nvrtc.h,sha256=HvTqAzGfYmMG5U1BR2w8wDPuQnEaysEALlVe7y36DMM,2645 +bitblas/3rdparty/cutlass/include/cutlass/functional.h,sha256=3VXOmMoSfk_ip6aeNbgFiwGcqTpcg5fJQyqjz9wo30I,15485 +bitblas/3rdparty/cutlass/include/cutlass/gemm/collective/builders/sm90_common.inl,sha256=0gi1FiTxibS3zG0htps4JwkTuDlQwxWTy_3BYh5TF4w,14598 +bitblas/3rdparty/cutlass/include/cutlass/gemm/collective/builders/sm90_gmma_builder.inl,sha256=D_gRkttMPQWKlXjWS7g1Bb1jLo8SxMaSrm4OTJvK0XI,25615 +bitblas/3rdparty/cutlass/include/cutlass/gemm/collective/collective_builder.hpp,sha256=5tM_Ec-s4nFfyGojPyqubNB8ZLJqUl2KIrF0Abh0KtQ,3589 +bitblas/3rdparty/cutlass/include/cutlass/gemm/collective/collective_mma.hpp,sha256=WQJ3muvRNc1s72QUvJfm6JykJmOm0zvvbSxLOqBoFsk,3404 +bitblas/3rdparty/cutlass/include/cutlass/gemm/collective/fp8_accumulation.hpp,sha256=jf2j7FIeOqzOeXcH_Bt7HcidmAVR9Z38OVwy0GAG5TM,4768 +bitblas/3rdparty/cutlass/include/cutlass/gemm/collective/sm70_mma_twostage.hpp,sha256=eHdnJa8e7r2Pel_QXhZ4PfFvp1wBlh_sorLzMOhFKN8,22199 +bitblas/3rdparty/cutlass/include/cutlass/gemm/collective/sm80_mma_multistage.hpp,sha256=klhqeVN743nhyBmZHu7yqEyaa_gIOs0PPvUZ8qyk8GI,27515 +bitblas/3rdparty/cutlass/include/cutlass/gemm/collective/sm90_mma_multistage_gmma_ss.hpp,sha256=a2ypTotsJne3qikM2z8CfLyvLo9sVjrasKTT6o9HCLQ,24206 +bitblas/3rdparty/cutlass/include/cutlass/gemm/collective/sm90_mma_tma_gmma_rs_warpspecialized.hpp,sha256=HUNQwIhS9KWY1PSTfGrgcHgz4p1iUKhckXiDrT_9UM0,31405 +bitblas/3rdparty/cutlass/include/cutlass/gemm/collective/sm90_mma_tma_gmma_ss.hpp,sha256=3yAMe4b99elccHxOJLTXO39hcRYJrqjM4mD8IQ5ZH04,22254 +bitblas/3rdparty/cutlass/include/cutlass/gemm/collective/sm90_mma_tma_gmma_ss_warpspecialized.hpp,sha256=wq29v8MINBKwGlVrY1jJONSQx7ZWUJwR3G8HvlHfCK8,22186 +bitblas/3rdparty/cutlass/include/cutlass/gemm/collective/sm90_mma_tma_gmma_ss_warpspecialized_fp8.hpp,sha256=3Dk-44SfiHtcg5cHDY35qR13H2so9IDUv5bvLPs1M2A,22435 +bitblas/3rdparty/cutlass/include/cutlass/gemm/device/base_grouped.h,sha256=nj2rrm0KY8qp5SYnSdsykhZIoI4esj7beSRz5fBuV2I,16881 +bitblas/3rdparty/cutlass/include/cutlass/gemm/device/default_gemm_configuration.h,sha256=gPcOvUPGKXE0b_vBdT2NjJDO5VZoLzLyXFQ_QQawZAI,24262 +bitblas/3rdparty/cutlass/include/cutlass/gemm/device/ell_gemm.h,sha256=qVPbgyMu_Y9YFi-awKYziMdGn-p82XKGTYIAARsh0zg,27616 +bitblas/3rdparty/cutlass/include/cutlass/gemm/device/gemm.h,sha256=nXztg3lE3i30KcwlbeWZ7B6Qq7Z9buMXX3hCxb5iyfo,25202 +bitblas/3rdparty/cutlass/include/cutlass/gemm/device/gemm_array.h,sha256=jJpcDihwKAZ90tBl2HB8TQSgxpr3MvhRL5mJOtc-lY4,22367 +bitblas/3rdparty/cutlass/include/cutlass/gemm/device/gemm_batched.h,sha256=momECNEH8zQ-MOAl3NS67zCJpK8sitcJWrhcSkZQU4w,22375 +bitblas/3rdparty/cutlass/include/cutlass/gemm/device/gemm_complex.h,sha256=vmfUteQY5S78X4550fGIkz9HO5f7vhxjrCeshUIHp0w,22725 +bitblas/3rdparty/cutlass/include/cutlass/gemm/device/gemm_grouped.h,sha256=d_AuwZia9IMnGIPTDHoqVxRGAdvTbqUQ8DlVCPttTmY,2591 +bitblas/3rdparty/cutlass/include/cutlass/gemm/device/gemm_layernorm_mainloop_fusion.h,sha256=vH1N7tkaW_X6-ArnoI_HQL9RcPf-l6321ywXo7wGw5M,13736 +bitblas/3rdparty/cutlass/include/cutlass/gemm/device/gemm_sparse.h,sha256=3Uyq8IROOD48KO_jZgnl91DiBGz9rAJmitH5-HT4Svo,17329 +bitblas/3rdparty/cutlass/include/cutlass/gemm/device/gemm_sparse_row_broadcast.h,sha256=D5SQ5ncLEQUVNwvxvR4z9wL4NoL-9O5HARLhFlGKGp4,17393 +bitblas/3rdparty/cutlass/include/cutlass/gemm/device/gemm_splitk_parallel.h,sha256=lwU6BpOS-e-3CWVHz5uvESC8g9dRIBUYoPh7sGuMJOs,20436 +bitblas/3rdparty/cutlass/include/cutlass/gemm/device/gemm_universal.h,sha256=voCza8tqBOPNNhoCaDey1PFTK0fz4tQoyPL5KmnTikY,15600 +bitblas/3rdparty/cutlass/include/cutlass/gemm/device/gemm_universal_adapter.h,sha256=Rnag5D478qMxPA1VV4PFmlK35Rgg5bLq7-YBRxlEBNk,21294 +bitblas/3rdparty/cutlass/include/cutlass/gemm/device/gemm_universal_base.h,sha256=_4Ko5EWZfQDUGntHPBxxyKCJHAbXsD4N6enxmU7tPAE,12990 +bitblas/3rdparty/cutlass/include/cutlass/gemm/device/gemm_universal_streamk_with_broadcast.h,sha256=YHF_jXCg5EIqCdvnMSs34wJ5gLvkToe6PC6PLnoVUAE,14027 +bitblas/3rdparty/cutlass/include/cutlass/gemm/device/gemm_universal_with_broadcast.h,sha256=av5BhY5oEJfFzeURLXNZwJEdg3g0m5aJ5lkSKMOr2b0,13968 +bitblas/3rdparty/cutlass/include/cutlass/gemm/device/gemm_with_k_reduction.h,sha256=xFXVqYf3x4qttZ8aPq86ao5DzY3dNCdUQMtA-yWVseo,14853 +bitblas/3rdparty/cutlass/include/cutlass/gemm/device/gemv.h,sha256=Efirv6H5YnQRUWmDWse_-DQ4gqQiBVpegUo3btTKEb0,5961 +bitblas/3rdparty/cutlass/include/cutlass/gemm/device/rank_2k.h,sha256=k8Y_sAJKEzKxGOC5FBomZgR9m64oPi_CxXPuQXmRkeA,18127 +bitblas/3rdparty/cutlass/include/cutlass/gemm/device/rank_2k_grouped.h,sha256=PFGRKZziJeExE1Gf6g4ThBLqls-vAnO6NP1UN7BWDtg,2747 +bitblas/3rdparty/cutlass/include/cutlass/gemm/device/rank_k.h,sha256=17fvE5o1VsEr3umdNEvzZuefUFBM2diAZwhGH40Znnw,16719 +bitblas/3rdparty/cutlass/include/cutlass/gemm/device/symm.h,sha256=vkKfFuuYSqZkP1BV9e2mdzAnYYzB3CVpGuuRQZBOHek,21050 +bitblas/3rdparty/cutlass/include/cutlass/gemm/device/trmm.h,sha256=mKLIPOEsNi9ALH6aAElT1O1pTXUg_b1TUrgMx92Xhec,26464 +bitblas/3rdparty/cutlass/include/cutlass/gemm/dispatch_policy.hpp,sha256=RwgIv5xId86c1N_1EqHl2owEb9nMSbFGCQ0J04eDBgE,7224 +bitblas/3rdparty/cutlass/include/cutlass/gemm/gemm.h,sha256=GNyxGxHAaOlFE6i-rDid7RO2HbN8Ijbwr0bTWwBjK_s,4630 +bitblas/3rdparty/cutlass/include/cutlass/gemm/gemm_enumerated_types.h,sha256=MZgpPNlsL8cQIffHNdHPfosQslD2PGuum61sbx9GXdk,3556 +bitblas/3rdparty/cutlass/include/cutlass/gemm/kernel/default_ell_gemm.h,sha256=Z7smSavO_C31Mt3HF8sAUrFhsjAGVBJOjZTbdNvH86Q,29360 +bitblas/3rdparty/cutlass/include/cutlass/gemm/kernel/default_gemm.h,sha256=osiVx_ASvC9dvl532sWhgASKFbRICeePNOyKjFz4BFw,39181 +bitblas/3rdparty/cutlass/include/cutlass/gemm/kernel/default_gemm_complex.h,sha256=cMHaVEUQrAzhf6oVVfvBybDMMtZfG6criwDyPGfaqYg,16130 +bitblas/3rdparty/cutlass/include/cutlass/gemm/kernel/default_gemm_grouped.h,sha256=9ozyNQqj-uIlzDl43K_hqFs0L8p6dNsSoZSScQCZbfA,12385 +bitblas/3rdparty/cutlass/include/cutlass/gemm/kernel/default_gemm_grouped_softmax_mainloop_fusion.h,sha256=A1L3NhYc-OmVP665stdsee6mePDUMVgTFLsH0kvHv5M,6592 +bitblas/3rdparty/cutlass/include/cutlass/gemm/kernel/default_gemm_layernorm_mainloop_fusion.h,sha256=uPmivW6sp27GoCSs7DFh3j0uOiirMbuFIFfVoqw7HIc,5848 +bitblas/3rdparty/cutlass/include/cutlass/gemm/kernel/default_gemm_planar_complex_universal.h,sha256=gL9iM9UXuexVbarR82UTPP8qo3aUb5Nuv93vvq6viro,11104 +bitblas/3rdparty/cutlass/include/cutlass/gemm/kernel/default_gemm_sparse.h,sha256=CXBS43zEJuIeJDps_kTOyv3uJGoxnhl0npKtuPLXoCc,7983 +bitblas/3rdparty/cutlass/include/cutlass/gemm/kernel/default_gemm_sparse_row_broadcast.h,sha256=q3XfpeSNnw4LdJ_1TUyeAPEA5DvupOIdDb5-rqij-RQ,8059 +bitblas/3rdparty/cutlass/include/cutlass/gemm/kernel/default_gemm_splitk_parallel.h,sha256=3AZxr3vi4E9LqWusBCN4XPlVtaN571uU-9DQAVBpYVI,4932 +bitblas/3rdparty/cutlass/include/cutlass/gemm/kernel/default_gemm_streamk_with_broadcast.h,sha256=Pz8739BasLQnwDH-EOFO1pSjo58FyAU5daxkzR4RevM,5446 +bitblas/3rdparty/cutlass/include/cutlass/gemm/kernel/default_gemm_universal.h,sha256=LJoMcR8l-EnXG4eJKDrsbM42zHLJuXtMnJ_yQbZvmFc,12332 +bitblas/3rdparty/cutlass/include/cutlass/gemm/kernel/default_gemm_universal_with_visitor.h,sha256=1HqzZnsHQDORz2i4UGgfxts9PvXhZMQMA6vrZt5kMSs,5697 +bitblas/3rdparty/cutlass/include/cutlass/gemm/kernel/default_gemm_with_broadcast.h,sha256=PfRYMn6o3jcPtKZwvcL11zrj4ScDnGNzQDT2wuemtVc,8123 +bitblas/3rdparty/cutlass/include/cutlass/gemm/kernel/default_gemm_with_k_reduction.h,sha256=Ta-XSVTrth7Y2UN3fjFEUhmpDb-R2u93FTM2hkXhG4U,6457 +bitblas/3rdparty/cutlass/include/cutlass/gemm/kernel/default_gemm_with_reduction.h,sha256=aXs4FK85cvjuqNyBwWDXFmjBjHPvh73cmCLuIMxTKxs,8084 +bitblas/3rdparty/cutlass/include/cutlass/gemm/kernel/default_gemv.h,sha256=TlJ7ipRu8Xu7N45PE-plVrQuPJkkm33PjsjiY2owR9w,5349 +bitblas/3rdparty/cutlass/include/cutlass/gemm/kernel/default_rank_2k.h,sha256=znjNCvXJzbiJsyqt8tt132oEBjGdJed77XSgwjz51rM,11560 +bitblas/3rdparty/cutlass/include/cutlass/gemm/kernel/default_rank_2k_complex.h,sha256=fLhyol40FxMCXy079Jr2CiGfxG9W9A7hhfAoBLcThho,20509 +bitblas/3rdparty/cutlass/include/cutlass/gemm/kernel/default_rank_2k_grouped.h,sha256=-i2lcxybH3WmD090HFzsHdrgq7IuvOaaiJAAqgiFgAM,12470 +bitblas/3rdparty/cutlass/include/cutlass/gemm/kernel/default_rank_2k_universal.h,sha256=GYwRykM88Vk2KB1cngC3tDGiA09NLaFguf4jd0L82aQ,10620 +bitblas/3rdparty/cutlass/include/cutlass/gemm/kernel/default_rank_k.h,sha256=pdEzYUigjM0INCcD03V4iy5pp2IChgAEIbeUciy3OsE,9872 +bitblas/3rdparty/cutlass/include/cutlass/gemm/kernel/default_rank_k_complex.h,sha256=LlWLGriOUfK2gGFqWL0NVDKdEW1yjtRBwIZRWgFsqLc,16990 +bitblas/3rdparty/cutlass/include/cutlass/gemm/kernel/default_rank_k_universal.h,sha256=vEeO82dS7Vp3WG_jVFyJGOPho09PRPC-1RS_h5RV2DM,9444 +bitblas/3rdparty/cutlass/include/cutlass/gemm/kernel/default_symm.h,sha256=LY4BUI_3qNV3xSkLTO7fjhcfK3fEYsIHnmx6iQ_qZq0,13375 +bitblas/3rdparty/cutlass/include/cutlass/gemm/kernel/default_symm_complex.h,sha256=F2SuRHkc69_jv53l7TNv8Pj8OZ8nqN1mM7eVybYJTbY,21830 +bitblas/3rdparty/cutlass/include/cutlass/gemm/kernel/default_symm_universal.h,sha256=GO4ZN_rzYtUYxy_TMArrSvOMq5p9eQVLR9krUBUu-Jo,10315 +bitblas/3rdparty/cutlass/include/cutlass/gemm/kernel/default_trmm.h,sha256=-q_5mBiHW5VdaaSh5vGl0_8KmbizgvzOXdmFCQC_Lkc,10873 +bitblas/3rdparty/cutlass/include/cutlass/gemm/kernel/default_trmm_complex.h,sha256=FHtnQAa8JYikvI1tbp0ULU5nbjyPZLwJqhOuT5m1LKE,10730 +bitblas/3rdparty/cutlass/include/cutlass/gemm/kernel/default_trmm_universal.h,sha256=LejjFa-wzPzX_nNFKXoZ7qr8vIj62Wgm_DgMhqAHZr0,10850 +bitblas/3rdparty/cutlass/include/cutlass/gemm/kernel/ell_gemm.h,sha256=SZs6JoC7ZrjYUAJfqDFG7apGofZol5_rnR6BUDN9YJA,28916 +bitblas/3rdparty/cutlass/include/cutlass/gemm/kernel/gemm.h,sha256=6zOXh8--MzGDez42W7JhD53QZhB8bGRXRONzQhOtomU,13362 +bitblas/3rdparty/cutlass/include/cutlass/gemm/kernel/gemm_array.h,sha256=YDB_JOtWkjDRJICzyOaOENlIZb6sCzpRzSQzARFhvjE,8698 +bitblas/3rdparty/cutlass/include/cutlass/gemm/kernel/gemm_batched.h,sha256=Ps7FWy_bWs2f7tpu7yBhiNaVJIvJTYc2GS9GxQxbewU,8766 +bitblas/3rdparty/cutlass/include/cutlass/gemm/kernel/gemm_grouped.h,sha256=U_naRt0ubgG8qNFgtTQrJRgKSSSNozxUIhf7uHYlLVQ,14692 +bitblas/3rdparty/cutlass/include/cutlass/gemm/kernel/gemm_grouped_problem_visitor.h,sha256=xf75pfsmc1OmuhWarvTNz9etVtXI9hmQch0Rxzobuuc,4690 +bitblas/3rdparty/cutlass/include/cutlass/gemm/kernel/gemm_grouped_softmax_mainloop_fusion.h,sha256=5WfmAh076zCtG-TQJBId31YTYLO33_vlWJ51Nz1xCIE,15623 +bitblas/3rdparty/cutlass/include/cutlass/gemm/kernel/gemm_layernorm_mainloop_fusion.h,sha256=afl4GverCKN7CTEcL5V63rrKIh4GEzHHqgdRyBIiZsk,27663 +bitblas/3rdparty/cutlass/include/cutlass/gemm/kernel/gemm_params.h,sha256=NsnhBiZa1EjoDpLT27YKhzN1GG9TPUQrdB-z-_jLhUg,6144 +bitblas/3rdparty/cutlass/include/cutlass/gemm/kernel/gemm_pipelined.h,sha256=Z1sVwoUjuQRDcrQMqE4mdCmt4Cg9F9WKf4o24m9xc_I,5146 +bitblas/3rdparty/cutlass/include/cutlass/gemm/kernel/gemm_planar_complex.h,sha256=jPhbMpG1t1FskhRXvM4gkOOLFWu98zYbcb2HKFnhWKM,23352 +bitblas/3rdparty/cutlass/include/cutlass/gemm/kernel/gemm_planar_complex_array.h,sha256=tvDfaIATyQEvokZJW13F_0pghZIqdM4CRGgDMOd9qjk,18941 +bitblas/3rdparty/cutlass/include/cutlass/gemm/kernel/gemm_splitk_parallel.h,sha256=-3Ty1796xeuKTkHpAzow13CLiuRQDJf5oR6FzGMwcfU,8142 +bitblas/3rdparty/cutlass/include/cutlass/gemm/kernel/gemm_streamk_with_fused_epilogue.h,sha256=AZ8zB_qQPcrjV4XJ4Ci9ZMdezR_j-WDvkoamYsfKrgg,79837 +bitblas/3rdparty/cutlass/include/cutlass/gemm/kernel/gemm_transpose_operands.h,sha256=nLULpaW9xSfruvu1vNdWkKU7rSRmzrBFurQ8PcQv1KQ,4291 +bitblas/3rdparty/cutlass/include/cutlass/gemm/kernel/gemm_universal.h,sha256=F1kJgD1R-JPYu8MKWJ7S_sOHh3aS3sZM94S1ugB0YeY,23563 +bitblas/3rdparty/cutlass/include/cutlass/gemm/kernel/gemm_universal.hpp,sha256=hCaKjlEKvItldcH_0bCYiy4EbxoEaRzlf3HM1_C6tyY,3546 +bitblas/3rdparty/cutlass/include/cutlass/gemm/kernel/gemm_universal_streamk.h,sha256=6eqX_QB_bA0RnuxsNb-k9XQHdT5WTvhemp9jEqdB6Po,39224 +bitblas/3rdparty/cutlass/include/cutlass/gemm/kernel/gemm_universal_with_visitor.h,sha256=m_Vr59ZCKz5mReQYcTiMWjaLCFuvfD9kv_sVP-aJLB8,10423 +bitblas/3rdparty/cutlass/include/cutlass/gemm/kernel/gemm_universal_with_visitor_streamk.h,sha256=GCoH1zOlfKpRNdO9DBP4_7QqXm4PWzx6CQJkaExBsuk,28696 +bitblas/3rdparty/cutlass/include/cutlass/gemm/kernel/gemm_with_fused_epilogue.h,sha256=xJ9VP4zAfi5UmSaT76R3SHGKtqK4H4uXdNQa9v_ikC8,47795 +bitblas/3rdparty/cutlass/include/cutlass/gemm/kernel/gemm_with_k_reduction.h,sha256=yr558-X-0GKLESWoMsSM0gu_lqqZYjFSqEdBOLyt_ew,23866 +bitblas/3rdparty/cutlass/include/cutlass/gemm/kernel/gemv.h,sha256=htp3gOsFGShKbhBMNFXeGIJTDXBG4TFZ0X3KZHzop9Q,18393 +bitblas/3rdparty/cutlass/include/cutlass/gemm/kernel/gemv_batched_strided.h,sha256=rmYhWjjAM-oggULeHi-sNN_LCG4ZMQpAWknfN9093iQ,8942 +bitblas/3rdparty/cutlass/include/cutlass/gemm/kernel/grouped_problem_visitor.h,sha256=YP7OZsobKZ4DKSEKJsuSABzEMPS5lBH89-P-uTEeni4,16765 +bitblas/3rdparty/cutlass/include/cutlass/gemm/kernel/params_universal_base.h,sha256=MDyUq3beUVZ3CVu01dVz8sl_eyDpxUJZGFEluSo2wm8,8404 +bitblas/3rdparty/cutlass/include/cutlass/gemm/kernel/rank_2k_grouped.h,sha256=OL14nQmu39lkDFHBINBCdLRd8iZWKKpvHNRWkI0d9WE,22943 +bitblas/3rdparty/cutlass/include/cutlass/gemm/kernel/rank_2k_grouped_problem_visitor.h,sha256=leR0ihVDKzstSmu68GZmilZw4uP5-H24cy-qWYl5gYM,16100 +bitblas/3rdparty/cutlass/include/cutlass/gemm/kernel/rank_2k_transpose_operands.h,sha256=EfuSgHeXc4RLunciv640ucSOn8VE5c7OoAaSCdVHwzg,4334 +bitblas/3rdparty/cutlass/include/cutlass/gemm/kernel/rank_2k_universal.h,sha256=jhNFfDBHdFL39ll50oF9v9ARaGnumaAWBS6HxTfhKMo,24143 +bitblas/3rdparty/cutlass/include/cutlass/gemm/kernel/rank_k_universal.h,sha256=iF7-dGDLI632VtRdL1mbcCWV0VUnPOdsh6Ef2srT6pQ,17548 +bitblas/3rdparty/cutlass/include/cutlass/gemm/kernel/sm70_gemm.hpp,sha256=W19Pcc10S1IqDPX1XfT55JeXVmSumxwWRZHUaGXlx04,10609 +bitblas/3rdparty/cutlass/include/cutlass/gemm/kernel/sm90_gemm_tma.hpp,sha256=6zJzMSfjSqNv1TWnjLEiVICHTJXOZVhkAgwRHANV4-Y,13092 +bitblas/3rdparty/cutlass/include/cutlass/gemm/kernel/sm90_gemm_tma_warpspecialized.hpp,sha256=BK-beNXa1CQYrnfFqZi87gBuMDVZXBac9sr9S_vIRPU,18986 +bitblas/3rdparty/cutlass/include/cutlass/gemm/kernel/sm90_gemm_tma_warpspecialized_cooperative.hpp,sha256=ZO_cb--RQ5m6NRNNQT9HMVC4omHEkhNCwZahstRcpE8,26244 +bitblas/3rdparty/cutlass/include/cutlass/gemm/kernel/sm90_gemm_tma_warpspecialized_pingpong.hpp,sha256=pI_Nycpunc_v5S0Y49k9xriINDDvBEd9DCV5cN9lf9A,26342 +bitblas/3rdparty/cutlass/include/cutlass/gemm/kernel/sm90_tile_scheduler.hpp,sha256=GNtazTeGRpcONCMiny_TVeRzi3NO1s0aubT8yyFSQug,11515 +bitblas/3rdparty/cutlass/include/cutlass/gemm/kernel/sm90_tile_scheduler_stream_k.hpp,sha256=otDBFLoOOytFUJwFIm2y84pAPQbAhAMU8fK-Tgm6KvA,29645 +bitblas/3rdparty/cutlass/include/cutlass/gemm/kernel/sparse_gemm.h,sha256=GMDIktgyJN00AassibwhjKlyqUZ9HaWvFu4H10l6mYA,13591 +bitblas/3rdparty/cutlass/include/cutlass/gemm/kernel/sparse_gemm_row_broadcast.h,sha256=iJPBDUiCY0nSME2erCj69lH2Hkgj2ZXrgF23mZnYBz4,13619 +bitblas/3rdparty/cutlass/include/cutlass/gemm/kernel/symm_universal.h,sha256=8EpK7sQFkuvlQNCDgqdSPbyQONIn7RGbRwahDAdkYK8,23881 +bitblas/3rdparty/cutlass/include/cutlass/gemm/kernel/tile_scheduler.hpp,sha256=QQeEkqVmM_AwhXz1Yguzytj4Omu4ycX8mZN7QrAQAX8,3984 +bitblas/3rdparty/cutlass/include/cutlass/gemm/kernel/tile_scheduler_params.h,sha256=9plFICmF4Q6mvx_rbRWeeQrAHfxwHL7WOTef-cDAHog,37583 +bitblas/3rdparty/cutlass/include/cutlass/gemm/kernel/trmm_universal.h,sha256=AOHRjnseM-5CW0ODnczxd7e8clvU7TbWWEpwttI5XKI,19518 +bitblas/3rdparty/cutlass/include/cutlass/gemm/thread/mma.h,sha256=AtaYmfSlpfDsXXBZDczP2klrzqRsEDPl2VyvRcYY7F4,3567 +bitblas/3rdparty/cutlass/include/cutlass/gemm/thread/mma_sm50.h,sha256=YSdtX6xTIpHKHNlBK_JMY3BD28rdaT-u167UNuWQAPA,15373 +bitblas/3rdparty/cutlass/include/cutlass/gemm/thread/mma_sm60.h,sha256=mO1VYeraxu2kAZ-KtMhM2P9OqTyEmCAzjzNGAkCfSME,29987 +bitblas/3rdparty/cutlass/include/cutlass/gemm/thread/mma_sm61.h,sha256=zeKU2pYVOHqx72rta7jE8MdksIs53TnHaP8CPSxxsPU,8142 +bitblas/3rdparty/cutlass/include/cutlass/gemm/threadblock/default_ell_mma.h,sha256=va8eF1pK8dMWWh3pQ8mYXqDDuoPtBbcvlk_wdty99I8,31930 +bitblas/3rdparty/cutlass/include/cutlass/gemm/threadblock/default_gemv_core.h,sha256=czc_hyzTGthyMfmWn4MSEo4AXcWYwiAdb1S38_JIh1E,6979 +bitblas/3rdparty/cutlass/include/cutlass/gemm/threadblock/default_mma.h,sha256=DGgBk0-XGnmGknrX4UZv5pNeUqvrsTQjzDckVPxZ3W0,35582 +bitblas/3rdparty/cutlass/include/cutlass/gemm/threadblock/default_mma_core.h,sha256=D70cU3GkXSEM2x0LgdA5MWrLT-C57rrxGsTNwYmtg9U,5123 +bitblas/3rdparty/cutlass/include/cutlass/gemm/threadblock/default_mma_core_simt.h,sha256=43_xz3V_PiWJ0xr-apagZgRW8zb5Ou7TtkfofneilRI,57426 +bitblas/3rdparty/cutlass/include/cutlass/gemm/threadblock/default_mma_core_sm70.h,sha256=Rywpvb-R2xPxqXEtpQh1yk5A8Zf8MGDyQGGMAlS-E00,19257 +bitblas/3rdparty/cutlass/include/cutlass/gemm/threadblock/default_mma_core_sm75.h,sha256=IkW_Ohju13DS2QFmcKERu7diX_9eDwrmzWFQUVzisUQ,42310 +bitblas/3rdparty/cutlass/include/cutlass/gemm/threadblock/default_mma_core_sm80.h,sha256=vr6hd_k92AYJhmy8v5vtTwrQjmpPhmmig8ML6ZhuGqo,102804 +bitblas/3rdparty/cutlass/include/cutlass/gemm/threadblock/default_mma_core_sparse_sm80.h,sha256=ndiP_TA-piAjfoCbl0Z-bukIHz7_dnEJ3mr9DjqE-cA,32106 +bitblas/3rdparty/cutlass/include/cutlass/gemm/threadblock/default_mma_core_with_access_size.h,sha256=SV57KV4a2nSmJoOJzRF4mc8ZHFI6gFcuENpJSFMaUtw,12650 +bitblas/3rdparty/cutlass/include/cutlass/gemm/threadblock/default_mma_core_with_reduction.h,sha256=6Qs25KcA9eLlZ1AmobULF9z1nxpHQs-Rq9MQ94XMtBQ,7387 +bitblas/3rdparty/cutlass/include/cutlass/gemm/threadblock/default_mma_core_wmma.h,sha256=NdkPqbWPO6x328LofdeEXof2DCr5M1pBZD37yhS9wFI,20975 +bitblas/3rdparty/cutlass/include/cutlass/gemm/threadblock/default_mma_layernorm_mainloop_fusion.h,sha256=7GgT2EvkQiGnLCY6MzaA6LzcxV4dtsI_KAuKWz1qxMk,7998 +bitblas/3rdparty/cutlass/include/cutlass/gemm/threadblock/default_mma_planar_complex_multistage.h,sha256=geitRJDAE3ONz46bkbvJBfZPh2-Qavb4MBBv1qxdb6g,5110 +bitblas/3rdparty/cutlass/include/cutlass/gemm/threadblock/default_mma_planar_complex_pipelined.h,sha256=mFG-PWH9zt94vgu9hBmNVBTHXjlxEbOMhkJZhmhKZIw,4627 +bitblas/3rdparty/cutlass/include/cutlass/gemm/threadblock/default_mma_softmax_mainloop_fusion.h,sha256=BUMjsTotGR_UioHrJhmw1_5Z4h2HwdbRDmIPm3joEC4,7113 +bitblas/3rdparty/cutlass/include/cutlass/gemm/threadblock/default_mma_with_reduction.h,sha256=Uj8JPl_9gRNbR6xlmcTKYWcn0TU-ruIK9itHLZMJv0U,6323 +bitblas/3rdparty/cutlass/include/cutlass/gemm/threadblock/default_multistage_mma_complex.h,sha256=WOmMw090gfQQPPTYDggJylXHRjSsAODHQ0bhZ5S0eLI,7121 +bitblas/3rdparty/cutlass/include/cutlass/gemm/threadblock/default_multistage_mma_complex_core.h,sha256=33HBpUUJdBPhkDUchxSzgbpiP44crjLTIBKAKfdrEy0,4959 +bitblas/3rdparty/cutlass/include/cutlass/gemm/threadblock/default_multistage_mma_complex_core_sm80.h,sha256=D8MVOQbrww2IYYh87vn8vG8il_f6mUs9Tvz-VQHFYRY,65005 +bitblas/3rdparty/cutlass/include/cutlass/gemm/threadblock/default_multistage_trmm_complex.h,sha256=wMPbdflOlHLY0quAMNLDSydc9aVAX1TpJxxlEF2Im8I,25495 +bitblas/3rdparty/cutlass/include/cutlass/gemm/threadblock/default_sparse_mma.h,sha256=tvgrAM7wMKOAxm1cLdHvAShM15xCUQYkPCFj52vzusE,8509 +bitblas/3rdparty/cutlass/include/cutlass/gemm/threadblock/default_trmm.h,sha256=k5oPLMuaatxE5vlzW6Yh6jjp_RyGKTAZds9ziZkH6NU,19515 +bitblas/3rdparty/cutlass/include/cutlass/gemm/threadblock/ell_mma_multistage.h,sha256=FGUiy4W0fFULo0eZAP2RXZWH_iETgEZtx5ZU-FPFiN4,24233 +bitblas/3rdparty/cutlass/include/cutlass/gemm/threadblock/ell_mma_pipelined.h,sha256=pgPEg2cpPnQBMdeEs6EDzot4okY5niJaQxlpeYQgDWs,13837 +bitblas/3rdparty/cutlass/include/cutlass/gemm/threadblock/gemv.h,sha256=gCGCoGbtx4vAO_S82IOfZdODXmecf2zpJM5C74kIyfQ,4726 +bitblas/3rdparty/cutlass/include/cutlass/gemm/threadblock/index_remat.h,sha256=cFyShhIx20Tn5AQ8STnTwPWCcpQVm_FJ8Jl7_I88wBA,3652 +bitblas/3rdparty/cutlass/include/cutlass/gemm/threadblock/mma_base.h,sha256=bXxQaXC9_hPagV9c_ZSUb3vvtajv7gvVec86r5QGGWI,7823 +bitblas/3rdparty/cutlass/include/cutlass/gemm/threadblock/mma_blas3_multistage.h,sha256=3G3PqXKWRxM0cZmf2BB5ME7wBa_c1wujeCP3edWnYIA,27600 +bitblas/3rdparty/cutlass/include/cutlass/gemm/threadblock/mma_layernorm_mainloop_fusion_multistage.h,sha256=mTpkFu2g-3uvy_SsVemlm4EGfq4umDehHMQ8sNjoHu0,32816 +bitblas/3rdparty/cutlass/include/cutlass/gemm/threadblock/mma_multistage.h,sha256=js5nE8cvHhov-UHRamMp1hsCWQoI9QAgAQCqhMNui7k,27801 +bitblas/3rdparty/cutlass/include/cutlass/gemm/threadblock/mma_pipelined.h,sha256=r9SUIA3nbXrbC1hOjh-K1W5yDAO4atQbDPnnHWQ4ZGo,15995 +bitblas/3rdparty/cutlass/include/cutlass/gemm/threadblock/mma_planar_complex_base.h,sha256=9uYmM4kxqrwM_-8vM7QZSEQOgqjwuPYt1A0KVPflBDY,6901 +bitblas/3rdparty/cutlass/include/cutlass/gemm/threadblock/mma_planar_complex_multistage.h,sha256=-epIXb1UGyiEVPSPM5rT3u0EGqOWWnMU9apuc9u9h3s,22839 +bitblas/3rdparty/cutlass/include/cutlass/gemm/threadblock/mma_planar_complex_pipelined.h,sha256=CAbuR2Hh73f7lfoc7KydEnjsTT0GoN5oJwTha5gTo6I,14747 +bitblas/3rdparty/cutlass/include/cutlass/gemm/threadblock/mma_singlestage.h,sha256=-O3XwAG5G463_tnOlRHb-mlntuYc4ZLwXqg5LnoAvJ4,9864 +bitblas/3rdparty/cutlass/include/cutlass/gemm/threadblock/mma_softmax_mainloop_fusion_multistage.h,sha256=l3kSCEhdascQP1zzkDMeMm0lIx9t0p4WdV9QnKrFLc0,27246 +bitblas/3rdparty/cutlass/include/cutlass/gemm/threadblock/mma_sparse_base.h,sha256=QRQT_74jU5stM62dLUjx2FGp7kJ_qsNL3T-ThMD39oM,9210 +bitblas/3rdparty/cutlass/include/cutlass/gemm/threadblock/mma_sparse_multistage.h,sha256=MQ39jPwo_nTF-qEs1_n9xDzKivjYkyRpM3pKY-DiqM0,25519 +bitblas/3rdparty/cutlass/include/cutlass/gemm/threadblock/mma_with_reduction_multistage.h,sha256=xlRkqT6RWItZo7uVtFvBGiLAbz1zCs1HALpGsMNG_9A,20395 +bitblas/3rdparty/cutlass/include/cutlass/gemm/threadblock/threadblock_swizzle.h,sha256=VF3eWRC0ogYzOJNzxqG-TGChCveJlf8Dxzl81A_IBBU,15041 +bitblas/3rdparty/cutlass/include/cutlass/gemm/threadblock/threadblock_swizzle_streamk.h,sha256=3-0-ZN2Xoz_CaoVvtkDjPXddcUlJHeQNegkERJhMdCQ,26650 +bitblas/3rdparty/cutlass/include/cutlass/gemm/warp/default_mma_complex_tensor_op.h,sha256=pvs5Gg_di2Qb8pixg2V2ERSVUiL5LDvHk2tEJSDnXfA,20553 +bitblas/3rdparty/cutlass/include/cutlass/gemm/warp/default_mma_sparse_tensor_op.h,sha256=WBCscsFugVEukPZMBn6je-HFfKsiEiuxBHpNzSoje78,6684 +bitblas/3rdparty/cutlass/include/cutlass/gemm/warp/default_mma_tensor_op.h,sha256=ZWerXDxp9tYmKwikls8rKJ69WDxxpzZI_yadQinTwSo,5178 +bitblas/3rdparty/cutlass/include/cutlass/gemm/warp/default_mma_tensor_op_sm80.h,sha256=YV1KCNG9cbsPUpnwiac2OBvsSuU22ci_6oYHxkycS-s,9026 +bitblas/3rdparty/cutlass/include/cutlass/gemm/warp/default_mma_with_reduction_tensor_op.h,sha256=Jz3jDsr-L5suIteerGvX7-rVEoF0X6SCin6wDivG_Rg,4053 +bitblas/3rdparty/cutlass/include/cutlass/gemm/warp/default_mma_wmma_tensor_op.h,sha256=N9ohwG4dLp1prxrh0cXvyqjjqGu8ftowvvrJ5mLt4c4,4685 +bitblas/3rdparty/cutlass/include/cutlass/gemm/warp/layernorm_scale_bias_transform.h,sha256=Cso0XxaSXoXSSVd9H9yy4Gr8TgieaX_Mby4b6ypzBqk,5691 +bitblas/3rdparty/cutlass/include/cutlass/gemm/warp/mma.h,sha256=sB35oGwG6L0mAIahwBAO0XDQfpl_VRIGWTxGsEfaATY,2619 +bitblas/3rdparty/cutlass/include/cutlass/gemm/warp/mma_complex_tensor_op.h,sha256=AtZu2eIaCOz8CKiHSlap6aJ7imDCmtvmrp3CpaD97iw,37767 +bitblas/3rdparty/cutlass/include/cutlass/gemm/warp/mma_complex_tensor_op_fast_f32.h,sha256=8go1lI_3SHv5Rm9O3ql-rHQV_RB1KXkA-qbSn9LYokk,23132 +bitblas/3rdparty/cutlass/include/cutlass/gemm/warp/mma_complex_tensor_op_tile_iterator_sm80.h,sha256=oF5m8NAIGthwwR1MWuYZ8JYHvsT2DR9gx-yKUQYG8BM,78519 +bitblas/3rdparty/cutlass/include/cutlass/gemm/warp/mma_gaussian_complex_tensor_op.h,sha256=S_qUs6K8d4muWIAV1jO8vQMLh6dOn-XTVdRk-8ecLdA,21178 +bitblas/3rdparty/cutlass/include/cutlass/gemm/warp/mma_gaussian_complex_tensor_op_tile_iterator_sm80.h,sha256=XpkckfVE_gK6GCdQiBcsWCXILHrnnAvkClPJCJCdN58,14589 +bitblas/3rdparty/cutlass/include/cutlass/gemm/warp/mma_planar_complex.h,sha256=B46GlnNK7un_MmuUcKfHuIhcv5r_6XnWbQ1JjKeLa0s,6144 +bitblas/3rdparty/cutlass/include/cutlass/gemm/warp/mma_simt.h,sha256=gyt_pzR2V_GySFTzT1HnvcQQdicmACRr0CBWOwtX_Ec,8419 +bitblas/3rdparty/cutlass/include/cutlass/gemm/warp/mma_simt_policy.h,sha256=ydnzkJbaEoj4gjMIVGGE7_sI7_BhT5_gjhOi3zoS5gQ,3079 +bitblas/3rdparty/cutlass/include/cutlass/gemm/warp/mma_simt_tile_iterator.h,sha256=uHhmZiY5yV31bRLaI9J-umaajjo-SIfnp7usWSMP974,59793 +bitblas/3rdparty/cutlass/include/cutlass/gemm/warp/mma_sparse_tensor_op.h,sha256=JqLjsIut3UmY0LI2OXNrpw50I1uh2vPcsCCn02oodkY,11758 +bitblas/3rdparty/cutlass/include/cutlass/gemm/warp/mma_tensor_op.h,sha256=L-1xkIFtyk3N4oaD65ZT_b2L8s5AIe7B57LoqA9RAxU,14407 +bitblas/3rdparty/cutlass/include/cutlass/gemm/warp/mma_tensor_op_fast_f32.h,sha256=f-oHFT77Sj0ZXfv8jZcvdy0vpzHzr-oieKFC15-jOdI,15721 +bitblas/3rdparty/cutlass/include/cutlass/gemm/warp/mma_tensor_op_fragment_iterator.h,sha256=pgTvQnpPVWaX7us16KsLAduWI_pqkNOWUsg89yP3bfw,18643 +bitblas/3rdparty/cutlass/include/cutlass/gemm/warp/mma_tensor_op_policy.h,sha256=MXzmUBfmvMig8c24Sg2zEsdsXX5HRM6gl68N6L41L4w,2939 +bitblas/3rdparty/cutlass/include/cutlass/gemm/warp/mma_tensor_op_sm70.h,sha256=xPtrNXPbz03JDGqRaloKtzchL3k6XnMkrYuGkfJRmX0,8966 +bitblas/3rdparty/cutlass/include/cutlass/gemm/warp/mma_tensor_op_tile_access_iterator.h,sha256=WUWzxc5h-CtJouRyvnE-DhzgaiPByk2YuZ3wB7V0k7E,11017 +bitblas/3rdparty/cutlass/include/cutlass/gemm/warp/mma_tensor_op_tile_iterator.h,sha256=9oj3eQAdmoeQm6hJAJhjOdEoTbR8GEjmLVbjAC4rAZU,135937 +bitblas/3rdparty/cutlass/include/cutlass/gemm/warp/mma_tensor_op_tile_iterator_sm70.h,sha256=U5Et8DvYRsSPqCE13ZyMjbxGVtlrSe-QUNKAJL7aiDY,99553 +bitblas/3rdparty/cutlass/include/cutlass/gemm/warp/mma_tensor_op_tile_iterator_sm80.h,sha256=aEDe8rCDBMwlcKKFrDapvLU40toAPDdXpXn_eZVxuJA,75040 +bitblas/3rdparty/cutlass/include/cutlass/gemm/warp/mma_tensor_op_tile_iterator_sparse.h,sha256=EHfBs2sn-YgLaR8yEYucrwRbT4968jZfggiPDJgpSgA,13151 +bitblas/3rdparty/cutlass/include/cutlass/gemm/warp/mma_tensor_op_tile_iterator_wmma.h,sha256=ui708zVsdSM6Dcd4RdbnPo8FpgxO724RrXa3t814X10,27101 +bitblas/3rdparty/cutlass/include/cutlass/gemm/warp/mma_tensor_op_wmma.h,sha256=gQUgxuBuIueyfgltlJsvf_u0g1FTHgSFzyJzaDa257A,7241 +bitblas/3rdparty/cutlass/include/cutlass/gemm/warp/mma_with_reduction_tensor_op.h,sha256=ByJKAcQYUtYzUO5VSCKbZPUl8sZXEUr-Lns7FcLJ3n4,17303 +bitblas/3rdparty/cutlass/include/cutlass/gemm/warp/scale_bias_tile_iterator.h,sha256=M5CJq4pQXd0GmZVVXNQamZyaQUcyx5k-VMVqdpAzAjc,19101 +bitblas/3rdparty/cutlass/include/cutlass/gemm/warp/softmax_scale_bias_transform.h,sha256=lefohougoM4GfrU3QShpFkMCQjg1L7qDORb5tAyiw3Y,4610 +bitblas/3rdparty/cutlass/include/cutlass/gemm/warp/tile_iterator_planar_complex.h,sha256=41toIvlksmL6I8db0anBitVOUBg_0GVLaEuwarm-DW0,8728 +bitblas/3rdparty/cutlass/include/cutlass/gemm_coord.h,sha256=VLU9olM3BTqIDA4heaYqTAytXaRftr8n1sBFSTgleE8,10592 +bitblas/3rdparty/cutlass/include/cutlass/gemm_coord.hpp,sha256=SF-X5gRZh4dackjbIaWA6z2JdlZgFbVsO5s6j0wmsmg,2848 +bitblas/3rdparty/cutlass/include/cutlass/half.h,sha256=EKahhxr9mRlbWfePM8eG5SU_hEsli9Xvjeg-_dYLDiY,24009 +bitblas/3rdparty/cutlass/include/cutlass/integer_subbyte.h,sha256=ii-xMZ8_EQBPmGsYV28BNAvp_gQOTKYGbDL8718wNKo,7353 +bitblas/3rdparty/cutlass/include/cutlass/kernel_hardware_info.h,sha256=hoie5YZ9VFYaBTAejkiVOWBwLRsZ0FHk5PULlsZTMx8,3193 +bitblas/3rdparty/cutlass/include/cutlass/kernel_hardware_info.hpp,sha256=xbRLKvgHeKdLJhb9ZaVBJVKhzwsz00Qfg2pBYjueMBI,2006 +bitblas/3rdparty/cutlass/include/cutlass/kernel_launch.h,sha256=pmM3poTvVtOXekGXblpPP5reInm-E0i8rF9CqlMWXQU,2801 +bitblas/3rdparty/cutlass/include/cutlass/layout/layout.h,sha256=iDmT3SjF3uizVpONXgMcWtYke528pPV9ITi9hJsMBrk,3020 +bitblas/3rdparty/cutlass/include/cutlass/layout/matrix.h,sha256=-JHQ7Tyr5FCEmmtlfb7pErB-4epvX2OjVosuMAgEFX8,35129 +bitblas/3rdparty/cutlass/include/cutlass/layout/permute.h,sha256=OnYIjolnjifZrI00_HiMle_svJOOqCG5lLq2vESNjXM,24906 +bitblas/3rdparty/cutlass/include/cutlass/layout/pitch_linear.h,sha256=v6gcXHw6QVYZurZV6r6rk5Gqjflj495slYpxausxnmA,5107 +bitblas/3rdparty/cutlass/include/cutlass/layout/tensor.h,sha256=5b_q4QQhD8UMgRiDlBsJ7ueg_srbFr2yxJ9q5zS7wDY,18383 +bitblas/3rdparty/cutlass/include/cutlass/layout/tensor_op_multiplicand_sm70.h,sha256=S6RKlH6CiZx2CRP3nl3vULhsYQwMIGUv7Eqsnvc-gQE,29599 +bitblas/3rdparty/cutlass/include/cutlass/layout/tensor_op_multiplicand_sm75.h,sha256=1jI6b8t6PTa4Gy52jo0QD6hBBeiS8oGGDyRK2rs0NMg,33137 +bitblas/3rdparty/cutlass/include/cutlass/layout/tensor_op_multiplicand_sm80.h,sha256=5pZpl0TF-w5t-4A53NGLTngHk9BeGnM_0ulZK0js7-k,29336 +bitblas/3rdparty/cutlass/include/cutlass/layout/vector.h,sha256=MancrlKB57Jo6jtHgUxFGeuOoxyZFExI_goeMv7Yd4Y,3354 +bitblas/3rdparty/cutlass/include/cutlass/matrix.h,sha256=OvY3_bCKGNkIiJyiMF9pb66jU20nezbZ2BBBHTTtBjs,364115 +bitblas/3rdparty/cutlass/include/cutlass/matrix_coord.h,sha256=0wt4E8yeh7dnl7_r9cSGvF6zg9hmjIE2swk-E4VZc3Y,4991 +bitblas/3rdparty/cutlass/include/cutlass/matrix_shape.h,sha256=eVtNUdDDLH9o0Q7bWcgQRbam5jQh-KiPZ120UbBv9H4,2726 +bitblas/3rdparty/cutlass/include/cutlass/numeric_conversion.h,sha256=FqNGLTLpLe32yge9mb8nvnLCFL3Kh3mOi0extwBgXd4,72722 +bitblas/3rdparty/cutlass/include/cutlass/numeric_size.h,sha256=gGEmIbhP7QxjCnsiRrOBZzwoqQJrfSH06eRQ2jQcLVA,3605 +bitblas/3rdparty/cutlass/include/cutlass/numeric_types.h,sha256=7-4Rl2P5X_XNX2v-QFEPXtDD7qkA49hyq_ELRUhfYZE,3445 +bitblas/3rdparty/cutlass/include/cutlass/pipeline/pipeline.hpp,sha256=ew3F3GcsapNiVMMmWLBTb1q4Wmq3FZd3snPbUHRkzyc,2091 +bitblas/3rdparty/cutlass/include/cutlass/pipeline/sm90_pipeline.hpp,sha256=onBlwYe6BzqPWxNfXlxLYjbHE1OHWG0Pz-_ZK8l5rG4,36593 +bitblas/3rdparty/cutlass/include/cutlass/pitch_linear_coord.h,sha256=5Qlk7V3XO90S5S7r0QxS0OUv68MZo8VqxhnVfWDGiQ0,5492 +bitblas/3rdparty/cutlass/include/cutlass/platform/platform.h,sha256=XShCBVCo76pUmZpYMGO__RsGBWK9qor6IxXHur-Mjwc,28165 +bitblas/3rdparty/cutlass/include/cutlass/predicate_vector.h,sha256=bjEKJclDxRKswG7_8tRzkKD-sjpkqqXBmVvqJvVElWI,15565 +bitblas/3rdparty/cutlass/include/cutlass/quaternion.h,sha256=qQ2GM_-l7YnNnBm31BwYzMiGlcNHDmI-mOTnVldOBwU,20891 +bitblas/3rdparty/cutlass/include/cutlass/real.h,sha256=oyB6kCq-6KXXAGeApPIPF_Mqv7IiNBzuDFuABzOnj68,2369 +bitblas/3rdparty/cutlass/include/cutlass/reduction/device/reduce_split_k.h,sha256=e2-FQWTAmOoUiUf4wxnQHhIuRVhDejC55T9xjgfnpqc,6823 +bitblas/3rdparty/cutlass/include/cutlass/reduction/device/tensor_reduce.h,sha256=TtavDAVgnftwyqL6MCYprccLlARAbEQKL9-M6mEsCUQ,8152 +bitblas/3rdparty/cutlass/include/cutlass/reduction/device/tensor_reduce_affine_contiguous.h,sha256=USPopfBMok1pakQMSZplbZGzcVtExmnV7wuMS6FdD7o,11579 +bitblas/3rdparty/cutlass/include/cutlass/reduction/device/tensor_reduce_affine_strided.h,sha256=NR7Ncc1PYhU1c97Rq1EVtOazO5BUYu5re9cQd681bys,11448 +bitblas/3rdparty/cutlass/include/cutlass/reduction/kernel/reduce_softmax_final.h,sha256=-6W911-OHwrnGe-cQR1D8ZRmHx0Om8RR1iWjXtmrYwI,8762 +bitblas/3rdparty/cutlass/include/cutlass/reduction/kernel/reduce_split_k.h,sha256=Lrdxxgi7xu7q1Ub3uNTiocaYbGKnCCk8r2VlMY1gU2E,7897 +bitblas/3rdparty/cutlass/include/cutlass/reduction/kernel/tensor_reduce_affine_contiguous.h,sha256=wX-4GMu7SQ8RGElTHY2bXf5SlH1ez41KdSaCx65dcNI,20685 +bitblas/3rdparty/cutlass/include/cutlass/reduction/kernel/tensor_reduce_affine_strided.h,sha256=C8XAXKIklI4LhedNwugLxpOPxfjZ5ve5MZa0cNT4U3g,21662 +bitblas/3rdparty/cutlass/include/cutlass/reduction/thread/reduce.h,sha256=yv99--zLpDQ64lAn32FJmmS8NWqq0nAYbbp54cbON0w,7208 +bitblas/3rdparty/cutlass/include/cutlass/reduction/thread/reduction_operators.h,sha256=aJFiaNIxf9mtuPqvqL_mFLhaItUKgKL4eHOA0zowLE4,6790 +bitblas/3rdparty/cutlass/include/cutlass/reduction/threadblock_swizzle.h,sha256=GhjycomYl8Tpixt7RLIdcNEBs9Wf7zAY_0bfglMT07c,2936 +bitblas/3rdparty/cutlass/include/cutlass/relatively_equal.h,sha256=PJx-VrRoc4Wlf3pGLbxL-_tyKRQKSI8IvE71Pkw5TWg,6460 +bitblas/3rdparty/cutlass/include/cutlass/semaphore.h,sha256=17vFsd-URZMfzNAXv-giG_PfMBt22wVHHzCTnUd4IYg,3984 +bitblas/3rdparty/cutlass/include/cutlass/subbyte_reference.h,sha256=1UprhAc6CAoUfTQnzzC2ZPoQe2D7ZrMELFNjRaJQVF0,36697 +bitblas/3rdparty/cutlass/include/cutlass/tensor_coord.h,sha256=jZhH2zf7sRYipENz80df2iM5BcDkBMitENlEIZi_bss,8964 +bitblas/3rdparty/cutlass/include/cutlass/tensor_ref.h,sha256=7YXqyRuMRG3KjVFpggSnHt6G0ZcZ4ZXqgmeYuZcik38,12207 +bitblas/3rdparty/cutlass/include/cutlass/tensor_ref_planar_complex.h,sha256=pMHbll4oi5cJnFjVzA-_Nx-ev8KwYI_EFQ-Kdd20hxE,11201 +bitblas/3rdparty/cutlass/include/cutlass/tensor_view.h,sha256=nS_wOlSizVew6Xbo81lNRE95sxvV9JyJnZhwn9u4NXg,9509 +bitblas/3rdparty/cutlass/include/cutlass/tensor_view_planar_complex.h,sha256=xzzMOBkLEzh58bbGZ8ypXdoAT95RHddS0bQXTq_LYsE,10250 +bitblas/3rdparty/cutlass/include/cutlass/tfloat32.h,sha256=zRlCyQuBZXM7HrUk6LX9hcgNWJT-fiI3rFRYYGsnhq4,13017 +bitblas/3rdparty/cutlass/include/cutlass/thread/matrix.h,sha256=MhmxD5gEbc1MDginWhQRJPOVimzIDA1BDhMMTWBqdJ8,5893 +bitblas/3rdparty/cutlass/include/cutlass/trace.h,sha256=d_IFVKSWBsuvRPu5te2cCjUyCWg8noTUHBPMncYzMH0,2581 +bitblas/3rdparty/cutlass/include/cutlass/transform/collective/sm90_wgmma_transpose.hpp,sha256=_4e2B9WDs10YmSagoZnuJfAbKgSFCdCSrx446dxiGik,33733 +bitblas/3rdparty/cutlass/include/cutlass/transform/pitch_linear_thread_map.h,sha256=unepyAOx9bidJk1xE-azPeP0_gMIr22MXHXbjVjanvY,33349 +bitblas/3rdparty/cutlass/include/cutlass/transform/thread/transpose.h,sha256=6FgBtdno8uaQJUZsJiiON7NWtbwBuyFVE7Xvi5SnJ3I,3835 +bitblas/3rdparty/cutlass/include/cutlass/transform/thread/unary_op.h,sha256=4EmPeB-58iehQwG0v17VkevZ-A_qI9xN3GnTsjwBiMs,4309 +bitblas/3rdparty/cutlass/include/cutlass/transform/threadblock/ell_iterator.h,sha256=_x-68ikPF0uABIIYCVnLDxiyVPjWyXQ80d1WlXxtDfI,6181 +bitblas/3rdparty/cutlass/include/cutlass/transform/threadblock/ell_predicated_tile_access_iterator.h,sha256=ZNuCEyFG4j5BdMnzrMH-bBmBKzRm2FLg_fZKsZ3aYdE,44443 +bitblas/3rdparty/cutlass/include/cutlass/transform/threadblock/ell_predicated_tile_iterator.h,sha256=cmtLO7dbOE_ftOJ-ZMiieES31wo82u-ZV7Xth-mtNh0,44309 +bitblas/3rdparty/cutlass/include/cutlass/transform/threadblock/predicated_scale_bias_vector_access_iterator.h,sha256=6L-LtU2CBJFOQu5Ka7HGrRMHTVLn0lIGFzZrxVOrAm4,12890 +bitblas/3rdparty/cutlass/include/cutlass/transform/threadblock/predicated_scale_bias_vector_iterator.h,sha256=OzTBFKfehggv2SKZ4bvQKjeHs0pZs5Z7nJxhHKPZAVM,11097 +bitblas/3rdparty/cutlass/include/cutlass/transform/threadblock/predicated_tile_access_iterator.h,sha256=1fxv1JvyXGXUEE434NG6Xr9ZiSGCKIisUV_2CN1eW9U,72537 +bitblas/3rdparty/cutlass/include/cutlass/transform/threadblock/predicated_tile_access_iterator_2dthreadtile.h,sha256=ahscQJ_3hwPajnOXpst-Oc6IxgW2i_DI052lQ-Z-Qcg,28232 +bitblas/3rdparty/cutlass/include/cutlass/transform/threadblock/predicated_tile_access_iterator_params.h,sha256=7nP8lRiXPKxwaKp2LnlffNBl2AyWkPPPflYAGRVHviM,10715 +bitblas/3rdparty/cutlass/include/cutlass/transform/threadblock/predicated_tile_access_iterator_triangular_matrix.h,sha256=ttWRl4Zp-aV6u2Z6pab_jo4sbRdRooFQc3-tQH0QriU,31412 +bitblas/3rdparty/cutlass/include/cutlass/transform/threadblock/predicated_tile_iterator.h,sha256=6hIEeIELNYFotdiUqV-JHOisK3UFDUcS87gGPTROApg,62949 +bitblas/3rdparty/cutlass/include/cutlass/transform/threadblock/predicated_tile_iterator_2dthreadtile.h,sha256=Z5BumkelWiAiVdQHlWcUX98YTU2NzLvx5koR4AJwPGk,27175 +bitblas/3rdparty/cutlass/include/cutlass/transform/threadblock/predicated_tile_iterator_triangular_matrix.h,sha256=ZDO_ks7r37jAUuJ2dueudTDqcZqp-9iJKYQNRT7DgqI,28064 +bitblas/3rdparty/cutlass/include/cutlass/transform/threadblock/predicated_vector_access_iterator.h,sha256=nW4lFn9XEBP27gaVU7m7w6irjqmveU2mWCMhwpdJZNc,13088 +bitblas/3rdparty/cutlass/include/cutlass/transform/threadblock/regular_scale_bias_vector_access_iterator.h,sha256=7aAevMby1v_QVUgCm-aqkRWDHElv8jHGg5cOEZPC6Qk,8232 +bitblas/3rdparty/cutlass/include/cutlass/transform/threadblock/regular_tile_access_iterator.h,sha256=M6tvdrDBchE6GzW-AgB0LEsu4gVxDWTUdF_U-A5ve1U,2638 +bitblas/3rdparty/cutlass/include/cutlass/transform/threadblock/regular_tile_access_iterator_pitch_linear.h,sha256=Z8HS_qY3vN7GhUVYctCUQmC-yFphNphujypIs2W05eo,13283 +bitblas/3rdparty/cutlass/include/cutlass/transform/threadblock/regular_tile_access_iterator_pitch_linear_direct_conv.h,sha256=Yk2zB_l3ELu1VF94IoAP_F1JbbIzmzc4lif9SQc0MwM,18623 +bitblas/3rdparty/cutlass/include/cutlass/transform/threadblock/regular_tile_access_iterator_tensor_op.h,sha256=xS6l3OpKkUxz1hat5adEKVjYsv4l-0Y2XLujFjKQwfo,27922 +bitblas/3rdparty/cutlass/include/cutlass/transform/threadblock/regular_tile_access_iterator_tensor_op_sm80.h,sha256=O8Z5DQhRPvLRT0jd2FDpcRZusktS73niJFaDfN4U_CA,47789 +bitblas/3rdparty/cutlass/include/cutlass/transform/threadblock/regular_tile_iterator.h,sha256=Ss8fW27zQcPozmPxNyvm8qFbsY9pXGefpUquS3rT7iE,2616 +bitblas/3rdparty/cutlass/include/cutlass/transform/threadblock/regular_tile_iterator_pitch_linear.h,sha256=Ml__hojDLTjXw3kxPO9VKJ0QL1RpBEBVsIDcgkv5qsE,16508 +bitblas/3rdparty/cutlass/include/cutlass/transform/threadblock/regular_tile_iterator_pitch_linear_2dthreadtile.h,sha256=_zHqVSWjGoot6S1FQnKsCByTYGToAcxOg-_9KspLX9I,15486 +bitblas/3rdparty/cutlass/include/cutlass/transform/threadblock/regular_tile_iterator_tensor_op.h,sha256=lE4fGig2JKBjobD7T3RlBzCwhpdRjiPsq0A97Cuu8Nk,36050 +bitblas/3rdparty/cutlass/include/cutlass/transform/threadblock/regular_tile_iterator_tensor_op_sm70.h,sha256=mfzl4kuesLWw3wk8NC1kq3qy5VCjb8W9L8HrIKJPMNM,43663 +bitblas/3rdparty/cutlass/include/cutlass/transform/threadblock/vector_iterator.h,sha256=3kwObkmTFDXloYlkz_iZNtKpNTgtQHm3JqEkpNTuHSA,5226 +bitblas/3rdparty/cutlass/include/cutlass/transform/warp/vector_fragment_iterator.h,sha256=ikEsOWCcetezVf3yetAOQgRyCekD52wUsythz_iQECE,8828 +bitblas/3rdparty/cutlass/include/cutlass/uint128.h,sha256=pmCy6QkwSI9D2hKFEnhFXzXJlpM9j5ww96oRScqDvZY,8120 +bitblas/3rdparty/cutlass/include/cutlass/wmma_array.h,sha256=mzjzUU4gnykkh5h2SZBELBV2cwJg3JdFqi_DDTApyBA,4543 +bitblas/3rdparty/cutlass/include/cutlass/workspace.h,sha256=GGSJEbKBCCu_6dxnrt2aZnIh0_FMSgP6QhkBzyJNNaU,3388 +bitblas/3rdparty/cutlass/media/docs/build/building_in_windows_with_visual_studio.md,sha256=2NA6oMWL9_7aYVzwfRk-tcVSOqyRW3LrHk-leEB1wFE,4006 +bitblas/3rdparty/cutlass/media/docs/build/building_with_clang_as_host_compiler.md,sha256=9tJclugACxQbrNHhK0HNntFeIaO4ss21RgFO3Ul5_Cc,1657 +bitblas/3rdparty/cutlass/media/docs/code_organization.md,sha256=phfCKYLfDyqKAv7Q0bg_S6kBXeSMM1kkbHxyQoGC_b0,12245 +bitblas/3rdparty/cutlass/media/docs/cute/00_quickstart.md,sha256=br8AybVoZ5nWZ2XWQCapPl2bwiIHSVIAcVTvRLGgZwc,4825 +bitblas/3rdparty/cutlass/media/docs/cute/01_layout.md,sha256=e2-Thc7UewieWZzWhQ-_oJJgA60DF1zDo3Nh4BkRXLw,9162 +bitblas/3rdparty/cutlass/media/docs/cute/02_layout_operations.md,sha256=O12MuwKTbRwkogqLwe5E2lYbE-x1dRPwXOx9kMn-GzE,34867 +bitblas/3rdparty/cutlass/media/docs/cute/03_tensor.md,sha256=WsZOZaXUbxAk_6M0slDYaay46Fm90Nh39TAnKrTxHsU,10159 +bitblas/3rdparty/cutlass/media/docs/cute/04_algorithms.md,sha256=jl24jTjsl6J2XIcMa44FjZQFYmsQJ5eCwjNPjDbWgWo,8382 +bitblas/3rdparty/cutlass/media/docs/cute/0t_mma_atom.md,sha256=rKjNyxPTN8DUa3PV1cqe5R4ZR5T28qBUtoMzBIzhGEM,19299 +bitblas/3rdparty/cutlass/media/docs/cute/0x_gemm_tutorial.md,sha256=dBasSiV3uiubVR3RZHni8dhvyXAXp1rVkGFSDF6AUHs,34639 +bitblas/3rdparty/cutlass/media/docs/cute/0y_predication.md,sha256=kmOcQo-iSkjZPy3s0pRZ5RhPp2lE-Cpi7pU853fs0Q0,8113 +bitblas/3rdparty/cutlass/media/docs/cute/0z_tma_tensors.md,sha256=mGCY-inv7v5FHXwN-0x1S1YSVlcdN5uXzroRitRW-EI,3386 +bitblas/3rdparty/cutlass/media/docs/cutlass_3x_backwards_compatibility.md,sha256=kiIcc8CaTzxxFpBX8VgRLuk0z6j2-yTiTqwvn6Z5UAI,23025 +bitblas/3rdparty/cutlass/media/docs/cutlass_3x_design.md,sha256=_22EcEm3Xrsg8jknSKNT5jzEWNFXuIc4TEQwYWJp4K4,6857 +bitblas/3rdparty/cutlass/media/docs/doxygen_mainpage.md,sha256=2ivCJLrIuvj19ijcTS6ziyFnjJyiPc1eKQdb8nmBhcA,3281 +bitblas/3rdparty/cutlass/media/docs/efficient_gemm.md,sha256=WlICMdYtvJ5iUfp9QNLytLBwFfhB3rTJTrzobchXr64,19727 +bitblas/3rdparty/cutlass/media/docs/functionality.md,sha256=IafXmG2KAlHO3uc62PZgpQHpxtv6ndTAFFbYLDgDiRo,26303 +bitblas/3rdparty/cutlass/media/docs/fundamental_types.md,sha256=BGP9a00nQnNaBeoZA_AD5B9dczVjMgPt7Lym2zbEZ74,14076 +bitblas/3rdparty/cutlass/media/docs/gemm_api.md,sha256=I3Clwx2KAESqPtM__3XqnpaHxMAk4jYH22h2t8B_k2g,21487 +bitblas/3rdparty/cutlass/media/docs/gemm_api_3x.md,sha256=HK91c1nM3f7z_TERICSpPSUlwbptMqtmSa1cU4aYcRI,30903 +bitblas/3rdparty/cutlass/media/docs/grouped_scheduler.md,sha256=e1Gn1n4mtk7i4joPBV4YI4GvR8T34l8tXHJ0cLBuWEg,19482 +bitblas/3rdparty/cutlass/media/docs/implicit_gemm_convolution.md,sha256=FIy6_m-iyelhsxi-dDMD4T65e5ATV9BFaSGIE3SdeSs,36997 +bitblas/3rdparty/cutlass/media/docs/layout.md,sha256=56PusUu8Ot8G5vclMIg-fjenfF2FpwmI0gJ9USvEG9g,10960 +bitblas/3rdparty/cutlass/media/docs/pipeline.md,sha256=Gnwcfi4PH-vlv5HkaM492NZYJLKr9pAlKLIqj7PCQ60,8740 +bitblas/3rdparty/cutlass/media/docs/profiler.md,sha256=9mHIOZERE-AQBnMP352E_XQliHYObFEgOv5KuASf1hg,30687 +bitblas/3rdparty/cutlass/media/docs/programming_guidelines.md,sha256=WzpEmgDW9Dg5hCobprFAccSgEeL7hxLyroP4IV4o8WA,28642 +bitblas/3rdparty/cutlass/media/docs/quickstart.md,sha256=jGEvtkLy9f_pvFCxQgtHI3T-bDevm9Md_t0enHqFLUs,25253 +bitblas/3rdparty/cutlass/media/docs/terminology.md,sha256=JbCS72BUNwP8hGauqfmxm8ptX7vWN6PmDpE3FHsBtOc,6633 +bitblas/3rdparty/cutlass/media/docs/tile_iterator_concept.md,sha256=j4ea3kCnakOk1_zQcqgjNsVllmslt3XaOAgiAI1QE3M,22839 +bitblas/3rdparty/cutlass/media/docs/utilities.md,sha256=aOFk2x9znAP1dXPG8aQv70bhGN1z-t5MKUBng9wk_GU,12344 +bitblas/3rdparty/cutlass/media/images/13_example_block_resident_fusion.png,sha256=VqiUW91eQg1JAwfxl9JHhsr9fR-ePon5VyJg8JyP-q0,11949 +bitblas/3rdparty/cutlass/media/images/13_example_fusion.png,sha256=vfhpQpo66SFKTA82WkKURhhaFRM--bcaG1khfwg0WOo,16053 +bitblas/3rdparty/cutlass/media/images/13_example_rf_resident_fusion.png,sha256=E7t0k7ZVQsRXa668uXfo7npzi89f9cJCoxmJzCNsZfk,12038 +bitblas/3rdparty/cutlass/media/images/13_example_shmem_resident_fusion.png,sha256=yJCVH22cAduRebm3GseDM8TDA9eKopltnfZU7hCnKkU,18318 +bitblas/3rdparty/cutlass/media/images/conv2d-fprop-int4.png,sha256=UZOSTyTSy030IZZuGXN1_H68GHSnasOqlgwIVFbH92E,391882 +bitblas/3rdparty/cutlass/media/images/cute/HMMA.8x8x4.NT.png,sha256=-1sAaINxnvZfX7rPF-hDYDHy0TB-4cMuE5zJhdc4X40,547992 +bitblas/3rdparty/cutlass/media/images/cute/HMMA.8x8x4.quadpair.AB.png,sha256=pmzl3Kek5gVJvGMnyH1kvfeyeMk4pLtLLU1uVKD3L1s,609515 +bitblas/3rdparty/cutlass/media/images/cute/HMMA.8x8x4.quadpair.C.png,sha256=AQH_argSuxXkFD9iL_JrOp5lDkIVoH4CbSAC7zAXGGw,522137 +bitblas/3rdparty/cutlass/media/images/cute/gmma_coremat_cd_fp16.png,sha256=TlQSXPaJPINQXF_eVaJcZresl-DMbtLv9XrgSdsFhFg,137035 +bitblas/3rdparty/cutlass/media/images/cute/gmma_wg_n_slice.png,sha256=dGi3XXGFIxp1Jo_ek879THAGATAj26AkT2KUXjgLZCU,2007411 +bitblas/3rdparty/cutlass/media/images/cute/logical_divide-and-zipped_divide-2.png,sha256=VEL8lvSjAM9FiZFU5WXICt-OgwPUl2LqivrHKxQqk3Y,254099 +bitblas/3rdparty/cutlass/media/images/cute/logical_divide-and-zipped_divide.png,sha256=PLTjIrLntHkEpwxwCa6mfAk-7_1fQ1glkYFMZqBywdQ,250709 +bitblas/3rdparty/cutlass/media/images/cutlass-2.8-gemm-performance.png,sha256=o05niLDu5bllk8Gp7CXMp_r01TOVF_rayEndtZWHeJE,127094 +bitblas/3rdparty/cutlass/media/images/cutlass-2.9-implicit-gemm-performance.png,sha256=YdHTlVfIg_Blom0SN-EBCLl0Q6t27Y620gD_O_eK0bc,4767239 +bitblas/3rdparty/cutlass/media/images/cutlass-3.0-gemm-peak-performance.png,sha256=a4c8lJ9gxFtzi1qKFbl8RXVqvWIzMZpa_XOrGzZLZ9o,285327 +bitblas/3rdparty/cutlass/media/images/cutlass-3.1-gemm-peak-performance.png,sha256=oxmPznUNopn7yOCrRbI0HzBcKWjfcpbsrnJ3HbxGZ5Q,166773 +bitblas/3rdparty/cutlass/media/images/cutlass-gemm-components.png,sha256=n0IUD8RkwVTpjVH6MdMAFRW38IfCq4Mlu5OtgLP3Zs0,127050 +bitblas/3rdparty/cutlass/media/images/cutlass-layered-organization.png,sha256=METgJUY-RUliFDLWNyNA7OGYk0OEAwVPtzJ5RYhRC2Y,56248 +bitblas/3rdparty/cutlass/media/images/cutlass-logo-small.png,sha256=MjUthiTOUyUBdC7YA5cgq-_6fD8wHBDfK7nAynmIPTY,1488 +bitblas/3rdparty/cutlass/media/images/cutlass-performance-plot.png,sha256=hCa_r6gWjeGn8p87O6T7F7WR_I4j91A1FW5QYqqgvhU,69902 +bitblas/3rdparty/cutlass/media/images/cutlass-reduction-in-named-iterators.png,sha256=WUK3iMcRyninYmb90IOL63BWNzYLZi41mqwdTmCnKyM,333316 +bitblas/3rdparty/cutlass/media/images/cutlass-threadblock-gemm.png,sha256=r9u_ucCa6_3YaD7SHbpstj4p_-wcoRxOedzcavNW2uY,60809 +bitblas/3rdparty/cutlass/media/images/cutlass-threadblock-mma-pipelined.png,sha256=D3qKGERmEaALeaJR4BeJaChFc3VS5pZYGz8scOBXjnE,177404 +bitblas/3rdparty/cutlass/media/images/cutlass-tile-iteration.png,sha256=gU7s7neYM7AfMuXuRFMYDOQukPxmTTXJtENvhjJtGdo,76377 +bitblas/3rdparty/cutlass/media/images/cutlass-tile-structure.png,sha256=yAAZvEPbZQryjQ7sO9LQqvkvFESYjRzn136jQy4YVBg,116377 +bitblas/3rdparty/cutlass/media/images/cutlass-warp-level-gemm-api-instantiation.png,sha256=Fa5XDXvStXP4S1ZbgTPnhobQv-HzKNbjvss1MHJS6wM,166485 +bitblas/3rdparty/cutlass/media/images/cutlass-warp-level-gemm-operation.png,sha256=kPGWGlkzQCzwZ5cL7wD9oQNC3U6yy27pvKIwUDXEfxg,75734 +bitblas/3rdparty/cutlass/media/images/cutlass-warp-thread-tile-structure.png,sha256=LmucCIqYxn5utJySb-xRVZvGigxMXiJneNzc1E1QmWk,179689 +bitblas/3rdparty/cutlass/media/images/gemm-hierarchy-with-epilogue-no-labels.png,sha256=q6wx3eEEFAvi5biLx3cQy3YGerVoq_A5zPd4n2q_uM4,184294 +bitblas/3rdparty/cutlass/media/images/gemm-hierarchy-with-epilogue.png,sha256=iDAnR0FsUtxT7-6ezzdf0A_wHDsQiJqwTvtHuqvMKkU,256447 +bitblas/3rdparty/cutlass/media/images/gemm-structural-components.png,sha256=DuNJSsHDR-8_Gu5wGsAq6qeThHKBTUIlxdjBfkrRBeo,245863 +bitblas/3rdparty/cutlass/media/images/grouped-gemm-schedule-2x2.png,sha256=lmQ0cBaAbj8NvfgP0Zz3SyzE0nPBhCVkRe2ffSaSJRM,6292 +bitblas/3rdparty/cutlass/media/images/grouped-gemm-schedule-varied.png,sha256=J0VQIrHX9p00SlUb2MMdmyzLynXHlHb5vlIk51ucGcQ,5913 +bitblas/3rdparty/cutlass/media/images/grouped-syr2k-schedule-3x3.png,sha256=A23RL6Lg-b3DkFnNVeYnA_yoSEnqjdHKPNcY5Zn5FTw,4513 +bitblas/3rdparty/cutlass/media/images/grouped-syr2k-schedule-ideal.png,sha256=X7Ry0QwBxggzCougzAWJw-WmLS0fYgK_DuNnAt_tImc,6666 +bitblas/3rdparty/cutlass/media/images/grouped-syr2k-schedule-macro.png,sha256=neyH56XJ-tn5Tp4T00YJSWrEcH-9nomxmrOh0ETuF4o,8418 +bitblas/3rdparty/cutlass/media/images/grouped-syr2k-schedule-using-grouped-gemm-scheduler.png,sha256=6bC_QApZLHkX-TZWyE3rBgJ7G8Ton_63wCiy_XoApds,7030 +bitblas/3rdparty/cutlass/media/images/ldmatrix-8x128bx4.png,sha256=ZbVVip_c2NjTQaA9EBwlIF2gKAr_duxcQzOJtgycuaA,560084 +bitblas/3rdparty/cutlass/media/images/ldmatrix-tensorop-32x32x32.png,sha256=Ka_t9GY7XDB0dFITR1lvWFvcZM3TGKAXbbq8wLy3Sh4,1219789 +bitblas/3rdparty/cutlass/media/images/mma-8x8x32.png,sha256=Cyoj_fiXAurXgLidS--9UaY3jCPTwqFK-ZEae-uG9uc,215559 +bitblas/3rdparty/cutlass/media/images/software-pipeline.png,sha256=r4ZdU2YEcxrfvY_fSUy5_jD2R0KI79TWiLuPw9KVces,224299 +bitblas/3rdparty/cutlass/media/images/tensor-op-permuted-smem-layout-TN-k0.png,sha256=8SjypczMrZfegXl06cpU5sIltyz15bXN9PjX28fPbdc,181688 +bitblas/3rdparty/cutlass/media/images/tensor-op-permuted-smem-layout-TN-k1.png,sha256=YUG0vKB9InAi8RdfR3Guc754WAblxGgRnpAnoOd720c,186274 +bitblas/3rdparty/cutlass/media/images/tensor-op-permuted-smem-layout-TN.png,sha256=AAuUqgJSRmYLQlkEXBPYsAXkCFJLCb7woKyqDTsk5A4,265401 +bitblas/3rdparty/cutlass/python/README.md,sha256=cSbVQLoQOcIzSvS70MzfYOwjxMVt6_EEkxxx0i6yUpw,8514 +bitblas/3rdparty/cutlass/python/__pycache__/setup.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/__pycache__/setup_library.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/__pycache__/setup_pycute.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/cutlass/__init__.py,sha256=q6rJkXuWDo8Gu6CCXflTePIkm24kvBXyi3ngPvLruEE,5149 +bitblas/3rdparty/cutlass/python/cutlass/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/cutlass/__pycache__/library_defaults.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/cutlass/__pycache__/shape.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/cutlass/__pycache__/swizzle.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/cutlass/backend/__init__.py,sha256=D_BMRA-4_dyuVyV51UdePkcgtioUijcmvAK5CmmVU10,779 +bitblas/3rdparty/cutlass/python/cutlass/backend/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/cutlass/backend/__pycache__/arguments.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/cutlass/backend/__pycache__/c_types.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/cutlass/backend/__pycache__/compiler.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/cutlass/backend/__pycache__/conv2d_operation.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/cutlass/backend/__pycache__/epilogue.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/cutlass/backend/__pycache__/frontend.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/cutlass/backend/__pycache__/gemm_operation.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/cutlass/backend/__pycache__/library.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/cutlass/backend/__pycache__/memory_manager.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/cutlass/backend/__pycache__/operation.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/cutlass/backend/__pycache__/reduction_operation.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/cutlass/backend/__pycache__/type_hint.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/cutlass/backend/arguments.py,sha256=lk_Jmdi4Hq2wgS21cBtHere5Q382njSTRfe-XjtdyaQ,5019 +bitblas/3rdparty/cutlass/python/cutlass/backend/c_types.py,sha256=MPDmyp5E3TwADy5_egzS3sA41s25CSjflaPhkfsv8Go,21101 +bitblas/3rdparty/cutlass/python/cutlass/backend/compiler.py,sha256=9zHqi_GfQZI_Rj-mVgo5lRk21Ok_bJg2PJCxy0qrTmE,18313 +bitblas/3rdparty/cutlass/python/cutlass/backend/conv2d_operation.py,sha256=fgn8LFM7BEcslzIcjdYTLEGfA-BkK8n9qBxT7Llkxbc,26528 +bitblas/3rdparty/cutlass/python/cutlass/backend/epilogue.py,sha256=Xd00qQgLrZoi-WNfbJtKSoRTzXKjdgjHw6n2MolxSao,16708 +bitblas/3rdparty/cutlass/python/cutlass/backend/evt/__init__.py,sha256=C38QRONvMtt-R6WK6QRx0xsDGYiX23pUOOAAXiq_f88,1885 +bitblas/3rdparty/cutlass/python/cutlass/backend/evt/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/cutlass/backend/evt/__pycache__/epilogue.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/cutlass/backend/evt/backend/__init__.py,sha256=dPkU8BtjO798GxATGwrcEwr5rdoyGUt_4ghwkblaYko,2047 +bitblas/3rdparty/cutlass/python/cutlass/backend/evt/backend/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/cutlass/backend/evt/backend/__pycache__/emitter_base.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/cutlass/backend/evt/backend/__pycache__/sm80_emitter.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/cutlass/backend/evt/backend/__pycache__/sm80_nodes.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/cutlass/backend/evt/backend/__pycache__/sm90_emitter.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/cutlass/backend/evt/backend/__pycache__/sm90_nodes.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/cutlass/backend/evt/backend/emitter_base.py,sha256=IUDSb8dz1thuB8TIn8rCZ6WgSC-Y1WQrRJ_FImwnMWU,6445 +bitblas/3rdparty/cutlass/python/cutlass/backend/evt/backend/sm80_emitter.py,sha256=weZ0YMYIgEQ2TF-iP7j31rguxt-V_vkPQ7wQsH5Il-o,2252 +bitblas/3rdparty/cutlass/python/cutlass/backend/evt/backend/sm80_nodes.py,sha256=r23VVkeSD6p_-c0zfWhn5iGIS-a3dg5KGZ6_X4VwaVA,7559 +bitblas/3rdparty/cutlass/python/cutlass/backend/evt/backend/sm90_emitter.py,sha256=U7SiMKRy7roj4Ia9DASn8NSFZka0VXnceLEC4ZROFfA,3820 +bitblas/3rdparty/cutlass/python/cutlass/backend/evt/backend/sm90_nodes.py,sha256=NNA37ru1l7Eudio_PpLa_jinIOCyTjSZqrJJoqG0_1Y,10888 +bitblas/3rdparty/cutlass/python/cutlass/backend/evt/epilogue.py,sha256=-NDiVB-LQL2-P0NChT59VzR_BUwNjPArEU4Uf7nXoiE,6880 +bitblas/3rdparty/cutlass/python/cutlass/backend/evt/frontend/__init__.py,sha256=YFswJwm6q3dDIkBjpA6L259pOv-RkxZMin8TTCelpWA,1867 +bitblas/3rdparty/cutlass/python/cutlass/backend/evt/frontend/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/cutlass/backend/evt/frontend/__pycache__/frontend_base.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/cutlass/backend/evt/frontend/__pycache__/python_ast.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/cutlass/backend/evt/frontend/frontend_base.py,sha256=OBPkjS4RmrOmV-iHVu5PmflgEH4djEKmPHDJ9aJOEOs,8866 +bitblas/3rdparty/cutlass/python/cutlass/backend/evt/frontend/python_ast.py,sha256=ChfxK6kjTAzyJtGRSQDznP7dLAE69PXyHg-jUnf_mjI,6737 +bitblas/3rdparty/cutlass/python/cutlass/backend/evt/ir/__init__.py,sha256=8kCkXtuKYc8ATa7d4Thy7Px6RnmyDhJFnIB98zv1cUw,2405 +bitblas/3rdparty/cutlass/python/cutlass/backend/evt/ir/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/cutlass/backend/evt/ir/__pycache__/compute_nodes.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/cutlass/backend/evt/ir/__pycache__/dag_ir.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/cutlass/backend/evt/ir/__pycache__/layout_algorithm.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/cutlass/backend/evt/ir/__pycache__/layout_nodes.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/cutlass/backend/evt/ir/__pycache__/load_nodes.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/cutlass/backend/evt/ir/__pycache__/node.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/cutlass/backend/evt/ir/__pycache__/store_nodes.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/cutlass/backend/evt/ir/__pycache__/tensor.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/cutlass/backend/evt/ir/compute_nodes.py,sha256=671yVse4hUFJqdv6Oue4IkdgcnIV9-yw6WbB9PfKROo,3412 +bitblas/3rdparty/cutlass/python/cutlass/backend/evt/ir/dag_ir.py,sha256=t_2xl-RSJW0oecd3_bHOhh66WzJn-53cnyQZF5mlNfg,7515 +bitblas/3rdparty/cutlass/python/cutlass/backend/evt/ir/layout_algorithm.py,sha256=dxd9fRAt2PYh7Nk6esgpIYHq-FZH-t8s82Hj0CGv4Fs,13226 +bitblas/3rdparty/cutlass/python/cutlass/backend/evt/ir/layout_nodes.py,sha256=K8rJv0JZ7jhrjnHGIyFGHMokuhOqvtngTKxI6MHEwzU,13259 +bitblas/3rdparty/cutlass/python/cutlass/backend/evt/ir/load_nodes.py,sha256=8cV0vC1-W6u4xu74GXgCv6pfKJoLGvvugOUkm_G44F0,9566 +bitblas/3rdparty/cutlass/python/cutlass/backend/evt/ir/node.py,sha256=vQE0raAKkiezhmFHHZbp9VJ0vrLeEK7HmlibTGh5-PM,10339 +bitblas/3rdparty/cutlass/python/cutlass/backend/evt/ir/store_nodes.py,sha256=Y4OByjv3zpFIkOuR78gYoHwhp2S3snZ3mj5PEog0fCM,9420 +bitblas/3rdparty/cutlass/python/cutlass/backend/evt/ir/tensor.py,sha256=wmDbqule3GQbu5X8O-AAVbGCX0-t0KNqcRAtrDwSWoc,4900 +bitblas/3rdparty/cutlass/python/cutlass/backend/evt/passes/__init__.py,sha256=Y5Smx6arXaj1fNrQdWdgQZ2rzJDLAK1UDtl11mARHsY,2552 +bitblas/3rdparty/cutlass/python/cutlass/backend/evt/passes/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/cutlass/backend/evt/passes/__pycache__/graph_drawer.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/cutlass/backend/evt/passes/__pycache__/pass_argument_type.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/cutlass/backend/evt/passes/__pycache__/pass_dag_2_tree.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/cutlass/backend/evt/passes/__pycache__/pass_fix_element_d.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/cutlass/backend/evt/passes/__pycache__/pass_get_impl.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/cutlass/backend/evt/passes/__pycache__/pass_layout_elimination.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/cutlass/backend/evt/passes/__pycache__/pass_manager.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/cutlass/backend/evt/passes/__pycache__/pass_no_op_elimination.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/cutlass/backend/evt/passes/__pycache__/pass_preprocess_red.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/cutlass/backend/evt/passes/__pycache__/pass_shape_type_propagation.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/cutlass/backend/evt/passes/__pycache__/smem_size_calculator.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/cutlass/backend/evt/passes/graph_drawer.py,sha256=pyfYqtPYdwcULQhcUdJ4_SdebkbyodYBgk1W3Hloxpo,6125 +bitblas/3rdparty/cutlass/python/cutlass/backend/evt/passes/pass_argument_type.py,sha256=mgZmdkOJjS_NUBT-PUROdkzLFslQzr9JZQo07shKvy8,5291 +bitblas/3rdparty/cutlass/python/cutlass/backend/evt/passes/pass_dag_2_tree.py,sha256=bWZr8Q9LWtUynSkHMIpFpwDCflyJDVL_j-Ak-wQLTak,6809 +bitblas/3rdparty/cutlass/python/cutlass/backend/evt/passes/pass_fix_element_d.py,sha256=KM4AU7oC8RkGwFG-pXR7PDUN4kNskp1-QZ038esLwO0,2984 +bitblas/3rdparty/cutlass/python/cutlass/backend/evt/passes/pass_get_impl.py,sha256=TxfktX9FeFAcK3MYIh0irgs5HmhF6NPRPIZaR7Z_6qs,4189 +bitblas/3rdparty/cutlass/python/cutlass/backend/evt/passes/pass_layout_elimination.py,sha256=ZX3yZVlDRm0-WrnaA0gyVYis0NYZFseGLrUxWgxkrW8,9032 +bitblas/3rdparty/cutlass/python/cutlass/backend/evt/passes/pass_manager.py,sha256=OYkpTeYJ4Jje2P3A1FPRmvpErSu9lBhQsdNoXvTRdm8,5403 +bitblas/3rdparty/cutlass/python/cutlass/backend/evt/passes/pass_no_op_elimination.py,sha256=47gwsccLNJAL6uEi9VgMaMZXhtcTKaATR06Fl_97HAE,2414 +bitblas/3rdparty/cutlass/python/cutlass/backend/evt/passes/pass_preprocess_red.py,sha256=Xcp2RosdNpIhRKd4nlXCrb7zLApPybM7b5c4OcM96G4,4457 +bitblas/3rdparty/cutlass/python/cutlass/backend/evt/passes/pass_shape_type_propagation.py,sha256=0DaRXDFTdb7SdF_D4Yfpspkhs9RPS4RWYj3W4t0zgsw,2817 +bitblas/3rdparty/cutlass/python/cutlass/backend/evt/passes/smem_size_calculator.py,sha256=SwRsMhoOF1NTnNhdKCNah4amRb91JQlAKCf8k_s23mc,7960 +bitblas/3rdparty/cutlass/python/cutlass/backend/frontend.py,sha256=6YUITtdOS8Ke7ux1PhL4KNxHSnDqIr125hL4oxtO9YI,3986 +bitblas/3rdparty/cutlass/python/cutlass/backend/gemm_operation.py,sha256=_UZTYaFuDd6LBVxzJa9lGL7RimZ_8N0umvasEGYY3PE,83767 +bitblas/3rdparty/cutlass/python/cutlass/backend/library.py,sha256=pU79IHM9abO48xaQU2AQ3IyUgv3Mc_P0KomepOneg08,17533 +bitblas/3rdparty/cutlass/python/cutlass/backend/memory_manager.py,sha256=BjISziKeqDvGufBTWgozd3QjBiBt_UOm8AatD9rzRgQ,3005 +bitblas/3rdparty/cutlass/python/cutlass/backend/operation.py,sha256=pbTXIuvEwlyV1ly_a6HybDa86U0WlagCHacHdGT_Ih4,5282 +bitblas/3rdparty/cutlass/python/cutlass/backend/reduction_operation.py,sha256=gForJEvPW8dyQnF_dkW3A5GoGaJU42RBekjsAmQVTN0,15083 +bitblas/3rdparty/cutlass/python/cutlass/backend/type_hint.py,sha256=ZWDxMRhPDHWjhWFylg-SExi7Y_2yZ9hniAnlraxXs9g,1907 +bitblas/3rdparty/cutlass/python/cutlass/backend/utils/__init__.py,sha256=L9XiVarePP-Ex7lZF2FaV8WiV8WtnUVPLyEeVjg4M9I,2011 +bitblas/3rdparty/cutlass/python/cutlass/backend/utils/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/cutlass/backend/utils/__pycache__/datatypes.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/cutlass/backend/utils/__pycache__/device.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/cutlass/backend/utils/__pycache__/software.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/cutlass/backend/utils/datatypes.py,sha256=L3JlbewqbTXmaSEhyGuLwbZNaLxte9HWwgpwRq3yENI,4935 +bitblas/3rdparty/cutlass/python/cutlass/backend/utils/device.py,sha256=rIMt7dpdQhVgXb7Jc82bMpYdFLmZEUb0HMYAZo0VetU,3072 +bitblas/3rdparty/cutlass/python/cutlass/backend/utils/software.py,sha256=20-o-YaCFrqREdB96BUMA0MVBHRJK0SZt5Rp6XX51rY,3748 +bitblas/3rdparty/cutlass/python/cutlass/emit/__init__.py,sha256=W2xf0g_I5GdAE0-IiGeJpblRugHDiqWGDSYjuGUL1h8,1838 +bitblas/3rdparty/cutlass/python/cutlass/emit/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/cutlass/emit/__pycache__/common.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/cutlass/emit/__pycache__/pytorch.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/cutlass/emit/common.py,sha256=jSs2P1jnjcuM17hL4Rky7bZ2tS8rqKiarl3kggRa1r4,10566 +bitblas/3rdparty/cutlass/python/cutlass/emit/pytorch.py,sha256=GDx06HzZzcnSo2yZRE9yLGT4SG5mFSy6DX1z9bhSSTw,37236 +bitblas/3rdparty/cutlass/python/cutlass/epilogue/__init__.py,sha256=o--_F030woPzjI0ou38BFQS7rcbFM4DO-N5upF41z4o,2100 +bitblas/3rdparty/cutlass/python/cutlass/epilogue/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/cutlass/epilogue/__pycache__/epilogue.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/cutlass/epilogue/__pycache__/evt_ops.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/cutlass/epilogue/epilogue.py,sha256=8hmKltrCXOL3J9Ven4ATeyTfIooRkxB2vzPgv-v1dUM,5562 +bitblas/3rdparty/cutlass/python/cutlass/epilogue/evt_ops.py,sha256=iO9BQEznKTI6KTHYIkt0wmtRjrWcmRVHYTWzqP_mirM,3048 +bitblas/3rdparty/cutlass/python/cutlass/library_defaults.py,sha256=RTP2O4e4IvZ250heeyLC_fjP7YZrWljj74MVWB_hQFM,21252 +bitblas/3rdparty/cutlass/python/cutlass/op/__init__.py,sha256=-BJ0Uq8GTZnSvb465krGRiiwyeNtR9cftmqVjZ60e-4,1992 +bitblas/3rdparty/cutlass/python/cutlass/op/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/cutlass/op/__pycache__/conv.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/cutlass/op/__pycache__/gemm.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/cutlass/op/__pycache__/gemm_grouped.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/cutlass/op/__pycache__/op.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/cutlass/op/conv.py,sha256=KoFhVyvUXD_HWCtgcorx5ngXTs3VWovGliXcBFr6SMc,42340 +bitblas/3rdparty/cutlass/python/cutlass/op/gemm.py,sha256=Zxosrh3Ef79b3EWMeUK7PhEBJ7f187TFSbwLuWEN1PY,30506 +bitblas/3rdparty/cutlass/python/cutlass/op/gemm_grouped.py,sha256=lKjuOnb8gzNmXWxNG9lcdR0jdfGcIVKeiPxSqW8_4N0,12104 +bitblas/3rdparty/cutlass/python/cutlass/op/op.py,sha256=1sgfjDbfKZCMXj7M5Nq-YYFawrIOkEdqwe3zz5wvihg,16336 +bitblas/3rdparty/cutlass/python/cutlass/profiler/__init__.py,sha256=XR9gpfmk3dzZ9IZClOUp_jB47fs26ftDDxTJSJliZSA,1899 +bitblas/3rdparty/cutlass/python/cutlass/profiler/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/cutlass/profiler/__pycache__/event_profiler.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/cutlass/profiler/event_profiler.py,sha256=50ZoiBAyew9bt26D8F50eSCPpWv1SOi2gATBqchUoMg,6866 +bitblas/3rdparty/cutlass/python/cutlass/shape.py,sha256=G7sUQiJV3ZCybULQEuJAxrpA4F-spuK1rpDCIj3_y00,5664 +bitblas/3rdparty/cutlass/python/cutlass/swizzle.py,sha256=suQ_YUQsEmmuCoID-1z1_sz_m3SWdYXZC48UHqO7FKc,2710 +bitblas/3rdparty/cutlass/python/cutlass/utils/__init__.py,sha256=695VaGJH2R7dgVVEO2OyvZgu9CDMTF61gYOoWV-Pd8E,2011 +bitblas/3rdparty/cutlass/python/cutlass/utils/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/cutlass/utils/__pycache__/check.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/cutlass/utils/__pycache__/datatypes.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/cutlass/utils/check.py,sha256=wt9SpOhxfXUR4x76SdQBBx_rTnJ-3MxBvPzu5W5WCRc,11857 +bitblas/3rdparty/cutlass/python/cutlass/utils/datatypes.py,sha256=NHmtxjtWaivYld4QsAUOUcbuk0KcZq1XIgq1Y1m0ChQ,9964 +bitblas/3rdparty/cutlass/python/cutlass_library/__init__.py,sha256=MDkmD6Z6OC4eSZBqaaEzM0ZnJepexxbe8Kta5umCgIo,2238 +bitblas/3rdparty/cutlass/python/cutlass_library/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/cutlass_library/__pycache__/conv2d_operation.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/cutlass_library/__pycache__/conv3d_operation.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/cutlass_library/__pycache__/gemm_operation.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/cutlass_library/__pycache__/generator.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/cutlass_library/__pycache__/library.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/cutlass_library/__pycache__/manifest.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/cutlass_library/__pycache__/rank_2k_operation.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/cutlass_library/__pycache__/rank_k_operation.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/cutlass_library/__pycache__/symm_operation.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/cutlass_library/__pycache__/trmm_operation.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/cutlass_library/conv2d_operation.py,sha256=um-BGGcbo-CITfsqDhQ6Xm5P3bDcbIiRg0V3rGe33iw,19522 +bitblas/3rdparty/cutlass/python/cutlass_library/conv3d_operation.py,sha256=KRxnX_Cz2ZSvxNZ_UntffrDE4Mdl5A-Kxjt059TYUKI,14090 +bitblas/3rdparty/cutlass/python/cutlass_library/gemm_operation.py,sha256=fKkq3AtJ24fTTlTR0nKiXPitgYw5x9OcqVRCnzRU3c8,50410 +bitblas/3rdparty/cutlass/python/cutlass_library/generator.py,sha256=kc4qnkPFJMc27JQbKFE9ebg1rZ6nqBwF4PBf5XUVMas,217483 +bitblas/3rdparty/cutlass/python/cutlass_library/library.py,sha256=8HvZ69KRWZ-EL5fjbHBCB6I6QSMH9DTvI_wFxqQKliA,32191 +bitblas/3rdparty/cutlass/python/cutlass_library/manifest.py,sha256=Z4AiCrt3gmtZaOMeInJsK3ogFilqhtatFJzL2u-vEBM,24653 +bitblas/3rdparty/cutlass/python/cutlass_library/rank_2k_operation.py,sha256=tgJtunRCpK_xseb7MeSYKEp9s_CoVKIAJ9_W1pbvJRk,15917 +bitblas/3rdparty/cutlass/python/cutlass_library/rank_k_operation.py,sha256=2D7hWV80x3uZOO6zdCIpWOthQ8hOavpnTdiC5buhRH8,15503 +bitblas/3rdparty/cutlass/python/cutlass_library/symm_operation.py,sha256=iA_Z8VQBbI7jzvHgqdQ5m_mK-6BVmQFiMBGp9sLmuLo,15865 +bitblas/3rdparty/cutlass/python/cutlass_library/trmm_operation.py,sha256=0SMJy7WqeJa2DWvDuXN2TCbjDa4ZYrjfTifcsmrSQxo,16350 +bitblas/3rdparty/cutlass/python/docker/Dockerfile-cuda11.8-pytorch,sha256=Be_aqUxWb1WB7e2fqLY3feq4WE1i5nIMMOwlfUwz2AU,2106 +bitblas/3rdparty/cutlass/python/docker/Dockerfile-cuda12.0-pytorch,sha256=KbFQu30PN12YQNpHtC1zzcLrV_2bWQC2H4QocCTn-5M,2010 +bitblas/3rdparty/cutlass/python/docker/Dockerfile-cuda12.1-pytorch,sha256=BooWDGKS8hP1Ug6A1IOqwtarWeHeGvMrldgi1c2C6-0,2010 +bitblas/3rdparty/cutlass/python/docs/.buildinfo,sha256=0RfxuqUWQlk1MHWBriSRowH_gTsJengzW8I_u3GGvxk,230 +bitblas/3rdparty/cutlass/python/docs/_modules/cutlass/emit/pytorch.html,sha256=sJAPfxIeN1Zpx9xyXF52qpyRjKRHQo7_E-asmzEtUBo,73479 +bitblas/3rdparty/cutlass/python/docs/_modules/cutlass/epilogue.html,sha256=8usbONDEt8p1OZuFP0gy5H60Rtjbq1WYfdAgOWKonbE,23166 +bitblas/3rdparty/cutlass/python/docs/_modules/cutlass/library_defaults.html,sha256=4IkzOWlcC3RvxTa4B5el4OMOAs35E4VT6aizR0GWorg,78070 +bitblas/3rdparty/cutlass/python/docs/_modules/cutlass/op/gemm.html,sha256=UOP0h0ok2vrtEX3YBABt9TBNMwCfDpBFA9MaD1-nRf8,107380 +bitblas/3rdparty/cutlass/python/docs/_modules/cutlass/op/gemm_grouped.html,sha256=UwyunkTOI3mlpDUmH10SQ-hPGvVQeCLBBtd3tfyiOb8,51670 +bitblas/3rdparty/cutlass/python/docs/_modules/cutlass/op/op.html,sha256=NjdYhj44XAVBDH2PHw_puc6yGxPEF3OIK5t4CSrtflc,27011 +bitblas/3rdparty/cutlass/python/docs/_modules/cutlass/swizzle.html,sha256=kgBdhJVxS0xlAE5ADV8brL_TrLy0yd4WkbjovtgYC_c,19858 +bitblas/3rdparty/cutlass/python/docs/_modules/cutlass/utils/check.html,sha256=Ge-ILUrFrTrn3vGfzlBw2PFdWxt3Nu8IiW58eIvfFXs,38575 +bitblas/3rdparty/cutlass/python/docs/_modules/cutlass/utils/datatypes.html,sha256=4gDLau4BWb4UZfezN7ob1MsjrIO4Uhvd7vprphwzKSg,60946 +bitblas/3rdparty/cutlass/python/docs/_modules/index.html,sha256=soBia49trg75O1yPax1DuXRkBwhl0oRAUQWTOJjggZw,14574 +bitblas/3rdparty/cutlass/python/docs/_sources/contribute.md.txt,sha256=3NobGMfRsguCl-kbkeVbcRbBqJDLABjhq7xpRbTqq7Q,1017 +bitblas/3rdparty/cutlass/python/docs/_sources/cutlass.emit.rst.txt,sha256=06g8yeWylqNqe7JKIGpmht0PC3zJexYgIZ6RVPHb8tU,233 +bitblas/3rdparty/cutlass/python/docs/_sources/cutlass.op.rst.txt,sha256=bMyVBezluQ72aYhDTXhpsjbmdca5NFhkgsepFPrN5Hs,348 +bitblas/3rdparty/cutlass/python/docs/_sources/cutlass.rst.txt,sha256=PjzW4J-Eb5r576eqzoEyEt9NnweXIU9slYTTqE8gxvw,464 +bitblas/3rdparty/cutlass/python/docs/_sources/cutlass.utils.rst.txt,sha256=tlHfYig4QeP7iG56YHOpIWRC8EOwG9MldF6JeIQsR80,244 +bitblas/3rdparty/cutlass/python/docs/_sources/examples.rst.txt,sha256=YsHNYS8QP7InSTGJLZmQyrTaxf3JQa2qWEPcxIKB034,223 +bitblas/3rdparty/cutlass/python/docs/_sources/externals/00_basic_gemm.nblink.txt,sha256=esX8jxKVnZmJe009-A33s3s2SFWFQiRox5KQcNC_gLI,66 +bitblas/3rdparty/cutlass/python/docs/_sources/externals/01_epilogue.nblink.txt,sha256=T6UmbQ2qt_EiZGQccClUdSQWDH2Vl6r03EoALzYnTqo,64 +bitblas/3rdparty/cutlass/python/docs/_sources/externals/02_pytorch_extension_grouped_gemm.nblink.txt,sha256=jGXKUf-yWDmZw64bAyOzHlVHebMWb2vmuF7OBd4ybVo,86 +bitblas/3rdparty/cutlass/python/docs/_sources/index.rst.txt,sha256=slJZN9sdsrzvtZfu-YWtWdDvUpDdXCbUvOb49DJpv1Y,925 +bitblas/3rdparty/cutlass/python/docs/_sources/install.md.txt,sha256=ot0zlQyIZRSKfyaMpAAFhQ7j848R7gB3UZlzvcu-hs0,1735 +bitblas/3rdparty/cutlass/python/docs/_sources/modules.rst.txt,sha256=EEqGlXxNdnbELj7oZH_jmXZ3v-fRwhS6xV2c6T8myyo,80 +bitblas/3rdparty/cutlass/python/docs/_static/basic.css,sha256=mYD6KMvc2Na0N-3LGpEeDip4jX-g3-bqJaMC2CSjCU0,14813 +bitblas/3rdparty/cutlass/python/docs/_static/check-solid.svg,sha256=7fxN6LWvlmLBnXTQ7wWd6wAoP2sa4h38yOBS1WF6HH8,313 +bitblas/3rdparty/cutlass/python/docs/_static/clipboard.min.js,sha256=Jh_6BvOBA5z30YmE0TZMWfPCubYLH6BdX5yMFS5NW-U,9031 +bitblas/3rdparty/cutlass/python/docs/_static/copy-button.svg,sha256=jPlyrG0IcxVMgkXquWpQkCbuEy8Dv2jsef3-P6ewOgU,411 +bitblas/3rdparty/cutlass/python/docs/_static/copybutton.css,sha256=D3yfMDvTBYvcnbcmP-VgwKQfNSZynOHwDMq1J3JMVHY,2060 +bitblas/3rdparty/cutlass/python/docs/_static/copybutton.js,sha256=ie5BY7ov3UdASIPryBv5P2lvarAqpXlTMaj_cWHp4lY,8467 +bitblas/3rdparty/cutlass/python/docs/_static/copybutton_funcs.js,sha256=SheOz_XZhrVhICkpmsb00IxAH-FirzAXa1AdMYslt1M,2698 +bitblas/3rdparty/cutlass/python/docs/_static/cutlass-logo-small.png,sha256=MjUthiTOUyUBdC7YA5cgq-_6fD8wHBDfK7nAynmIPTY,1488 +bitblas/3rdparty/cutlass/python/docs/_static/debug.css,sha256=DQXNnnnVMjQwRmfAjwKXHeYZbA_8pZPDkDs2Z7QFWtY,1266 +bitblas/3rdparty/cutlass/python/docs/_static/doctools.js,sha256=PWK4H2OwQYo5qPWjIyA9iN2vyMUib4bTEZcAJdhte2w,4472 +bitblas/3rdparty/cutlass/python/docs/_static/documentation_options.js,sha256=VHqncsloP41Vk55mUxq2f2mvOn8Q8FM4JOUpu830b24,420 +bitblas/3rdparty/cutlass/python/docs/_static/file.png,sha256=XEvJoWrr84xLlQ9ZuOUByjZJUyjLnrYiIYvOkGSjXj4,286 +bitblas/3rdparty/cutlass/python/docs/_static/language_data.js,sha256=lbHUThuloxVdifhCejssmBFY-Va_SLnN8AMCZei3pgk,4758 +bitblas/3rdparty/cutlass/python/docs/_static/logo-dark-mode.png,sha256=D389r3sufUpSS2eq6rFIFiOVSjzOHltiEohlso7Qhag,50546 +bitblas/3rdparty/cutlass/python/docs/_static/logo-light-mode.png,sha256=2KUsvJWSaNfmt-ZaMErlQps-_P0SJiBlXjLkG7zblNA,48816 +bitblas/3rdparty/cutlass/python/docs/_static/minus.png,sha256=R-f8UNs2mfHKQc6aL_ogLADF0dUYDFX2K6hZsb1swAg,90 +bitblas/3rdparty/cutlass/python/docs/_static/nbsphinx-broken-thumbnail.svg,sha256=bGZNEKWyzXHk0dNqjLqix3PLmNaigkOWzO3ylvLWd0U,4467 +bitblas/3rdparty/cutlass/python/docs/_static/nbsphinx-code-cells.css,sha256=s_dnLTrdmeq7Ja4FWvBJ8uGHvyiSnmjGjPd1q59dqkk,6625 +bitblas/3rdparty/cutlass/python/docs/_static/nbsphinx-gallery.css,sha256=pWSzaL-J9a9XRmA7le1VtiwmYbDSVPvPSsHqOfDxu0Q,584 +bitblas/3rdparty/cutlass/python/docs/_static/nbsphinx-no-thumbnail.svg,sha256=U5DosgxNvqF6Fe-C1iN5htJfZCK1_o1_8BAjPwxsoFQ,2871 +bitblas/3rdparty/cutlass/python/docs/_static/plus.png,sha256=VBFRmblqEwy6AhR8R8DetD3Mm58ItRYruoZCs0mArGM,90 +bitblas/3rdparty/cutlass/python/docs/_static/pygments.css,sha256=NmRtnOVaN7fqabMiBm9io0OD1R2eD8EtUA7TC7qmVWA,19606 +bitblas/3rdparty/cutlass/python/docs/_static/scripts/furo-extensions.js,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +bitblas/3rdparty/cutlass/python/docs/_static/scripts/furo.js,sha256=W3ap-P2-xfQNrDTMriya6NVHai9m8euonI10C_D6F7E,5265 +bitblas/3rdparty/cutlass/python/docs/_static/scripts/furo.js.LICENSE.txt,sha256=PrpxjJir4K2N1EAe3J3fq_l5-bubisRGRgthsDaUlw0,187 +bitblas/3rdparty/cutlass/python/docs/_static/scripts/furo.js.map,sha256=ttyIAi8yXBtuUxGP2LhuIwU6NZbpOwrnfNKDk8cjBFo,28242 +bitblas/3rdparty/cutlass/python/docs/_static/searchtools.js,sha256=W5-svLNuXhXkCeLbQkOfuMvB5DJ14zemRbs8dsMZG5M,18215 +bitblas/3rdparty/cutlass/python/docs/_static/skeleton.css,sha256=53ArywPT6wLmNoH3U9iKKL7o-O0T5Q5YrISivDGlxx0,6034 +bitblas/3rdparty/cutlass/python/docs/_static/sphinx_highlight.js,sha256=CiBGS2V5dSLeGEIafbGghRomqubdBrcQnUQiNjE8J-4,4712 +bitblas/3rdparty/cutlass/python/docs/_static/styles/furo-extensions.css,sha256=QVUzRMggB1M1OfNoF4B_VDBC1p8BkV1b5NoxKR81wmI,5529 +bitblas/3rdparty/cutlass/python/docs/_static/styles/furo-extensions.css.map,sha256=a2seMurKMWXJi0Q70LXJiXqrU7Dm1L4-IGeAeyMapAc,7809 +bitblas/3rdparty/cutlass/python/docs/_static/styles/furo.css,sha256=A4EvDbAFSEYo2S8pwlgC5s0VvQ4nq98t6AngbglcVeQ,48697 +bitblas/3rdparty/cutlass/python/docs/_static/styles/furo.css.map,sha256=kriXhesNHd6Z-RyXPbMQt8VSQJ-thoZclbUrQei0taA,73615 +bitblas/3rdparty/cutlass/python/docs/_static/tabs.css,sha256=crBI6I7eH6mFrBUtJ0Ay5VzFfKhCXOpQ4RLI9QFO1rQ,2589 +bitblas/3rdparty/cutlass/python/docs/_static/tabs.js,sha256=2wcCzK0uyaKnnCuV5ypAlxH7I-pgQcEpvXE2jlQ_32w,551 +bitblas/3rdparty/cutlass/python/docs/contribute.html,sha256=sJviXKV5JQ7grRvW1QUhEbjOf2zfTopdB6D7JEZIHwI,16313 +bitblas/3rdparty/cutlass/python/docs/cutlass.emit.html,sha256=c9bR6uetlYs5TFoLe9fN8umaGqqe9vl9lVHEBHnnbS4,25143 +bitblas/3rdparty/cutlass/python/docs/cutlass.html,sha256=MWDdzbQ6ZGykLar2QdzwI8rGeYRq4pe-juHt-LRymfM,42694 +bitblas/3rdparty/cutlass/python/docs/cutlass.op.html,sha256=HRTqW7EXonb3VwHKyPDXJS48h-tAfXsVnOpfZaaB19c,75085 +bitblas/3rdparty/cutlass/python/docs/cutlass.utils.html,sha256=-LyU6wsA5oQizAhNSocywkZ0c7-p0ji3Brzu1DNWZEU,48674 +bitblas/3rdparty/cutlass/python/docs/examples.html,sha256=5u5bvHIy7jB51LN6UeDmwqcXQLbVZm_rEtXzOF4zpYQ,17476 +bitblas/3rdparty/cutlass/python/docs/externals/00_basic_gemm.html,sha256=wqDAUPblDNyHu18tQDBr82MBQkc_gLeToPV2NGhfzZQ,53298 +bitblas/3rdparty/cutlass/python/docs/externals/00_basic_gemm.ipynb,sha256=KC4aiCieJjJnrvzd79I34aUVS6WZn5KvciecNGBoj4k,25274 +bitblas/3rdparty/cutlass/python/docs/externals/01_epilogue.html,sha256=6gPHbWiYafssI0B91er0Vcv8Hm8xRIuMbDDJHnDj6Wg,47243 +bitblas/3rdparty/cutlass/python/docs/externals/01_epilogue.ipynb,sha256=cQvd-U6Wy2MAjMNwDdh4pIMLO7Kjz1ImwJgQFchhp7c,25337 +bitblas/3rdparty/cutlass/python/docs/externals/02_pytorch_extension_grouped_gemm.html,sha256=7ctxzxWwMovQowwbdAbxaWb1XSM1hdUD5xwt456ljMs,40814 +bitblas/3rdparty/cutlass/python/docs/externals/02_pytorch_extension_grouped_gemm.ipynb,sha256=a15aJ3KWeq2YVhNIofk2r3yPx9o6c4lINUhf7wgT7ZI,12612 +bitblas/3rdparty/cutlass/python/docs/genindex.html,sha256=RVaC33ukCxcTNwG-LvmCXA1G3R6Yf5REeaWfk2DAArQ,29848 +bitblas/3rdparty/cutlass/python/docs/index.html,sha256=WC05P6X3MDd2OLSLH2w0nzvGsxXM24aWIpU2o7swgOU,40052 +bitblas/3rdparty/cutlass/python/docs/install.html,sha256=SIPOU88HeqYrQNx050WCU0eW9sigpyI4A8czjwgUA8g,19649 +bitblas/3rdparty/cutlass/python/docs/modules.html,sha256=Rj3IQ9ahhLC2dzcYAOoniy7oGV38vWzK0-PJ5SpDNTs,27496 +bitblas/3rdparty/cutlass/python/docs/objects.inv,sha256=Mepibxdi5S7q9ammEhkWYMED1reQokc5Z9yHHaDbh4c,3228 +bitblas/3rdparty/cutlass/python/docs/py-modindex.html,sha256=Wg_qZJtFhgY2F0qRvOahJR0_AeZ5E4kfo_H3ZG9hoqA,16440 +bitblas/3rdparty/cutlass/python/docs/search.html,sha256=0nQ47kHj-0vmrG_EkQMcdRnnzx55Ua0iyTkw0HbSPVw,14104 +bitblas/3rdparty/cutlass/python/docs/searchindex.js,sha256=DIrNX43J9qjuU17QyGV21P-a7c9tGLzYs5pXBZSLP7k,34493 +bitblas/3rdparty/cutlass/python/docs_src/Makefile,sha256=t7vEuKV-juMon3dqoO0XjD5ygnAFXQpV6OWgNzdDpWQ,639 +bitblas/3rdparty/cutlass/python/docs_src/make.bat,sha256=7VJcxNQbYri5bUtipE7zLWzP2TJKN5qC1fcbX7bVd3Y,765 +bitblas/3rdparty/cutlass/python/docs_src/source/__pycache__/conf.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/docs_src/source/_static/cutlass-logo-small.png,sha256=MjUthiTOUyUBdC7YA5cgq-_6fD8wHBDfK7nAynmIPTY,1488 +bitblas/3rdparty/cutlass/python/docs_src/source/_static/logo-dark-mode.png,sha256=D389r3sufUpSS2eq6rFIFiOVSjzOHltiEohlso7Qhag,50546 +bitblas/3rdparty/cutlass/python/docs_src/source/_static/logo-light-mode.png,sha256=2KUsvJWSaNfmt-ZaMErlQps-_P0SJiBlXjLkG7zblNA,48816 +bitblas/3rdparty/cutlass/python/docs_src/source/_templates/layout.html,sha256=vgqZgZnwbiqPmy1M8Sj3AAWGbXXSVjhHePLeN8HGSYw,2321 +bitblas/3rdparty/cutlass/python/docs_src/source/conf.py,sha256=dRXH60oSc0gRMN0YkT9pq015XV33ayC3V3bU3090VCs,3664 +bitblas/3rdparty/cutlass/python/docs_src/source/contribute.md,sha256=3NobGMfRsguCl-kbkeVbcRbBqJDLABjhq7xpRbTqq7Q,1017 +bitblas/3rdparty/cutlass/python/docs_src/source/cutlass.emit.rst,sha256=06g8yeWylqNqe7JKIGpmht0PC3zJexYgIZ6RVPHb8tU,233 +bitblas/3rdparty/cutlass/python/docs_src/source/cutlass.op.rst,sha256=bMyVBezluQ72aYhDTXhpsjbmdca5NFhkgsepFPrN5Hs,348 +bitblas/3rdparty/cutlass/python/docs_src/source/cutlass.rst,sha256=PjzW4J-Eb5r576eqzoEyEt9NnweXIU9slYTTqE8gxvw,464 +bitblas/3rdparty/cutlass/python/docs_src/source/cutlass.utils.rst,sha256=tlHfYig4QeP7iG56YHOpIWRC8EOwG9MldF6JeIQsR80,244 +bitblas/3rdparty/cutlass/python/docs_src/source/examples.rst,sha256=YsHNYS8QP7InSTGJLZmQyrTaxf3JQa2qWEPcxIKB034,223 +bitblas/3rdparty/cutlass/python/docs_src/source/externals/00_basic_gemm.nblink,sha256=esX8jxKVnZmJe009-A33s3s2SFWFQiRox5KQcNC_gLI,66 +bitblas/3rdparty/cutlass/python/docs_src/source/externals/01_epilogue.nblink,sha256=T6UmbQ2qt_EiZGQccClUdSQWDH2Vl6r03EoALzYnTqo,64 +bitblas/3rdparty/cutlass/python/docs_src/source/externals/02_pytorch_extension_grouped_gemm.nblink,sha256=jGXKUf-yWDmZw64bAyOzHlVHebMWb2vmuF7OBd4ybVo,86 +bitblas/3rdparty/cutlass/python/docs_src/source/index.rst,sha256=slJZN9sdsrzvtZfu-YWtWdDvUpDdXCbUvOb49DJpv1Y,925 +bitblas/3rdparty/cutlass/python/docs_src/source/install.md,sha256=ot0zlQyIZRSKfyaMpAAFhQ7j848R7gB3UZlzvcu-hs0,1735 +bitblas/3rdparty/cutlass/python/docs_src/source/modules.rst,sha256=EEqGlXxNdnbELj7oZH_jmXZ3v-fRwhS6xV2c6T8myyo,80 +bitblas/3rdparty/cutlass/python/pycute/__init__.py,sha256=JxBy7qLNSodRysdCEYq3CTXHeaSe9tTB8P7e6BY2iPs,1889 +bitblas/3rdparty/cutlass/python/pycute/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/pycute/__pycache__/int_tuple.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/pycute/__pycache__/layout.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/pycute/__pycache__/swizzle.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/pycute/__pycache__/typing.cpython-310.pyc,, +bitblas/3rdparty/cutlass/python/pycute/int_tuple.py,sha256=XCKvXM0MhZHfJe5C896Z3Rs0iZTrmFUwjQEOdexokCY,7813 +bitblas/3rdparty/cutlass/python/pycute/layout.py,sha256=s8ajCe4AyJMf7tqKLqTqSTmID0rEtZDe92FbrubEqGM,12421 +bitblas/3rdparty/cutlass/python/pycute/swizzle.py,sha256=pAJf-gbUR-R85Hlk4lyjAQ7eDYpCI0-uf7LrzO4_izk,4475 +bitblas/3rdparty/cutlass/python/pycute/typing.py,sha256=z5zkuCMRCjsOfdmhiFkI6IPVhXN06b1tHIgG3DxFsCA,1981 +bitblas/3rdparty/cutlass/python/setup.py,sha256=o__YU9opCMBPPumnyT7K5KEN6hAtmnTw4wY3DWhXuhY,2582 +bitblas/3rdparty/cutlass/python/setup_library.py,sha256=zUFLmioMGwcdg-RDtSjPaAmp4W7a2Gyz06n26oDAHzk,2067 +bitblas/3rdparty/cutlass/python/setup_pycute.py,sha256=Owj4EbWoTQxvYF0BIB_LF8HJ_f8v_I1Yy3iO5Npseng,2045 +bitblas/3rdparty/cutlass/test/CMakeLists.txt,sha256=Oe7Ocw6FY5EMqVwJjdlWDUZRppK83LdxHUq2jm4NpTM,1667 +bitblas/3rdparty/cutlass/test/python/cutlass/conv2d/__pycache__/conv2d_problem_sizes.cpython-310.pyc,, +bitblas/3rdparty/cutlass/test/python/cutlass/conv2d/__pycache__/conv2d_sm80.cpython-310.pyc,, +bitblas/3rdparty/cutlass/test/python/cutlass/conv2d/__pycache__/conv2d_test_utils.cpython-310.pyc,, +bitblas/3rdparty/cutlass/test/python/cutlass/conv2d/__pycache__/run_all_tests.cpython-310.pyc,, +bitblas/3rdparty/cutlass/test/python/cutlass/conv2d/conv2d_problem_sizes.py,sha256=A1cilTV0oud3743GlIGlocMzg-w-0GBZp4XLwh2BuD8,18093 +bitblas/3rdparty/cutlass/test/python/cutlass/conv2d/conv2d_sm80.py,sha256=BOUdWRsH_twQv7b4AiK-aJpy5o8xmmj-6dDhAeJ5o_8,6931 +bitblas/3rdparty/cutlass/test/python/cutlass/conv2d/conv2d_test_utils.py,sha256=cPENt-cBXXfxDmbVC6nmFqvaOSz1lASvbokBOfWhK9o,14198 +bitblas/3rdparty/cutlass/test/python/cutlass/conv2d/run_all_tests.py,sha256=HSwQPdmw8vdytOaENH_TzyROt9Bw1hUPCv_7ietfCtk,2182 +bitblas/3rdparty/cutlass/test/python/cutlass/emit/__pycache__/pytorch.cpython-310.pyc,, +bitblas/3rdparty/cutlass/test/python/cutlass/emit/pytorch.py,sha256=tV2xifT05UBrVceU4oDHeg1bOSgZCXOzjeWxvC2khCs,11118 +bitblas/3rdparty/cutlass/test/python/cutlass/evt/__pycache__/evt_compute_sm80_90.cpython-310.pyc,, +bitblas/3rdparty/cutlass/test/python/cutlass/evt/__pycache__/evt_layout_sm80_90.cpython-310.pyc,, +bitblas/3rdparty/cutlass/test/python/cutlass/evt/__pycache__/evt_load_sm80_90.cpython-310.pyc,, +bitblas/3rdparty/cutlass/test/python/cutlass/evt/__pycache__/evt_mixed_sm80_90.cpython-310.pyc,, +bitblas/3rdparty/cutlass/test/python/cutlass/evt/__pycache__/evt_store_sm80_90.cpython-310.pyc,, +bitblas/3rdparty/cutlass/test/python/cutlass/evt/__pycache__/run_all_tests.cpython-310.pyc,, +bitblas/3rdparty/cutlass/test/python/cutlass/evt/evt_compute_sm80_90.py,sha256=yLw2hzRJ3qZZikoyTDoN7lvyG0X0pQaR81We5l2xKOQ,3906 +bitblas/3rdparty/cutlass/test/python/cutlass/evt/evt_layout_sm80_90.py,sha256=mkCQq-EDhRA5Yf_WR4mX0SFUVLaIwmSlE3z2mqjIViI,6666 +bitblas/3rdparty/cutlass/test/python/cutlass/evt/evt_load_sm80_90.py,sha256=-lm2zcYTjOrrMp7j9fy_RbtGufZGXw3eDt9rlQAop6o,5747 +bitblas/3rdparty/cutlass/test/python/cutlass/evt/evt_mixed_sm80_90.py,sha256=wC0LYapsr2Gq5txloRCnzXff1m6wtF_GZFcRyiX03Yw,13119 +bitblas/3rdparty/cutlass/test/python/cutlass/evt/evt_store_sm80_90.py,sha256=kApi2bFd04KbamfWLgHSvZqNZVhYkCrGnVgeG91Y79s,6105 +bitblas/3rdparty/cutlass/test/python/cutlass/evt/run_all_tests.py,sha256=cNlDY2RV20ujKYhkNPe3sD9RiFV7y2p1ETkgqIAK1zM,2179 +bitblas/3rdparty/cutlass/test/python/cutlass/evt/utils/__pycache__/evt_testbed.cpython-310.pyc,, +bitblas/3rdparty/cutlass/test/python/cutlass/evt/utils/evt_testbed.py,sha256=8AOjFnBP2MKCHXts9WteGSUjPGJEJhvY5S75Iw_vaRU,8910 +bitblas/3rdparty/cutlass/test/python/cutlass/gemm/__pycache__/gemm_batched.cpython-310.pyc,, +bitblas/3rdparty/cutlass/test/python/cutlass/gemm/__pycache__/gemm_f16_sm80.cpython-310.pyc,, +bitblas/3rdparty/cutlass/test/python/cutlass/gemm/__pycache__/gemm_f16_sm90.cpython-310.pyc,, +bitblas/3rdparty/cutlass/test/python/cutlass/gemm/__pycache__/gemm_f32_sm80.cpython-310.pyc,, +bitblas/3rdparty/cutlass/test/python/cutlass/gemm/__pycache__/gemm_f64_sm80.cpython-310.pyc,, +bitblas/3rdparty/cutlass/test/python/cutlass/gemm/__pycache__/gemm_f64_sm90.cpython-310.pyc,, +bitblas/3rdparty/cutlass/test/python/cutlass/gemm/__pycache__/gemm_s8_sm80.cpython-310.pyc,, +bitblas/3rdparty/cutlass/test/python/cutlass/gemm/__pycache__/gemm_s8_sm90.cpython-310.pyc,, +bitblas/3rdparty/cutlass/test/python/cutlass/gemm/__pycache__/gemm_testbed.cpython-310.pyc,, +bitblas/3rdparty/cutlass/test/python/cutlass/gemm/__pycache__/run_all_tests.cpython-310.pyc,, +bitblas/3rdparty/cutlass/test/python/cutlass/gemm/__pycache__/utils.cpython-310.pyc,, +bitblas/3rdparty/cutlass/test/python/cutlass/gemm/gemm_batched.py,sha256=PSIESot6pyU2GaNBXDHUr45qQp6OBGngIlDzMqXVCzc,4893 +bitblas/3rdparty/cutlass/test/python/cutlass/gemm/gemm_f16_sm80.py,sha256=JgKiMUysaugBi6NlFWJ-3GmQeqwm7aPOmzOfczIqna4,8835 +bitblas/3rdparty/cutlass/test/python/cutlass/gemm/gemm_f16_sm90.py,sha256=7rvuo8iR5EW0CDKDdYY1-G2JN4i21BoVvE1EhUCrEjY,8841 +bitblas/3rdparty/cutlass/test/python/cutlass/gemm/gemm_f32_sm80.py,sha256=1AkAmmx7O--IPnin0SHLn4MqHFJZmJfTemsej664byk,5568 +bitblas/3rdparty/cutlass/test/python/cutlass/gemm/gemm_f64_sm80.py,sha256=LslM0O5dEqXkImo5nvgR4kJXSHlxJXNuG-jZlgS-TQM,5318 +bitblas/3rdparty/cutlass/test/python/cutlass/gemm/gemm_f64_sm90.py,sha256=G6IUt_xsnseLPQWujYyrqPrSmA1j2rIWRDq4XhJXnGY,3228 +bitblas/3rdparty/cutlass/test/python/cutlass/gemm/gemm_s8_sm80.py,sha256=7Ac_hWrsv_hekgr53P9FWEyTWv389yK5vd3IIfo5wc8,5316 +bitblas/3rdparty/cutlass/test/python/cutlass/gemm/gemm_s8_sm90.py,sha256=81AeeS-tJE5qSsobiNAGwYTyHZoPHhEhwvLGx0t7xko,5387 +bitblas/3rdparty/cutlass/test/python/cutlass/gemm/gemm_testbed.py,sha256=kl1luD5Pmxhw66B3SVJRk5ENt1ncmJcJrNlMbX88xzs,14797 +bitblas/3rdparty/cutlass/test/python/cutlass/gemm/run_all_tests.py,sha256=bUcOhjpIr0SfuZy31gRq9KxXtCOdRyGQ1Ltl2XqXG_A,2180 +bitblas/3rdparty/cutlass/test/python/cutlass/gemm/utils.py,sha256=TTJV_DTj9vZSXzhwGFLKuqSJ0r3ZnL5kPf5sJMzrcMc,9764 +bitblas/3rdparty/cutlass/test/python/cutlass/interface/__pycache__/conv2d_interface.cpython-310.pyc,, +bitblas/3rdparty/cutlass/test/python/cutlass/interface/__pycache__/evt_interface.cpython-310.pyc,, +bitblas/3rdparty/cutlass/test/python/cutlass/interface/__pycache__/gemm_interface.cpython-310.pyc,, +bitblas/3rdparty/cutlass/test/python/cutlass/interface/__pycache__/utils.cpython-310.pyc,, +bitblas/3rdparty/cutlass/test/python/cutlass/interface/conv2d_interface.py,sha256=5yovfvMuxxRZYz2IbnqCQ7yFmeuRrpKgZyvwcL8nvew,12233 +bitblas/3rdparty/cutlass/test/python/cutlass/interface/evt_interface.py,sha256=hSyL86y2MkWwCsHc6xJs3D5J7TfdsaOvbByHX7Y64pM,9612 +bitblas/3rdparty/cutlass/test/python/cutlass/interface/gemm_interface.py,sha256=3TAEX6OlGbglPQXqdKKICSV4cPl07J8mQFDs-LU9f-c,17681 +bitblas/3rdparty/cutlass/test/python/cutlass/interface/utils.py,sha256=jqu8CaS3JVespF2iJ7E9HISmpvV1UYcM8Uj4_pGtjR8,3023 +bitblas/3rdparty/cutlass/test/python/pycute/__pycache__/run_all_tests.cpython-310.pyc,, +bitblas/3rdparty/cutlass/test/python/pycute/__pycache__/test_coalesce.cpython-310.pyc,, +bitblas/3rdparty/cutlass/test/python/pycute/__pycache__/test_complement.cpython-310.pyc,, +bitblas/3rdparty/cutlass/test/python/pycute/__pycache__/test_composition.cpython-310.pyc,, +bitblas/3rdparty/cutlass/test/python/pycute/__pycache__/test_int_tuple.cpython-310.pyc,, +bitblas/3rdparty/cutlass/test/python/pycute/__pycache__/test_left_inverse.cpython-310.pyc,, +bitblas/3rdparty/cutlass/test/python/pycute/__pycache__/test_right_inverse.cpython-310.pyc,, +bitblas/3rdparty/cutlass/test/python/pycute/__pycache__/test_typing.cpython-310.pyc,, +bitblas/3rdparty/cutlass/test/python/pycute/run_all_tests.py,sha256=Sqi_2Cm5RH1CLtJ3AOG3cPuw6dLLGd3uBMRRFCpx3aw,3136 +bitblas/3rdparty/cutlass/test/python/pycute/test_coalesce.py,sha256=ma9PuqJRIsS2MzkHTHLViBCjxMyvA0pYyO0fCd_kik4,3177 +bitblas/3rdparty/cutlass/test/python/pycute/test_complement.py,sha256=OLnaGNemU4Coz1iuLZWB75oVlv7x0H7JkXyXcPJRVz0,3162 +bitblas/3rdparty/cutlass/test/python/pycute/test_composition.py,sha256=D-2XXS0nke-v6hLDRuMouZWZizrQEhYIRKMJo01aL-0,6630 +bitblas/3rdparty/cutlass/test/python/pycute/test_int_tuple.py,sha256=BMb7P7ySwRAapic1bYSpE8eLrul_pxEXgOMD7E5_Voo,2953 +bitblas/3rdparty/cutlass/test/python/pycute/test_left_inverse.py,sha256=lfgM2YGXyEoSDhstvVMo1kbMF2qu2QCGkSlbv6ycAEA,2970 +bitblas/3rdparty/cutlass/test/python/pycute/test_right_inverse.py,sha256=7ywpbhTlMqtjZ5SGabWdQHDiIc7T0jbMuyYLauzy9Sk,3199 +bitblas/3rdparty/cutlass/test/python/pycute/test_typing.py,sha256=toc2UEUyEeVMlU_tY4fhqtm00v3ovj6gpv2HPLjjvIw,2563 +bitblas/3rdparty/cutlass/test/unit/CMakeLists.txt,sha256=8-gO0xF6pfjQ5z1_Iz59s43H_yklEZnKobnpctllDDs,4342 +bitblas/3rdparty/cutlass/test/unit/cluster_launch/CMakeLists.txt,sha256=mQTecEdj-tjXyZf9vZhf1_kycGP3CQzSL3VqtxU21GA,1688 +bitblas/3rdparty/cutlass/test/unit/cluster_launch/cluster_launch.cu,sha256=MeZDYkaF4THMCUYnFxsBZSJls2R9zeM0TZIxxG-Hyb4,12088 +bitblas/3rdparty/cutlass/test/unit/common/cutlass_unit_test.h,sha256=4k-pDoTklw6eGkBWFgOzmGLrnu8K31ZrT1KUv7XNigQ,4900 +bitblas/3rdparty/cutlass/test/unit/common/filter_architecture.cpp,sha256=B3Pu9zJb6-4zMYfOcHjuy49qdf2cVRpeo8aFT_o2FHo,5381 +bitblas/3rdparty/cutlass/test/unit/conv/CMakeLists.txt,sha256=x28SWkUAuO30c7YpWVK6v7t_kkXnd9IcrJbOT9zV_X4,2249 +bitblas/3rdparty/cutlass/test/unit/conv/device/CMakeLists.txt,sha256=10ziD1SaZMhTjjbovENhTncOlSrA_vO2jUvZps34UxA,8967 +bitblas/3rdparty/cutlass/test/unit/conv/device/cache_testbed_output.h,sha256=EHwXpl02pYeCOxELgxTaNUjYsyxCAF913EbB-Lm1n_s,21797 +bitblas/3rdparty/cutlass/test/unit/conv/device/conv2d_dgrad_implicit_gemm_cf32nhwc_cf32nhwc_cf32nhwc_simt_f32_sm50.cu,sha256=WqiBGn-idlmO7oF1_9PzqApd_bLu41_B421j_64n4lk,5344 +bitblas/3rdparty/cutlass/test/unit/conv/device/conv2d_dgrad_implicit_gemm_cf32nhwc_cf32nhwc_cf32nhwc_simt_f32_sm80.cu,sha256=iGGRRtO3RitMPdvLNPgVxtHi4EYwC8zEQt5EFJ2mZMY,5443 +bitblas/3rdparty/cutlass/test/unit/conv/device/conv2d_dgrad_implicit_gemm_f16nhwc_f16nhwc_f16nhwc_tensor_op_f16_sm80.cu,sha256=I-HOLa388bAqomAEhtNQNNzJWxcpJwOB6XQlg81-aLY,11470 +bitblas/3rdparty/cutlass/test/unit/conv/device/conv2d_dgrad_implicit_gemm_f16nhwc_f16nhwc_f32nhwc_tensor_op_f32_sm70.cu,sha256=KRkp-eQANydxmPvN6muQz7rRbN7nINLykmeuBIsf4-c,5239 +bitblas/3rdparty/cutlass/test/unit/conv/device/conv2d_dgrad_implicit_gemm_f16nhwc_f16nhwc_f32nhwc_tensor_op_f32_sm75.cu,sha256=8DZgocLH7n8uxD5JS5iF47zcKjtkbbneFQBkWE28lGM,9110 +bitblas/3rdparty/cutlass/test/unit/conv/device/conv2d_dgrad_implicit_gemm_f16nhwc_f16nhwc_f32nhwc_tensor_op_f32_sm80.cu,sha256=SylQMnRtdvvWqo68UvM946uskw6WRssi50N86_prsZs,8485 +bitblas/3rdparty/cutlass/test/unit/conv/device/conv2d_dgrad_implicit_gemm_f32nhwc_f32nhwc_f32nhwc_simt_f32_sm80.cu,sha256=7PQnGPfWnB8cE6kQJ9-NHi9Li8AB7zQUJGoyY7bBX6s,5243 +bitblas/3rdparty/cutlass/test/unit/conv/device/conv2d_dgrad_implicit_gemm_tf32nhwc_tf32nhwc_f32nhwc_tensor_op_f32_sm80.cu,sha256=Sy8dys7ART7se0XJlywyMbgCxuieqH-DWPlbYxwH-do,5378 +bitblas/3rdparty/cutlass/test/unit/conv/device/conv2d_fprop_few_channels_f16nhwc_f16nhwc_f16nhwc_tensor_op_f32_sm80.cu,sha256=KuxtykZST_73oKjUwESm_xIfr6kF9skDtyUYjMDhJsM,12054 +bitblas/3rdparty/cutlass/test/unit/conv/device/conv2d_fprop_fixed_channels_f16nhwc_f16nhwc_f16nhwc_tensor_op_f32_sm80.cu,sha256=jfPWBcYGAi1A8d_Bgk_bNWVO-gK1UzSbzocson06Cho,9603 +bitblas/3rdparty/cutlass/test/unit/conv/device/conv2d_fprop_implicit_gemm_cf32nhwc_cf32nhwc_cf32nhwc_simt_f32_sm50.cu,sha256=FdL41GPMfpEMVdsjqX1TJf2F2CZiBbXZ4-020ox1pHo,5267 +bitblas/3rdparty/cutlass/test/unit/conv/device/conv2d_fprop_implicit_gemm_cf32nhwc_cf32nhwc_cf32nhwc_simt_f32_sm80.cu,sha256=4LzREC811c67YVKd0ZXSdb6X25QJJ59139DsXxu8TUY,5357 +bitblas/3rdparty/cutlass/test/unit/conv/device/conv2d_fprop_implicit_gemm_f16nhwc_f16nhwc_f16nhwc_simt_f16_sm60.cu,sha256=fMNNIKec32n_5t6IuA-TYsI0y7UMjNgw5W4hGgrIvAU,5089 +bitblas/3rdparty/cutlass/test/unit/conv/device/conv2d_fprop_implicit_gemm_f16nhwc_f16nhwc_f16nhwc_tensor_op_f16_sm80.cu,sha256=HKYwcODIxiV_rRieaNVKRGdqy5xyDoKSIcpAgDncLqM,13690 +bitblas/3rdparty/cutlass/test/unit/conv/device/conv2d_fprop_implicit_gemm_f16nhwc_f16nhwc_f16nhwc_tensor_op_f32_sm80.cu,sha256=6-qKzKk9Ot_Ly7S5bK0aSc119zhcA2AcR6zvnM5sUkw,5390 +bitblas/3rdparty/cutlass/test/unit/conv/device/conv2d_fprop_implicit_gemm_f16nhwc_f16nhwc_f32nhwc_tensor_op_f32_sm70.cu,sha256=ZSPvH801ZWV-mJgRZkpf3TYREWTJfTdQAoy8OsDiMBM,5191 +bitblas/3rdparty/cutlass/test/unit/conv/device/conv2d_fprop_implicit_gemm_f16nhwc_f16nhwc_f32nhwc_tensor_op_f32_sm75.cu,sha256=O68V-pniwtZ6EPUl5me5xYqOyVSAchZTMiaoQCIvSxI,11136 +bitblas/3rdparty/cutlass/test/unit/conv/device/conv2d_fprop_implicit_gemm_f16nhwc_f16nhwc_f32nhwc_tensor_op_f32_sm80.cu,sha256=uDpOQXEkMHjytV1sN3_whi95EKowCBfgOwKZIa-d_1g,5291 +bitblas/3rdparty/cutlass/test/unit/conv/device/conv2d_fprop_implicit_gemm_f32nhwc_f32nhwc_f32nhwc_simt_f32_sm50.cu,sha256=u1XVaTiZpQmMg6HfglmMrawga_x6sf-HTx2A7sPXe-Q,3551 +bitblas/3rdparty/cutlass/test/unit/conv/device/conv2d_fprop_implicit_gemm_f32nhwc_f32nhwc_f32nhwc_simt_f32_sm80.cu,sha256=W3Ulg2Vx6HMSSzBBDzGhvqi3kHv2UD8jmcyk6JVGB_s,5157 +bitblas/3rdparty/cutlass/test/unit/conv/device/conv2d_fprop_implicit_gemm_qf32nhwc_qf32nhwc_qf32nhwc_simt_f32_sm50.cu,sha256=op2YLcqiP7Gn1Ypdv9ZaiJPB3M6wzBXup79eFeyEfN4,8278 +bitblas/3rdparty/cutlass/test/unit/conv/device/conv2d_fprop_implicit_gemm_s4ncxhwx_s4cxrskx_s4ncxhwx_tensor_op_s32_sm75.cu,sha256=SCVNDjlwj_lMobyzarq580QGPXlraX6DCFmPsyQcizE,20553 +bitblas/3rdparty/cutlass/test/unit/conv/device/conv2d_fprop_implicit_gemm_s4ncxhwx_s4cxrskx_s4ncxhwx_tensor_op_s32_sm80.cu,sha256=v3mDfwgIYQT8FurJUEsNVCoQKFsm6BwSqIxDJZ9BuDk,20647 +bitblas/3rdparty/cutlass/test/unit/conv/device/conv2d_fprop_implicit_gemm_s4nhwc_s4nhwc_s32nhwc_tensor_op_s32_sm75.cu,sha256=mQhZrxEsGPjajP_lkYZl_WCCvEPEYYcFA8Kjie_2f2g,5150 +bitblas/3rdparty/cutlass/test/unit/conv/device/conv2d_fprop_implicit_gemm_s4nhwc_s4nhwc_s32nhwc_tensor_op_s32_sm80.cu,sha256=AJuGihqluigVNVQQoGe7gijWiq0fCO4Onc_plhmkWPw,5239 +bitblas/3rdparty/cutlass/test/unit/conv/device/conv2d_fprop_implicit_gemm_s8ncxhwx_s8cxrskx_s8ncxhwx_tensor_op_s32_sm75.cu,sha256=KQKFWfqOWELCW5T0HX3P4R_jUDWQMEzfkYZkuXHHDsU,26113 +bitblas/3rdparty/cutlass/test/unit/conv/device/conv2d_fprop_implicit_gemm_s8ncxhwx_s8cxrskx_s8ncxhwx_tensor_op_s32_sm80.cu,sha256=N42JYfR4mVUlZaziOnNRr5OFkkASroaHOXc6JeJnL5M,26210 +bitblas/3rdparty/cutlass/test/unit/conv/device/conv2d_fprop_implicit_gemm_s8nhwc_s8nhwc_s32nhwc_tensor_op_s32_sm75.cu,sha256=g_b8qBj0E2GVwP1llSC7nd4pq_nRSIh8jmn-NyoAkN4,5106 +bitblas/3rdparty/cutlass/test/unit/conv/device/conv2d_fprop_implicit_gemm_s8nhwc_s8nhwc_s32nhwc_tensor_op_s32_sm80.cu,sha256=DxPXhN6aGI8tMdSp7yjyew7iYkDyIdumXWsxCwwsY-U,5194 +bitblas/3rdparty/cutlass/test/unit/conv/device/conv2d_fprop_implicit_gemm_tf32nhwc_tf32nhwc_f32nhwc_tensor_op_f32_sm80.cu,sha256=Me6LRs3IhOS_m9fZN9lMT_WuTMkm7FXwFtukfgVy1MM,5738 +bitblas/3rdparty/cutlass/test/unit/conv/device/conv2d_fprop_with_broadcast_sm70.cu,sha256=hB1PaW8Bcy_vE2-KbdOLF-ruzoJieXjQ7DcOId4yHz8,5439 +bitblas/3rdparty/cutlass/test/unit/conv/device/conv2d_fprop_with_broadcast_sm75.cu,sha256=6hgADO3HFHCQEyPYi2ocuMGtsLczNkPCa7L6JwrE7RY,7363 +bitblas/3rdparty/cutlass/test/unit/conv/device/conv2d_fprop_with_reduction_sm75.cu,sha256=0pcTCo0Drk9zEgHxToTw7vew36Reaz69jWeNHpDwwJ4,3984 +bitblas/3rdparty/cutlass/test/unit/conv/device/conv2d_problems.h,sha256=JMKn2PqMtGnJDh-bg5UZfVL3obBXzetzzi3YJH8F14M,39407 +bitblas/3rdparty/cutlass/test/unit/conv/device/conv2d_strided_dgrad_implicit_gemm_f16nhwc_f16nhwc_f32nhwc_tensor_op_f32_sm80.cu,sha256=FVBIZyWoi15cPSMWLD_jmOik1m-UvmgibyK64XIpUOI,14471 +bitblas/3rdparty/cutlass/test/unit/conv/device/conv2d_strided_dgrad_implicit_gemm_swizzling4_sm80.cu,sha256=Y7ZwEcR2JDOpwwicHJT7C3TUXY0Qek5ssFIIpSoVFiY,4173 +bitblas/3rdparty/cutlass/test/unit/conv/device/conv2d_strided_dgrad_implicit_gemm_tf32nhwc_tf32nhwc_f32nhwc_tensor_op_f32_sm80.cu,sha256=8yXuUtlH3yzIiiqnVfhL-HrZ5JUpFGh4UHoo5uqKOWA,4662 +bitblas/3rdparty/cutlass/test/unit/conv/device/conv2d_testbed.h,sha256=MbQHkpOjGyuqWc7hAr3hhZqz9sCGYcaCyz_zeW2hejw,26225 +bitblas/3rdparty/cutlass/test/unit/conv/device/conv2d_testbed_interleaved.h,sha256=a50eWAaeQQtcAUcDzHczHvmKAmyQBZOSPIEXNYmbifI,22109 +bitblas/3rdparty/cutlass/test/unit/conv/device/conv2d_wgrad_implicit_gemm_cf32nhwc_cf32nhwc_cf32nhwc_simt_f32_sm50.cu,sha256=5BATol7ie57q4iqTdiwHXqNupAj8dxhxpdHWxJ2rOWU,5179 +bitblas/3rdparty/cutlass/test/unit/conv/device/conv2d_wgrad_implicit_gemm_cf32nhwc_cf32nhwc_cf32nhwc_simt_f32_sm80.cu,sha256=VySHFKkAHDa2ySYZG6Xu0feYVcgO5hOgFK2gblTrofQ,5358 +bitblas/3rdparty/cutlass/test/unit/conv/device/conv2d_wgrad_implicit_gemm_f16nhwc_f16nhwc_f16nhwc_tensor_op_f16_sm80.cu,sha256=4Xz7XpEoeBbxvZ4uyp4AopLHoNQR_bTKanBsr-9Ss10,5264 +bitblas/3rdparty/cutlass/test/unit/conv/device/conv2d_wgrad_implicit_gemm_f16nhwc_f16nhwc_f32nhwc_tensor_op_f32_sm70.cu,sha256=JsVdUspsc6fExaSMsTioueUu_djKV5pyyuwT_Um42A4,3615 +bitblas/3rdparty/cutlass/test/unit/conv/device/conv2d_wgrad_implicit_gemm_f16nhwc_f16nhwc_f32nhwc_tensor_op_f32_sm75.cu,sha256=c3Sp8nE0SvP_SBS0wSBhHvFDzxtjkVQrlU-ZiD_cs28,7591 +bitblas/3rdparty/cutlass/test/unit/conv/device/conv2d_wgrad_implicit_gemm_f16nhwc_f16nhwc_f32nhwc_tensor_op_f32_sm80.cu,sha256=aMcmtH771jejblGcCrqGeaq3nVTCP-zcyIw7iKXyjPk,10514 +bitblas/3rdparty/cutlass/test/unit/conv/device/conv2d_wgrad_implicit_gemm_f32nhwc_f32nhwc_f32nhwc_simt_f32_sm80.cu,sha256=4t64H7IPyGAakEfUMcVxIK3159zWQ7i0F8mEr09isIo,5157 +bitblas/3rdparty/cutlass/test/unit/conv/device/conv2d_wgrad_implicit_gemm_tf32nhwc_tf32nhwc_f32nhwc_tensor_op_f32_sm80.cu,sha256=FMM_q7a1Ng_IX6Ng3b1O98VxrLp1NtKgejPGMSQYzU0,5772 +bitblas/3rdparty/cutlass/test/unit/conv/device/conv2d_with_broadcast_testbed.h,sha256=bFl8SutpISW6ta8DXbpnOHZ-dZqEc2XzLW7A70hv9gM,23527 +bitblas/3rdparty/cutlass/test/unit/conv/device/conv2d_with_reduction_testbed.h,sha256=ikIYJ3thiy38qWxuZm4f5JWFjQ_09ddZ755Yw4h_xAI,21513 +bitblas/3rdparty/cutlass/test/unit/conv/device/conv3d_dgrad_implicit_gemm_f16ndhwc_f16ndhwc_f32ndhwc_tensor_op_f32_sm80.cu,sha256=47LE-fKASCzjuI1uw8tbGCqFHvVOLZOyad-LQ12hLU4,5135 +bitblas/3rdparty/cutlass/test/unit/conv/device/conv3d_dgrad_implicit_gemm_tf32ndhwc_tf32ndhwc_f32ndhwc_tensor_op_f32_sm80.cu,sha256=H7xAvNeU1Hkpr45GGMNRhukTlRUE406epTjz1_82zXM,5347 +bitblas/3rdparty/cutlass/test/unit/conv/device/conv3d_fprop_implicit_gemm_f16ndhwc_f16ndhwc_f32ndhwc_tensor_op_f32_sm75.cu,sha256=NgtQsE5oyp7zVqHIVrkb3aejNvuAhP5zYnl_mx5h4G4,3736 +bitblas/3rdparty/cutlass/test/unit/conv/device/conv3d_fprop_implicit_gemm_f16ndhwc_f16ndhwc_f32ndhwc_tensor_op_f32_sm80.cu,sha256=bo2eF92Po8EfZhGsso_w5TaMgTmSYDamz4p9MlDRn-A,6560 +bitblas/3rdparty/cutlass/test/unit/conv/device/conv3d_fprop_implicit_gemm_tf32ndhwc_tf32ndhwc_f32ndhwc_tensor_op_f32_sm80.cu,sha256=6tt-jSy-WZQCCPNo4Kq-g5f6XKCZgD3V9EYSbIK9UZI,5257 +bitblas/3rdparty/cutlass/test/unit/conv/device/conv3d_problems.h,sha256=F7KXo3mzCj6x0l8Ahont1I7MSpmmMl0jANPCRvxNsDQ,12276 +bitblas/3rdparty/cutlass/test/unit/conv/device/conv3d_testbed.h,sha256=5gf3Ji27wxaB8wVJH_EvEnrVsgi2JmICLbZQPiJUEJc,21644 +bitblas/3rdparty/cutlass/test/unit/conv/device/conv3d_wgrad_implicit_gemm_f16ndhwc_f16ndhwc_f32ndhwc_tensor_op_f32_sm75.cu,sha256=_T1wueShanQgxlNIClDNQlv2oigCDG04nz9IgnKzZYo,3622 +bitblas/3rdparty/cutlass/test/unit/conv/device/conv3d_wgrad_implicit_gemm_f16ndhwc_f16ndhwc_f32ndhwc_tensor_op_f32_sm80.cu,sha256=sz6aItVbJrcYB7Yg7cOO6GDChSaAfpr-oS_D7jfBchk,6560 +bitblas/3rdparty/cutlass/test/unit/conv/device/conv3d_wgrad_implicit_gemm_tf32ndhwc_tf32ndhwc_f32ndhwc_tensor_op_f32_sm80.cu,sha256=vcxWBsZMln9XZ3R8MwXLhBtydX8zt2jhAFAN7ZT_4E8,5256 +bitblas/3rdparty/cutlass/test/unit/conv/device/depthwise_conv2d_direct_conv_testbed.h,sha256=KI8ushQ_orKrqm6GPY0TcKVY0qsnrpViw5WDpH_yOUM,17700 +bitblas/3rdparty/cutlass/test/unit/conv/device/depthwise_conv2d_fprop_direct_conv_f16nhwc_f16nhwc_f16nhwc_simt_f16_sm60.cu,sha256=WikSpJPJcMxgsg-vBK5Q1urkVSXl3LOb8o16Azs7Z1I,18451 +bitblas/3rdparty/cutlass/test/unit/conv/device/depthwise_conv2d_fprop_direct_conv_fixed_stride_dilation_f16nhwc_f16nhwc_f16nhwc_simt_f16_sm60.cu,sha256=JZhU8la7qB2b9WJOz0EAD_Dj_Bu3HWNdTU3LYam60jE,22194 +bitblas/3rdparty/cutlass/test/unit/conv/device/depthwise_conv2d_fprop_implicit_gemm_f16nhwc_f16nhwc_f16nhwc_simt_f16_sm60.cu,sha256=o18YSSzP63lJPzhAm9O5IZl6-hHqnBWbg4zE3X3cC0U,9383 +bitblas/3rdparty/cutlass/test/unit/conv/device/group_conv2d_fprop_implicit_gemm_f16nhwc_f16nhwc_f16nhwc_tensor_op_f32_sm80.cu,sha256=-hFEfKzrC_VU0Xnc3KfzHnnnwrAOFe1NZKFQ2OpQ6QY,20090 +bitblas/3rdparty/cutlass/test/unit/core/CMakeLists.txt,sha256=5JD36yN0v6GavX5ofzYI5TPPVruW6hs9_nc9b9qptW0,2370 +bitblas/3rdparty/cutlass/test/unit/core/array.cu,sha256=3fyzGuOwQ0ARGlMzHe04jh4VRC9FiTBnvf9DtGLKAH4,7365 +bitblas/3rdparty/cutlass/test/unit/core/bfloat16.cu,sha256=1DPDeysJsyujwaGqD2RY0B7uRMco54YWdq9LE9_W8vo,7353 +bitblas/3rdparty/cutlass/test/unit/core/complex.cu,sha256=inx6FQsTuUp8vcVi9EJCLCip91eqgumrfkx9FdBUF0Q,6981 +bitblas/3rdparty/cutlass/test/unit/core/cpp11.cu,sha256=ehBD4YdROIl9sTTIWrksUvDSGwDBSF43ZUlBUTcWiQU,3738 +bitblas/3rdparty/cutlass/test/unit/core/float8.cu,sha256=-dLD0WAO3-Dn1kBUcgI0qSpQ6JROIUEvyhxfKfmGHAI,4208 +bitblas/3rdparty/cutlass/test/unit/core/functional.cu,sha256=xV-LWEh-Jxgy_pun5Lo6TwbYgsucZfC5rCub8FOHvYc,13001 +bitblas/3rdparty/cutlass/test/unit/core/half.cu,sha256=2FcEIIpCsOuFnb30wMAdlqJt2Ttmv8PfRUnOsQCLSpg,3553 +bitblas/3rdparty/cutlass/test/unit/core/matrix.cu,sha256=wV05gbO_1kl99HyaU-cKCOHlKapKWqfHquT0I3JbngI,5295 +bitblas/3rdparty/cutlass/test/unit/core/matrix_coord.cu,sha256=Z9RSQj_XfJiZ10lXIV4r9RgTvhNY8IFPvc16ZJ0tIqs,8592 +bitblas/3rdparty/cutlass/test/unit/core/numeric_conversion.cu,sha256=S6Y_aHWActKOqvAQiVbxPnx-35ePpoL0FxgvbKVqmR0,14188 +bitblas/3rdparty/cutlass/test/unit/core/predicate_vector.cu,sha256=G3NgHT4nC8mIYe7S2jHai8_GiPXBffXmtBqDlk72G6o,8148 +bitblas/3rdparty/cutlass/test/unit/core/quaternion.cu,sha256=UWfGWRYaFHwnocBmxhG0WuvVONkzwDxt01BvqbxuwKU,5777 +bitblas/3rdparty/cutlass/test/unit/core/tensor_ref.cu,sha256=zrSEvbffUBkWzJlb-60EhKJQiCC6av6MEPfOIznCBks,6746 +bitblas/3rdparty/cutlass/test/unit/core/tensor_view.cu,sha256=a5r3puBvtDoAemxwi7JBg-w7NPPRZqkp5D26NX_JBSY,8885 +bitblas/3rdparty/cutlass/test/unit/core/test_unit_core.cpp,sha256=YBx69TuUpsXEWTa5bIS1NzJ1Lvhjnsa0nlNUmxCWZPw,2050 +bitblas/3rdparty/cutlass/test/unit/core/tfloat32.cu,sha256=Yq9pHnKk8MJZnsaLYmGu7axxEVO5awClwSVJucO2gZI,7088 +bitblas/3rdparty/cutlass/test/unit/cute/CMakeLists.txt,sha256=WBCgLIJkOGB7lufv5aW3yF5KtbtB9MAdgUTr4BwKwCw,2136 +bitblas/3rdparty/cutlass/test/unit/cute/ampere/CMakeLists.txt,sha256=4qOCvygSCLpnfXtZFr0UhVJYsWUNZLfvQbkhsOzhkn0,1689 +bitblas/3rdparty/cutlass/test/unit/cute/ampere/cp_async.cu,sha256=55ar9lv7epK4ploDstwLQqQqLpZNlVtMuwEeY2GwLRo,3527 +bitblas/3rdparty/cutlass/test/unit/cute/ampere/ldsm.cu,sha256=W6EZGFu8Ywu7NKYQ08YM4MAO870WxbhbXKIBJ4bnwxg,14320 +bitblas/3rdparty/cutlass/test/unit/cute/core/CMakeLists.txt,sha256=YW__M6lNOzNGotwrN3jmjUkDk_7c5nt1oM8q8jzZkp8,2000 +bitblas/3rdparty/cutlass/test/unit/cute/core/array_subbyte.cpp,sha256=bUKE-kSjJI9riKNsO6N605GeT9qz7FiGgeDcjIKf7ow,6891 +bitblas/3rdparty/cutlass/test/unit/cute/core/bitfield.cpp,sha256=_GUT1L0dsJvPSrCA0MtuRBZqqx2YeY1d4TfF6ig5vss,3472 +bitblas/3rdparty/cutlass/test/unit/cute/core/coalesce.cpp,sha256=KLYGQvZWSEzbszYwpvdRMh9PZgJi6qyxgaBsqJ8keY4,4861 +bitblas/3rdparty/cutlass/test/unit/cute/core/compact_xmajor.cpp,sha256=VzHZwq9NBstfEcBgjJF00qWcmuolbyQ8xjRekrWJvwM,8195 +bitblas/3rdparty/cutlass/test/unit/cute/core/compare.cpp,sha256=oL-1tF_tTAqF-bbVBo6-WT8d-WbZsPLw98IEEVlVuZg,5620 +bitblas/3rdparty/cutlass/test/unit/cute/core/complement.cpp,sha256=9oew2sbIVPoJSEv41N22ryES4Y-lS98MBXD3PT6_v_g,7178 +bitblas/3rdparty/cutlass/test/unit/cute/core/composition.cpp,sha256=2C0GN0_lTbYTtwkO0vT-70rG4UVOsBNyKT6Eq10mdFw,12569 +bitblas/3rdparty/cutlass/test/unit/cute/core/constants.cpp,sha256=hjDeN2DxuRjSPIH9p4iJBttXWbA_7cXbrlmZQk48Opc,3195 +bitblas/3rdparty/cutlass/test/unit/cute/core/core_unit.cpp,sha256=dGskDewQFfxkyF3ttE-_h54aqy0G09a1E8IGDZpVZLw,2007 +bitblas/3rdparty/cutlass/test/unit/cute/core/inverse_left.cpp,sha256=T-u8M_DJzEmLWJtV_LcAPa_EjfXrAkzwsQmpI9hsHqc,4856 +bitblas/3rdparty/cutlass/test/unit/cute/core/inverse_right.cpp,sha256=i3138ICwKa2z1y6-p23tZpts86PbUURyg11lmUd4Q98,6867 +bitblas/3rdparty/cutlass/test/unit/cute/core/logical_divide.cpp,sha256=KlLf823HXlB4_YJKeWJdtEnJDTxbfAUlFeLFYLiSr-c,6734 +bitblas/3rdparty/cutlass/test/unit/cute/core/logical_product.cpp,sha256=nUiXxCpVXExzIIt6rq3hLvXwEqbX17_vgvfzWivW9oQ,5914 +bitblas/3rdparty/cutlass/test/unit/cute/core/mixedbits.cpp,sha256=N9-hBQjc6eCLXTZgBz-ope252mF7YqvNebnlxire9zU,2956 +bitblas/3rdparty/cutlass/test/unit/cute/core/nullspace.cpp,sha256=FgGbORz0NJzMYP-fV9Vk5F94a_CRh-JsdEguEZnLPUA,3267 +bitblas/3rdparty/cutlass/test/unit/cute/core/pointer.cpp,sha256=Gwdhpzcu_EuIdNUizIEgrXlhKbyetDz5oEzuNEaMaho,3940 +bitblas/3rdparty/cutlass/test/unit/cute/core/reverse.cpp,sha256=HM6-ekCblcmpIwbsqwChZ9F5gpWYsPndOGdogEAUJHQ,4971 +bitblas/3rdparty/cutlass/test/unit/cute/core/transform.cpp,sha256=gQ6G4XAk1kExyobTAJowpmZUJzzHsRQmxTRvTndnkyw,2342 +bitblas/3rdparty/cutlass/test/unit/cute/core/tuple.cpp,sha256=5G_Y-1U4C4nocB84zvoHVRlVt4_sTzQnCJxdiw1Y408,13304 +bitblas/3rdparty/cutlass/test/unit/cute/hopper/CMakeLists.txt,sha256=OLKcq6NUZbH0cchEBeiqIyA0yRFe7KXoD1XwyJNlxLg,2547 +bitblas/3rdparty/cutlass/test/unit/cute/hopper/bulk_load.cu,sha256=C1bplkg-frMb5HiiGg0d4ROtEnfqAWuWwEdet0_8IGM,7030 +bitblas/3rdparty/cutlass/test/unit/cute/hopper/bulk_store.cu,sha256=E9ky4BQU3ujOeFpbAtZvCAySFYPq9vSV65eyE5G855Y,6407 +bitblas/3rdparty/cutlass/test/unit/cute/hopper/stsm.cu,sha256=OjL6s4q-DZIm4aceCWjwDgB0xemtfHzEpX-AiuBIBHE,14367 +bitblas/3rdparty/cutlass/test/unit/cute/hopper/tma_load.cu,sha256=_wa0IArQei3ubI32w6LKAUwdKV8CzXAWh82_EbyMjsY,18082 +bitblas/3rdparty/cutlass/test/unit/cute/hopper/tma_load_testbed.hpp,sha256=pL7_A4YMJLna_Fw8CeqstynEr-LnVQi2dDUqkUcRTmU,7855 +bitblas/3rdparty/cutlass/test/unit/cute/hopper/tma_store.cu,sha256=uzcoVGyvE_KgUdInfJZML6CXpbzvwHfkLCrIcCdZ5UY,13192 +bitblas/3rdparty/cutlass/test/unit/cute/hopper/tma_store_testbed.hpp,sha256=TIvkDMjrvX5UBs4tSk-L7gaB_KoRba7dbgREqBS-lPg,7108 +bitblas/3rdparty/cutlass/test/unit/cute/layout/CMakeLists.txt,sha256=3ZkE_5ErEduP7N84Xg_OSITIOqVb4SYPxEfpY9sR1iw,1688 +bitblas/3rdparty/cutlass/test/unit/cute/layout/layout_operator.cu,sha256=RsbywvHqYTVlmujjlB9FdR3mQBxLnqMt6yq3ydcmygA,4544 +bitblas/3rdparty/cutlass/test/unit/cute/msvc_compilation/CMakeLists.txt,sha256=OkQ2N11gCHcgOaw1sZMEobud7obyJ3yx2Wpmv2II9Ig,1688 +bitblas/3rdparty/cutlass/test/unit/cute/msvc_compilation/tuple.cpp,sha256=zGqvPreupzN-sIIRM3iRv0AfBIaXhzDiIpWty-jm7zk,6533 +bitblas/3rdparty/cutlass/test/unit/data/hashes/cached_results_cutlass_test_unit_conv_device_simt.txt,sha256=MmTgU4MnD8faV01HNxPutQdJG3txYqDRQWIwTJBLKh4,71556 +bitblas/3rdparty/cutlass/test/unit/data/hashes/cached_results_cutlass_test_unit_conv_device_tensorop_f16_sm80.txt,sha256=lccgyVaVUooIzus_LTyImW92mS26o26N284XPRbJ4Gw,30745 +bitblas/3rdparty/cutlass/test/unit/data/hashes/cached_results_cutlass_test_unit_conv_device_tensorop_f32_sm70.txt,sha256=AbpJCY09nE4Th7maNtY1ahBVteKV5ydcCC28aL5Lgrk,29308 +bitblas/3rdparty/cutlass/test/unit/data/hashes/cached_results_cutlass_test_unit_conv_device_tensorop_f32_sm75.txt,sha256=pDhbHvFJQWuJv1hV_TyEyt_N3voM3h40p4sDVFOO17c,74311 +bitblas/3rdparty/cutlass/test/unit/data/hashes/cached_results_cutlass_test_unit_conv_device_tensorop_f32_sm80.txt,sha256=EksJTdJxB9gjm5KItwPEbPw2ySAlCYO_3dODKMOzTsw,161075 +bitblas/3rdparty/cutlass/test/unit/data/hashes/cached_results_cutlass_test_unit_conv_device_tensorop_f32_tf32_sm80.txt,sha256=r8sYzHcMV81bTGUZvyt_oKL1sdermVT7hUsBfFF6DE8,49224 +bitblas/3rdparty/cutlass/test/unit/data/hashes/cached_results_cutlass_test_unit_conv_device_tensorop_s32.txt,sha256=1vvce7BnCJToenfUx8Go8ondXb8WLx2Ned25hEkMves,20893 +bitblas/3rdparty/cutlass/test/unit/data/hashes/cached_results_cutlass_test_unit_conv_device_tensorop_s32_interleaved.txt,sha256=owFD9j8Dw-806iMuZek7wH5fnR4JBn6lCacS6zYccJU,21317 +bitblas/3rdparty/cutlass/test/unit/epilogue/CMakeLists.txt,sha256=G4cwJaqCtPbxtsET5gs6Wvi_lG5Np51ApyrCPHJdopE,1990 +bitblas/3rdparty/cutlass/test/unit/epilogue/thread/CMakeLists.txt,sha256=zJTEGANMYZO8Tpx1XVbI-HQ7qqwm-YRsKYvLzhjfGa0,1748 +bitblas/3rdparty/cutlass/test/unit/epilogue/thread/activation.cu,sha256=HtJDplSTIXYPkTSOQDaxFUrPtuvfv9aKFMQWp5ypACI,15818 +bitblas/3rdparty/cutlass/test/unit/epilogue/thread/linear_combination.cu,sha256=tP5pACVR5UOL5S6XyK3OHQP-Mlu5UW_XyRphKfdlRaw,6534 +bitblas/3rdparty/cutlass/test/unit/epilogue/thread/linear_combination_planar_complex.cu,sha256=gumVr3Zv5BTN6oeVOh8kQUIVwogB_LiOzLLtnhnJC_M,9964 +bitblas/3rdparty/cutlass/test/unit/epilogue/threadblock/CMakeLists.txt,sha256=bAgzoJ3TU9LjeaTVRvCkJyePeftCXFZPJf09iSnGxi0,1957 +bitblas/3rdparty/cutlass/test/unit/epilogue/threadblock/epilogue_planar_complex.cu,sha256=9qOaU9nJCWJPj2ApdVIkjk5znvJ2hqrKHsKuoQuCHt4,13824 +bitblas/3rdparty/cutlass/test/unit/epilogue/threadblock/epilogue_simt.cu,sha256=EbagFJ_ucHRhogOlj-8h7OysC1NXhF6spAwJLZoWELI,27176 +bitblas/3rdparty/cutlass/test/unit/epilogue/threadblock/epilogue_simt_sm60.cu,sha256=CgjorPdRF3rfZhiW3EjXjP0ltRckV7o-FuwiWLJyDP0,12061 +bitblas/3rdparty/cutlass/test/unit/epilogue/threadblock/epilogue_simt_sm61.cu,sha256=QD1M_zIN06s4HQEWh_vruJpAW9k0xe31JWcJWDFeq2E,25275 +bitblas/3rdparty/cutlass/test/unit/epilogue/threadblock/epilogue_tensor_op.cu,sha256=icRn3x4SnHOL_qBQOJWr4-2l2FkOSd-CWLrgbnRLoI4,84612 +bitblas/3rdparty/cutlass/test/unit/epilogue/threadblock/epilogue_volta_tensor_op.cu,sha256=mLQqThfsjeij6XG1mxrQx5uP77MZTLY_AqbuMMISYVo,70486 +bitblas/3rdparty/cutlass/test/unit/epilogue/threadblock/epilogue_with_reduction_tensor_op.cu,sha256=sE__VS6VEyjsNEX1Ob3MYTFJwkkEE8w4-QZWbeDSTsE,25293 +bitblas/3rdparty/cutlass/test/unit/epilogue/threadblock/epilogue_with_reduction_testbed.h,sha256=VjsMvLO9SdUiBbWNysVkXMYJ6B1ItV_HgqMjP_Jpi-o,13012 +bitblas/3rdparty/cutlass/test/unit/epilogue/threadblock/epilogue_wmma_tensor_op_sm70.cu,sha256=l9PGy8YLGfb7PAW3AyaVUygI7c_7mJFZHrHo479fHHU,7743 +bitblas/3rdparty/cutlass/test/unit/epilogue/threadblock/output_tile_threadmap.cu,sha256=I2ngv32m4UPmwJi-5pufWMULiW5ToYpeDaQyMeSshbg,19178 +bitblas/3rdparty/cutlass/test/unit/epilogue/threadblock/predicated_tile_iterator.cu,sha256=SjFK9H5FnH2d5QSM4WLmm48hX6Wk4TK-xDuSKDtBpNo,28433 +bitblas/3rdparty/cutlass/test/unit/epilogue/threadblock/testbed.h,sha256=ikXaaNenB75TSYAq59yYtnToddkV_R3tdOgCwF_knw8,11038 +bitblas/3rdparty/cutlass/test/unit/epilogue/threadblock/testbed_planar_complex.h,sha256=EzUwgNds5Rn22W8pzNko35cMDre8yeHoM3cw3DuL3YY,11734 +bitblas/3rdparty/cutlass/test/unit/epilogue/warp/CMakeLists.txt,sha256=UefFeBJw0heO_nMWd_OBRct1F9s8hpJHn6-5_CaTCJQ,1779 +bitblas/3rdparty/cutlass/test/unit/epilogue/warp/fragment_iterator_tensor_op.cu,sha256=jJOzFu-6W8BTY7OrMfPFS_LGmKQUaE6s04qhOsgLosk,6783 +bitblas/3rdparty/cutlass/test/unit/epilogue/warp/fragment_iterator_volta_tensor_op.cu,sha256=lWn28psuBS_mIDKzHqFR89K3E6tdn9xDvrgjVCWuPko,7275 +bitblas/3rdparty/cutlass/test/unit/epilogue/warp/fragment_iterator_wmma_tensor_op.cu,sha256=Sc7vqhoWSESZw9ytKu4M9L7JE3dtoAb70MZ3FU2tTr0,6616 +bitblas/3rdparty/cutlass/test/unit/gemm/CMakeLists.txt,sha256=CNZ0EqVB9_xM5pklgSwSj-EHR5fFFaaJUu_vyYWOP2o,2041 +bitblas/3rdparty/cutlass/test/unit/gemm/device/CMakeLists.txt,sha256=UJMT8eu_SR2zbd8KQGbQIlo0c1LhB2_RMvMNxI2YB7E,22852 +bitblas/3rdparty/cutlass/test/unit/gemm/device/__pycache__/simt_sm50.cpython-310.pyc,, +bitblas/3rdparty/cutlass/test/unit/gemm/device/default_gemm_configuration.hpp,sha256=8R78uAWb67_MWcIlYFcWPyzoKUPX_cYdy5oQCQTuqTI,53062 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_b1t_b1n_s32n_tensor_op_s32_sm75.cu,sha256=DweO2OrgDmtex3tXuh9EpZJ0td3_FY2gbH3G1-gbbPM,10188 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_b1t_b1n_s32n_tensor_op_s32_sm80.cu,sha256=FGYwtLdiBS_GN5ell2GdGlOrnvo7ufRa1mBuJ1MEQ5c,33161 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_b1t_b1n_s32n_wmma_tensor_op_s32_sm75.cu,sha256=ozsaLgnFCobmydiLgreiYZyLBjDmdcv-fz3CC9Lc274,8933 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_b1t_b1n_s32t_tensor_op_s32_sm75.cu,sha256=UQ0wx83ICJM4Fjc_RSsWpUFpmRAZS4upkkbFBJ7safg,10162 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_b1t_b1n_s32t_tensor_op_s32_sm80.cu,sha256=1kTREg-9yoZm0gZKlY-MTXaoX-6gUtx3VOFBHgg6cfY,17912 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_b1t_b1n_s32t_wmma_tensor_op_s32_sm75.cu,sha256=LMbI3DucrNzRioDLi1OrBDhrszZPEY73i4fFCavdzjs,8914 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_bf16n_bf16n_f32t_tensor_op_f32_sm80.cu,sha256=4EfuaX3LkQPrhOHqmsf0IxEzck5eQIuLAqL2uERoFSg,16447 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_bf16t_bf16t_bf16t_tensor_op_f32_sm80.cu,sha256=nnVVaUtsoF-12z9g0kQydiTHEK9r0_rUYWZ9sCd_HW8,16575 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_cf32n_cf32t_cf32t_tensor_op_tf32_f32_sm80.cu,sha256=QtPqAcbwVR_7s0pSpDAP6MFzKjtCLpXYGjeNhBYrb_A,8318 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_cf32t_cf32n_cf32t_tensor_op_tf32_f32_sm80.cu,sha256=VdshAl21gTi5fb3WNdz7MXzWXRvrqt2eD5gajgZLHQQ,8317 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_cf64n_cf64t_cf64t_tensor_op_f64_gaussian_sm80.cu,sha256=3CPyiYHZ7Ts_JsW2mov4TrUFJgUM3qYfk0ThbZvi_2I,6714 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_cf64n_cf64t_cf64t_tensor_op_f64_gaussian_sm90.cu,sha256=F2ThMCOYajQVaYAilmOmOopen4Sy_ZoZUGNiHkkeng8,6746 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_cf64n_cf64t_cf64t_tensor_op_f64_sm80.cu,sha256=_DtdulhTPx3DcKS5yV0KUH8L8T49fQy0UrYJZjqojvU,7895 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_cf64n_cf64t_cf64t_tensor_op_f64_sm90.cu,sha256=fhER_3T5impAQ-zLKkTR4eYelLvq9szPcCHQf9yPevI,7929 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_cf64t_cf64n_cf64t_tensor_op_f64_gaussian_sm80.cu,sha256=oYbvqLJT9IkZCM0IOZxinEZdP6T2RwrABmi8AnxpsJs,6516 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_cf64t_cf64n_cf64t_tensor_op_f64_gaussian_sm90.cu,sha256=ApGwF0a3cyJgWOcjidm12AOMRUNNWqpizGF6o8NDerQ,6548 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_cf64t_cf64n_cf64t_tensor_op_f64_sm80.cu,sha256=6JjBb1jmidCoFaBuWaXC30Iih6mgXFF3s8QZWHe4G28,9016 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_cf64t_cf64n_cf64t_tensor_op_f64_sm90.cu,sha256=vWhEO0lTa2Em5FDmJc7lbjxgppx3MaHI4ZNRNWqIc3k,9051 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_f16n_f16n_f16n_direct_store_tensor_op_f32_sm80.cu,sha256=lvDQ_2_SQMfL4_F4dc8snoHWijpIlpE0aOesY-MrqzY,4627 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_f16n_f16n_f16n_wmma_tensor_op_f16_sm70.cu,sha256=r85PgJ1t49P1fq2GcdDvZta5-dFxDWDOo_uKSpHEB0o,6165 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_f16n_f16n_f16n_wmma_tensor_op_f32_sm70.cu,sha256=dG_lJm-RrPzsao2GAlVDR64EliAqbo7pcdQb-BNiwWc,6124 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_f16n_f16n_f16t_tensor_op_f32_sm75.cu,sha256=LqQK6AiqMGLYolfOT3f2OMFc93_B78wxPuzm6kFOCzo,9634 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_f16n_f16n_f16t_tensor_op_f32_sm80.cu,sha256=02ukXmf03fydrxDEVdBOSS0YOtV3CFUhymJWvgjGXO8,16357 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_f16n_f16n_f16t_tensor_op_f32_sparse_sm80.cu,sha256=tHdCGFXQd8_48Pu1jYnpWKFXjLKfRg0eV_-UOsGUlxQ,14158 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_f16n_f16n_f16t_volta_tensor_op_f32_sm70.cu,sha256=2q65miVsIwZUNBuui8C_LffM8waj3g-AEW5QbP2CTWU,8845 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_f16n_f16n_f16t_wmma_tensor_op_f16_sm70.cu,sha256=gTDPAxbQnsdAHVd2fl01O_yUr8pCjeq6alXAAmJsazc,13583 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_f16n_f16n_f16t_wmma_tensor_op_f32_sm70.cu,sha256=CT8ppRCG0WlJalPTl1uIf0O6mkLmQu02EY1WgNYUt7U,13464 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_f16n_f16n_f32n_tensor_op_f32_sm75.cu,sha256=_60Dt8gWhQxWjtSna6ofnYBPy9QXgiUx-olc_aBr15Y,9571 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_f16n_f16n_f32n_tensor_op_f32_sm80.cu,sha256=l5LuufijtK5ex66uVc-EAG-Ix43MDg-eiKrxuCVmnVw,16239 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_f16n_f16n_f32n_wmma_tensor_op_f32_sm70.cu,sha256=oMG0GLszPIKlOCcl_7nKB8cDjUx25iYjeojhN0nzw3w,6140 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_f16n_f16n_f32t_tensor_op_f32_sm75.cu,sha256=SAFbgoB3k87mBCvcwlX_V88PA35xuZ18mBiUK3x2Zq0,9544 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_f16n_f16n_f32t_tensor_op_f32_sm80.cu,sha256=28n-tXhivBFGiQjBNFJjw2NtYKs40ttXvUrnQRyUDo8,16417 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_f16n_f16n_f32t_tensor_op_f32_sparse_sm80.cu,sha256=yBt1fEvms6ZzgCsQkPxoUA3-rgf0FfNKA2RAzOej9f4,13075 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_f16n_f16n_f32t_volta_tensor_op_f32_sm70.cu,sha256=qTcZDpfYWuzDRF4UDRQB6DRkCXv2Zd0I9NrnU32oILc,8775 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_f16n_f16n_f32t_wmma_tensor_op_f32_sm70.cu,sha256=lrgNx4fwyejHfBsincX8poXZRaRSCI9Ej2-vGqYlrR0,11470 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_f16n_f16t_f16n_wmma_tensor_op_f16_sm70.cu,sha256=_REPyLmoiZ1hchz2X0jTiZ3o6URsia01lEY9g3iisMg,6156 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_f16n_f16t_f16n_wmma_tensor_op_f32_sm70.cu,sha256=pmeVALlJ65_mc5VjAjGKZJjd-il0tR5sUiQExr_zw7w,6116 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_f16n_f16t_f16t_tensor_op_f16_slicedk_sm75.cu,sha256=Fat9xmjeFiyiClPK7yuvCn6wiDcS_rjyVekV4PwBKUg,3528 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_f16n_f16t_f16t_tensor_op_f16_slicedk_sm80.cu,sha256=ikWOSB3CZ8yqrqV8SvmSF3T_pnDnCvnMJzsr5Dd-POI,3539 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_f16n_f16t_f16t_tensor_op_f16_sm75.cu,sha256=PVyyCWrtBydqSIcVb6tEtLQFUcVCs2gkhAMQOVZAXms,7965 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_f16n_f16t_f16t_tensor_op_f16_sm80.cu,sha256=7Rv2V00Hil2DJJnmWxYQmiEHecgJnWz53ei9Y51KKxg,16470 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_f16n_f16t_f16t_tensor_op_f16_sparse_sm80.cu,sha256=XmF-4Bz-ACjNlRaqOSJXgOzYV7Fs2fxzGAI__plckXc,13273 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_f16n_f16t_f16t_tensor_op_f32_sm80.cu,sha256=LxPhk2jOrNNXuOIJTMlkd6J-wK6d3Fqk2_pwAatiSU4,3648 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_f16n_f16t_f16t_volta_tensor_op_f16_sm70.cu,sha256=Ftfvp8qfxL5cMdEKdh5q6uYRIQU6FDQ7fpHr1r2OzF4,8608 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_f16n_f16t_f16t_wmma_tensor_op_f16_sm70.cu,sha256=vFCFFJUZxW_m6csgAZ9746RLUP1gLUneqCVa55C-7UE,13518 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_f16n_f16t_f16t_wmma_tensor_op_f32_sm70.cu,sha256=Jrb79sYmu6SP_qwR2Gbz1ihjjNPsbHHS7M441nVCHuY,3645 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_f16n_f16t_f32n_wmma_tensor_op_f32_sm70.cu,sha256=YxvPr4zmrTaFsu6VSp0jofx04HJBlKhaPfPt1AC_wb8,6096 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_f16n_f16t_f32t_tensor_op_f32_sm75.cu,sha256=9SS_kVaz6lZdNdWQl6gEJZvZlGxJTp4nqh334U-JZ70,7845 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_f16n_f16t_f32t_tensor_op_f32_sm80.cu,sha256=aaKQpIoDBbpvLAVbn95a3Y4efA70K08fl0INh0wFCGI,18135 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_f16n_f16t_f32t_tensor_op_f32_sparse_sm80.cu,sha256=ewNUJsVhcRy2Zqoh8iWzF3JARdALp27cdNpbbGYXYUk,13008 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_f16n_f16t_f32t_volta_tensor_op_f32_sm70.cu,sha256=RDA6mt4duCltMQOkfHJbNTQtnUPw3XAH-ngIv8MW9d4,8505 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_f16n_f16t_f32t_wmma_tensor_op_f32_sm70.cu,sha256=BcFlMgO6qhZ0tdlgpxdiqciD5ROvBAEFXBhi-aeVls8,11497 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_f16t_f16n_f16n_singlestage_wmma_tensor_op_f16_sm70.cu,sha256=06HrbRnex1_F5vtinPpPIEJ_5hi1ZQ0qVAKoaN4s8JE,11090 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_f16t_f16n_f16n_wmma_tensor_op_f16_sm70.cu,sha256=mNYd-ewrtR52CHnWWPbPqU-1MPseQZ75Fk2_KxAAp-E,6156 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_f16t_f16n_f16n_wmma_tensor_op_f32_sm70.cu,sha256=R84_EvYM-4f1rzbM8QAyLpbQ1PxmiSjsvcy8sp32ALY,6116 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_f16t_f16n_f16t_singlestage_wmma_tensor_op_f16_sm70.cu,sha256=KEtXIbw02euvvkO1Fb3KT9AuhLKbyJIQFtVQKidmaOA,11066 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_f16t_f16n_f16t_tensor_op_f16_broadcast_sm80.cu,sha256=AjTRlekA2VFr9JthzhUJaWEnu7AwIN_GgOYdgKcCALY,17080 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_f16t_f16n_f16t_tensor_op_f16_slicedk_sm75.cu,sha256=cZ_V9dIBnWNYqgNB1RidfOfh_2zE0S3ji9ZIbK6mH4U,3528 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_f16t_f16n_f16t_tensor_op_f16_slicedk_sm80.cu,sha256=1czRHjSqIkhNR1LzzRNAOB7HWjH99Bp9tQ1gxMxDq34,3540 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_f16t_f16n_f16t_tensor_op_f16_sm75.cu,sha256=PEUeDHG8M8JOjnHs_xvtjmTcDq_BULNK2XAqO0m7Ft8,7964 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_f16t_f16n_f16t_tensor_op_f16_sm80.cu,sha256=m6zQZD2ReIbwuA5cci_jBFXNdY_Ukd3u0HkTONZyLkA,16457 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_f16t_f16n_f16t_tensor_op_f16_sparse_sm80.cu,sha256=jIWv5rircSsy66PWnojV02UuOyLcVB1ItA8xBj0ZOls,13266 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_f16t_f16n_f16t_volta_tensor_op_f16_sm70.cu,sha256=QmhH-L3StwmAG2300SEKmMG0hLU1k510vqxrMPsUE18,8933 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_f16t_f16n_f16t_wmma_tensor_op_f16_sm70.cu,sha256=qVqLhPZbQoM0kJO4tB4LYLg4eG8bZjcEOIsZ0Ci5iSk,13551 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_f16t_f16n_f16t_wmma_tensor_op_f32_sm70.cu,sha256=3aXyV0FaYKw8_05G-12AlWqs2Imql5J8y3I8DTwVv8o,13540 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_f16t_f16n_f32n_wmma_tensor_op_f32_sm70.cu,sha256=pyKHjyY8-Q_SMJy-cs7YDFvuv-eTXMG5L1HY0u_oMaM,6130 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_f16t_f16n_f32t_singlestage_wmma_tensor_op_f32_sm70.cu,sha256=z8TPiQMHAQSy0a5bBStiLRFpI86I4i4WjHlKFcwtlyE,8160 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_f16t_f16n_f32t_tensor_op_f32_sm75.cu,sha256=WcE383f6P2-9HUxjXX16ns59EBlUbnX8uxDt99ynOEo,7847 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_f16t_f16n_f32t_tensor_op_f32_sm80.cu,sha256=5MbN7tVDvTWPCm-eYRBD_K2cE7Vz1-frClpvJfrD55o,16131 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_f16t_f16n_f32t_tensor_op_f32_sparse_sm80.cu,sha256=yhJtIruuajsHwAgWZwsuR3cIhk6f2zVcOMYHzm5sILo,13014 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_f16t_f16n_f32t_volta_tensor_op_f32_sm70.cu,sha256=SFEWD9Z1kJ4eviiaVe6D4i51KTE4XGwR0HrqIRSUehM,8754 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_f16t_f16n_f32t_wmma_tensor_op_f32_sm70.cu,sha256=vEAVeQwiHGVZ7RzSA11-COQBzZPqVw8k1eMdzjXWz3M,11497 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_f16t_f16t_f16n_wmma_tensor_op_f16_sm70.cu,sha256=Ohc2jwcR9luPdYpH669euygGoJt3n_HSPk4pKHGXFJQ,6147 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_f16t_f16t_f16n_wmma_tensor_op_f32_sm70.cu,sha256=v9EygePeERipi2c8SGF31rxZnrVZnQQqPoswG_Y8lBw,6107 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_f16t_f16t_f16t_wmma_tensor_op_f16_sm70.cu,sha256=RCQwq9y_FLbbB04Yr19wWok1gA28tSDrOfzZmEwHJBU,13518 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_f16t_f16t_f16t_wmma_tensor_op_f32_sm70.cu,sha256=wR634t5MQlq-YiVCi9pz2Kh0h7OLGiRjlptbPeDVDCg,13398 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_f16t_f16t_f32n_tensor_op_f32_sm75.cu,sha256=JKxU8MqForVRpc1qZPXAv-a-Qc_Yd0deDIL9LBJujnY,7845 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_f16t_f16t_f32n_tensor_op_f32_sm80.cu,sha256=4cRREUT1rnhX-XuAzW5_6ydL4UxVH3xfTpPOF5Q4CDc,16149 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_f16t_f16t_f32n_wmma_tensor_op_f32_sm70.cu,sha256=2NUgq61uFrOzuyHBhL8Ot9zQZw1y8MxtutONfurPtNI,6119 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_f16t_f16t_f32t_tensor_op_f32_sm75.cu,sha256=Rj-_evB0JBvSn-LnVib6LIHLOfWRfWDr4NOB91_09Rk,7827 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_f16t_f16t_f32t_tensor_op_f32_sm80.cu,sha256=1ETqviOhaoIZ9ySp4AB72bnsgcCYd1d8otgET6ceNdc,16101 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_f16t_f16t_f32t_tensor_op_f32_sparse_sm80.cu,sha256=XyYdL42o92Z0twqkAxcvlCLCSDyXh8g7JOdQ3pmKf6g,9526 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_f16t_f16t_f32t_volta_tensor_op_f32_sm70.cu,sha256=hsp3IqAg0OfTDX2274Xh868Yvbp5wVj9CuSIVEVtmYs,7898 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_f16t_f16t_f32t_wmma_tensor_op_f32_sm70.cu,sha256=1wT1EtSp04X6QnVi_6w_LgaxTbVntBj1YT_WcTrxuWg,11470 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_f32n_f32n_f32t_tensor_op_bf16_f32_sm80.cu,sha256=CL0HJVCrCZu2gehu3MkCIbhqMbC8iFB6htyzJ5Sec18,3584 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_f32n_f32n_f32t_tensor_op_f32_sm80.cu,sha256=Y09VnM9TO5N_Ul-oJqEfGrLOGo90BixcVSDmDEY6gsg,3473 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_f32n_f32n_f32t_tensor_op_f32_sparse_sm80.cu,sha256=X-yXNFKF4q1KDuSoHm2D0lDoNyGpPEBfroR8fkRvoso,12967 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_f32n_f32t_f32t_tensor_op_f32_sparse_sm80.cu,sha256=Qdv59elXqqgmqa2tm-ca-4j-wbuQn34BtB_9ozMpd7s,12931 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_f32t_f32n_f32t_tensor_op_f32_sparse_sm80.cu,sha256=7Z8P1fHpmEKm5mLFEqGBt4TZZrovvCn6Wrfwo8leTL8,12930 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_f32t_f32t_f32t_tensor_op_f32_sparse_sm80.cu,sha256=l473J1SbDpMGv2YiRCObMHSW66MXc1cDeDPHCeKYZDk,12895 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_f64n_f64t_f64t_tensor_op_f64_sm80.cu,sha256=xuc8EviNMWwoNdWxvBXWwQIUCh4Bby5I847pS2ecemw,8349 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_f64n_f64t_f64t_tensor_op_f64_sm90.cu,sha256=kHb6HQJug6G_1B4wv1Q-dFWCSDjOlrauCs2vDwdMWa8,7299 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_f64t_f64n_f64t_tensor_op_f64_sm80.cu,sha256=rD7Cwxi30_6q0spMo3k6Mkt2GCxjK3m6IX03wQvxtIc,8348 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_f64t_f64n_f64t_tensor_op_f64_sm90.cu,sha256=ffjRL8xAa1IgqDrAvT2Z5ZvsNMthc8wPj2ycTyAV3r0,7290 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_grouped_scheduler_sm80.cu,sha256=Y7gniIuS5JBmrM9gLLtMW_hIPQLxApYwD0gDy64iUoY,10240 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_grouped_sm80.cu,sha256=wfCwumqUTO0Uoba64F4ClHdXW9mU-9lgU122aDThCOQ,26102 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_planar_complex_f16_f16_f32_tensor_op_sm70.cu,sha256=EtyssfI9DiUcHm2dvSgMuY0SilIFLNzjN_ZVV3lfT3Y,11339 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_planar_complex_f16_f16_f32_tensor_op_sm75.cu,sha256=9DkiMHV7h_sg4RT9BiMoZ1LdKaDj9K2nbd1mVbAS8KE,7346 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_planar_complex_f16_f16_f32_tensor_op_sm80.cu,sha256=FthS5vE8kA9a5VZ0QCWmfEHK_WEMQ6u3rACqG9tSI64,12397 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_s4n_s4t_s4n_tensor_op_s32_sm75.cu,sha256=54V6OUrGIpOFFVm2t9DsoruNwM2ia0WKOQmD3UirVUc,6857 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_s4n_s4t_s4n_tensor_op_s32_sm80.cu,sha256=2Q4KMOzR-fWvHNeEdKKyBNYby4-bd-_Ff4UlXhct5DI,7239 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_s4t_s4n_s32n_tensor_op_s32_sm75.cu,sha256=htQWUg05uoelLzGB0Lw34tglRpb-a_TtpESb6cXl-rw,8119 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_s4t_s4n_s32n_tensor_op_s32_sm80.cu,sha256=VxzsRvbZtZ-mDxrKfW31u1vv72lYwU_oPWU-UkHO96c,16882 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_s4t_s4n_s32n_wmma_tensor_op_s32_sm75.cu,sha256=3Vd1pG8o0qSCorPIrsUQfBdZ-7bN_cfCDEVNVG84Fmo,8405 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_s4t_s4n_s32t_tensor_op_s32_sm75.cu,sha256=qsFyxdOtiHSQnBBtk4rwDKfPaaZIQNMIsyOibJpVqq0,8101 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_s4t_s4n_s32t_tensor_op_s32_sm80.cu,sha256=GDveWvOzbA2cR32nfezxOPZnzxyT_eKC_LjOOb3oEn0,17111 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_s4t_s4n_s32t_tensor_op_s32_sparse_sm80.cu,sha256=iJX3dUscaIoiK1dB1kDzb70jeXCU1NmjQXQgOXvd7bs,12637 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_s4t_s4n_s32t_wmma_tensor_op_s32_sm75.cu,sha256=X5tLz_ZQEd-6ggby9PFo0dfwBCuFScB6ETH8W7yAhvU,8387 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_s4t_s4n_s4n_tensor_op_s32_sm75.cu,sha256=-zw8uw3NCteshV-fPIBTNmuBSKoIke3rFiHQDyBfG0g,10938 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_s4t_s4n_s4n_tensor_op_s32_sm80.cu,sha256=oJXtsQJA7nZunGCFvQRp-SefDt7vBTbOa4FHo_fLUW4,18441 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_s4t_s4n_s4t_tensor_op_s32_sm75.cu,sha256=hGoQrip_vMm342TltbDqym6yuHvLMraXuqBX52wDG54,10911 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_s4t_s4n_s4t_tensor_op_s32_sm80.cu,sha256=Ut21kDQ36BI3jYDkRnA7Z34CNYdGDYYBAP7CouCMTiw,18441 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_s8n_s8t_s8n_tensor_op_s32_sm75.cu,sha256=UZa-RF62ODwgA8rvAUKxO_eNIjTn3zS0CBywp4vN4Fw,9586 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_s8n_s8t_s8n_tensor_op_s32_sm80.cu,sha256=fzHp7JMjgY_lk6HDwNDm3cE3k2qhEZvfCsXJw_OP08w,11288 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_s8t_s8n_f16t_tensor_op_s32_sm80.cu,sha256=62QjgCQ5Pb3-XiL1e9ifT4xpys6xMePpdnVF1a7k5q8,3514 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_s8t_s8n_s32n_tensor_op_s32_sm75.cu,sha256=-y7xxxCMbhX-XH9pP6lihia8Tl005jgiWxjpAbxntSw,7975 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_s8t_s8n_s32n_tensor_op_s32_sm80.cu,sha256=Ffkywey-48TU7hqCbdzwSrDKI415KMRF7bCd9_JT1vA,16531 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_s8t_s8n_s32n_wmma_tensor_op_s32_sm72.cu,sha256=1fMMsUVrROgjHhjHO4oK4SpmJ-2XshCOfqzRTXa2Kr0,5693 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_s8t_s8n_s32t_tensor_op_s32_sm75.cu,sha256=mCoeNteSkCeLRXlxLDbg2IDGGlMlh8Zpi6vuv6yUwB0,7957 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_s8t_s8n_s32t_tensor_op_s32_sm80.cu,sha256=eO1QACVkmUpvHVhXwyPkklrqXdWMH1nJtNs_UfumHUI,16691 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_s8t_s8n_s32t_tensor_op_s32_sparse_sm80.cu,sha256=M4WGoJJ440Vco0JwKSt6RGMYnRXv05OZiZJMhZ9jqyU,12408 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_s8t_s8n_s32t_wmma_tensor_op_s32_sm72.cu,sha256=Xv91tG1f6O43AeWqiHEqFZw7AO7NTG-W8kw6wdkwTmY,6864 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_s8t_s8n_s8n_tensor_op_s32_sm75.cu,sha256=fbZP58KfpHwE43nWzN-rwArk4zeolsHF4uGdP_LCdqc,8538 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_s8t_s8n_s8n_tensor_op_s32_sm80.cu,sha256=d1nKBQ1YC5KNNK-_gd7GBRH-myms6Kp1Hkd2nUaBlxs,17362 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_s8t_s8n_s8n_wmma_tensor_op_s32_sm72.cu,sha256=05VcArfhcs7c68MtnWDz1Lvn0ZDpV6MNHRLBmbRKz9I,6675 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_s8t_s8n_s8t_tensor_op_s32_sm75.cu,sha256=sAwao8iKK_7wPsVIFjDUbRItKBNujBeGlpTmfOJpYgM,8543 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_s8t_s8n_s8t_tensor_op_s32_sm80.cu,sha256=bcLP9EJVoa0uCCrSkq_hOjcecv76Bhib6AbECMMUTaA,17312 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_s8t_s8n_s8t_wmma_tensor_op_s32_sm72.cu,sha256=Idkr6-WZaQF15lyZuw81dywV9oJHNkLGhMGLuTk0X5I,6663 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_splitk_serial_tensor_op_sm75.cu,sha256=XYg8dNfOg6c7eylyDGcqkFGqVEDzawuKfMhLPXaJLkc,4663 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_splitk_simt_sm50.cu,sha256=WEYrHG2qnVafZ3PkPzvxGeWVK6h4om4ktpfO5LS3gLc,4945 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_splitk_tensor_op_sm70.cu,sha256=Ffb6OsSA71X41Wyz3szcER-ni65QxBNlWPQxGkdHkyU,6616 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_splitk_tensor_op_sm75.cu,sha256=Z64piZh64w2TNdcxXhF-RJZLXm91pZDgJn6-5ATxBK0,10581 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_testbed_3x.hpp,sha256=6L0T7KgQjy_-OOtf86jLo00FziCFn2HqJ8Ipn2GnxgE,52432 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_testbed_3x_evt.hpp,sha256=p78ZVmbkUWckD8L6eOCiJWcQga5ycMDGPCJPwbqZOcc,46426 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_testbed_3x_tensor_broadcast.hpp,sha256=qdlVmiwY7xKE_XVFJdYTujZRCTLVfKxMI9QB62uLHyA,18794 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_tf32n_tf32n_f32t_tensor_op_f32_sm80.cu,sha256=B7OT1jDN1wiDbKtkIreS2Y2QHb7V3ls-TxyXkdY8dTU,16950 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_tf32n_tf32t_f32t_tensor_op_f32_sm80.cu,sha256=zyJg2QxDTKx4fnBXNOjs39ytpukvxMDpDhCP5ahz5NU,16902 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_tf32t_tf32n_f32t_tensor_op_f32_sm80.cu,sha256=Vs_ZRlkURR8u1NfHq93rKaGGOp27yf5YTPeau9UCC6k,15131 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_tf32t_tf32t_f32t_tensor_op_f32_sm80.cu,sha256=dWSUHCPruA32qWRM6-SUzDrvqJxz_n4wc-XttCAtjig,16855 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_u8t_u8n_s32t_wmma_tensor_op_s32_sm72.cu,sha256=XprLVn3z1zseuNMtHT-Th9KPgLT8jvVPBnw0aEVQwz8,6854 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_universal_cf32n_cf32n_cf32n_tensor_op_f32_sm80.cu,sha256=AmrO5bhxL6-MnKdKsQVJmjPWx_tzDevmw9J-a666W3E,6686 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_universal_cf64n_cf64t_cf64t_tensor_op_f64_gaussian_sm80.cu,sha256=4PPGj4o0VImSDQ4XTd90TmvcgFgFhz-bXodaRcVlbQ8,6755 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_universal_cf64n_cf64t_cf64t_tensor_op_f64_sm80.cu,sha256=LVP2r92TC90yv9tCf7cEBW7mMNp7sdBT8KKE3psuMMM,6687 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_universal_f16n_f16t_f32n_tensor_op_f32_sm75.cu,sha256=fVVUOohNjlNxWgE4QjrAQNuSCkZ8b-Yfa6uGH6IrSaE,4726 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_universal_f16n_f16t_f32t_tensor_op_f32_sm75.cu,sha256=RKnUnG9TBGcItuTtkqOfeFH4jxEj95AGQlalUN5ml5k,4718 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_with_broadcast_f16n_f16n_f16n_tensorop_f32_sm75.cu,sha256=_Henhk7A-l8tzZ2mcYsj8_BXwp9hk6-cy9n1jHyZA8Q,16715 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_with_reduction_f16n_f16n_f16n_tensorop_f32_sm75.cu,sha256=LJheI8r_5b5CQ6yXKmDNmI4lBJnWDQ4gM7lzO9NRvlE,12841 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemm_with_reduction_f16t_f16n_f16n_tensorop_f32_sm80.cu,sha256=8HO5w2VmynVtr5FcFDh3KiLST2EQFszjgD1bWcdA4a0,4544 +bitblas/3rdparty/cutlass/test/unit/gemm/device/gemv.cu,sha256=ZOHxQWUhfXgPb9-eCOnRE0zWbOALQI4AAQjzRqdiG6w,17409 +bitblas/3rdparty/cutlass/test/unit/gemm/device/hemm_cf32h_cf32n_tensor_op_f32_ls_sm80.cu,sha256=gT2Z8WVsW46nwEpurmjTH9e3BGxkNj55ZzKZYIffCHQ,6028 +bitblas/3rdparty/cutlass/test/unit/gemm/device/hemm_cf32h_cf32n_tensor_op_f32_rs_sm80.cu,sha256=fvEQaZLIJo32BNfddwW-8Ol6GdRNjhWlHnbVdbaMf7Q,6031 +bitblas/3rdparty/cutlass/test/unit/gemm/device/hemm_cf32h_cf32n_tensor_op_fast_f32_ls_sm80.cu,sha256=QU9sSuleFe7L21xRkgjoBdDzqVW9FkGmOrYIO0eO2jc,6064 +bitblas/3rdparty/cutlass/test/unit/gemm/device/hemm_cf32h_cf32n_tensor_op_fast_f32_rs_sm80.cu,sha256=8wf4mgZTiQmze4X64qUv1r47Zv-wjxIY0SxaDlc2-9g,6067 +bitblas/3rdparty/cutlass/test/unit/gemm/device/hemm_cf64_cf64_cf64_tensor_op_f64_sm90.cu,sha256=Os0p8uIWNiAqQbOPqYdfbA8QMUI9dqTmK5x2ws5r0_M,4908 +bitblas/3rdparty/cutlass/test/unit/gemm/device/hemm_cf64h_cf64n_cf64n_tensor_op_ls_f64_gaussian_sm80.cu,sha256=Qebi5MTUgNIfjeAsOTbLZoIRE0WkipXclevRMOXquWk,6088 +bitblas/3rdparty/cutlass/test/unit/gemm/device/hemm_cf64h_cf64n_cf64n_tensor_op_ls_f64_sm80.cu,sha256=hQNCmcULhNJGufAvIRVntS0FZY4nVt2KEWatdSiG8Ek,6037 +bitblas/3rdparty/cutlass/test/unit/gemm/device/hemm_cf64h_cf64n_cf64n_tensor_op_rs_f64_sm80.cu,sha256=G6sG-7PBC6qK8lpLDGeirduDYKLGvuQKw68MrJQSjE0,6040 +bitblas/3rdparty/cutlass/test/unit/gemm/device/her2k_cf32h_cf32n_tensor_op_f32_sm80.cu,sha256=GpuZlWkvQaTSnfr6H1VOpIPzYBDNIaqbn3fQ5AZvsMU,5382 +bitblas/3rdparty/cutlass/test/unit/gemm/device/her2k_cf32h_cf32n_tensor_op_fast_f32_sm80.cu,sha256=NW67CZDYTStI-EbOjW-4-FMCJ-acbuS-jim4jCcwNB0,5406 +bitblas/3rdparty/cutlass/test/unit/gemm/device/her2k_cf64_cf64_tensor_op_f64_sm90.cu,sha256=t1qQIbeSHakzUKIbV5MMOIBUAvt7ljBC2H06egtlCC0,5401 +bitblas/3rdparty/cutlass/test/unit/gemm/device/her2k_cf64h_cf64n_tensor_op_f64_grouped_sm80.cu,sha256=7asphR6beW0UZYdutCq1dRUqJE0WPtDLUTphRbA-owA,13055 +bitblas/3rdparty/cutlass/test/unit/gemm/device/her2k_cf64n_cf64n_tensor_op_f64_grouped_sm80.cu,sha256=6fGxMBSUEwmQJL4CvSOtZ8EsJKZEjPf6tyDAlRYJCC0,13027 +bitblas/3rdparty/cutlass/test/unit/gemm/device/her2k_cf64n_cf64n_tensor_op_f64_sm80.cu,sha256=75EM-UpM5J24zyRLXZ0ESobsmBwNxw8PFwVO7qgGg3Q,5388 +bitblas/3rdparty/cutlass/test/unit/gemm/device/her2k_cf64n_cf64t_tensor_op_f64_sm80.cu,sha256=r3AOT9iFLqj1toLEievPCrSGWuBVVt4qEWrUX8SB4VE,6939 +bitblas/3rdparty/cutlass/test/unit/gemm/device/herk_cf32h_cf32n_tensor_op_f32_sm80.cu,sha256=LiTKK98T8mWL1ru0CgriS6r_xvNadnxn_-UXzDzQUPs,7677 +bitblas/3rdparty/cutlass/test/unit/gemm/device/herk_cf32h_cf32n_tensor_op_fast_f32_sm80.cu,sha256=qufR5wHLhsei9rkNxh6t1Xt4oCibDlw5lX5a45xD-4E,7725 +bitblas/3rdparty/cutlass/test/unit/gemm/device/herk_cf64_cf64_tensor_op_f64_sm90.cu,sha256=RInuhlMQYUxPw2i-Z_UNL9ND4GCFSlAueNy9o6Ieth0,3853 +bitblas/3rdparty/cutlass/test/unit/gemm/device/herk_cf64h_cf64n_tensor_op_f64_sm80.cu,sha256=5Nc6ESqSbQkXi5OMgOOo-E10fn0lmaNox0kNkIXqIC8,6396 +bitblas/3rdparty/cutlass/test/unit/gemm/device/multistage_testbed.h,sha256=AZX0VR2WO8MOswszDDl0UnUDeB7cIM_VqC1W_9T0hn4,10123 +bitblas/3rdparty/cutlass/test/unit/gemm/device/multistage_testbed_interleaved.h,sha256=6gq41BDvG8o4dVKbDMmkv2N_NC23BW9rzl5vVRLbEjU,10272 +bitblas/3rdparty/cutlass/test/unit/gemm/device/rank_2k_grouped_scheduler_sm80.cu,sha256=vD4f1Z6cadCa3tWP9iyX8pcZXEj84n-5TrvUa0lKeO0,11186 +bitblas/3rdparty/cutlass/test/unit/gemm/device/simt_cgemm_nn_sm50.cu,sha256=auw9J0uM3SGWJ0IauxVFl5U2hYtvXEwLO0EA4TFVk_A,46795 +bitblas/3rdparty/cutlass/test/unit/gemm/device/simt_cgemm_nt_sm50.cu,sha256=x4by9l-vKF3zYRsbr99h_gzidxZh8hWaYttAHe_iwRs,54085 +bitblas/3rdparty/cutlass/test/unit/gemm/device/simt_cgemm_nt_sm80.cu,sha256=XK9GMw4au5tGo6BR45S7xMOnh5w88mUTM-I6uCOtYQ0,8318 +bitblas/3rdparty/cutlass/test/unit/gemm/device/simt_cgemm_tn_sm50.cu,sha256=U_Ib4v1OORMRjEujWQ-80WrkvPytXpuI9-mvUpfXQFI,46687 +bitblas/3rdparty/cutlass/test/unit/gemm/device/simt_cgemm_tn_sm80.cu,sha256=F3CqzK2HvLbAAqLsLaSNtIcSVBSQ_y0ha07ajZboy5c,8411 +bitblas/3rdparty/cutlass/test/unit/gemm/device/simt_cgemm_tt_sm50.cu,sha256=_WOg1XAF-67LQyNZdMJWkcN34h3wWV9WAjDtUAPURuI,46578 +bitblas/3rdparty/cutlass/test/unit/gemm/device/simt_dgemm_nn_sm50.cu,sha256=GVWj4TA48qI2UKzmPdDDdasy-H-6WeKLlQBU5qDA2Xg,40533 +bitblas/3rdparty/cutlass/test/unit/gemm/device/simt_dgemm_nt_sm50.cu,sha256=bdTZUxLSBkQMO00KOnFeL-kY-LIt7AZH3LmP09W4XaA,47656 +bitblas/3rdparty/cutlass/test/unit/gemm/device/simt_dgemm_tn_sm50.cu,sha256=X-74an-pishUwAT_c0tIPlZDNyWTn3PcEL67F00yXro,40441 +bitblas/3rdparty/cutlass/test/unit/gemm/device/simt_dgemm_tt_sm50.cu,sha256=fmbLe1XTkYHxY9AY73kG2lpN3UWeWJrsjz_9nKDM5S0,40354 +bitblas/3rdparty/cutlass/test/unit/gemm/device/simt_f8gemm_tn_sm50.cu,sha256=iiaCrfsck0CB9nEBI1zbIvO7Oa7YGyMb_m94fFhinpo,3513 +bitblas/3rdparty/cutlass/test/unit/gemm/device/simt_hgemm_nn_sm50.cu,sha256=LeOAQWVxQ8UIUJ915Por4NVmy1-ENG-C1ToMJjpd_Sw,89517 +bitblas/3rdparty/cutlass/test/unit/gemm/device/simt_hgemm_nt_sm50.cu,sha256=xSyfr6HoIbIHzdrG_twoU4jOcDohEiSAQ-LuCIZzWo4,89304 +bitblas/3rdparty/cutlass/test/unit/gemm/device/simt_hgemm_tn_sm50.cu,sha256=uEfHxltY3fPoMKCE0ThSWB_MAqLjtQRSvshMaZhKa8Q,89304 +bitblas/3rdparty/cutlass/test/unit/gemm/device/simt_hgemm_tt_sm50.cu,sha256=MgtmskPPjjedQfqZNU2TLO0NamWJpDbM6BVQtIrSa44,89091 +bitblas/3rdparty/cutlass/test/unit/gemm/device/simt_igemm_nn_sm50.cu,sha256=A01H3ZoNBLPVL56uVvcfbDwrBof_iCk4rhXtQVBHVOU,69175 +bitblas/3rdparty/cutlass/test/unit/gemm/device/simt_igemm_nt_sm50.cu,sha256=1Sol-g-C9ieu7LfXJZVcRKjOD8ou49W6tL6ZK7Oscns,71438 +bitblas/3rdparty/cutlass/test/unit/gemm/device/simt_igemm_tn_sm50.cu,sha256=UiC_78kR-NLzmD1PffFRkPP5z-UmNzJ0LsANPS4A88I,67796 +bitblas/3rdparty/cutlass/test/unit/gemm/device/simt_igemm_tt_sm50.cu,sha256=U4TOzpao7h3AinuSJt0u_JkWWjnj-otv5lSc8thPCGA,70056 +bitblas/3rdparty/cutlass/test/unit/gemm/device/simt_int8_igemm_sm61.cu,sha256=zrWmSycxvDZF_CFxCGpeYnDHkYjZVJB4DVkPhfsMzjg,7156 +bitblas/3rdparty/cutlass/test/unit/gemm/device/simt_int8_igemm_sm61_perf.cu,sha256=o9YEYdbB8WniIzPs3N_KBsbGjcj9L8WD9eJcZcb8OTA,6067 +bitblas/3rdparty/cutlass/test/unit/gemm/device/simt_int8_igemm_sm61_sliced_k.cu,sha256=q9uvwjt6fi5KS5mjQ0HBXdKrr6UYWIDfrndAbxU4OFE,9063 +bitblas/3rdparty/cutlass/test/unit/gemm/device/simt_qgemm_nn_sm50.cu,sha256=HCTMpBE6fQ9iDyGP_0VbEIUXo0AMH7g7SiRRo0CnZA0,35894 +bitblas/3rdparty/cutlass/test/unit/gemm/device/simt_qgemm_nt_sm50.cu,sha256=KIe8KpCFURgYJyn_DvuPBYi7hIjfjP33nwRPkIKz9W0,35813 +bitblas/3rdparty/cutlass/test/unit/gemm/device/simt_qgemm_tn_sm50.cu,sha256=wzIIYxM9sY_5oZS7LgTrBE-b5UahGfhAmbliBaZ1JGI,35813 +bitblas/3rdparty/cutlass/test/unit/gemm/device/simt_qgemm_tt_sm50.cu,sha256=5-thDxhHyqU9CeLext9R2cFRm0sVFt4L-yNuxEhwSJI,35732 +bitblas/3rdparty/cutlass/test/unit/gemm/device/simt_sgemm_nn_sm50.cu,sha256=_DTa60LefXpCgsLXIgDl8qvTsthuYCivBRb_C5CIxlg,70872 +bitblas/3rdparty/cutlass/test/unit/gemm/device/simt_sgemm_nt_sm50.cu,sha256=KZojJ4JlRjxpxK4QUF0CzBpnl_fbWJrpzeN0UfDXZMg,73136 +bitblas/3rdparty/cutlass/test/unit/gemm/device/simt_sgemm_nt_sm80.cu,sha256=xDxVz_3GtZIa1rWNryMhIi5O8P8yVeSD28svXET8KxE,8870 +bitblas/3rdparty/cutlass/test/unit/gemm/device/simt_sgemm_tn_sm50.cu,sha256=Qu1I4aGgPynOx1D3-1NolezfGPNY9nIQQUdZuiKuwZ0,69488 +bitblas/3rdparty/cutlass/test/unit/gemm/device/simt_sgemm_tn_sm80.cu,sha256=T_ILxIvhSTgiEfPMTr5OJGPIIQNaK2fCtsgLf_Y36kQ,8865 +bitblas/3rdparty/cutlass/test/unit/gemm/device/simt_sgemm_tt_sm50.cu,sha256=-flNBAOvVoQn6xHcVup-lwt2MR_RW71_4KNAIttaSJA,71755 +bitblas/3rdparty/cutlass/test/unit/gemm/device/simt_sm50.py,sha256=rJlmyX0cUEpQbG8-hhIfu4c-MLiAOwxfj4y4rCEOMts,17045 +bitblas/3rdparty/cutlass/test/unit/gemm/device/simt_zgemm_nn_sm50.cu,sha256=Zafneq_vbQZizNbeuM-aEdMGlEKP_az9zklaoKvIkUU,33231 +bitblas/3rdparty/cutlass/test/unit/gemm/device/simt_zgemm_nt_sm50.cu,sha256=EQo3sSy4ZMaXZrIjAstebi_DPgX1Ww5vFxe_D0roS-w,33156 +bitblas/3rdparty/cutlass/test/unit/gemm/device/simt_zgemm_tn_sm50.cu,sha256=ZD8BIBrtQ5UD497jCIB1IJ6nWv3odcCe6A9rmeGZXmQ,33156 +bitblas/3rdparty/cutlass/test/unit/gemm/device/simt_zgemm_tt_sm50.cu,sha256=SM1R0IRQsi0incEHI4uhmV9rhnN-yfb13AoGB1YT1UM,33081 +bitblas/3rdparty/cutlass/test/unit/gemm/device/sm50_gemm_f32_f32_f32_simt.cu,sha256=Pdtis8STjag44x2u1aUaY6V6q4xPmewRqfYZ-qZEtJ0,5238 +bitblas/3rdparty/cutlass/test/unit/gemm/device/sm50_gemm_f64_f64_f64_simt.cu,sha256=ZyCJXjXMxTHt1eOk9yJn7vrPeOB7e9MsVtgB6Bi5Bpk,5253 +bitblas/3rdparty/cutlass/test/unit/gemm/device/sm61_gemm_s8_s8_s32_simt.cu,sha256=-gjllPRFyUlRxlKCP2GtJP7oz8HIIh9mLdYzses32SA,5357 +bitblas/3rdparty/cutlass/test/unit/gemm/device/sm80_gemm_f16_f16_f32_tensor_op_f32.cu,sha256=LecbHoxAMnsGBx9v9g5fVvcwjqBZRHbZW9teSV_6PrQ,5479 +bitblas/3rdparty/cutlass/test/unit/gemm/device/sm80_gemm_f32_f32_f32_simt.cu,sha256=TpR1PtBfjRAFkG5yYhcKV6U0k7TzvWdiGjX3R_FA9NQ,5238 +bitblas/3rdparty/cutlass/test/unit/gemm/device/sm80_gemm_f64_f64_f64_simt.cu,sha256=9iPiJt2rT9iBulYZ_0vDKh3U5wgSO_CsVBRo8Big0pQ,5253 +bitblas/3rdparty/cutlass/test/unit/gemm/device/sm80_gemm_f64_f64_f64_tensor_op_f64.cu,sha256=u3yEYXg4htjq9r9vBaizE6PIpAKgRnyaHjKGuYhSOZ4,3875 +bitblas/3rdparty/cutlass/test/unit/gemm/device/sm80_gemm_s8_s8_s32_tensor_op.cu,sha256=oBVx4H-MxNO23nk2olGvxqozWCtz8eqme8EIEHTiamY,3734 +bitblas/3rdparty/cutlass/test/unit/gemm/device/sm80_gemm_tf32_tf32_f32_tensor_op_f32.cu,sha256=MmlVWPKYld4hlvbYGm2EzksVJcEN0uWCt0S0vFuIrnw,5387 +bitblas/3rdparty/cutlass/test/unit/gemm/device/sm90_evt_operations.hpp,sha256=Mfr4KRBIXg0Sp_4tcWRlp5uIIevQvkxn6G9TIKqZ3Ek,17622 +bitblas/3rdparty/cutlass/test/unit/gemm/device/sm90_gemm_bf16_bf16_bf16_alignx_tensor_op_f32.cu,sha256=TgHwahZKqZC313bG05GblPF59J4Ne2VIm6sYedbcvSM,8214 +bitblas/3rdparty/cutlass/test/unit/gemm/device/sm90_gemm_bf16_bf16_bf16_tensor_op_f32.cu,sha256=UVGGb-ATmNujcXvz8pM7SX7zBTIIuIOI_MzaK38D0os,8187 +bitblas/3rdparty/cutlass/test/unit/gemm/device/sm90_gemm_f16_f16_f16_alignx_tensor_op.cu,sha256=bNquVgyfMZ3QwIaeAfwXySd4okk-8LDNSIvd3GD4Lu0,19509 +bitblas/3rdparty/cutlass/test/unit/gemm/device/sm90_gemm_f16_f16_f16_tensor_op.cu,sha256=FumnY8F6-AiXjSY3FgC0ne2n_DFn1Az_OwXimERB5zY,34699 +bitblas/3rdparty/cutlass/test/unit/gemm/device/sm90_gemm_f16_f16_f16_tensor_op_f32_cluster_unspecialized.cu,sha256=h6-7uLrXpawS5TEzcUBB7TqzAFQHypm90jySdyX6ExM,25032 +bitblas/3rdparty/cutlass/test/unit/gemm/device/sm90_gemm_f16_f16_f16_tensor_op_f32_cluster_warpspecialized.cu,sha256=mvEceqOweYmM4YMY21KuLJMsZDGsJxU-AzvWGbk3dn0,25544 +bitblas/3rdparty/cutlass/test/unit/gemm/device/sm90_gemm_f16_f16_f16_tensor_op_f32_cluster_warpspecialized_cooperative.cu,sha256=L4F6xX5RXDKgikLnU6FWjJxuckYiGBIqYTgQqVthGac,35785 +bitblas/3rdparty/cutlass/test/unit/gemm/device/sm90_gemm_f16_f16_f16_tensor_op_f32_cluster_warpspecialized_cooperative_aux_load.cu,sha256=rP3FuEBdAo4r_KVZ7ODPONERRLMiu8_KDyhYvkfcF0c,9618 +bitblas/3rdparty/cutlass/test/unit/gemm/device/sm90_gemm_f16_f16_f16_tensor_op_f32_cluster_warpspecialized_cooperative_bias_elementwise.cu,sha256=8eHI5y3RYcwIwPVcyYCE2lHH5v9tINL644gs5ermj40,20729 +bitblas/3rdparty/cutlass/test/unit/gemm/device/sm90_gemm_f16_f16_f16_tensor_op_f32_cluster_warpspecialized_cooperative_dag.cu,sha256=XlDUlE9U4JxDAUW-bF2yz3y-rHYT-1hVWB80kVlQUdU,7247 +bitblas/3rdparty/cutlass/test/unit/gemm/device/sm90_gemm_f16_f16_f16_tensor_op_f32_cluster_warpspecialized_cooperative_reduce.cu,sha256=SxhAAinDWMI9d6fdOAr4lMbX0D_MmI5MjUor7Y7dLko,8438 +bitblas/3rdparty/cutlass/test/unit/gemm/device/sm90_gemm_f16_f16_f16_tensor_op_f32_cluster_warpspecialized_cooperative_row_broadcast.cu,sha256=cbwvyJaYbog9TuqZJqNoPMlIJlIPYS1UT22VgMyZAUk,6863 +bitblas/3rdparty/cutlass/test/unit/gemm/device/sm90_gemm_f16_f16_f16_tensor_op_f32_cluster_warpspecialized_pingpong.cu,sha256=ORG8BKp-5Jf8QwBjKcG60D5PsJjq--XrfXjqz3ZeHMI,53040 +bitblas/3rdparty/cutlass/test/unit/gemm/device/sm90_gemm_f16_f16_f16_tensor_op_f32_cluster_warpspecialized_pingpong_aux_load.cu,sha256=ElbgD4AG4Hy3hcGcUJF4YGTUE6n6ANfC6DfZTh2i2jw,9549 +bitblas/3rdparty/cutlass/test/unit/gemm/device/sm90_gemm_f16_f16_f16_tensor_op_f32_cluster_warpspecialized_pingpong_bias_elementwise.cu,sha256=u7aRbL5_RPu__L2Pux6ZvlOUhXMVaZ-Psk8ZKh6O-F0,18558 +bitblas/3rdparty/cutlass/test/unit/gemm/device/sm90_gemm_f16_f16_f16_tensor_op_f32_cluster_warpspecialized_pingpong_dag.cu,sha256=HVZZc967Ir1XoVb4k1RWOAEn7s8xMGJsA93OhCNT0Vs,7216 +bitblas/3rdparty/cutlass/test/unit/gemm/device/sm90_gemm_f16_f16_f16_tensor_op_f32_cluster_warpspecialized_pingpong_reduce.cu,sha256=HpGOX5Sw7xeCAK2gxOk9qDaAemu7-BZAvdjy-o5sYq8,8392 +bitblas/3rdparty/cutlass/test/unit/gemm/device/sm90_gemm_f16_f16_f16_tensor_op_f32_cluster_warpspecialized_pingpong_row_broadcast.cu,sha256=VOa3Z4nIjZ1vb15pJSE02cU7biQFgd92ok7ZjnrgsnE,6832 +bitblas/3rdparty/cutlass/test/unit/gemm/device/sm90_gemm_f16_f16_f16_tensor_op_f32_cooperative_stream_k.cu,sha256=_0Lj_vBM9nFF0mWuvuNwaf2fci0gpCfw3TKMMlcq5yY,38709 +bitblas/3rdparty/cutlass/test/unit/gemm/device/sm90_gemm_f16_f16_f16_tensor_op_f32_tensor_broadcast.cu,sha256=eOpx5aff0A9LtrnjNDgZoXf3E_YSB6nEKdK-bM0Zg_0,11938 +bitblas/3rdparty/cutlass/test/unit/gemm/device/sm90_gemm_f32_f32_f32_tensor_op_f32.cu,sha256=cCBj-kGANDjs7KyL7eWbcWCxSzn171QvZ5eJMNkwYcM,6624 +bitblas/3rdparty/cutlass/test/unit/gemm/device/sm90_gemm_f32_f32_f32_tensor_op_f32_tensor_broadcast.cu,sha256=KY29kuK6_kKG7txzZ1EE8dTJV4qa1tsisEvWYTS01eY,4507 +bitblas/3rdparty/cutlass/test/unit/gemm/device/sm90_gemm_f8_f8_bf16_tensor_op_fp32.cu,sha256=GqKPpNkv_r-DUoEb7zwFQKexh9mcxYiVi-bV29u4-ZI,22739 +bitblas/3rdparty/cutlass/test/unit/gemm/device/sm90_gemm_f8_f8_bf16_tensor_op_fp32_evt.cu,sha256=U5FHDt_VzTVaAolzg3f1N9uyQ6O-zgsw01Fk4qZqV-8,8436 +bitblas/3rdparty/cutlass/test/unit/gemm/device/sm90_gemm_f8_f8_f32_tensor_op_f32_cluster_warpspecialized_cooperative.cu,sha256=QbLDlaKuBEKPSwIrHvPz_219izzo1Mu9kXEUmsmhyLs,22313 +bitblas/3rdparty/cutlass/test/unit/gemm/device/sm90_gemm_f8_f8_f32_tensor_op_f32_cluster_warpspecialized_cooperative_evt.cu,sha256=3d1RE0FZgtRi0_vCA89PPHtM3cNkJNldrrHR6h7VThI,8382 +bitblas/3rdparty/cutlass/test/unit/gemm/device/sm90_gemm_f8_f8_f32_tensor_op_f32_cooperative_stream_k.cu,sha256=_6SK-zP5C66P3LvtTFVoeLL40oSB7K847795JB7agAc,22867 +bitblas/3rdparty/cutlass/test/unit/gemm/device/sm90_gemm_f8_f8_f32_tensor_op_fp32.cu,sha256=Fnpge36EuHua_CiGu5k030zTwh09kNJA0UG1086FSYw,22879 +bitblas/3rdparty/cutlass/test/unit/gemm/device/sm90_gemm_f8_f8_f8_tensor_op_fp32.cu,sha256=uvSOPf6BBWE31zrmXNLxZ_55UvIfrmEoAu7OZh5dWOY,54175 +bitblas/3rdparty/cutlass/test/unit/gemm/device/sm90_gemm_f8_f8_f8_tensor_op_fp32_evt.cu,sha256=if0CHz9nlyYbgOp-U-5qAkTvSGiRrYOdlJwCGzMd8HI,8468 +bitblas/3rdparty/cutlass/test/unit/gemm/device/sm90_gemm_s8_s8_s8_alignx_tensor_op_s32.cu,sha256=dYUC0HBht2mtBcnKg4w2sLCTR1DzZ_26sOU4yJJqva8,6529 +bitblas/3rdparty/cutlass/test/unit/gemm/device/sm90_gemm_s8_s8_s8_tensor_op_s32.cu,sha256=_BUzTlzWS0JJN82wkrbhl-ZSHzv5H3t_ujkWVUzW_-M,15719 +bitblas/3rdparty/cutlass/test/unit/gemm/device/sm90_gemm_s8_s8_s8_tensor_op_s32_tensor_broadcast.cu,sha256=h3B-sxxL7Pv4l5k6KosvqCp_06pqw1Wvn1JUo4MafHo,4515 +bitblas/3rdparty/cutlass/test/unit/gemm/device/sm90_gemm_stream_k_scheduler.cu,sha256=TJxCPJrY7315_Oin1dV7jgmnGcWu3Ixs8AJoUCTUFOc,12388 +bitblas/3rdparty/cutlass/test/unit/gemm/device/sm90_gemm_tf32_tf32_f32_alignx_tensor_op_f32.cu,sha256=UgE5pJvT4muNYd7diZaCcJfVJNvCVsDjB77Z_U8xy8w,6531 +bitblas/3rdparty/cutlass/test/unit/gemm/device/sm90_gemm_tf32_tf32_f32_tensor_op_f32.cu,sha256=Ocgjnurt_SlHRlcLfPRLwce_F6lo_pmiZ-CEKDHyI44,7990 +bitblas/3rdparty/cutlass/test/unit/gemm/device/sm90_gemm_tf32_tf32_f32_tensor_op_f32_gmma_rs_cluster_warpspecialized.cu,sha256=92CQdoCbgSfCc6M16fWy1TNjyz29v2xuhm0SK1S6G_8,21505 +bitblas/3rdparty/cutlass/test/unit/gemm/device/symm_cf32n_cf32n_tensor_op_f32_ls_sm80.cu,sha256=pmvsKMTQGiH4iIomMWwSkdj1oGpTRXlLZwjSyz1GSAA,5923 +bitblas/3rdparty/cutlass/test/unit/gemm/device/symm_cf32n_cf32n_tensor_op_f32_rs_sm80.cu,sha256=NqvoUR6pv2RlQvE4wNDegSxwropWS95sdxKl_R-K_qk,5926 +bitblas/3rdparty/cutlass/test/unit/gemm/device/symm_cf32n_cf32n_tensor_op_fast_f32_ls_sm80.cu,sha256=u6UV-B0tkd6nKS-zYjAodHBC8208GnuaFzIkHDbe-Oo,5959 +bitblas/3rdparty/cutlass/test/unit/gemm/device/symm_cf32n_cf32n_tensor_op_fast_f32_rs_sm80.cu,sha256=TgX4ljGhSAkqGNi4d_-XMffWz7DSGfZbMKtGBWsQFF4,5962 +bitblas/3rdparty/cutlass/test/unit/gemm/device/symm_cf64_cf64_cf64_tensor_op_f64_sm90.cu,sha256=kAjDRPGCSY7_Jvc3O8T6dsGoowp7o9358ShojrZwCfc,4838 +bitblas/3rdparty/cutlass/test/unit/gemm/device/symm_cf64n_cf64n_cf64n_tensor_op_ls_f64_gaussian_sm80.cu,sha256=xL-mZ-fs-1xKFxLoydww93CYXoJrS8f0e94XU8WGoWU,5983 +bitblas/3rdparty/cutlass/test/unit/gemm/device/symm_cf64n_cf64n_cf64n_tensor_op_ls_f64_sm80.cu,sha256=cvVlB_7AqCYX5PtrUTLRviNqH7RJjQqVGCSDXhHGHj4,5932 +bitblas/3rdparty/cutlass/test/unit/gemm/device/symm_cf64n_cf64n_cf64n_tensor_op_rs_f64_sm80.cu,sha256=8sJwMRfNsRmMQg4FuQCQON_bpz3pXB9iVlzvwVkZgDc,5935 +bitblas/3rdparty/cutlass/test/unit/gemm/device/symm_f32n_f32n_tensor_op_fast_f32_ls_sm80.cu,sha256=gLuz6rj2J8Xx8MilubmUhZiL2DUIvEqsRZ47SYmhe68,15203 +bitblas/3rdparty/cutlass/test/unit/gemm/device/symm_f32n_f32n_tensor_op_fast_f32_rs_sm80.cu,sha256=roy_pFIDcO6MJpckZQKr-iFfCi7wUhRwEc9XK-oKmmw,8623 +bitblas/3rdparty/cutlass/test/unit/gemm/device/symm_f32t_f32t_tensor_op_fast_f32_ls_sm80.cu,sha256=Oo45q0O_qx-W3Fw39pXnXj7pnYaXR4x3e67SbZ-_4JI,15104 +bitblas/3rdparty/cutlass/test/unit/gemm/device/symm_f64_f64_tensor_op_f64_sm90.cu,sha256=Bnjgi-FtK7ghGGlTOnhAot-E9Y2EF6vpFLqzO0bEOPQ,4777 +bitblas/3rdparty/cutlass/test/unit/gemm/device/symm_f64n_f64n_tensor_op_f64_ls_sm80.cu,sha256=tRdHzwW-ogSsgEW66sQmTsi9jdQTYHAgXlqjkVRYsSc,8103 +bitblas/3rdparty/cutlass/test/unit/gemm/device/symm_f64n_f64n_tensor_op_f64_rs_sm80.cu,sha256=X46nplHjterY77PqPo6pvHsDsh41bAqHlkVcEHBaKWg,8108 +bitblas/3rdparty/cutlass/test/unit/gemm/device/symm_f64n_f64t_tensor_op_f64_ls_sm80.cu,sha256=LPZ6cO0vSDY_T8Sy1CbRkyoM3UxZDjtOjMRgMWJdRFk,8088 +bitblas/3rdparty/cutlass/test/unit/gemm/device/symm_f64n_f64t_tensor_op_f64_rs_sm80.cu,sha256=ZPS5nzw4WFvMCLh-pp3NwHEeS_1y2BdJyutDpgx4RJ4,8093 +bitblas/3rdparty/cutlass/test/unit/gemm/device/symm_f64t_f64n_tensor_op_f64_ls_sm80.cu,sha256=LAZebz4qFgbmElk1eFGqafnucKsYVU3Xpktd2tmgBWw,8073 +bitblas/3rdparty/cutlass/test/unit/gemm/device/symm_f64t_f64n_tensor_op_f64_rs_sm80.cu,sha256=-fQ8m_5zVlQnIUTItzgq4vsVx6vCn0WoCJNzrxZFVsM,8078 +bitblas/3rdparty/cutlass/test/unit/gemm/device/symm_f64t_f64t_tensor_op_f64_ls_sm80.cu,sha256=qESHwSq43pPSbR1pHLbOKvxkeKY5b1Z7hNizI2KHbfM,8058 +bitblas/3rdparty/cutlass/test/unit/gemm/device/symm_f64t_f64t_tensor_op_f64_rs_sm80.cu,sha256=ESiFcNyEgK7pcyo73pj1Wk3EaJOijM496ieJam1bKpg,8063 +bitblas/3rdparty/cutlass/test/unit/gemm/device/symm_tf32n_f32n_tensor_op_f32_ls_sm80.cu,sha256=fbbHh3URxiBdFzY9KVAmWclcNOeIVNgz0PxCLbcTErI,15071 +bitblas/3rdparty/cutlass/test/unit/gemm/device/symm_tf32n_f32n_tensor_op_f32_rs_sm80.cu,sha256=Esg9_auFPxtk6sf2wBBDNCrVmaBg_dD7Fj4J-mj1Dvs,8551 +bitblas/3rdparty/cutlass/test/unit/gemm/device/symm_tf32t_f32t_tensor_op_f32_ls_sm80.cu,sha256=V8mydsv595p4qmqfghOKPK2q9UTHU6LLwkrMId3wMco,14972 +bitblas/3rdparty/cutlass/test/unit/gemm/device/syr2k_cf32n_cf32n_tensor_op_f32_sm80.cu,sha256=haC7aVEAFH_0GLPeynMT7ITKAeckWVTb6tHH5U4RDjc,5362 +bitblas/3rdparty/cutlass/test/unit/gemm/device/syr2k_cf32n_cf32n_tensor_op_fast_f32_sm80.cu,sha256=N35T9zxfvrd4jBSNM4zoin07Cfl6hpjwmPRKwzcWzPY,5386 +bitblas/3rdparty/cutlass/test/unit/gemm/device/syr2k_cf32n_cf32t_tensor_op_f32_sm80.cu,sha256=GN5CsbUOltI86wbV_a6RXRWEpAKSyrwu_xZC-Nu20xw,5356 +bitblas/3rdparty/cutlass/test/unit/gemm/device/syr2k_cf32n_cf32t_tensor_op_fast_f32_sm80.cu,sha256=0cQXX9OZhV5v_hVjqt7eqwDGsEK06KfOkYntjY-PrEM,5380 +bitblas/3rdparty/cutlass/test/unit/gemm/device/syr2k_cf64_cf64_tensor_op_f64_sm90.cu,sha256=XMnBUqlj31LZJwczVYjHyuAt8_EdxbpEjynK88S7yBw,5378 +bitblas/3rdparty/cutlass/test/unit/gemm/device/syr2k_cf64n_cf64n_tensor_op_f64_grouped_sm80.cu,sha256=VXGbZ7PE-DLkns-s0GMZSf0sBI1ph1NkdFt-bFBf-3A,12952 +bitblas/3rdparty/cutlass/test/unit/gemm/device/syr2k_cf64n_cf64n_tensor_op_f64_sm80.cu,sha256=CzPAChKHo_Uv2Tob720LqPTwAyjh_253197X2FgZvlo,5368 +bitblas/3rdparty/cutlass/test/unit/gemm/device/syr2k_cf64n_cf64t_tensor_op_f64_grouped_sm80.cu,sha256=YG9p-3aZCU2nFJzcrg1Y1-wXaTv-Le3-yWTCb1I6_3k,7208 +bitblas/3rdparty/cutlass/test/unit/gemm/device/syr2k_cf64n_cf64t_tensor_op_f64_sm80.cu,sha256=S-BrHXwA2Vgmg39TH2-QDgFnOJRSaOeOJwCq_j37xho,5362 +bitblas/3rdparty/cutlass/test/unit/gemm/device/syr2k_cf64t_cf64n_tensor_op_f64_grouped_sm80.cu,sha256=4ch9iZrqgaFxjTk2_Ugb2ILgq5Lf9SQWEkV5_hbIeh0,7199 +bitblas/3rdparty/cutlass/test/unit/gemm/device/syr2k_cf64t_cf64t_tensor_op_f64_grouped_sm80.cu,sha256=Y0jgZS3SXDfMZzcKAYxeOTo1KuLm74MCmY8J76kjSXw,7190 +bitblas/3rdparty/cutlass/test/unit/gemm/device/syr2k_f32n_f32n_tensor_op_fast_f32_sm80.cu,sha256=FILyt84lwArKlk3yDe5th7Xdik1evYYeU9nmA-2yfPM,4794 +bitblas/3rdparty/cutlass/test/unit/gemm/device/syr2k_f32t_f32n_tensor_op_fast_f32_sm80.cu,sha256=c_tmZixofAS5ueikfBHsbA9FLxf-ZB9ET2ZGVEJqWZk,4783 +bitblas/3rdparty/cutlass/test/unit/gemm/device/syr2k_f64_f64_tensor_op_f64_sm90.cu,sha256=II9fxLlg-3OySroRkPaBYO8nny798osZWkufsvR-NxY,4739 +bitblas/3rdparty/cutlass/test/unit/gemm/device/syr2k_f64n_f64n_tensor_op_f64_grouped_sm80.cu,sha256=z5tfhKbtgxDpIwR5PtEm6-RzXJ8vfEcgunuvUSTFnOI,19145 +bitblas/3rdparty/cutlass/test/unit/gemm/device/syr2k_f64n_f64n_tensor_op_f64_sm80.cu,sha256=8ZctbUprGhHbwKvHGSxCb3FUG2kenWv8TH99Tw9y3ZU,7991 +bitblas/3rdparty/cutlass/test/unit/gemm/device/syr2k_f64n_f64t_tensor_op_f64_grouped_sm80.cu,sha256=kJWTTrZ58ObliC-EjJxGbauMsA2al9AnPZIBFDeFGbw,11015 +bitblas/3rdparty/cutlass/test/unit/gemm/device/syr2k_f64n_f64t_tensor_op_f64_sm80.cu,sha256=bQJ8O68otI7GBKpXAHxPaRqUIU1N7gIPpeDi7_Lt-w4,7976 +bitblas/3rdparty/cutlass/test/unit/gemm/device/syr2k_f64t_f64n_tensor_op_f64_grouped_sm80.cu,sha256=Rvepm0cUgo8_s5qUlVm_pks696ciKdKhaJSDa6LH2fM,12342 +bitblas/3rdparty/cutlass/test/unit/gemm/device/syr2k_f64t_f64n_tensor_op_f64_sm80.cu,sha256=_4ggS06Lk4qw4SILVUvsA-xv458sWM3Gg4xI0BRUIdQ,7961 +bitblas/3rdparty/cutlass/test/unit/gemm/device/syr2k_f64t_f64t_tensor_op_f64_grouped_sm80.cu,sha256=8ZQc75HkYQ9GWdvptSBh2Jp6nrXuYbPBuZpTIb1Ww98,12321 +bitblas/3rdparty/cutlass/test/unit/gemm/device/syr2k_tf32n_f32n_tensor_op_f32_sm80.cu,sha256=-H-oPqCecZF5Y_AJxvyH85xGZfikZLVvbJkLH6dYdvw,4786 +bitblas/3rdparty/cutlass/test/unit/gemm/device/syr2k_tf32t_f32n_tensor_op_f32_sm80.cu,sha256=TE2ZG5zKAU3cw5-PvVOjDWjGhqybr5pJ0bOhIzdP57Q,4775 +bitblas/3rdparty/cutlass/test/unit/gemm/device/syrk_cf32n_cf32n_tensor_op_f32_sm80.cu,sha256=yrcVTRJIPuKBSYOGKc6YBjoKf-4Jbl6PJtqNoNc1CEw,4993 +bitblas/3rdparty/cutlass/test/unit/gemm/device/syrk_cf32n_cf32n_tensor_op_fast_f32_sm80.cu,sha256=z3APfGaW7-9GRMhjhsxNdehmRX5aKZBGDV-wf5alxtI,5017 +bitblas/3rdparty/cutlass/test/unit/gemm/device/syrk_cf32n_cf32t_tensor_op_f32_sm80.cu,sha256=_Rc3bqqNbW8AXu3GVGgOXYkZG7I4SrqPrBP3kJIPiSg,4987 +bitblas/3rdparty/cutlass/test/unit/gemm/device/syrk_cf32n_cf32t_tensor_op_fast_f32_sm80.cu,sha256=Oen7r-Rb234J1_PK3Q4HQmOzWmBcLbS4SyUHBg_5g70,5011 +bitblas/3rdparty/cutlass/test/unit/gemm/device/syrk_cf64_cf64_tensor_op_f64_sm90.cu,sha256=cge279g4bVcGZ1Q2sGYtiJIRQQd_HaNYe10tBJmASgk,5023 +bitblas/3rdparty/cutlass/test/unit/gemm/device/syrk_cf64n_cf64n_tensor_op_f64_sm80.cu,sha256=Ytd_4EvwmAbXYpA9QUaviSalv3qkBBm6M5jxB2wKH2k,4996 +bitblas/3rdparty/cutlass/test/unit/gemm/device/syrk_cf64n_cf64t_tensor_op_f64_gaussian_sm80.cu,sha256=6rxFXX00a6xet0REw95Xz1sC-S87Ya4Ili-XIlEtJ1Y,3793 +bitblas/3rdparty/cutlass/test/unit/gemm/device/syrk_cf64n_cf64t_tensor_op_f64_sm80.cu,sha256=T-5IV3jFg0dKqNIuZ_64myHGsVbyS8F2eShAUPO9JjY,4990 +bitblas/3rdparty/cutlass/test/unit/gemm/device/syrk_f32n_f32t_tensor_op_fast_f32_sm80.cu,sha256=X3cKyAF9Cb-ChaeC6K1CttF2G72VDhuQ1ERsLbOfxpc,16083 +bitblas/3rdparty/cutlass/test/unit/gemm/device/syrk_f32t_f32t_tensor_op_fast_f32_sm80.cu,sha256=7cIPzuQWDvDDFv252OcBtTAx1J7lKPf0LV_f_MaX4lc,16041 +bitblas/3rdparty/cutlass/test/unit/gemm/device/syrk_f64_f64_tensor_op_f64_sm90.cu,sha256=pJBBoTKZ7Kb_SMQ7H_szQt2lUhKSXJSA1DBstmSMrUU,4529 +bitblas/3rdparty/cutlass/test/unit/gemm/device/syrk_f64n_f64t_tensor_op_f64_sm80.cu,sha256=lpWrvAoz0nTslwqfFC78XPcR6aVV8L_YUMz5mHl1L6Q,7451 +bitblas/3rdparty/cutlass/test/unit/gemm/device/syrk_f64t_f64n_tensor_op_f64_sm80.cu,sha256=hTFntM-trVTBdNiGFVEkG-hPbGAYoWidIlh2lGlm_0E,9401 +bitblas/3rdparty/cutlass/test/unit/gemm/device/syrk_tf32n_f32t_tensor_op_f32_sm80.cu,sha256=8pnBbHzTnR6cLBRA_Y20suX38dRiBjjp_rPQHoZn_Kg,16027 +bitblas/3rdparty/cutlass/test/unit/gemm/device/syrk_tf32t_f32t_tensor_op_f32_sm80.cu,sha256=hDqcq3ODNiIZVhKj4HdP8JLM-p3EXaTFvYRDvq3oqI4,15985 +bitblas/3rdparty/cutlass/test/unit/gemm/device/testbed.h,sha256=tRfrQMvCOrlJbeM4stP0AAGKCIoYRFzZLc7ogfhNxMM,20431 +bitblas/3rdparty/cutlass/test/unit/gemm/device/testbed_complex.h,sha256=S4e8YWOZYkYLmgMHfudqAOH9KEAuQUR-okeHLLwNu-Y,8264 +bitblas/3rdparty/cutlass/test/unit/gemm/device/testbed_gemm_with_broadcast.h,sha256=3nShNE40VYs6RU3IYBroPsEDbG9-RJNczN4JB26xC-o,20702 +bitblas/3rdparty/cutlass/test/unit/gemm/device/testbed_gemm_with_reduction.h,sha256=PaeC20gUNXLGbXci5hIJtIrLXzYA8_HzfEpT2Y1zkio,19445 +bitblas/3rdparty/cutlass/test/unit/gemm/device/testbed_grouped.h,sha256=NCPy9F-6ep1MifzJppZ5TI7XS3hBUXfyGPzgcPkV4Ns,16502 +bitblas/3rdparty/cutlass/test/unit/gemm/device/testbed_grouped_rank_2k.h,sha256=6sDYtjIcY7cwcSStCvQiNLwcF9kkQ9yU94a7qDcS4VM,16562 +bitblas/3rdparty/cutlass/test/unit/gemm/device/testbed_grouped_rank_2k_scheduler.h,sha256=1Iu8YM6lNnS01__2xDk6hrcubikTrgXG5lOI6Z9PVk8,17002 +bitblas/3rdparty/cutlass/test/unit/gemm/device/testbed_grouped_scheduler.h,sha256=cEqOOaP2SlQOZQm1dkiJiCeCT1M94-VpdyaJedXQgLY,14698 +bitblas/3rdparty/cutlass/test/unit/gemm/device/testbed_interleaved.h,sha256=1yetYlR6WfUMjdQgc0zFj3Ix6sF7PYQ_8wZXc7U-zG4,10228 +bitblas/3rdparty/cutlass/test/unit/gemm/device/testbed_planar_complex.h,sha256=ok_S0OlE6ubOixOikaF01cYSBwi_q_2GNPVxJ4Slb-s,9481 +bitblas/3rdparty/cutlass/test/unit/gemm/device/testbed_rank2k_universal.h,sha256=_Psmzf9Q_ISO9o_KTmjvYEDDbbsKfIjbPWpNj_duKzE,20898 +bitblas/3rdparty/cutlass/test/unit/gemm/device/testbed_rank_k_universal.h,sha256=JsdyO-PlbFBbGV3aEb3xR_kg4s-w61YNF5fPXjffX8U,15652 +bitblas/3rdparty/cutlass/test/unit/gemm/device/testbed_sanity.h,sha256=4Q72Sx5m72ZbAwmJ9mN5c6pqlN5gQG9V0ibrD0HkolA,8639 +bitblas/3rdparty/cutlass/test/unit/gemm/device/testbed_sparse.h,sha256=_axj7uBrLJ6amgcFAM-kOQO8jm8_RGdOeMedZ3kCYb8,16347 +bitblas/3rdparty/cutlass/test/unit/gemm/device/testbed_splitk.h,sha256=mjvYcI650VBEsk29-uE5SeLXTxZqTMj2iDflxvz5IDQ,6124 +bitblas/3rdparty/cutlass/test/unit/gemm/device/testbed_symm_universal.h,sha256=5-462yUGmMPCfrHr-psZRg_uV87qOC1eMzHaO1RZcTc,19993 +bitblas/3rdparty/cutlass/test/unit/gemm/device/testbed_trmm_universal.h,sha256=iOPYHCTlqcMh28_plQzpU9p60gQeXduy7sIBeAmp7vI,20230 +bitblas/3rdparty/cutlass/test/unit/gemm/device/testbed_universal.h,sha256=U_UgjE4E-hIC7zrAIJvvYJKb7nDT8FmiQc3EA13v388,17409 +bitblas/3rdparty/cutlass/test/unit/gemm/device/testbed_utils.h,sha256=41PFHr8v9YfA_iWIU7ydEfBJvlnUcedL-Q1ZjGbROl0,2626 +bitblas/3rdparty/cutlass/test/unit/gemm/device/trmm_cf32n_cf32n_cf32t_tensor_op_f32_sm80.cu,sha256=ApqB5YfJ9cPNbL4otphLg1jyV_CbJkd3lmfokZxA0e8,9916 +bitblas/3rdparty/cutlass/test/unit/gemm/device/trmm_cf32n_cf32n_cf32t_tensor_op_fast_f32_sm80.cu,sha256=PFdBHX-eof2M_VB3BKQU5koYumk3A2EApWVBuNvkmLA,9988 +bitblas/3rdparty/cutlass/test/unit/gemm/device/trmm_cf64_cf64_cf64_tensor_op_f64_sm90.cu,sha256=CwrCCkLeyz6YjjpyYXyTtSxZcqxtOclGfMAJ74Gt5us,4988 +bitblas/3rdparty/cutlass/test/unit/gemm/device/trmm_cf64n_cf64n_cf64t_tensor_op_f64_gaussian_sm80.cu,sha256=dSOZ0qwf9IYdBUU-qHlGgEJbzfFY0pBk7zCjDgem2CQ,4992 +bitblas/3rdparty/cutlass/test/unit/gemm/device/trmm_cf64n_cf64n_cf64t_tensor_op_f64_sm80.cu,sha256=av0v3F7V54lKa0K7oqGoq0mRyG95xA9dVPBXZwWE_kQ,9762 +bitblas/3rdparty/cutlass/test/unit/gemm/device/trmm_f32n_f32t_f32t_tensor_op_fast_f32_ls_sm80.cu,sha256=R2s-aIp9InCEYObLP5ok0d2qXE3n182XMFXCK_sTvVE,15614 +bitblas/3rdparty/cutlass/test/unit/gemm/device/trmm_f32n_f32t_f32t_tensor_op_fast_f32_rs_sm80.cu,sha256=gNsyarqfPYCrGpubMzsWqY1-kpDH-oBAFcBBwowOntA,8733 +bitblas/3rdparty/cutlass/test/unit/gemm/device/trmm_f32t_f32n_f32n_tensor_op_fast_f32_ls_sm80.cu,sha256=shXK4R6i8QsrvN-ftS1xxYxpCrZB6PI1Dh2I91NLr48,14089 +bitblas/3rdparty/cutlass/test/unit/gemm/device/trmm_f32t_f32n_f32t_tensor_op_fast_f32_ls_sm80.cu,sha256=NCSdrUu2AlH56ZD1mvw5l9uqIB-XWxEeB3jCyXDPEik,14444 +bitblas/3rdparty/cutlass/test/unit/gemm/device/trmm_f64_f64_f64_tensor_op_f64_sm90.cu,sha256=m0GBGID9DMOx8r1_30efHXsQYYofP8b0DyCFxv_vPMU,4607 +bitblas/3rdparty/cutlass/test/unit/gemm/device/trmm_f64n_f64n_f64t_tensor_op_f64_ls_sm80.cu,sha256=ZbMyfu3baMBVa3c836E3kXyFcqvI6a0VrHTDsHoR2No,12798 +bitblas/3rdparty/cutlass/test/unit/gemm/device/trmm_f64n_f64n_f64t_tensor_op_f64_rs_sm80.cu,sha256=ZtpHiHJBPSpE9iI65W36JaafxNlGhrX073AcIBIcTOA,12809 +bitblas/3rdparty/cutlass/test/unit/gemm/device/trmm_f64n_f64t_f64t_tensor_op_f64_rs_sm80.cu,sha256=jycD90gS8AImo10fQDipsY2DHE0hEdvvqjudknOvLQI,12764 +bitblas/3rdparty/cutlass/test/unit/gemm/device/trmm_f64t_f64t_f64n_tensor_op_f64_ls_sm80.cu,sha256=4RUJVZdiu29u2sdqsmewH1rRL_W-Im6pXIGe6S_1buQ,12768 +bitblas/3rdparty/cutlass/test/unit/gemm/device/trmm_f64t_f64t_f64n_tensor_op_f64_rs_sm80.cu,sha256=HBvoEa6aKnAPLvoZ09ohJ3Xya2tRkCW9iXzd7teWOuQ,12779 +bitblas/3rdparty/cutlass/test/unit/gemm/device/trmm_tf32n_tf32t_f32t_tensor_op_f32_ls_sm80.cu,sha256=xXbIzTciJ8nFN8Q55dF24LcIwpGfbpM0LhJoEDR9dkQ,15504 +bitblas/3rdparty/cutlass/test/unit/gemm/device/trmm_tf32n_tf32t_f32t_tensor_op_f32_rs_sm80.cu,sha256=hXAUNdtQxqC5RFr3ghtR88E5UJzYztPrX5Q8ec9img8,8673 +bitblas/3rdparty/cutlass/test/unit/gemm/device/trmm_tf32t_tf32n_f32n_tensor_op_f32_ls_sm80.cu,sha256=GDnAqtaBE-slXpykBWjELLNPEC-tTBDGvzulzPMn0Pw,13989 +bitblas/3rdparty/cutlass/test/unit/gemm/device/trmm_tf32t_tf32n_f32t_tensor_op_f32_ls_sm80.cu,sha256=YpmaF73vuN0NcQfjWd7H4qz1mkyfDl6TNjkAFG2IROc,14344 +bitblas/3rdparty/cutlass/test/unit/gemm/kernel/batched_gemv.cu,sha256=UxRIlQgi70_hTB62C9SakzPOXPNrsBRtL6-WOuNj4e0,46470 +bitblas/3rdparty/cutlass/test/unit/gemm/kernel/testbed_gemv.h,sha256=rqnWSrBi5jSWnNvNMfeGC_0ywKPSDioyPQI03UpF_RA,14362 +bitblas/3rdparty/cutlass/test/unit/gemm/thread/CMakeLists.txt,sha256=6YsqUcVuBOwIwLdM1NzlmOCDCJniGtBT46vHSxUuRWs,1816 +bitblas/3rdparty/cutlass/test/unit/gemm/thread/gemm_sm50.cu,sha256=sgtR6KY21HLiuxAzJP1WnnFS_lJnENEoSl-EtVMus_s,4847 +bitblas/3rdparty/cutlass/test/unit/gemm/thread/gemm_sm60.cu,sha256=UOI0Zz-jdX2Bs6UaCzu8msFac4dnteHhBcTIUxUuqbE,12503 +bitblas/3rdparty/cutlass/test/unit/gemm/thread/gemm_sm61.cu,sha256=_7YL1EHr6wauR5yCC9yCj1VQcSYqoAeU1-lxv-os7Kk,3109 +bitblas/3rdparty/cutlass/test/unit/gemm/thread/host/CMakeLists.txt,sha256=3_KPIBtsypddKAsCW0LM6SEchmPPAdG8TDRTkWKYC60,1709 +bitblas/3rdparty/cutlass/test/unit/gemm/thread/host/gemm_sm60_host.cu,sha256=sB_3MlLbFhD8ymZVcSZKVuHIhaAKC93P7bQU5pVQM1U,5198 +bitblas/3rdparty/cutlass/test/unit/gemm/thread/host/testbed_host.h,sha256=wF-hgrJIIGNPDI-PsKgmNu1vyEczAkuzL1NlvAe7OHE,7161 +bitblas/3rdparty/cutlass/test/unit/gemm/thread/testbed.h,sha256=r62U2CM1bKQpjpR770FG1gfkmuvxy_mFhOMwgP2YE64,7124 +bitblas/3rdparty/cutlass/test/unit/gemm/threadblock/CMakeLists.txt,sha256=I8kxtoknOrf2hfL-8nawkJm4sRIgsrs7ZGgmdJfnNZw,2019 +bitblas/3rdparty/cutlass/test/unit/gemm/threadblock/batched_gemv.cu,sha256=Bfjt0UkQb76EuyHr5x9BQqy9E778kxPrWYFIGukYyU0,25036 +bitblas/3rdparty/cutlass/test/unit/gemm/threadblock/epilogue_workspace.cu,sha256=M79yxTi5iJsVsPQBYNPp1mvHPyIUhV1FGkYyR7uVJTI,4345 +bitblas/3rdparty/cutlass/test/unit/gemm/threadblock/mma_multistage.cu,sha256=QykQ1gI0t8ssFpjGFzW0lPslTzuihHIGboPfHI2KcpE,135043 +bitblas/3rdparty/cutlass/test/unit/gemm/threadblock/mma_multistage_slicedk.cu,sha256=9WInRq9Cw3qW85TYyouTwEtY-RttUyskm-lYQVewJoQ,4644 +bitblas/3rdparty/cutlass/test/unit/gemm/threadblock/mma_multistage_sparse.cu,sha256=qgBdlQ0L_hCBe-jc5mUC4XIOMILqNfK4Non_O3puJ6Y,94442 +bitblas/3rdparty/cutlass/test/unit/gemm/threadblock/mma_multistage_sparse_testbed.h,sha256=b9YUa0mRvkdYR9Trc19JgW81BxeioWs7OdjSLibLCQI,16988 +bitblas/3rdparty/cutlass/test/unit/gemm/threadblock/mma_multistage_testbed.h,sha256=LsNrF32z5hfEa-FPIAYfdiACEdwG01t0MoluMoGHXAM,13829 +bitblas/3rdparty/cutlass/test/unit/gemm/threadblock/mma_multistage_testbed_slicedk.h,sha256=ASxT5QJhXWZkN6t7DKBpweOpGQMPcoco3ykghSDJeGU,14471 +bitblas/3rdparty/cutlass/test/unit/gemm/threadblock/mma_pipelined_simt.cu,sha256=rq1fEsSuo6s-hu9dXj2mRKR3KfDGfb92Hg1C-9Wpn10,49052 +bitblas/3rdparty/cutlass/test/unit/gemm/threadblock/mma_pipelined_slicedk.cu,sha256=T1Z8cQPWtfrWS2la9qLaOq9qfpSrL5RsF5DvW8B0Ftk,8407 +bitblas/3rdparty/cutlass/test/unit/gemm/threadblock/mma_pipelined_sm70.cu,sha256=OhsBGVtiCQBlf6VSCMmkQET9ONx6DblMJAw43v_2lr0,18705 +bitblas/3rdparty/cutlass/test/unit/gemm/threadblock/mma_pipelined_sm75.cu,sha256=s8xVAToxhXVTQJn9y_LOtPXmfH0YlY0NU268_WRuc1k,78121 +bitblas/3rdparty/cutlass/test/unit/gemm/threadblock/mma_pipelined_sm80.cu,sha256=M0nb411D-OFPr_cADNqZsCAeihwOSRFKbX8-iQHWltY,21051 +bitblas/3rdparty/cutlass/test/unit/gemm/threadblock/mma_pipelined_testbed.h,sha256=fSPnZ9hTbu1zl0qaZxKmO9xfJX7ZsM3PEef8akTBWzQ,13703 +bitblas/3rdparty/cutlass/test/unit/gemm/threadblock/mma_pipelined_testbed_slicedk.h,sha256=UoiLixYCyupqU38mQgHuwQtK3SuSEfnmkzyBbv7lm8g,14171 +bitblas/3rdparty/cutlass/test/unit/gemm/threadblock/mma_pipelined_wmma_sm70.cu,sha256=IInl_VTNVm70HUYXRi0BQ0KDrNHWZFGvyIJlKgeqBtc,29772 +bitblas/3rdparty/cutlass/test/unit/gemm/threadblock/mma_pipelined_wmma_sm75.cu,sha256=izEg8y43Rc7nnprCnWJlNmmkVvyVvl8qLSnfEkV7r_A,12395 +bitblas/3rdparty/cutlass/test/unit/gemm/threadblock/mma_planar_complex_sm80.cu,sha256=ksK-wcDF0zm5sdDaOjjHe_1ez5lGM7gkm6Yj54DSGz8,3502 +bitblas/3rdparty/cutlass/test/unit/gemm/threadblock/mma_planar_complex_testbed.h,sha256=4tXPkViaN510ctxm1NkAvbMbb3qWSwW3Sd5zvxI_VZw,12070 +bitblas/3rdparty/cutlass/test/unit/gemm/threadblock/mma_singlestage_wmma_sm70.cu,sha256=uQefHg7k7GMgtgLW4wB6fQtH6DljmFKtKIqL0zy5AUY,16308 +bitblas/3rdparty/cutlass/test/unit/gemm/threadblock/mma_singlestage_wmma_sm75.cu,sha256=heyABJw2DRqKd3yNFhx-QcmvDU13oodtdjf5hevKQHA,12501 +bitblas/3rdparty/cutlass/test/unit/gemm/warp/CMakeLists.txt,sha256=b76Z4OL9flC7R_Z5WGhllBxWhm6JIC2czrWX2Z-EG88,1913 +bitblas/3rdparty/cutlass/test/unit/gemm/warp/gemm_complex_sm80.cu,sha256=RD5DSTleLq5xOWKYFn4geAj9NZIsoHezSe9aSqzuWgo,22128 +bitblas/3rdparty/cutlass/test/unit/gemm/warp/gemm_complex_sm90.cu,sha256=RjXSMJ4xz7atASB4YTbnawiiYasFFJpAG61W7O0qQxQ,10914 +bitblas/3rdparty/cutlass/test/unit/gemm/warp/gemm_gaussian_complex_sm80.cu,sha256=npl97ExW2mxt_B04if16zP5DkKKkFJ_LSo-kx3jmGPo,9873 +bitblas/3rdparty/cutlass/test/unit/gemm/warp/gemm_sm50.cu,sha256=bL_77vMvGNzJw7IUVT-1ebN7cfHSefvquZ5x7P5HIrs,18220 +bitblas/3rdparty/cutlass/test/unit/gemm/warp/gemm_sm60.cu,sha256=jbn0WlzhVT2cYjkw0oklvh30LMLU5fdPBTJyAeYiQ34,4920 +bitblas/3rdparty/cutlass/test/unit/gemm/warp/gemm_sm61.cu,sha256=leZgMRH1SszTsPLlT14jwNPerhltOezJnyWD0Km2NhA,6291 +bitblas/3rdparty/cutlass/test/unit/gemm/warp/gemm_sm70.cu,sha256=XqAnObH8NXe8_o3r8_gTudoheGsmN1pYvB8EZ6C94y4,9297 +bitblas/3rdparty/cutlass/test/unit/gemm/warp/gemm_sm75.cu,sha256=LE60_UZj4TFRsxHkB7hLh8MRO83BTNLw2uQ5rQUyHSM,37940 +bitblas/3rdparty/cutlass/test/unit/gemm/warp/gemm_sm80.cu,sha256=menQxip0LkbHVZhW2zUaMEmHuozsVRsSNyeoabxo5qs,81657 +bitblas/3rdparty/cutlass/test/unit/gemm/warp/gemm_sm90.cu,sha256=qKrle3jcuT99AuDXJjhxAqvVWFdkYeJEJmZEHuvKAEs,9087 +bitblas/3rdparty/cutlass/test/unit/gemm/warp/gemm_sparse_sm80.cu,sha256=PhM6KbH69FB-kqZh37cN8vWBxSRVPHBMieVgNJHy10g,48928 +bitblas/3rdparty/cutlass/test/unit/gemm/warp/testbed.h,sha256=N5iPmGTepISbZUkMvzlrMYdDOlfsRNdBQXqiLXRuBH8,49273 +bitblas/3rdparty/cutlass/test/unit/gemm/warp/wmma_sm70.cu,sha256=iZh-gwTuPCyK3DNlyv9yJmtK-7Bzk172p7xpKnS-JW0,25780 +bitblas/3rdparty/cutlass/test/unit/gemm/warp/wmma_sm72.cu,sha256=1UHRt6RZ7rqX1QxBKJ5FbmiaBcV7stuvbKmbJidH5N0,7541 +bitblas/3rdparty/cutlass/test/unit/gemm/warp/wmma_sm75.cu,sha256=7GU_j3VwsD-ONlLFdgmHhEGsNaatBuIEeCw9KILdNCE,6486 +bitblas/3rdparty/cutlass/test/unit/layout/CMakeLists.txt,sha256=xelm7H9Rsygh-6d0EzbCv4xA1EXRE5dHcLgFavW6nuA,1703 +bitblas/3rdparty/cutlass/test/unit/layout/matrix.cu,sha256=_wyzr-0-fXtDvDd-AL1PfKNl1H9F39OCJoak_twuZNk,5788 +bitblas/3rdparty/cutlass/test/unit/layout/tensor.cu,sha256=3Z22epEndaAu1gjUySWRQbzEEHN494J-gugZftX7g1I,5984 +bitblas/3rdparty/cutlass/test/unit/layout/tensor_nhwc.cu,sha256=luWsa81LUwKpd0iA4AVEh7kmNLhceX_D0U6ASoVz1II,7081 +bitblas/3rdparty/cutlass/test/unit/nvrtc/CMakeLists.txt,sha256=FLqCeoZIu5Cnyx_sWN76uSKf3WsChCqL7m8awyY3ieg,4597 +bitblas/3rdparty/cutlass/test/unit/nvrtc/cutlass/nvrtc/environment.h,sha256=tftuUmK0gtyeeR-csQU33WslkkcKkLP2_TPmCsar3R8,2096 +bitblas/3rdparty/cutlass/test/unit/nvrtc/kernel/thread/contraction.hpp,sha256=76X1UW9y2NyiYE5g8DLYjhJRUenmraTYCEIrx8T1e9o,5373 +bitblas/3rdparty/cutlass/test/unit/nvrtc/kernel/thread/testbed_kernel.h,sha256=ZwkSDSrrmQyPQIJvad-fCUIC5XQYNa8Wft4FI428tAI,2915 +bitblas/3rdparty/cutlass/test/unit/nvrtc/stdlib/assert.h,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +bitblas/3rdparty/cutlass/test/unit/nvrtc/stdlib/stdint.h,sha256=1CQ6DgD_Ozpjb0dV9P3rd-bl7ahX5lXs_O-Ok3RNAUk,4250 +bitblas/3rdparty/cutlass/test/unit/nvrtc/thread/.gitignore,sha256=UhdYOJU9Vjs6oLXF_Nyik501ZKxsNNGVVk76lSNCgSM,17 +bitblas/3rdparty/cutlass/test/unit/nvrtc/thread/CMakeLists.txt,sha256=D_pDL63Z-TUFVw_sBlvfAaW6w01wm-EeBc56s-OehG8,1940 +bitblas/3rdparty/cutlass/test/unit/nvrtc/thread/nvrtc_config.in,sha256=LQ6ksaI11iFHGHODJBaLS2W1GEpJTonWJlfpraC3-HQ,73 +bitblas/3rdparty/cutlass/test/unit/nvrtc/thread/nvrtc_contraction.cu,sha256=ZOm8c2z-Sb1YtUvVsOiPGJNw8syz58Q-uzAxPCmhH84,2782 +bitblas/3rdparty/cutlass/test/unit/nvrtc/thread/nvrtc_gemm.cu,sha256=TGYa0i4luIVF9zo4w4QDABwGqR05qV3iOFAqMvXUP4c,5727 +bitblas/3rdparty/cutlass/test/unit/nvrtc/thread/testbed.h,sha256=hS0GMT_5M8jtR1HZ9nchwnUvzPZoGYp8pAsO9F0cLhA,12365 +bitblas/3rdparty/cutlass/test/unit/pipeline/CMakeLists.txt,sha256=-wU1VluXMAd_YqfedAAOqjUY5Hfn8QIdU8NtVsIHGPs,1821 +bitblas/3rdparty/cutlass/test/unit/pipeline/pipeline_async.cu,sha256=6T3Ecx2lJiYtOJ-FiI7HvgPPH5zRXB1qkrI50aHL8jY,15387 +bitblas/3rdparty/cutlass/test/unit/pipeline/pipeline_tma_async.cu,sha256=rBaalCGTTbl3DsyMUwusjXHXIR6gvGQbFxasU2QOmhg,15158 +bitblas/3rdparty/cutlass/test/unit/pipeline/pipeline_tma_async_warp_specialized.cu,sha256=J8Sx16nEeGdXtXSnpnC5qV2AHIxcxf_ytfgtnt2OtlY,17124 +bitblas/3rdparty/cutlass/test/unit/pipeline/pipeline_tma_async_warp_specialized_persistent.cu,sha256=14Uol5AXxDMm8Osmb_SWRXKgQlVrKDXMbjvUpeL-cGU,19917 +bitblas/3rdparty/cutlass/test/unit/pipeline/sequence_barrier.cu,sha256=HcL5VK1lRVlSNaElgsED_P9f9ARDBlryvl3ctLMeHi8,7644 +bitblas/3rdparty/cutlass/test/unit/pipeline/testbed.h,sha256=1cbvFFL_3FyAtx0i_enSnGQT8qxnjRXXV7CaPYpTZs4,4327 +bitblas/3rdparty/cutlass/test/unit/reduction/CMakeLists.txt,sha256=-mRMjw52IgxhTtnMb25et_sRcp-KFL9JWzv8YaZhUtM,1991 +bitblas/3rdparty/cutlass/test/unit/reduction/device/CMakeLists.txt,sha256=cTWYKhnQKYIMw-DM66XI7QAkduaNewHbpEeBa3qcGzE,1728 +bitblas/3rdparty/cutlass/test/unit/reduction/device/tensor_reduce_contiguous.cu,sha256=Z63hUJhcBaOx3zoyBdMbmOQ23cb9nnK75jpQMfDbEBE,14684 +bitblas/3rdparty/cutlass/test/unit/reduction/device/tensor_reduce_strided.cu,sha256=KqKYCATf2VYZWOHmkgLR7MwvmNnE8eYdC-LhxGvT2-o,15609 +bitblas/3rdparty/cutlass/test/unit/reduction/kernel/CMakeLists.txt,sha256=6ZpEA01swPvHjZoV8Pd9G6N-0LZCOp-4ZzJFy4LX_Pw,1691 +bitblas/3rdparty/cutlass/test/unit/reduction/kernel/reduce_splitk.cu,sha256=zmJuBTjzS5DHFQZ3Lnm4kEnT7T5CstJbV0E2Icn2izk,11316 +bitblas/3rdparty/cutlass/test/unit/reduction/kernel/reduce_splitk_testbed.h,sha256=SN3L1PCx0m60aGLZJYdIUxTrnfmYS1qkkkqyzrduB1s,2228 +bitblas/3rdparty/cutlass/test/unit/reduction/thread/CMakeLists.txt,sha256=D4oH-VhVNgTq2-jLK4UINQTnJM49tVBtb1dKMS-PuZ0,1706 +bitblas/3rdparty/cutlass/test/unit/reduction/thread/reduction_thread.cu,sha256=rEal7R2xAbTUiaka7H8OSppuxkIc4tVZe5qv3IzseEc,3110 +bitblas/3rdparty/cutlass/test/unit/reduction/thread/testbed.h,sha256=soH39W3rBkv4La9j3WpAxzzlk1Y0xZmaY__kb7DwQkg,6657 +bitblas/3rdparty/cutlass/test/unit/substrate/CMakeLists.txt,sha256=wdbEhFcz5N3uh9z2wfrr-dg8BFvYfCc4WxHZ6Z5nWyw,1686 +bitblas/3rdparty/cutlass/test/unit/substrate/dependent_false.cpp,sha256=ZnNC86s-tXSk2yVxTKGu_LdonCz576GBWuqaANc2dK4,3312 +bitblas/3rdparty/cutlass/test/unit/test_unit.cpp,sha256=47igFz9SRwjEOvwrYQSGClTNhJrqBiKMp_QsWX_9Dzo,2047 +bitblas/3rdparty/cutlass/test/unit/transform/CMakeLists.txt,sha256=yXUjCqsdXAy1ESlAfZd80gax_WkPZR_3HNkhI02uvJE,1823 +bitblas/3rdparty/cutlass/test/unit/transform/threadblock/CMakeLists.txt,sha256=SmfE9TRMsEYXwZ24cMBE5auAbwfR1ZhhKPGt82Bb-tQ,1744 +bitblas/3rdparty/cutlass/test/unit/transform/threadblock/predicated_tile_iterator.cu,sha256=Z8bA8Jov0rYoktp75hd4Q9VPE0Pq6Uct-8OjzvAbykA,25527 +bitblas/3rdparty/cutlass/test/unit/transform/threadblock/regular_tile_iterator_tensor_op.cu,sha256=HMSTZT1lC45rmWAIMYH2TT6uqymmBcUdHHr-9zsFWRE,9501 +bitblas/3rdparty/cutlass/test/unit/util/CMakeLists.txt,sha256=gEqki6VWP0umvj5GhQOF1u-QxSuVgYpDY4UgJ8ytiuw,1718 +bitblas/3rdparty/cutlass/test/unit/util/cutlass_test_levels.cu,sha256=g0-BMGSRqKWmEDie-TrYHMcFs45y0Nc2WFsKhP67kOI,2663 +bitblas/3rdparty/cutlass/test/unit/util/rms_norm.cu,sha256=XpV-cmc9rtGTYeiw7XbXn3914DRzTGBaHWWLag-hs6g,4459 +bitblas/3rdparty/cutlass/test/unit/util/tensor_reduce.cu,sha256=wA5uza7dKp_pMrKoVFxmXIFZnz4Lb74n56iWY5A7Dco,7474 +bitblas/3rdparty/cutlass/tools/CMakeLists.txt,sha256=zbGwYitvtr2n3iyGtSSv5SytKswpgSi1WlNcy1VL6Ak,2092 +bitblas/3rdparty/cutlass/tools/library/CMakeLists.txt,sha256=jYga9UrC0iT0o40imUnG_G4h8793FoSJhQnr3PZUOpU,10325 +bitblas/3rdparty/cutlass/tools/library/include/cutlass/library/arch_mappings.h,sha256=uBgUAhWnHxemLVyLbxFP9J-EqxDMP2vuP2WV8QV59ZA,4272 +bitblas/3rdparty/cutlass/tools/library/include/cutlass/library/descriptions.h,sha256=Dnk9BAhtnB-OApt-KmUkQNU0rWI8bwAahYvlsyX3YKE,18327 +bitblas/3rdparty/cutlass/tools/library/include/cutlass/library/handle.h,sha256=GRF0o-kiXQPR5Kn_lRCPc2bxRO-WkwDN3EhgjVjp3Q4,16188 +bitblas/3rdparty/cutlass/tools/library/include/cutlass/library/library.h,sha256=yrArmp7z6Ik8tGQNFJddn3-vW57dMEvQVhi-aJRENhM,20172 +bitblas/3rdparty/cutlass/tools/library/include/cutlass/library/manifest.h,sha256=gKIH1Gdtl0CzpV8aXpKjICGwa4lK0gCbTI_8EfyKHqk,4070 +bitblas/3rdparty/cutlass/tools/library/include/cutlass/library/operation_table.h,sha256=_hxAHmk0NQcbwnhiL8kMMCpKV5njAWHp-DL01ctpTB4,18740 +bitblas/3rdparty/cutlass/tools/library/include/cutlass/library/singleton.h,sha256=sqXhGJryCovLgOLNKmyRIijQsVbGMXbbHKUZAeXdUJo,2724 +bitblas/3rdparty/cutlass/tools/library/include/cutlass/library/types.h,sha256=4Uc4mQzmSJUpwcGcxMUscqf7dq8Lnlj7FEqw9McKKYA,5869 +bitblas/3rdparty/cutlass/tools/library/include/cutlass/library/util.h,sha256=yhh3k1Tsk9PrSJebjIUbqQuToPyvU9Vp34dn2mXVe3s,8140 +bitblas/3rdparty/cutlass/tools/library/src/conv2d_operation.h,sha256=BYGDWbttJ0xoziI6unOTgGBjGxajUUcp01owgMML_xE,22377 +bitblas/3rdparty/cutlass/tools/library/src/conv3d_operation.h,sha256=3CUqvSCZONKwKIymbwnV-CFBv_VqrwICZDPURLPw1do,13850 +bitblas/3rdparty/cutlass/tools/library/src/gemm_operation.h,sha256=sYlg0LAtSWyfcQx1m6TlvzjhVPv6JDPQherYsEaxTeU,42608 +bitblas/3rdparty/cutlass/tools/library/src/gemm_operation_3x.hpp,sha256=-ISAUqgAoqIhCO-3q7pZorJo4fN3jISFmg7djNpJkfM,13764 +bitblas/3rdparty/cutlass/tools/library/src/handle.cu,sha256=xwSDKLSHWrw4kc-UV8PHozIMGVDlL_IbaE1CA1YhMlM,36476 +bitblas/3rdparty/cutlass/tools/library/src/library_internal.h,sha256=WAT8ONsjusi-5DVWQcKK5B8MxPw6F5lAsI8OO8B4jL4,12961 +bitblas/3rdparty/cutlass/tools/library/src/manifest.cpp,sha256=Rpn1-6IIuNarHdX9BVhbfA5dXzELtWiLB-EvjvV9Y-Y,3775 +bitblas/3rdparty/cutlass/tools/library/src/operation_table.cu,sha256=gAp_x7Ja5GUq-dfyYiOXNVvrOuXfeSNwDV4Ac5DBru0,5553 +bitblas/3rdparty/cutlass/tools/library/src/rank_2k_operation.h,sha256=LeixHH5DbewfmSBm4wvVVTNKdyTtySeIsP_uQfPKmwo,12873 +bitblas/3rdparty/cutlass/tools/library/src/rank_k_operation.h,sha256=wukJVoBGeohkaWnhoqcF1PoINRo_kkqADOWHTKxPsS0,11367 +bitblas/3rdparty/cutlass/tools/library/src/reduction/init_reduction_operations.cu,sha256=VcBgfDZ9S84FHgjRefl6k-4YrpjNz81BCSH-QjRFDwE,3334 +bitblas/3rdparty/cutlass/tools/library/src/reduction/reduction_device.cu,sha256=BHVUXKNmt1qJGuccIK-7wH-si79TpjwX45s8eLv0SIY,7409 +bitblas/3rdparty/cutlass/tools/library/src/reduction/reduction_operation.h,sha256=6ehQV4CIA9SEG0gDjPpQ87BAfNPTVGjPoeOXvksztzc,10269 +bitblas/3rdparty/cutlass/tools/library/src/reference/conv2d.cu,sha256=RfgI-AYRGyquszkNRr_Cu1OWauFGDjGkbipvXtpX7Sg,6746 +bitblas/3rdparty/cutlass/tools/library/src/reference/conv3d.cu,sha256=Z6jdBji8vSyKwFD2OW4CGOqF8-iqrQGgq_9VB6MM5-0,6286 +bitblas/3rdparty/cutlass/tools/library/src/reference/conv_reference_operation.h,sha256=1SnfKcxwaqw3RemFaqGm9-j5vuPkUZSFOVwHaXb753s,17210 +bitblas/3rdparty/cutlass/tools/library/src/reference/gemm_e4m3a_e4m3out.cu,sha256=Ubwdq_lKUyzz7w1SHK6fh-1aWJqLOke9RSm7oUvVmwk,5473 +bitblas/3rdparty/cutlass/tools/library/src/reference/gemm_e4m3a_e5m2out.cu,sha256=772azeHx37jrYByyONoBDiNn743NoPgXD42qqHaskEU,5070 +bitblas/3rdparty/cutlass/tools/library/src/reference/gemm_e5m2a_e4m3out.cu,sha256=LfHwDWQcjW0wny8wDpy0pen3wu-YShvO4EsE5x8QYIk,5070 +bitblas/3rdparty/cutlass/tools/library/src/reference/gemm_e5m2a_e5m2out.cu,sha256=pnWEaSSssaB0BJ2qHVLzQ59zMlkDWxaN3PeRXwt9JMo,5070 +bitblas/3rdparty/cutlass/tools/library/src/reference/gemm_fp32out.cu,sha256=S07SJjzeTbMVKLMN_KN-NGj1JJU6yPHS3S3nvOiMND0,3633 +bitblas/3rdparty/cutlass/tools/library/src/reference/gemm_fp8in_bf16out.cu,sha256=IxSegDP8fPvnSP0wsxum3U0yhzIQ_GvaAcSBhXah5i4,4262 +bitblas/3rdparty/cutlass/tools/library/src/reference/gemm_fp8in_fp16out.cu,sha256=-emb2mg2mQRvKDkShVEOUEjxPvXUAcVzH4swP9aalKc,4260 +bitblas/3rdparty/cutlass/tools/library/src/reference/gemm_fp8in_fp32out.cu,sha256=P_Xph7ISan22pqthk_iyWZMI_9sxWc6JLFC0-QRMSOw,4260 +bitblas/3rdparty/cutlass/tools/library/src/reference/gemm_fp_other.cu,sha256=sQXZgqEMqCROaJHY23jt1hgvN0fmRcufUCix7u6Sjcs,3140 +bitblas/3rdparty/cutlass/tools/library/src/reference/gemm_int4.cu,sha256=iDyqsJkaagZtWXGUnyWd_cAIU0fCVe-7HuVgjbrRyoI,3729 +bitblas/3rdparty/cutlass/tools/library/src/reference/gemm_int8_canonical.cu,sha256=MiUcnBbSmzokCcbtergdcz9_hwbJB3ZqhxQmZy0-sBk,3683 +bitblas/3rdparty/cutlass/tools/library/src/reference/gemm_int8_interleaved_32.cu,sha256=RsZS0U5UVy24zM21LHerB1z5NeVCxOT-FNcpwGrbL4M,3721 +bitblas/3rdparty/cutlass/tools/library/src/reference/gemm_int8_interleaved_64.cu,sha256=v3m1MGzcHEBu-zsWjKh2H7tFNV5-8sSYCrL1Y4HpITg,3744 +bitblas/3rdparty/cutlass/tools/library/src/reference/gemm_reference_operation.h,sha256=yRcdqmGkJefAxuXooOXcNXMyP6RuGu-acNQLgNJ4vA8,16453 +bitblas/3rdparty/cutlass/tools/library/src/reference/initialize_reference_operations.cu,sha256=vYzAqwZWkSAZvlhsuxt2g1ff2XODoQ6PiOmliVBt4yg,4666 +bitblas/3rdparty/cutlass/tools/library/src/singleton.cu,sha256=FkjdLx5dMMu81m9g0g_0zHxXIlDlxyhK2ls3G2nF5Xg,2669 +bitblas/3rdparty/cutlass/tools/library/src/symm_operation.h,sha256=vBZdUh749dowLBVwAjm3-hnEKu9rOlrGRL-SSbrzymg,13134 +bitblas/3rdparty/cutlass/tools/library/src/trmm_operation.h,sha256=yxtLSJnzE6b7wu97rz-O0vpEOmbiEjv7yZTxO-i-eAg,11698 +bitblas/3rdparty/cutlass/tools/library/src/util.cu,sha256=UGa5IfuQ2_bjoPLkjeoJs85uLfc54Wp0Q4b4xe9jKGk,46594 +bitblas/3rdparty/cutlass/tools/profiler/CMakeLists.txt,sha256=DBR_sqLARfNIon1tjerIpXCZxAeox7t4cHqGVmzyKYY,5145 +bitblas/3rdparty/cutlass/tools/profiler/include/cutlass/profiler/conv2d_operation_profiler.h,sha256=eyfqc7nTVgMECl1-hZB6RoTjXeydwOvcjO9I1Pyx3dc,18227 +bitblas/3rdparty/cutlass/tools/profiler/include/cutlass/profiler/conv3d_operation_profiler.h,sha256=lK8Pl0OW3BOxV5lslu58bDFriLcH2n1FRFINCM6jx4Y,16101 +bitblas/3rdparty/cutlass/tools/profiler/include/cutlass/profiler/cublas_helpers.h,sha256=cBWZ6HrKrpF4grWNViVNakGLIhH0I97hxrEHZZX2wy8,10623 +bitblas/3rdparty/cutlass/tools/profiler/include/cutlass/profiler/cudnn_helpers.h,sha256=8RsIgwBLh2HaHaBZ2VccWnypwSnFjtndOjbGQmugpeM,20435 +bitblas/3rdparty/cutlass/tools/profiler/include/cutlass/profiler/cutlass_profiler.h,sha256=A6yw3LIEAxUYPL_7IS_QVI03IX_yLa5w37CqA_vab8g,3233 +bitblas/3rdparty/cutlass/tools/profiler/include/cutlass/profiler/debug.h,sha256=TrfkhZMhN7kC_Hsi66dcGf0UlQ-0Z6TZjlGLSQqDaqU,2454 +bitblas/3rdparty/cutlass/tools/profiler/include/cutlass/profiler/device_allocation.h,sha256=VmwZZel3JFRkAQ9veHV6lfN68d4QFtDFS78qYi7eewM,7459 +bitblas/3rdparty/cutlass/tools/profiler/include/cutlass/profiler/device_context.h,sha256=Yy3sBSUCvzT3jLQQuPC3pY8UWnGOc4pEZcMlwuG1Nik,4290 +bitblas/3rdparty/cutlass/tools/profiler/include/cutlass/profiler/enumerated_types.h,sha256=6k09bvbFYBwmcozID-xOjm-wlHnTz_N9NkeAzC1COGM,6421 +bitblas/3rdparty/cutlass/tools/profiler/include/cutlass/profiler/gemm_operation_profiler.h,sha256=6rYyWYqcWSPnLrctovR_0G2kzibzhQgvZjxX2b9xrCA,8715 +bitblas/3rdparty/cutlass/tools/profiler/include/cutlass/profiler/gpu_timer.h,sha256=TnCZ73BXr66lNLoSnYzsPSESYNZfEgf4uJBRw2QlS14,2725 +bitblas/3rdparty/cutlass/tools/profiler/include/cutlass/profiler/operation_profiler.h,sha256=fVMyIjQBQNMA_N7cASm2JZy8I9D4V4hlmFLjPagO2oo,7924 +bitblas/3rdparty/cutlass/tools/profiler/include/cutlass/profiler/options.h,sha256=zOcvfwMNiFypS-MqeK6tb03zDCeh1w6WGL8OIjqmr7U,9273 +bitblas/3rdparty/cutlass/tools/profiler/include/cutlass/profiler/performance_report.h,sha256=babogp1cj_Fs6GB1ZIICpfykA6PCQMdXjymeL_68iI0,4337 +bitblas/3rdparty/cutlass/tools/profiler/include/cutlass/profiler/performance_result.h,sha256=l4m3XAXuBAJJdeI-dFsSFe4e7ZdWAyJiYcRZ8MX97N0,3941 +bitblas/3rdparty/cutlass/tools/profiler/include/cutlass/profiler/problem_space.h,sha256=2U315TCmWXmdHC59maC4btWyiGYxiCuWhbrxmUBJPuI,28189 +bitblas/3rdparty/cutlass/tools/profiler/include/cutlass/profiler/rank_2k_operation_profiler.h,sha256=_blXVvvURzG5CR-sZqXCt7cWHlc0E57HLCmGrbknhdA,6891 +bitblas/3rdparty/cutlass/tools/profiler/include/cutlass/profiler/rank_k_operation_profiler.h,sha256=G0Lqi-YPdcOCVIH3CIdjvOg5qkn7OfKtDpma1eJeqiM,6830 +bitblas/3rdparty/cutlass/tools/profiler/include/cutlass/profiler/reduction_operation_profiler.h,sha256=IKhEZf7vb5tWkuf0nOAmE3tEVRACBsDCS3y_FXGpRAg,5452 +bitblas/3rdparty/cutlass/tools/profiler/include/cutlass/profiler/sparse_gemm_operation_profiler.h,sha256=aIl_SNCXEWTtjk0qjEKYLBv2aKWStAwVtC58HPvGb1Y,6471 +bitblas/3rdparty/cutlass/tools/profiler/include/cutlass/profiler/symm_operation_profiler.h,sha256=7ntnSb9xt8TLMPT96_c7NlBJA2zYdr7baj7YHpAyZsc,6933 +bitblas/3rdparty/cutlass/tools/profiler/include/cutlass/profiler/trmm_operation_profiler.h,sha256=uA1sJ7j_CNFeNBQX92Exh8fNBfx2Q7gX9zzUsLUSOYM,6599 +bitblas/3rdparty/cutlass/tools/profiler/src/conv2d_operation_profiler.cu,sha256=PGumFZns4EbSA9_a1VzDIJcJNTq6wxE4CRs7UEVgKp8,54272 +bitblas/3rdparty/cutlass/tools/profiler/src/conv3d_operation_profiler.cu,sha256=GM9OI-WPEZg0nu5rwshUylBTP66zeERt-y14i7GCEsE,48776 +bitblas/3rdparty/cutlass/tools/profiler/src/cublas_helpers.cu,sha256=A5UqwvAhxqopjUHV6Z7pz6UwFRxUIoYMPvfjlT4v_3I,37138 +bitblas/3rdparty/cutlass/tools/profiler/src/cudnn_helpers.cpp,sha256=2ASH151fS6hCr2HNhJlHA1YmTMrItINJjC0XcjGBrAM,17066 +bitblas/3rdparty/cutlass/tools/profiler/src/cutlass_profiler.cu,sha256=qQlAinMXS1ojI4p4xe2y9lvJ6guLU173MUuD5uE_KaE,7391 +bitblas/3rdparty/cutlass/tools/profiler/src/device_allocation.cu,sha256=j8x7fONRpPYCU-CEqm-hnfJFN3DTfcqYnM5cOJK9W4w,73851 +bitblas/3rdparty/cutlass/tools/profiler/src/device_context.cu,sha256=jCUmlBcFqNt5-Xw_bSD0QMJVfZFPRrRyya4SW06s5pI,8359 +bitblas/3rdparty/cutlass/tools/profiler/src/enumerated_types.cpp,sha256=gMn3Awwy6gXJe-dQSPiZnf69660hozm3NE0MUcDARt4,8313 +bitblas/3rdparty/cutlass/tools/profiler/src/gemm_operation_profiler.cu,sha256=kBXkwhiVUwJUdFEMHj1fsdX5VR69Bm3PxXlPbyCDOc4,44007 +bitblas/3rdparty/cutlass/tools/profiler/src/gpu_timer.cpp,sha256=T0dizsXlbCJ_6JSr_r0B4GU5MbcdFMsqwr4luIngN0k,3892 +bitblas/3rdparty/cutlass/tools/profiler/src/main.cpp,sha256=-eNf5ZEKsdgpjVmGdugCl81v8e8Teyd7rzII1JrNVKI,2374 +bitblas/3rdparty/cutlass/tools/profiler/src/operation_profiler.cu,sha256=G-LvSJo_G-O2NeGJhVcU74-RDCyUpn2FDD9RqNIHcdE,22898 +bitblas/3rdparty/cutlass/tools/profiler/src/options.cu,sha256=d6bHvruQtJyRZYN_fE0N6kRs5xkOIZ1dD2QgkNB5XpU,28314 +bitblas/3rdparty/cutlass/tools/profiler/src/performance_report.cpp,sha256=2HHS2unfXkaTILPGT_Vsr2gvI6-CpZJospD9TgllSHw,14227 +bitblas/3rdparty/cutlass/tools/profiler/src/performance_result.cu,sha256=K-5sXCkHg7tR0V_uS4SQee7iAe-kbx9fFmOuqM1fI-k,2528 +bitblas/3rdparty/cutlass/tools/profiler/src/problem_space.cpp,sha256=pzg9E0c70AticSHeHUANB7vljODi03jzxOoFj5hHHXA,38798 +bitblas/3rdparty/cutlass/tools/profiler/src/rank_2k_operation_profiler.cu,sha256=aOyvw_7GMRVG3qow4Tg65v6Z7sDpkIEh39JWzIRAotk,25183 +bitblas/3rdparty/cutlass/tools/profiler/src/rank_k_operation_profiler.cu,sha256=zJLnDZIJlPG25g4cx7uCM2MYDzNXOXZKRa-DvJ6jpPU,24378 +bitblas/3rdparty/cutlass/tools/profiler/src/sparse_gemm_operation_profiler.cu,sha256=2Lpss4MAwcGejFjhLQ3fM2_tuGhQlwOXNeKoMqkf2Ws,20915 +bitblas/3rdparty/cutlass/tools/profiler/src/symm_operation_profiler.cu,sha256=02ofydX5bv64G6pAMSsrtsSlDB-0Ly6yQu835Aj10i0,26753 +bitblas/3rdparty/cutlass/tools/profiler/src/trmm_operation_profiler.cu,sha256=FAxxbMixdHw7DtcU2E6O0T9oOoSLmJA1eenK6EnPrJ8,24567 +bitblas/3rdparty/cutlass/tools/util/CMakeLists.txt,sha256=ULTclJAddo7gt8E_EnMUJy2IJ00myyU3YhMsZP_4TUI,2297 +bitblas/3rdparty/cutlass/tools/util/include/cutlass/util/GPU_Clock.hpp,sha256=Dy9SGIYRPaRlOKWwEGkoMZLZHxlGPmPQqf2jxlImCS8,2410 +bitblas/3rdparty/cutlass/tools/util/include/cutlass/util/command_line.h,sha256=Srm6887zWzzDNqQgPQG72P8g1MvuKUc9jxIO9d75fGQ,9774 +bitblas/3rdparty/cutlass/tools/util/include/cutlass/util/cublas_wrappers.hpp,sha256=zIoRRkErWZqQ-14D4QIapq50uclcLEuMEGqEi0XdiKU,19866 +bitblas/3rdparty/cutlass/tools/util/include/cutlass/util/debug.h,sha256=ZJ05nDINXkIdgVZoCAkwtqaIy5PGkmSo9ZsftYZ9AjQ,5104 +bitblas/3rdparty/cutlass/tools/util/include/cutlass/util/device_dump.h,sha256=MMFbGJyYKPuzGD5VaIHfpyqCEKFKS_n0DfovwCUkDHw,5953 +bitblas/3rdparty/cutlass/tools/util/include/cutlass/util/device_groupnorm.h,sha256=YDFlgvgJI_fYPQQDpBbUenGhRsTi8Dw9x3IvJu6i6n4,17696 +bitblas/3rdparty/cutlass/tools/util/include/cutlass/util/device_layernorm.h,sha256=G_eGH6547kfNBY4h_KNr3Fz0k3B1dVvqsc1QxZIN0f0,20881 +bitblas/3rdparty/cutlass/tools/util/include/cutlass/util/device_memory.h,sha256=wSUn_HQIfzvo1rvxmbAuSnbOlfUjAw-dZKIn3uDIia4,10561 +bitblas/3rdparty/cutlass/tools/util/include/cutlass/util/device_nchw_to_nhwc.h,sha256=Y508hA-tlmChPj8e8n7uIPpuQ0M7K_-WshwAeOITOls,5219 +bitblas/3rdparty/cutlass/tools/util/include/cutlass/util/device_nhwc_padding.h,sha256=--zClS06rrLcJZzaIoX72Q3-PQIqkBzqZkS6-H9douQ,11075 +bitblas/3rdparty/cutlass/tools/util/include/cutlass/util/device_nhwc_pooling.h,sha256=l8ARuuGQYY9y5PqMtdAVucSFrToZSqMgYlczNs89W6Y,18653 +bitblas/3rdparty/cutlass/tools/util/include/cutlass/util/device_nhwc_to_nchw.h,sha256=enZPDJL_pTJp-22BDIUOMvm7xdZiXOHLBF5_EHK6Ox4,5214 +bitblas/3rdparty/cutlass/tools/util/include/cutlass/util/device_rmsnorm.h,sha256=lve2QDTVqs7PUUtgIN3ZKqS72OeqBFCPXfZ0rHCp4-M,6981 +bitblas/3rdparty/cutlass/tools/util/include/cutlass/util/device_utils.h,sha256=9zsTze96K321HDsUw0NhNg4zM9Vgqr4JxO7RjFiGgIc,4007 +bitblas/3rdparty/cutlass/tools/util/include/cutlass/util/distribution.h,sha256=yAyCP1kIKGN8iQkaTddVie93zXfSr8KaEt1UYmSS7WI,4846 +bitblas/3rdparty/cutlass/tools/util/include/cutlass/util/exceptions.h,sha256=Jb5iX-ua5cWCiqeZ37LbgKlTcXQ2xXTvfy06CNjxqk4,2674 +bitblas/3rdparty/cutlass/tools/util/include/cutlass/util/gett_commandline.hpp,sha256=NirQ8NwnUi_19KItPxixQ8MyzGVs3KQpAqVHiOCXJ5I,13740 +bitblas/3rdparty/cutlass/tools/util/include/cutlass/util/helper_cuda.hpp,sha256=IPmYenzCqY3oqAmcgcGBYpqW6Ph0LI6wkoPgExfsnQM,3946 +bitblas/3rdparty/cutlass/tools/util/include/cutlass/util/host_reorder.h,sha256=ezaPEfNfg9d4Ba2hl36qQVQbvrI179D99hyPt-8lSSw,4821 +bitblas/3rdparty/cutlass/tools/util/include/cutlass/util/host_tensor.h,sha256=3_901yO0heB6vHO7K8xUCR1XsmqqWhy4rIWoM7WezwE,18081 +bitblas/3rdparty/cutlass/tools/util/include/cutlass/util/host_tensor_planar_complex.h,sha256=tdCXyoWoU0V8Rua5HFRCBsu40ww2E9lkvllPYIGhlh4,20354 +bitblas/3rdparty/cutlass/tools/util/include/cutlass/util/host_uncompress.h,sha256=-SaTAElO-ZHDvsvZKFt5Zh1di3tbgkWhbjEmWdypbJI,5890 +bitblas/3rdparty/cutlass/tools/util/include/cutlass/util/index_sequence.h,sha256=RKXhGAhNnqHv-SmTyvbop8DC0rw1F2KXa8VPbsGaqh8,1962 +bitblas/3rdparty/cutlass/tools/util/include/cutlass/util/packed_stride.hpp,sha256=u8QzH4wJ9uVSh6885mwc4zPe7h8Dd44RG3EZk2Smymo,4606 +bitblas/3rdparty/cutlass/tools/util/include/cutlass/util/print_error.hpp,sha256=eyA8MU0vU_zBqYm1Umrk418WpLpA-vya8YJZWrXBaqc,11065 +bitblas/3rdparty/cutlass/tools/util/include/cutlass/util/reference/detail/inner_product.h,sha256=zekcCVb7HBb19BdAU39mziUJBOyF9wzG5aaNFf_8G6c,4606 +bitblas/3rdparty/cutlass/tools/util/include/cutlass/util/reference/detail/linear_to_coordinate.h,sha256=juEcBKreGL9P9Lp8VzAu_AvvkbucaWifxooR6VNMvIg,3527 +bitblas/3rdparty/cutlass/tools/util/include/cutlass/util/reference/device/convolution.h,sha256=HinXEL8oYPYB0TdXGLWGWDWl5B8keVkfzLiWLvNZi7I,48350 +bitblas/3rdparty/cutlass/tools/util/include/cutlass/util/reference/device/gemm.h,sha256=eAW9RCX_-M6x9teBUpSw_xA9khMz7bTpwlVbsDyQTIc,14296 +bitblas/3rdparty/cutlass/tools/util/include/cutlass/util/reference/device/gemm_complex.h,sha256=Unq1rwIhsmX4LPZgxJHtfV1SGjfirnvH17ZzOqku5L4,10652 +bitblas/3rdparty/cutlass/tools/util/include/cutlass/util/reference/device/gemm_planar_complex.h,sha256=xYXJHAiEikSPb5ABxgFojP8HprGHVCNZKRLqORgR0T0,9652 +bitblas/3rdparty/cutlass/tools/util/include/cutlass/util/reference/device/gett.hpp,sha256=nuipK__U8LPv4yUCp3qAeFDkHXXo3BTy5ytpiXDmRJw,5438 +bitblas/3rdparty/cutlass/tools/util/include/cutlass/util/reference/device/kernel/gemm.h,sha256=IPMoJl6MxFvRZY9RNQu2oxq2JEV3sAUZ9-7kWUxmAaA,5381 +bitblas/3rdparty/cutlass/tools/util/include/cutlass/util/reference/device/kernel/tensor_elementwise.h,sha256=GklL9UyYTuUhk95qVF-o6YkmVAyWgnBCDL4CiwI4fJo,6198 +bitblas/3rdparty/cutlass/tools/util/include/cutlass/util/reference/device/kernel/tensor_foreach.h,sha256=8QUkTy5O_bi6MdiMwlv6qL854OJfTpFoInAzykizpEU,5127 +bitblas/3rdparty/cutlass/tools/util/include/cutlass/util/reference/device/rank_2k_complex.h,sha256=xS2CNOyDUihXBOVV4FswQBg7Xe3WeIwIxoWH8cMd7gw,11615 +bitblas/3rdparty/cutlass/tools/util/include/cutlass/util/reference/device/tensor_compare.h,sha256=OE-oJmzjfOQPu5CJEeoK5GKNyl1r2_8n7i8frWVa7rs,7278 +bitblas/3rdparty/cutlass/tools/util/include/cutlass/util/reference/device/tensor_fill.h,sha256=Y0sAOSyg4LVh-zRMmH--4y8CBwZQSZ5RI18M10AddiE,49624 +bitblas/3rdparty/cutlass/tools/util/include/cutlass/util/reference/device/tensor_foreach.h,sha256=UfiUP10aXYcDZrGc_faeN4yH7Gicubbv6aWax0wACSU,5454 +bitblas/3rdparty/cutlass/tools/util/include/cutlass/util/reference/device/tensor_reduce.h,sha256=-nis42tsIHLXsmBEcrkhEQySOVOA3i9FdgOpmc_imkU,15964 +bitblas/3rdparty/cutlass/tools/util/include/cutlass/util/reference/device/tensor_relu.h,sha256=9G9znhsj9kesPiVOch2efo_EkDaJZrgteF5YxNl3QTo,4589 +bitblas/3rdparty/cutlass/tools/util/include/cutlass/util/reference/device/thread/gemm.h,sha256=Xdu8Ipp-jYloI6U1Mr7abl972OBUQGrFuKeMBtYoQi0,5872 +bitblas/3rdparty/cutlass/tools/util/include/cutlass/util/reference/host/convolution.h,sha256=6VtQvWgQm3U9euCh0gNnYKMWGLqw4L5xmWGSV53XocU,28652 +bitblas/3rdparty/cutlass/tools/util/include/cutlass/util/reference/host/error_metrics.h,sha256=GC2VtB75hYuDMoa3di4P-VGB8UwTBB8sV7ZnFsxfX3Q,2766 +bitblas/3rdparty/cutlass/tools/util/include/cutlass/util/reference/host/gemm.h,sha256=YMt_Bm5jwFSSflqy24u557CJMxqOIm0Inl2nOD1sy38,20938 +bitblas/3rdparty/cutlass/tools/util/include/cutlass/util/reference/host/gemm_complex.h,sha256=r9N2d4HjHmKyNuSiTtCcJGT4y-nNiNIJZVJmMAM5m0o,7161 +bitblas/3rdparty/cutlass/tools/util/include/cutlass/util/reference/host/gemm_planar_complex.h,sha256=BR0nls97KyfXMjK3KNq9Rtw_X5y9HIv_xNhHBiH4QZM,7708 +bitblas/3rdparty/cutlass/tools/util/include/cutlass/util/reference/host/gett.hpp,sha256=OzzS9iH2l_fJW_Oho0nFF2jZOUtxe-mZe_5M8KF8jBs,19343 +bitblas/3rdparty/cutlass/tools/util/include/cutlass/util/reference/host/rank_2k.h,sha256=FeDslfQPKb7VwTnAMB5FqGjeno-mi5CK29DymAVH2mE,9441 +bitblas/3rdparty/cutlass/tools/util/include/cutlass/util/reference/host/rank_2k_complex.h,sha256=yUhna-WdNWQGIGSN0cdh9K-3-1DYxvUBzL9eNxgsCP0,11444 +bitblas/3rdparty/cutlass/tools/util/include/cutlass/util/reference/host/rank_k_complex.h,sha256=0sBqXQLsvlImmf-cnTTLu0_gwDa7BnGIGao6_TQTeS8,8148 +bitblas/3rdparty/cutlass/tools/util/include/cutlass/util/reference/host/symm.h,sha256=qMh8Kx4dqDWLEsbxA8abRcI--jiUGUkWcJaxsAUBrgo,10509 +bitblas/3rdparty/cutlass/tools/util/include/cutlass/util/reference/host/symm_complex.h,sha256=W59Abg_udLsNiJPMLAKuNOJVraJYflLZFr9I8kh9R1A,12296 +bitblas/3rdparty/cutlass/tools/util/include/cutlass/util/reference/host/tensor_compare.h,sha256=OdVCjaSrF2q6tBIMOPJmIsqH0RLcufbwh4LUj1_c3iM,11235 +bitblas/3rdparty/cutlass/tools/util/include/cutlass/util/reference/host/tensor_compare.hpp,sha256=60oj9wfi6qdcCs4TureAi8fmgmgaPrQd7V2IusrgZ64,3339 +bitblas/3rdparty/cutlass/tools/util/include/cutlass/util/reference/host/tensor_copy.h,sha256=obN5Qe6jETw1Ye8pQSz7Ww39IK-fa9g4IMh5uG_EC3A,8317 +bitblas/3rdparty/cutlass/tools/util/include/cutlass/util/reference/host/tensor_elementwise.h,sha256=NTC48jD_pQLtxcpoRQGCTwrojcS0gXnRfhnBBMxs9lc,9027 +bitblas/3rdparty/cutlass/tools/util/include/cutlass/util/reference/host/tensor_fill.h,sha256=fDjs_XdZJQZTCrqdzgJAy-f7MuF214QO0QgM3rLuAbM,46749 +bitblas/3rdparty/cutlass/tools/util/include/cutlass/util/reference/host/tensor_fill.hpp,sha256=cl5RO93yB207-pFSqe5vYUntyN-RM289yksQ8e1M2d8,12875 +bitblas/3rdparty/cutlass/tools/util/include/cutlass/util/reference/host/tensor_foreach.h,sha256=5Ylx3ljE9oh1nf_5YZYRhpnCqtsI86Yt8gxX1Xflo2k,4757 +bitblas/3rdparty/cutlass/tools/util/include/cutlass/util/reference/host/tensor_norm.h,sha256=EL1qKdwDyfdqU4Uj2FqCjB-xj3tj3sui-mTlTcv8lsU,2133 +bitblas/3rdparty/cutlass/tools/util/include/cutlass/util/reference/host/tensor_reduce.h,sha256=-3hPKUZDFpJuf3qQ7vL25j0H5vpu_59gEliidQoSYhs,6111 +bitblas/3rdparty/cutlass/tools/util/include/cutlass/util/reference/host/tensor_reduce.hpp,sha256=OuunNdXGgcoPNRVhGnuF-kIq7LMUuFy0lzhFVzW-RNk,5987 +bitblas/3rdparty/cutlass/tools/util/include/cutlass/util/reference/host/trmm.h,sha256=9zQnIgUmOyUmgui3bRHboM08cCFO1oqHGNCKdgSZdOg,7670 +bitblas/3rdparty/cutlass/tools/util/include/cutlass/util/reference/host/trmm_complex.h,sha256=Tng32cIp1cNcRSnoO2lAl0nUw8H0v8UPzrwuIzSJBLk,9874 +bitblas/3rdparty/cutlass/tools/util/include/cutlass/util/tensor_view_io.h,sha256=VSRyeBdqf-qsgWvJKp1lT9gHgwb4-v_Cm_9HVKDwpY0,8341 +bitblas/3rdparty/cutlass/tools/util/include/cutlass/util/type_traits.h,sha256=xCvDg7qRAzxqY8yVlpBK4j0-2TKQ3pgHP94Th3QJFcM,8809 +bitblas/3rdparty/tvm/CONTRIBUTORS.md,sha256=VugkA7zmCeNtQ7bnMn-TS296uZUA7Qqqh6E6XoFswak,14643 +bitblas/3rdparty/tvm/KEYS,sha256=qO78jZX4bE3OT8Gm4nfgfb01zGEmyyX7OG_XolGM8SM,45067 +bitblas/3rdparty/tvm/LICENSE,sha256=PlfUcIp58wKRsxyvDrchcXAqz8TFNmmHfSeawbVv2PU,12423 +bitblas/3rdparty/tvm/README.md,sha256=CRs24KH5Yk0Jk72obmtK_VtId06jDCnSHo-DNy7ZMHU,2924 +bitblas/3rdparty/tvm/__pycache__/conftest.cpython-310.pyc,, +bitblas/3rdparty/tvm/__pycache__/version.cpython-310.pyc,, +bitblas/3rdparty/tvm/build/config.cmake,sha256=F1N3M3WmBFgL4_MR-A0M1a70QWZuloOgG1X002op7rg,14663 +bitblas/3rdparty/tvm/build/libtvm.so,sha256=Ls7Lv8fJzU6WvMuSb5nEYec5QRV3QuK07MEckwB7G5I,151686512 +bitblas/3rdparty/tvm/build/libtvm_runtime.so,sha256=RC2oDMI4iWOeCc3r1U4vC7q9b6LmF2z4rZeICi29AYY,4655600 +bitblas/3rdparty/tvm/conftest.py,sha256=h8b0NPMY0jTABMuAM5kKQt2-PI4JryOua74Xy1YUsfY,4700 +bitblas/3rdparty/tvm/licenses/LICENSE.blockingconcurrentqueue.txt,sha256=H0LahPdenXXJODyR6g7AdUbdgpf2eE744SvyzFqTy20,1118 +bitblas/3rdparty/tvm/licenses/LICENSE.builtin_fp16.txt,sha256=Go8QWHU_G6iQ3phOSPAkKjpcKaao8u2f2BPzaYU4fo0,16708 +bitblas/3rdparty/tvm/licenses/LICENSE.cma.txt,sha256=2se7Ao_PqpKYfYxknAm5o_U5_UPESYoEWM9gHo4GMuo,1178 +bitblas/3rdparty/tvm/licenses/LICENSE.cnpy.txt,sha256=H_b6lK0p2UHOs73V6_smDdukw-lixQ-3pmyJnnad4f8,1073 +bitblas/3rdparty/tvm/licenses/LICENSE.concurrentqueue.txt,sha256=E240doYi5Zaebq7h8bJUlE5n4Honscwk1F984wXk_Z0,1324 +bitblas/3rdparty/tvm/licenses/LICENSE.cutlass.txt,sha256=XAroEd6JE-MoXaOPRlLYvwsc6J8eso79wPDpTj9WTQc,1518 +bitblas/3rdparty/tvm/licenses/LICENSE.cutlass_fpA_intB_gemm.txt,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358 +bitblas/3rdparty/tvm/licenses/LICENSE.dlpack.txt,sha256=Po9rw5J2pYbWDIxars4v-YkmIYHPKz0qEo21j5epMAw,11345 +bitblas/3rdparty/tvm/licenses/LICENSE.l2_cache_flush.txt,sha256=nkXoVr7czun2clQILKEYUdlU3i_tdEjEvtGa2aq5mpE,12262 +bitblas/3rdparty/tvm/licenses/LICENSE.libbacktrace.txt,sha256=dp2Dy7uBe6TiXR8WYjhCaqRVGZgeyhFgEeQRMIfHt7M,1471 +bitblas/3rdparty/tvm/licenses/LICENSE.libcrc.txt,sha256=wNyHUxnatDOP9057ArNlQWUKfMDyof1uxR-Q6pWOTZo,1074 +bitblas/3rdparty/tvm/licenses/LICENSE.libflash_attn.txt,sha256=jJzLlsBl5wYTW2y60nm3IdphVuUfOl8nxrMymvlBbXM,1558 +bitblas/3rdparty/tvm/licenses/LICENSE.picojson.txt,sha256=VYX-FBzHuwjJU_OFnbYIhSlo0LvGJbm22VwL1jSbrLY,1336 +bitblas/3rdparty/tvm/licenses/LICENSE.rang.txt,sha256=iNm062BXnBkew5HKBMFhMFctfu3EqG2qWL8oxuFMm80,1210 +bitblas/3rdparty/tvm/licenses/LICENSE.tensorrt_llm.txt,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358 +bitblas/3rdparty/tvm/licenses/LICENSE.vllm.txt,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357 +bitblas/3rdparty/tvm/mypy.ini,sha256=j-S0bUH5fzrNMPBbcJ0ug1BgFzBGnHybldQRUMoajKQ,1108 +bitblas/3rdparty/tvm/pyproject.toml,sha256=y-p1gyUHq9O6EYAs0hNSoOoM51itbybLxSTER6hFS1U,1252 +bitblas/3rdparty/tvm/python/.gitignore,sha256=i8pMXjxaWGwRC--n83ttYIuFXXCxQv1v_ofeFYBa2SY,36 +bitblas/3rdparty/tvm/python/__pycache__/gen_requirements.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/__pycache__/setup.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/gen_requirements.py,sha256=UUOjwF5WJSPL04uPGOijIZhUUoc7NlcsWJgulFUrt3U,22224 +bitblas/3rdparty/tvm/python/setup.py,sha256=iC8Nis9oFgTCHqa9rr8DNKh3qP_7jJyBpIUWVm5jVkk,10453 +bitblas/3rdparty/tvm/python/tvm/__init__.py,sha256=uKotdEaMIrvead-vnWIOLBSyTl22K66Y_Reqqrtn7_Q,3745 +bitblas/3rdparty/tvm/python/tvm/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/__pycache__/__init__.cpython-310.pyc,sha256=ehsfJfVQlLjT0klnMmcWFRgK4TWKdR44KOMwxLgCB0s,2839 +bitblas/3rdparty/tvm/python/tvm/__pycache__/__init__.cpython-38.pyc,sha256=j98LrPvHYVNhELquHsuqLwWOCw4YbSCSku6Axrv6At4,2828 +bitblas/3rdparty/tvm/python/tvm/__pycache__/error.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/__pycache__/error.cpython-310.pyc,sha256=PcOB9nDIa_bJ90Lk2pHimHbjN7HttlPlXrcPR-QHN9I,3787 +bitblas/3rdparty/tvm/python/tvm/__pycache__/error.cpython-38.pyc,sha256=i_Hs2oBAjvy8DN7D2A-DqWkYDwSK_tMQg-7kLXJwgLM,3896 +bitblas/3rdparty/tvm/python/tvm/__pycache__/generic.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/__pycache__/parser.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/__pycache__/parser.cpython-310.pyc,sha256=UjtDDjvAegWHBEn-mwuhE-Goc7o7Vp4DaM3_WmhsLg0,1142 +bitblas/3rdparty/tvm/python/tvm/__pycache__/parser.cpython-38.pyc,sha256=IFeFg8GaMfIkzEgzKodUu7ocZJ6cB0OMPh5bSiJf2NQ,1203 +bitblas/3rdparty/tvm/python/tvm/__pycache__/support.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/__pycache__/support.cpython-310.pyc,sha256=VWe02n8LriTVLpMnMWxEzzLM8Av9jLG6JAyRH5P70-w,2863 +bitblas/3rdparty/tvm/python/tvm/__pycache__/support.cpython-38.pyc,sha256=P-eBMmHf0dbSTKVsEDI5003otyO6t1u1FJD3ilozDX4,2834 +bitblas/3rdparty/tvm/python/tvm/_ffi/__init__.py,sha256=P3vvS_Vqclgoz9WgVcHWWgXTQHHfW7iDdRiea-lV9xg,1342 +bitblas/3rdparty/tvm/python/tvm/_ffi/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/_ffi/__pycache__/__init__.cpython-310.pyc,sha256=0EkZz8YrjEr76SUTAlNj1vtDcKd-H4TH27IVBpZhPqM,794 +bitblas/3rdparty/tvm/python/tvm/_ffi/__pycache__/__init__.cpython-38.pyc,sha256=O9bWByJ1teVnQoWaW2aOu-bIOxXYc984PaXTG6obCXk,781 +bitblas/3rdparty/tvm/python/tvm/_ffi/__pycache__/_pyversion.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/_ffi/__pycache__/_pyversion.cpython-310.pyc,sha256=yon8LfBiikyBIK-_dUHOSvnbvvac-wIVGPkO9SHZP94,361 +bitblas/3rdparty/tvm/python/tvm/_ffi/__pycache__/_pyversion.cpython-38.pyc,sha256=mURI7T7ITVQAhFh9GeQMDB3bgk3hcADr11vThpIQjYM,346 +bitblas/3rdparty/tvm/python/tvm/_ffi/__pycache__/base.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/_ffi/__pycache__/base.cpython-310.pyc,sha256=kwYOx67iEyeGL59oVzUmfB5ksXnxZXWlAiARF9kiVB0,10457 +bitblas/3rdparty/tvm/python/tvm/_ffi/__pycache__/base.cpython-38.pyc,sha256=6LT9177ZLcYhOcH4A59br3sXUe2tmtwRCeLuRyRDf7s,10436 +bitblas/3rdparty/tvm/python/tvm/_ffi/__pycache__/libinfo.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/_ffi/__pycache__/libinfo.cpython-310.pyc,sha256=tEfAQTcym18NETLmqhaFGUfvspL92UufykR6miouZBg,6866 +bitblas/3rdparty/tvm/python/tvm/_ffi/__pycache__/libinfo.cpython-38.pyc,sha256=DRkoB7L7jD1rrsyyRGTpYNAmISgG3pi56gBcILhTtPU,7454 +bitblas/3rdparty/tvm/python/tvm/_ffi/__pycache__/registry.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/_ffi/__pycache__/registry.cpython-310.pyc,sha256=h9zYZNB_rhGPgzXjyabZSI-xxf9rs6ZR8z54S6XJ8RY,8181 +bitblas/3rdparty/tvm/python/tvm/_ffi/__pycache__/registry.cpython-38.pyc,sha256=hS3dYvJFU9QKY_pV1N79Jr96jb-HQ69n5ceIlpYkCsg,8178 +bitblas/3rdparty/tvm/python/tvm/_ffi/__pycache__/runtime_ctypes.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/_ffi/__pycache__/runtime_ctypes.cpython-310.pyc,sha256=4Kxss2EWwSyceA5hNMo2Mpr64nCdULlXoEeQxIP8n-U,18657 +bitblas/3rdparty/tvm/python/tvm/_ffi/__pycache__/runtime_ctypes.cpython-38.pyc,sha256=Y8n0VNLvGbC89JjyYL3DW1WT3i4FwnTWnDg73aym6jo,18888 +bitblas/3rdparty/tvm/python/tvm/_ffi/_ctypes/__init__.py,sha256=v7CdPYj7NzpqH4E7dbeukZd8ZktlDaDafXSm2cis2IY,829 +bitblas/3rdparty/tvm/python/tvm/_ffi/_ctypes/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/_ffi/_ctypes/__pycache__/__init__.cpython-310.pyc,sha256=B9IAN2wcKIu4JvZTbQfa2EEIvjTcftg4kZdtqGtAxJk,215 +bitblas/3rdparty/tvm/python/tvm/_ffi/_ctypes/__pycache__/__init__.cpython-38.pyc,sha256=00LeXh2ye4kQKnr-ZvxU08baQW3wkd2tBDEodk7VKvs,202 +bitblas/3rdparty/tvm/python/tvm/_ffi/_ctypes/__pycache__/ndarray.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/_ffi/_ctypes/__pycache__/ndarray.cpython-310.pyc,sha256=nAt3z1HNxO7gDKdpkz-762Ujz6oRI-Lnudvs5etOMqY,4613 +bitblas/3rdparty/tvm/python/tvm/_ffi/_ctypes/__pycache__/ndarray.cpython-38.pyc,sha256=lO4yfcNV0VaJAFltpTLYTC8T9NCcMhNt_7GTqzf18Xs,4576 +bitblas/3rdparty/tvm/python/tvm/_ffi/_ctypes/__pycache__/object.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/_ffi/_ctypes/__pycache__/object.cpython-310.pyc,sha256=SyIhUOz8qmrZPXCEwvSoFwr3ICDs-3-23eQ0qfkSonQ,4187 +bitblas/3rdparty/tvm/python/tvm/_ffi/_ctypes/__pycache__/object.cpython-38.pyc,sha256=v6DwmtgJFh0j6tttnqlBEdtmNIHqcyEGuIrsLC3gLn8,4158 +bitblas/3rdparty/tvm/python/tvm/_ffi/_ctypes/__pycache__/packed_func.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/_ffi/_ctypes/__pycache__/packed_func.cpython-310.pyc,sha256=3Y5b3WMry8xDb2FchSwnGs-DP1v9ItOmjBktdhX1B3g,8796 +bitblas/3rdparty/tvm/python/tvm/_ffi/_ctypes/__pycache__/packed_func.cpython-38.pyc,sha256=ZPDvXEOXy7PNN-rdaYszpb1KCmgslSDSyzNGiYdihlU,8833 +bitblas/3rdparty/tvm/python/tvm/_ffi/_ctypes/__pycache__/types.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/_ffi/_ctypes/__pycache__/types.cpython-310.pyc,sha256=y_1Lt5q-n4xJKJ0aUlWVPnAYKUf9xSSJGLom2_Ty9YA,3182 +bitblas/3rdparty/tvm/python/tvm/_ffi/_ctypes/__pycache__/types.cpython-38.pyc,sha256=xTiWSCC5NzY4jvWqoEzChxki2Bn4UtHlX9pc6twUYCs,3221 +bitblas/3rdparty/tvm/python/tvm/_ffi/_ctypes/ndarray.py,sha256=bsDW2Ft6SdOckBxlPqZqLnZD6hEFeowiuBs9VHO6pZM,5100 +bitblas/3rdparty/tvm/python/tvm/_ffi/_ctypes/object.py,sha256=qR-rU6jGdYFLBiQKXYGJmriWL56tS04zQ8Xl2h4eIhM,5075 +bitblas/3rdparty/tvm/python/tvm/_ffi/_ctypes/packed_func.py,sha256=-pwQfUiBwbVVy5wd45wGagjEUqNI5avZzv_2GV2e8eA,12276 +bitblas/3rdparty/tvm/python/tvm/_ffi/_ctypes/types.py,sha256=LcbNZ_1Ma2VRVcJHiip-GaIcc-xqjQPGjHYHIVquP3M,3399 +bitblas/3rdparty/tvm/python/tvm/_ffi/_cy2/__init__.py,sha256=viK-XkYvZBv0RqCWZZDcFRNT0P2BXTYrYRhRoKmBN1g,809 +bitblas/3rdparty/tvm/python/tvm/_ffi/_cy2/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/_ffi/_cy3/__init__.py,sha256=xOuYFpY2nh_5NIgjRnDrU-6Wke1wMdP96h3KxeW6akQ,809 +bitblas/3rdparty/tvm/python/tvm/_ffi/_cy3/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/_ffi/_cy3/__pycache__/__init__.cpython-310.pyc,sha256=CI3FJUFP_XmCC8vztB1bXptk6JugZB8tU54wVMgC7ug,192 +bitblas/3rdparty/tvm/python/tvm/_ffi/_cy3/__pycache__/__init__.cpython-38.pyc,sha256=bXqpjFWdKPPfvFnqhzDK7YH9xT2x-Mef-3skmAV1Z_s,179 +bitblas/3rdparty/tvm/python/tvm/_ffi/_cython/base.pxi,sha256=q22ti0ArYVT_Mwf3NUQTdVNWAGFrAkKDU5L6SnLeJFs,6862 +bitblas/3rdparty/tvm/python/tvm/_ffi/_cython/core.pyx,sha256=VrU8Bt5wLcju8G6DBMevu7TluPPnZlpm3VtD7RGdlt0,882 +bitblas/3rdparty/tvm/python/tvm/_ffi/_cython/ndarray.pxi,sha256=6dI9tDhYQEemy12Qc6WlNHQkCRQTXns-ynNaicSwlFk,6041 +bitblas/3rdparty/tvm/python/tvm/_ffi/_cython/object.pxi,sha256=XObBkJaDfpw_ab8EyPkj4dAmoN4BWj7FjNQeAySsjNI,4696 +bitblas/3rdparty/tvm/python/tvm/_ffi/_cython/packed_func.pxi,sha256=43CA9pcz28gktka7N2QPSp_S-4QXpVlHrprIPD-yIoI,12994 +bitblas/3rdparty/tvm/python/tvm/_ffi/_pyversion.py,sha256=qbmOzD_WfNt5Id_CdTyUa0K4L_-ggqQ-S4V6rTjtgUQ,1070 +bitblas/3rdparty/tvm/python/tvm/_ffi/base.py,sha256=j6Zu-pESSn_lgqsDaeNB83GbmOdVYuhyqHJLIiMDHUU,14909 +bitblas/3rdparty/tvm/python/tvm/_ffi/libinfo.py,sha256=eovS5UQoC3xGHmPZ7MEYBpl4DQ1G848CnChrF4Ogm6E,9307 +bitblas/3rdparty/tvm/python/tvm/_ffi/registry.py,sha256=0iwnGA3PJIqPVYSkUNFCOrO8Nz4UhX6J-6YuM4VyIJE,9123 +bitblas/3rdparty/tvm/python/tvm/_ffi/runtime_ctypes.py,sha256=PC2n_m0glwbkXzyndbuxWjcFK3TtMFsykB0M9PYo4Sw,20805 +bitblas/3rdparty/tvm/python/tvm/arith/__init__.py,sha256=EolDE01e6wuwlouAfh8EVmgzb39id3FEDMmLnpXaEtU,1568 +bitblas/3rdparty/tvm/python/tvm/arith/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/arith/__pycache__/__init__.cpython-310.pyc,sha256=UsYMLyykhsRD5cBNxdrPWaWgHHfZ-jI-uTERZExy6IQ,1126 +bitblas/3rdparty/tvm/python/tvm/arith/__pycache__/__init__.cpython-38.pyc,sha256=WB2VXjtkPzRtygt5rTY0AkFPYR1lXQEHDJ1K4B4E1VY,1113 +bitblas/3rdparty/tvm/python/tvm/arith/__pycache__/_ffi_api.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/arith/__pycache__/_ffi_api.cpython-310.pyc,sha256=grlsKv56OCotJBKccbD1tH7VG9MDK5Y8mvZgf4XPCmw,273 +bitblas/3rdparty/tvm/python/tvm/arith/__pycache__/_ffi_api.cpython-38.pyc,sha256=iXNTnTliNkCZ2agOz4HAOsWIevK7Z_DYKtLddCmRiRY,260 +bitblas/3rdparty/tvm/python/tvm/arith/__pycache__/analyzer.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/arith/__pycache__/analyzer.cpython-310.pyc,sha256=7av0N2UZgYo2HO5fpwGe0UfVMWrMvnxTMcZs4PKoWS0,10507 +bitblas/3rdparty/tvm/python/tvm/arith/__pycache__/analyzer.cpython-38.pyc,sha256=_MU8-l70BmdLtQ1a9pQ2k2ZMOVo_U6uL-B2IPVcQk48,10594 +bitblas/3rdparty/tvm/python/tvm/arith/__pycache__/bound.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/arith/__pycache__/bound.cpython-310.pyc,sha256=ohM1Api_oDHoyrc-MJMZ5-QwW41hSgQxnVpukcJF6Oo,781 +bitblas/3rdparty/tvm/python/tvm/arith/__pycache__/bound.cpython-38.pyc,sha256=CxeGK4IOaKgtJqjb3ouBrcyfYwTXco9LCkPp-Ncnh08,768 +bitblas/3rdparty/tvm/python/tvm/arith/__pycache__/int_set.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/arith/__pycache__/int_set.cpython-310.pyc,sha256=oh6WlQs2qVXjDfQG8dd3AJK9yqRspw9NiKYZkXOKkwc,5647 +bitblas/3rdparty/tvm/python/tvm/arith/__pycache__/int_set.cpython-38.pyc,sha256=6H6Q3ExngClob-RFHUPHnZM5Dou3tcG2RZCw0jVncRc,5736 +bitblas/3rdparty/tvm/python/tvm/arith/__pycache__/int_solver.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/arith/__pycache__/int_solver.cpython-310.pyc,sha256=VbCPKZy9vOwwmWsCxgLVTuBugd6qMzrauZZgjs0moSw,6537 +bitblas/3rdparty/tvm/python/tvm/arith/__pycache__/int_solver.cpython-38.pyc,sha256=G5KzUdwfzwvNfUddYsdl5yoNf4hCmfPTq_icEE-ir6w,6600 +bitblas/3rdparty/tvm/python/tvm/arith/__pycache__/iter_affine_map.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/arith/__pycache__/iter_affine_map.cpython-310.pyc,sha256=0hyXHBxgM2MOyJ8mTFSX-ZSypWfOk-xrvKKx1ok2waA,9112 +bitblas/3rdparty/tvm/python/tvm/arith/__pycache__/iter_affine_map.cpython-38.pyc,sha256=wrlvpubeJgFJ-zrvYdLcPp2Af-avXuBrQRxZfGAFACU,9269 +bitblas/3rdparty/tvm/python/tvm/arith/__pycache__/pattern.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/arith/__pycache__/pattern.cpython-310.pyc,sha256=KJW9ER9EglXVzBUDC0MbFZ8q_Mgz3vTCiqdtUrqnrgw,2046 +bitblas/3rdparty/tvm/python/tvm/arith/__pycache__/pattern.cpython-38.pyc,sha256=dMmkdlLqDnv7YrL55LU-kj3d6N1aQZp-NTApSAdHKWw,2055 +bitblas/3rdparty/tvm/python/tvm/arith/_ffi_api.py,sha256=neiI3wByt346Gohd53xT8CFznIr3K3nhPb7rhY76zpY,870 +bitblas/3rdparty/tvm/python/tvm/arith/analyzer.py,sha256=IqA_dy0zNoztPNuvY-9Z9vWKRAGbJboScAGmXWT-5Xo,9538 +bitblas/3rdparty/tvm/python/tvm/arith/bound.py,sha256=8zc_j76kyAcxGo4eHjsHUEZioJczvS9ITvaQ5RFi4kU,1350 +bitblas/3rdparty/tvm/python/tvm/arith/int_set.py,sha256=n9BM0MIOuYEg_XonLYnvX9fmHSjAz1rnVb9aYgVgKG4,5409 +bitblas/3rdparty/tvm/python/tvm/arith/int_solver.py,sha256=WxdD_EfcKjD4rUlopvgZ1WF8RRH_GRtkI1wUb_G2lbs,6743 +bitblas/3rdparty/tvm/python/tvm/arith/iter_affine_map.py,sha256=rO6No2cGB9178hrNLtE8rQaeIRfC5KJ6UhBsnU6-Aso,9684 +bitblas/3rdparty/tvm/python/tvm/arith/pattern.py,sha256=p8dQd-pijFyzy2ANlpG7ZIxeYqtxx_uOcO288PzFmfo,2504 +bitblas/3rdparty/tvm/python/tvm/auto_scheduler/__init__.py,sha256=noRGtqGQiEVhFTvlXphYfR4w_6N8kO8h1zIVzynlg_s,2169 +bitblas/3rdparty/tvm/python/tvm/auto_scheduler/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/auto_scheduler/__pycache__/__init__.cpython-310.pyc,sha256=4f-gD3wSBnOpVfrr1b_h_S3yaAAjTqjkrDR4hWeT4zs,1619 +bitblas/3rdparty/tvm/python/tvm/auto_scheduler/__pycache__/__init__.cpython-38.pyc,sha256=webINBJP6uQlA0S62dcDnaErciUMB3YiBM8nbkNH3gE,1606 +bitblas/3rdparty/tvm/python/tvm/auto_scheduler/__pycache__/_ffi_api.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/auto_scheduler/__pycache__/_ffi_api.cpython-310.pyc,sha256=lczbQ0GQUbA5s92PNSttUb9kQtMs3d4bl54EEiXpa5Y,335 +bitblas/3rdparty/tvm/python/tvm/auto_scheduler/__pycache__/_ffi_api.cpython-38.pyc,sha256=HtrzBvRpeA5hBaPWCqndZcI6PXPMTYSarlPEWgxv2jE,322 +bitblas/3rdparty/tvm/python/tvm/auto_scheduler/__pycache__/compute_dag.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/auto_scheduler/__pycache__/compute_dag.cpython-310.pyc,sha256=JjUmlkdD4ehcSSSRQWClCGe1U1UYZY2Fkclr82GKwyc,9318 +bitblas/3rdparty/tvm/python/tvm/auto_scheduler/__pycache__/compute_dag.cpython-38.pyc,sha256=eAFqYp3LeEWtNAylsBfAeHvBqRWRlq6w4j-uByM33Dw,9339 +bitblas/3rdparty/tvm/python/tvm/auto_scheduler/__pycache__/dispatcher.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/auto_scheduler/__pycache__/dispatcher.cpython-310.pyc,sha256=2hgm34AJl1Jn4oTCC0skj8qcMvD9yVuIevj2-F4HrLg,13143 +bitblas/3rdparty/tvm/python/tvm/auto_scheduler/__pycache__/dispatcher.cpython-38.pyc,sha256=ZTJyfrFLB0aVxwXI1kFEIOSYugDfb3ER-zbO-vwyV2s,13146 +bitblas/3rdparty/tvm/python/tvm/auto_scheduler/__pycache__/feature.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/auto_scheduler/__pycache__/feature.cpython-310.pyc,sha256=oQK0ee860UMLmPSXD7W8BbKeGD6ODA0fSEcKLw4beI4,9227 +bitblas/3rdparty/tvm/python/tvm/auto_scheduler/__pycache__/feature.cpython-38.pyc,sha256=c2Kd5VvAdrqi_KeINNYJmjHK6iOuWIoFxpYqiFRa15I,9230 +bitblas/3rdparty/tvm/python/tvm/auto_scheduler/__pycache__/loop_state.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/auto_scheduler/__pycache__/loop_state.cpython-310.pyc,sha256=J4ANl6n_p8Zu5Y25-fnHrKEVuxAISzBV-qwI7EpE4UA,23112 +bitblas/3rdparty/tvm/python/tvm/auto_scheduler/__pycache__/loop_state.cpython-38.pyc,sha256=xsEKW690b1tEivmQYdkgaJXDIv6qh44Q5SnqrftSMNc,23295 +bitblas/3rdparty/tvm/python/tvm/auto_scheduler/__pycache__/measure.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/auto_scheduler/__pycache__/measure.cpython-310.pyc,sha256=hzgDUILg-FqPHkGD94KKUET9GiNLIxZsfAsp1Vd9pes,37268 +bitblas/3rdparty/tvm/python/tvm/auto_scheduler/__pycache__/measure.cpython-38.pyc,sha256=NR_ur4AWjPtb1laYoqQZKdfPI-Jkb0sMkrzc2urVZrY,37310 +bitblas/3rdparty/tvm/python/tvm/auto_scheduler/__pycache__/measure_record.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/auto_scheduler/__pycache__/measure_record.cpython-310.pyc,sha256=v9LHJXBsgiuY9uavTMeYu2VUEelLHY3SfYFvpsVJtWQ,10087 +bitblas/3rdparty/tvm/python/tvm/auto_scheduler/__pycache__/measure_record.cpython-38.pyc,sha256=6OH3Yqr3k3tsAT6IXG-w9d09Cu1Js6Ah6J-vfqU1jh0,10063 +bitblas/3rdparty/tvm/python/tvm/auto_scheduler/__pycache__/relay_integration.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/auto_scheduler/__pycache__/relay_integration.cpython-310.pyc,sha256=1IYRWIYCpD5cUQUtwKSE2cfToZRq2oLyxtpwj11LcKU,13547 +bitblas/3rdparty/tvm/python/tvm/auto_scheduler/__pycache__/relay_integration.cpython-38.pyc,sha256=z7Zq29yC7AhboPwqo4BGTrJ8N9jqTMRxjqv-8Phl7Os,13469 +bitblas/3rdparty/tvm/python/tvm/auto_scheduler/__pycache__/search_policy.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/auto_scheduler/__pycache__/search_policy.cpython-310.pyc,sha256=pbd2MZ4f5Dd8ErN76N3BHI82UHPXAGDU1XF113Ai6IE,9311 +bitblas/3rdparty/tvm/python/tvm/auto_scheduler/__pycache__/search_policy.cpython-38.pyc,sha256=SK5nSQH3VOGEbER3AkT-vSad5bQtAEO6snRI8FQtk8c,9288 +bitblas/3rdparty/tvm/python/tvm/auto_scheduler/__pycache__/search_task.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/auto_scheduler/__pycache__/search_task.cpython-310.pyc,sha256=4VHHYLzTgLttO1HJlO0ObKCo_BMKR5eNtORF8SKLEGs,17907 +bitblas/3rdparty/tvm/python/tvm/auto_scheduler/__pycache__/search_task.cpython-38.pyc,sha256=02-4wGRVOEI5UaYVsfGn3nvcYkWobqhtiY65k2w396E,17864 +bitblas/3rdparty/tvm/python/tvm/auto_scheduler/__pycache__/task_scheduler.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/auto_scheduler/__pycache__/task_scheduler.cpython-310.pyc,sha256=rlnaE6v7Qu6a_qEslQNKjAcbV4Ze-fRP9Gc5AuM0g28,18189 +bitblas/3rdparty/tvm/python/tvm/auto_scheduler/__pycache__/task_scheduler.cpython-38.pyc,sha256=hNdLsPqZv7EhqrpqIqvyPwB0sp0HwDHZKB6MJRp3Uek,18194 +bitblas/3rdparty/tvm/python/tvm/auto_scheduler/__pycache__/utils.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/auto_scheduler/__pycache__/utils.cpython-310.pyc,sha256=9EhjuM7bx_o-r_5mQExviPNBIf4sOx4biAYRkvbrz_I,11737 +bitblas/3rdparty/tvm/python/tvm/auto_scheduler/__pycache__/utils.cpython-38.pyc,sha256=MDnPAHsRotH315SiSoLORibguht5qrPlxLsOwDzXYvo,11706 +bitblas/3rdparty/tvm/python/tvm/auto_scheduler/__pycache__/workload_registry.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/auto_scheduler/__pycache__/workload_registry.cpython-310.pyc,sha256=H9kJ_h6_AByDNhyunus9XCzJVqJ3yB1mwBl5X1dvCuw,6756 +bitblas/3rdparty/tvm/python/tvm/auto_scheduler/__pycache__/workload_registry.cpython-38.pyc,sha256=87xgg0zjjeoYgkoFjiGRXqiCk0OMSHaVYLdjwePx_LI,6753 +bitblas/3rdparty/tvm/python/tvm/auto_scheduler/_ffi_api.py,sha256=TG4u1uBHtGeASlcoJQoaNVOoV2m7hf1CoPcCtt1Z6JI,924 +bitblas/3rdparty/tvm/python/tvm/auto_scheduler/compute_dag.py,sha256=qbLztishClboeAWQX_LMlhDg_O-X7asiJPSTrZUkum0,10770 +bitblas/3rdparty/tvm/python/tvm/auto_scheduler/cost_model/__init__.py,sha256=ApvKFLtj6Fi4i-NW4y0sNzLLf_39y4SyBZ0E4FEnZ7s,967 +bitblas/3rdparty/tvm/python/tvm/auto_scheduler/cost_model/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/auto_scheduler/cost_model/__pycache__/__init__.cpython-310.pyc,sha256=WYO3CiSW19uPjV5AITHOXAKvYP4oowSmYuW45-W_5Ss,339 +bitblas/3rdparty/tvm/python/tvm/auto_scheduler/cost_model/__pycache__/__init__.cpython-38.pyc,sha256=xPxdkIxxXAD51Twt6vX4kPNOTLJ504a5O520vvTVlz8,326 +bitblas/3rdparty/tvm/python/tvm/auto_scheduler/cost_model/__pycache__/cost_model.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/auto_scheduler/cost_model/__pycache__/cost_model.cpython-310.pyc,sha256=7534GQPZDxuK4hBKZzsuc4EIMik2KpLRrElyEfGTg-I,5804 +bitblas/3rdparty/tvm/python/tvm/auto_scheduler/cost_model/__pycache__/cost_model.cpython-38.pyc,sha256=BRb5MqCSapNgJ8o_jILJDBhghoRu1gD9-GJ9DhG0nD4,5815 +bitblas/3rdparty/tvm/python/tvm/auto_scheduler/cost_model/__pycache__/xgb_model.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/auto_scheduler/cost_model/__pycache__/xgb_model.cpython-310.pyc,sha256=f2z3ZpqO03wMKokPg-2QFqDAhyCyDQvUcvvobWyBFo0,19090 +bitblas/3rdparty/tvm/python/tvm/auto_scheduler/cost_model/__pycache__/xgb_model.cpython-38.pyc,sha256=aGOl1fUTompnPEWBWZwNjw5dhBzQhrrXaYEr35MwqX8,19045 +bitblas/3rdparty/tvm/python/tvm/auto_scheduler/cost_model/cost_model.py,sha256=lSeQeUhIYXLzmAgfZT1xnT4p6kC7yLV7xRJRjStbz6I,6065 +bitblas/3rdparty/tvm/python/tvm/auto_scheduler/cost_model/xgb_model.py,sha256=grCm0L0zWRnL4fnv5HOvfOq_ELTe5_oRAQqiV_c2Weo,23300 +bitblas/3rdparty/tvm/python/tvm/auto_scheduler/dispatcher.py,sha256=TnTaTmnDzxcNCrzK4UMCmQcCEG1Qpl2yxXqBTVel5No,16965 +bitblas/3rdparty/tvm/python/tvm/auto_scheduler/feature.py,sha256=9H24P9pxUr8GsBaAI61Xu0UBTQRxLLA2PQL7Q6thGsU,10794 +bitblas/3rdparty/tvm/python/tvm/auto_scheduler/loop_state.py,sha256=gxuGN33TfYDRyvnvWzCEPLhI0YNmHwU9Hflu9fCHwug,24583 +bitblas/3rdparty/tvm/python/tvm/auto_scheduler/measure.py,sha256=1vOHB01GXi71klwjrtn1RfC7YlBJHyDUHYaKUrACbQk,45887 +bitblas/3rdparty/tvm/python/tvm/auto_scheduler/measure_record.py,sha256=QS-awHLw1WxhE9A-EnyV-h-3wusJzPY3GSUA9CctzE4,11650 +bitblas/3rdparty/tvm/python/tvm/auto_scheduler/relay_integration.py,sha256=u7NJKXNRENb7-S7LYreCeMOTONyOYN-omyjoyNBC8Qs,17027 +bitblas/3rdparty/tvm/python/tvm/auto_scheduler/search_policy.py,sha256=yE1LQnBuVsgwdEJQWCeEylzUH9_48sREoqhWMxO6j-4,9631 +bitblas/3rdparty/tvm/python/tvm/auto_scheduler/search_task.py,sha256=5uaCZRr1c34NShEIL8PG4sO3wDEAgK16SbWR4jPUWTg,23857 +bitblas/3rdparty/tvm/python/tvm/auto_scheduler/task_scheduler.py,sha256=qJ8KR6guqBisiPSpyzIzCbQa9Pvs1weUc5f67do5ojw,25574 +bitblas/3rdparty/tvm/python/tvm/auto_scheduler/testing/__init__.py,sha256=08w8BaM8IsAKhgpNqR2NSeYSGKSXqX1TwqSXWbAdlVY,929 +bitblas/3rdparty/tvm/python/tvm/auto_scheduler/testing/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/auto_scheduler/testing/__pycache__/tune_onnx.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/auto_scheduler/testing/__pycache__/tune_relay.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/auto_scheduler/testing/__pycache__/tune_te.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/auto_scheduler/testing/tune_onnx.py,sha256=upmvdewvw12GG1NUIIPQl038ncoNCRtlJS81-4QZkcY,7050 +bitblas/3rdparty/tvm/python/tvm/auto_scheduler/testing/tune_relay.py,sha256=RdPzTHF4JWGYlpwIiDWwmbcHUXGdvCmwtpZODTcZSzY,7469 +bitblas/3rdparty/tvm/python/tvm/auto_scheduler/testing/tune_te.py,sha256=F_E4kRpWVFWZV9HtInupRdkPmGEBzgiuk3JlUmDy0x0,5383 +bitblas/3rdparty/tvm/python/tvm/auto_scheduler/utils.py,sha256=gH5a9VKl73ZazRa0LM2Y0rLgAIjb1M74V6LaNiNadP4,11629 +bitblas/3rdparty/tvm/python/tvm/auto_scheduler/workload_registry.py,sha256=IkTAFVRbtJvmTPxKFdueZ_QsaLiXXWbX_etlXlDY4P4,8826 +bitblas/3rdparty/tvm/python/tvm/autotvm/__init__.py,sha256=M3bcKEi8MSiUF7dUObH4DobKOdGXRRTLDCWVutwPlwI,1724 +bitblas/3rdparty/tvm/python/tvm/autotvm/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/autotvm/__pycache__/__init__.cpython-310.pyc,sha256=_cgzpzbeeLSz3G3nGymBAJvCSjpYv-8SpP0tz3BEuKw,1239 +bitblas/3rdparty/tvm/python/tvm/autotvm/__pycache__/__init__.cpython-38.pyc,sha256=JkwQn0YZtnMN4_5c6wpBTmbym_V0db4jOaMsfX096Io,1226 +bitblas/3rdparty/tvm/python/tvm/autotvm/__pycache__/database.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/autotvm/__pycache__/database.cpython-310.pyc,sha256=rT5Yy3HBq2mtaEb2OiuktYz1aLWO_mxJW-fRbnaxan8,6496 +bitblas/3rdparty/tvm/python/tvm/autotvm/__pycache__/database.cpython-38.pyc,sha256=PdT3XL6g4DCVcg9wVoBX-h9lvGphh7nTRtD1BZ6X-6A,6549 +bitblas/3rdparty/tvm/python/tvm/autotvm/__pycache__/env.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/autotvm/__pycache__/env.cpython-310.pyc,sha256=vdrjVxJTNnTKfOraZ_PLRNAvpaFIzkoOLxyoi_3fmcw,1116 +bitblas/3rdparty/tvm/python/tvm/autotvm/__pycache__/env.cpython-38.pyc,sha256=DwrorM6AbWTp2iVrUs8qcLSmO7gW3Xx8AuULUK02TIM,1101 +bitblas/3rdparty/tvm/python/tvm/autotvm/__pycache__/feature.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/autotvm/__pycache__/feature.cpython-310.pyc,sha256=UBXj91PSpDSEhZ2vPt6WNgF58IMyt_giHnl7B1pDB-Y,5696 +bitblas/3rdparty/tvm/python/tvm/autotvm/__pycache__/feature.cpython-38.pyc,sha256=b_D3JvrEiUw7DVgoAAyBc81wqy7GcNClkOaf2ugHC7k,5662 +bitblas/3rdparty/tvm/python/tvm/autotvm/__pycache__/record.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/autotvm/__pycache__/record.cpython-310.pyc,sha256=TaKxOktSU8R28r9d8NqMjGDAy4te6kiLco4gjJ7j468,9396 +bitblas/3rdparty/tvm/python/tvm/autotvm/__pycache__/record.cpython-38.pyc,sha256=rTe0b-Yf5GwGnERLbWm3vh028CaS_6qic4cq6jw4_Q8,9217 +bitblas/3rdparty/tvm/python/tvm/autotvm/__pycache__/tophub.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/autotvm/__pycache__/tophub.cpython-310.pyc,sha256=K18mw7HdvigTMIOVVJ8vsiELSk0YJiYegAqNvE4EiW8,5487 +bitblas/3rdparty/tvm/python/tvm/autotvm/__pycache__/tophub.cpython-38.pyc,sha256=rMwCyrEw3tMccIQ-BgdWlAnZerLIq332egwCLmruE_E,5486 +bitblas/3rdparty/tvm/python/tvm/autotvm/__pycache__/utils.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/autotvm/__pycache__/utils.cpython-310.pyc,sha256=Qqvw-T3zBzSrtPsfpYaRZvPEMIMPCOHKaEDDxmuhd_A,3923 +bitblas/3rdparty/tvm/python/tvm/autotvm/__pycache__/utils.cpython-38.pyc,sha256=Bw98q6YEXbuVek3IPtdlI4IxiOe5k_DgRGsvNQ3S1lQ,3912 +bitblas/3rdparty/tvm/python/tvm/autotvm/database.py,sha256=7T0pBM1_q0CdCsVN19Ja_fiu86BgQrqlvuB3fE9JL2M,6389 +bitblas/3rdparty/tvm/python/tvm/autotvm/env.py,sha256=gNRjhZwxKagZj5Ur7HlyZlUvnSJ_mb7o5nNFkhmp3yI,1674 +bitblas/3rdparty/tvm/python/tvm/autotvm/feature.py,sha256=Dn-wEehrK46vUovU1OxLLnPvUuqZzVUPi5uS8Nz5xCw,6390 +bitblas/3rdparty/tvm/python/tvm/autotvm/graph_tuner/__init__.py,sha256=BKQUueSahzgoiWPApaXGsTxM2JdRVgrS31HDLyv96eU,1042 +bitblas/3rdparty/tvm/python/tvm/autotvm/graph_tuner/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/autotvm/graph_tuner/__pycache__/_base.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/autotvm/graph_tuner/__pycache__/base_graph_tuner.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/autotvm/graph_tuner/__pycache__/dynamic_programming_stage.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/autotvm/graph_tuner/__pycache__/dynamic_programming_tuner.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/autotvm/graph_tuner/__pycache__/pbqp_tuner.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/autotvm/graph_tuner/_base.py,sha256=Ktpgpl0veb4Lq1Iy-vZUPmjhUjfFUKbjijJrb43GRoc,1074 +bitblas/3rdparty/tvm/python/tvm/autotvm/graph_tuner/base_graph_tuner.py,sha256=GBOoHoLsaf4gixoCuF6TfHa0yfRCoTjVbuWKpiR7iWs,25140 +bitblas/3rdparty/tvm/python/tvm/autotvm/graph_tuner/dynamic_programming_stage.py,sha256=f5AwDQ1Dz855fEbfwG7UiE159Epih1K2Pcko_kWtbQk,16019 +bitblas/3rdparty/tvm/python/tvm/autotvm/graph_tuner/dynamic_programming_tuner.py,sha256=TZrewH_L9KvmjT-T-IlC19G_qcmZc-Hr6BeJ-355kqM,9642 +bitblas/3rdparty/tvm/python/tvm/autotvm/graph_tuner/pbqp_tuner.py,sha256=XJZLyVchYGUGFjq-zftVl4uXRuESCgLKfC6TBngWapI,12926 +bitblas/3rdparty/tvm/python/tvm/autotvm/graph_tuner/utils/__init__.py,sha256=zUFTLgwauRSbt0WHFCVrIvn-tSGxSajaroS4I1cjTkw,1104 +bitblas/3rdparty/tvm/python/tvm/autotvm/graph_tuner/utils/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/autotvm/graph_tuner/utils/__pycache__/traverse_graph.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/autotvm/graph_tuner/utils/__pycache__/utils.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/autotvm/graph_tuner/utils/traverse_graph.py,sha256=A6pN1Kad_GpHkyias4qrTqOV_l6HrnBViAbxFuKp_Ww,12994 +bitblas/3rdparty/tvm/python/tvm/autotvm/graph_tuner/utils/utils.py,sha256=25mhBNIIQAcwGUPx_tGzkVg-SvSan5qhfByIu6kDsaE,4682 +bitblas/3rdparty/tvm/python/tvm/autotvm/measure/__init__.py,sha256=qo-4F9gFYjutAscpbWSN65OUzwE_rXqqaaheNTnMMoA,1140 +bitblas/3rdparty/tvm/python/tvm/autotvm/measure/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/autotvm/measure/__pycache__/__init__.cpython-310.pyc,sha256=3r1Ela51pfJFj4osI0xIGvbHrW_5yuK_cFi-IVU0UgQ,585 +bitblas/3rdparty/tvm/python/tvm/autotvm/measure/__pycache__/__init__.cpython-38.pyc,sha256=x4_DH2Akax3jSFHX871IdfTo1Q_vnczT15kophNatas,572 +bitblas/3rdparty/tvm/python/tvm/autotvm/measure/__pycache__/executor.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/autotvm/measure/__pycache__/executor.cpython-310.pyc,sha256=pQhm3Qshx6aIXRiTC6vsCK3LVjHgk_eLWNOJ0M8K7LA,3078 +bitblas/3rdparty/tvm/python/tvm/autotvm/measure/__pycache__/executor.cpython-38.pyc,sha256=frhEJKg708SrX3Zb-gtAgJ9nAhC5ZRqYZ9y8r7kcfAE,3124 +bitblas/3rdparty/tvm/python/tvm/autotvm/measure/__pycache__/measure.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/autotvm/measure/__pycache__/measure.cpython-310.pyc,sha256=NMXkqVmWdC5BuYFLPxkea18ribRGDJvJGj4q-S5B2f0,9154 +bitblas/3rdparty/tvm/python/tvm/autotvm/measure/__pycache__/measure.cpython-38.pyc,sha256=vhe9vK6z0q55TucWAvy2rbMwkyGjvzfvY-EBCcxiI4w,9142 +bitblas/3rdparty/tvm/python/tvm/autotvm/measure/__pycache__/measure_methods.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/autotvm/measure/__pycache__/measure_methods.cpython-310.pyc,sha256=N3Vsh1w0SeDNgbmw02t_qsz78vfqdrWJ9s_Ab8Xdu-E,25565 +bitblas/3rdparty/tvm/python/tvm/autotvm/measure/__pycache__/measure_methods.cpython-38.pyc,sha256=zlh_c-7_HNQR54l-t8gD0YiCC6aJSqfwPjTWlH4pugk,25420 +bitblas/3rdparty/tvm/python/tvm/autotvm/measure/executor.py,sha256=TKzv0rWiiF9d2b_E8g1oEW_OhFAszuqFhqxn2tNG-Og,3113 +bitblas/3rdparty/tvm/python/tvm/autotvm/measure/measure.py,sha256=-V5eQWypDjxZ5gRA-zZE9WDGhUuq-zBZ4THdwryk5iE,9650 +bitblas/3rdparty/tvm/python/tvm/autotvm/measure/measure_methods.py,sha256=_DoKESbxPQWlzATNYA77wRQnlXjOdNNv_VtFPB26cZw,32012 +bitblas/3rdparty/tvm/python/tvm/autotvm/record.py,sha256=-SeKjEk_ICJ9UrC7ps2Wx4TsojD7n2RIFje2SJCeJ5c,12207 +bitblas/3rdparty/tvm/python/tvm/autotvm/task/__init__.py,sha256=vf2B3yweomMIH0FimxZueugLOEK_Ai8phyrv9hBIYEA,1701 +bitblas/3rdparty/tvm/python/tvm/autotvm/task/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/autotvm/task/__pycache__/__init__.cpython-310.pyc,sha256=-UF8T51m6AwcIZU46jYzONXT0fY_0kK8usmxIWwI_oU,1228 +bitblas/3rdparty/tvm/python/tvm/autotvm/task/__pycache__/__init__.cpython-38.pyc,sha256=zO62qq0SEirJAFX6pk4u690HHsno4-JHSrC_I5geilI,1215 +bitblas/3rdparty/tvm/python/tvm/autotvm/task/__pycache__/code_hash.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/autotvm/task/__pycache__/code_hash.cpython-310.pyc,sha256=k0J5agFkgKZxxrja8J5PX55z9dJ51z28ci2SyUrZAPU,1977 +bitblas/3rdparty/tvm/python/tvm/autotvm/task/__pycache__/code_hash.cpython-38.pyc,sha256=r-nKvd1AF1vsuRODHefoxc8kkOPnbT21IoiG-pqiMpI,1988 +bitblas/3rdparty/tvm/python/tvm/autotvm/task/__pycache__/dispatcher.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/autotvm/task/__pycache__/dispatcher.cpython-310.pyc,sha256=ZxsVAfZrenfMCSb0ir4I0k28cK-76GYD4Qwne1EQhB8,14969 +bitblas/3rdparty/tvm/python/tvm/autotvm/task/__pycache__/dispatcher.cpython-38.pyc,sha256=-5kZSrJyzaouvecz4vmQ19-2m5p4sRiUUBTOOd6taC8,14990 +bitblas/3rdparty/tvm/python/tvm/autotvm/task/__pycache__/relay_integration.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/autotvm/task/__pycache__/relay_integration.cpython-310.pyc,sha256=ieSBFRLgvGnrfbLo8KvjGlYwMIqVGfRXwEFzJU-ZO78,4139 +bitblas/3rdparty/tvm/python/tvm/autotvm/task/__pycache__/relay_integration.cpython-38.pyc,sha256=kV-Bk75XyeoMRXzN3jhAZzBKLPFwEKGlcseKSkGN_SM,4089 +bitblas/3rdparty/tvm/python/tvm/autotvm/task/__pycache__/space.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/autotvm/task/__pycache__/space.cpython-310.pyc,sha256=EPkHonY3wHNsG3xITnfHervgrMmf_yaepJ083UlAl3E,46831 +bitblas/3rdparty/tvm/python/tvm/autotvm/task/__pycache__/space.cpython-38.pyc,sha256=LVyZK2BJlyyLGBNqi07tK169hiNo3jCs-FEn-7MsMjI,47451 +bitblas/3rdparty/tvm/python/tvm/autotvm/task/__pycache__/task.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/autotvm/task/__pycache__/task.cpython-310.pyc,sha256=AsqyRfcodN0jdQatRdM58hJNNOhjchr1MemP69l3Udg,16504 +bitblas/3rdparty/tvm/python/tvm/autotvm/task/__pycache__/task.cpython-38.pyc,sha256=g1Z8Zgdz5QEQ99ptNp-cWSWLPrJh82f4oAdipdftOiI,16742 +bitblas/3rdparty/tvm/python/tvm/autotvm/task/__pycache__/topi_integration.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/autotvm/task/__pycache__/topi_integration.cpython-310.pyc,sha256=AmqgD0KOT6cQH7CF0UAWihFMBTwY765EdoY8DKHIvf4,7693 +bitblas/3rdparty/tvm/python/tvm/autotvm/task/__pycache__/topi_integration.cpython-38.pyc,sha256=naSvbm9aAguNcQEqev_C_otgDuSApSWhLWZqGOOPblQ,7747 +bitblas/3rdparty/tvm/python/tvm/autotvm/task/code_hash.py,sha256=oUXDc1TfhxKkJQzjkEA-DWyL-HzkgOZ4ocRpHZNvKDA,2137 +bitblas/3rdparty/tvm/python/tvm/autotvm/task/dispatcher.py,sha256=TDVg-qisY_fJoZw2_kzcUvF0Eu_0AwXQQZNtlkFmufU,17019 +bitblas/3rdparty/tvm/python/tvm/autotvm/task/relay_integration.py,sha256=O4yHOUxpBZfn2ZL4yKenEg4_7IlIRN0eI9wBBaWX93c,5724 +bitblas/3rdparty/tvm/python/tvm/autotvm/task/space.py,sha256=xxSr9ep62HQwm1XjCvXUHPYtppnUGohLZhORCxPIJCY,48934 +bitblas/3rdparty/tvm/python/tvm/autotvm/task/task.py,sha256=wiz5UXha2WGYpyObxAHr8wtrKC6tfJ8B1oKKWQ0PoDI,18201 +bitblas/3rdparty/tvm/python/tvm/autotvm/task/topi_integration.py,sha256=JuZwF_urRTSicKNajIqVA4S-_718O0T_lAi8x5Hg-vM,8590 +bitblas/3rdparty/tvm/python/tvm/autotvm/testing/__init__.py,sha256=2FJUsKyYMFrb6TjhHQNvhhhThfcBuDwCG_SzvdjPDig,821 +bitblas/3rdparty/tvm/python/tvm/autotvm/testing/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/autotvm/testing/__pycache__/tune_relay.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/autotvm/testing/tune_relay.py,sha256=D1xrsySpGvxn-HwU5xtFCGDkVVpsEvS0bPSZz7Xe3iA,8433 +bitblas/3rdparty/tvm/python/tvm/autotvm/tophub.py,sha256=xERDA-cMGxvGtTgLZSdxj0GXngieizjcyHHhNJSPJCw,8399 +bitblas/3rdparty/tvm/python/tvm/autotvm/tuner/__init__.py,sha256=E8TErXBmgmJbJw1ZGUhPc0dlqOyx8EMToloxfXZ15MI,1270 +bitblas/3rdparty/tvm/python/tvm/autotvm/tuner/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/autotvm/tuner/__pycache__/__init__.cpython-310.pyc,sha256=N7gLLlbq3TYlEsGVDhMtNUtbZroxQbbbGntZenuRI8Q,733 +bitblas/3rdparty/tvm/python/tvm/autotvm/tuner/__pycache__/__init__.cpython-38.pyc,sha256=JzctZhXEMV5AtMQvCTZpUGukdGzdd_9cmhiJfIUWis0,720 +bitblas/3rdparty/tvm/python/tvm/autotvm/tuner/__pycache__/callback.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/autotvm/tuner/__pycache__/callback.cpython-310.pyc,sha256=o3n-fbikNomb4nzNzP0L2y51mFYe2BVAoH8U-hdj1Fo,4811 +bitblas/3rdparty/tvm/python/tvm/autotvm/tuner/__pycache__/callback.cpython-38.pyc,sha256=03p1Sxq_W45c_gAgkDxyQnVxfyyJ4j-qXakkPnYaMyY,4780 +bitblas/3rdparty/tvm/python/tvm/autotvm/tuner/__pycache__/droplet_tuner.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/autotvm/tuner/__pycache__/droplet_tuner.cpython-310.pyc,sha256=rhH8qqgNDXg1r1dxwnUvrnEnVKdd-CeUJcHcRykhCgk,4723 +bitblas/3rdparty/tvm/python/tvm/autotvm/tuner/__pycache__/droplet_tuner.cpython-38.pyc,sha256=rbvhCqqOdB2TaiD5e-HXDYgRS7S79bfMAaLnYxpdXR0,4663 +bitblas/3rdparty/tvm/python/tvm/autotvm/tuner/__pycache__/ga_tuner.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/autotvm/tuner/__pycache__/ga_tuner.cpython-310.pyc,sha256=a1gNIEYfTbBxoQynENG827mf3V-NjCFNEGUn0WLVy0I,3510 +bitblas/3rdparty/tvm/python/tvm/autotvm/tuner/__pycache__/ga_tuner.cpython-38.pyc,sha256=2lvBPnbsWCf0qWY6ubzn4IezyoAtFuxpYubiKSiUOlI,3469 +bitblas/3rdparty/tvm/python/tvm/autotvm/tuner/__pycache__/index_based_tuner.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/autotvm/tuner/__pycache__/index_based_tuner.cpython-310.pyc,sha256=HcGZsGbiReKCjGsSA3jIpAl-2NJO5O-zCzLzY7bujVQ,3261 +bitblas/3rdparty/tvm/python/tvm/autotvm/tuner/__pycache__/index_based_tuner.cpython-38.pyc,sha256=zLHkiI05pdZx3Vvv076HSFCpRK1DOW_ACoGWUGwhlmM,3220 +bitblas/3rdparty/tvm/python/tvm/autotvm/tuner/__pycache__/metric.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/autotvm/tuner/__pycache__/metric.cpython-310.pyc,sha256=gQ9FNPholiYun3VXdJ-Z9JSd3175IW--cafnft5bhTQ,2706 +bitblas/3rdparty/tvm/python/tvm/autotvm/tuner/__pycache__/metric.cpython-38.pyc,sha256=A4e8lSTrVY5E0R1sObojwXI8Yf4_qn8QEbsE0ySV-lA,2677 +bitblas/3rdparty/tvm/python/tvm/autotvm/tuner/__pycache__/model_based_tuner.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/autotvm/tuner/__pycache__/model_based_tuner.cpython-310.pyc,sha256=Yq0v5_Mo5nG9sjwz2WHSRbWyUYXbq2n5KTmGdcgVbuY,10227 +bitblas/3rdparty/tvm/python/tvm/autotvm/tuner/__pycache__/model_based_tuner.cpython-38.pyc,sha256=svb_WFDx0Mjf2B73BTrA93_NbJDzVFLWPo5BbvUKrBI,10266 +bitblas/3rdparty/tvm/python/tvm/autotvm/tuner/__pycache__/sa_model_optimizer.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/autotvm/tuner/__pycache__/sa_model_optimizer.cpython-310.pyc,sha256=6sbvTQrVKZpzo1V5_L3nyLuIw6As60FyHWtjIX_KBS0,4056 +bitblas/3rdparty/tvm/python/tvm/autotvm/tuner/__pycache__/sa_model_optimizer.cpython-38.pyc,sha256=OmJX1TSH9-KtP6cY3dtzAXVMUChW57QW4zkOapeUn-Q,4053 +bitblas/3rdparty/tvm/python/tvm/autotvm/tuner/__pycache__/tuner.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/autotvm/tuner/__pycache__/tuner.cpython-310.pyc,sha256=gJi1DWiS3hV6OuzNNG1eMVgvdNP36P478Jq732ruiMc,6120 +bitblas/3rdparty/tvm/python/tvm/autotvm/tuner/__pycache__/tuner.cpython-38.pyc,sha256=lEBJ82s6h4QOut3W5dKA4lHVd5I2-Ty5sSHlPZflOcM,6114 +bitblas/3rdparty/tvm/python/tvm/autotvm/tuner/__pycache__/xgboost_cost_model.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/autotvm/tuner/__pycache__/xgboost_cost_model.cpython-310.pyc,sha256=94FPMto3G30Ix374LQ7lwKSBPgGm5p_B4A6Odse6-5w,18449 +bitblas/3rdparty/tvm/python/tvm/autotvm/tuner/__pycache__/xgboost_cost_model.cpython-38.pyc,sha256=w1MgPWqojPDqshPpnqy7KBrnl9uuDOn6B0lApbRvmhQ,18610 +bitblas/3rdparty/tvm/python/tvm/autotvm/tuner/__pycache__/xgboost_tuner.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/autotvm/tuner/__pycache__/xgboost_tuner.cpython-310.pyc,sha256=def6whOlQGqJTOh3bVfveyZCyCGpXDF6hx_A7PVPBVA,3563 +bitblas/3rdparty/tvm/python/tvm/autotvm/tuner/__pycache__/xgboost_tuner.cpython-38.pyc,sha256=R7JuQRz_aO_w6kch54WEj6yt-tOzgm8oO7lxXoDREsY,3554 +bitblas/3rdparty/tvm/python/tvm/autotvm/tuner/callback.py,sha256=saI03_fLI_DEJm6-nQ_u_jCcFWOSLIw3jytJf3KwKNI,5258 +bitblas/3rdparty/tvm/python/tvm/autotvm/tuner/droplet_tuner.py,sha256=NVnc0WKvTs9eue9d1cnwC2AGf_EQSprI9BVIbzXLiiM,5218 +bitblas/3rdparty/tvm/python/tvm/autotvm/tuner/ga_tuner.py,sha256=OvJIWT2SjFvvke5HFuIiCHPIJ0uOl58xha6ewzWRSKM,5041 +bitblas/3rdparty/tvm/python/tvm/autotvm/tuner/index_based_tuner.py,sha256=e8BQWm_9KOySKE8T1pEPW27bE19NfCbSyhlk4Frl3jU,3586 +bitblas/3rdparty/tvm/python/tvm/autotvm/tuner/metric.py,sha256=YBAutc4eCvIWegFf4Mz3Fzd_2OiPykDUYSEOGFj3mWI,3309 +bitblas/3rdparty/tvm/python/tvm/autotvm/tuner/model_based_tuner.py,sha256=qC0IDayCMPaWZN5GTqEUYaf3WHenpIW9XKQHCKk_-TE,11562 +bitblas/3rdparty/tvm/python/tvm/autotvm/tuner/sa_model_optimizer.py,sha256=yENiRXyxyb7Sdcdwy28GT_dEqgRR8KMuXlOGqFGRjNk,5165 +bitblas/3rdparty/tvm/python/tvm/autotvm/tuner/tuner.py,sha256=TKRQdG5ejWorjiJyT5CrYOthXqjHpAtDEUkCqcjU5KU,7786 +bitblas/3rdparty/tvm/python/tvm/autotvm/tuner/xgboost_cost_model.py,sha256=2eCENypvU9fQGFI11MuGCVb8DomctSE_ar_qhLY0ez4,23505 +bitblas/3rdparty/tvm/python/tvm/autotvm/tuner/xgboost_tuner.py,sha256=d7wVA28kMfaAyL-6E2Sy4H9OeGr0aMjymXRmIzqG0Bc,4304 +bitblas/3rdparty/tvm/python/tvm/autotvm/utils.py,sha256=MHEmhcxF8QHoOS9U2ayiiLh4ho28dTfq1HVjzFz8ZQo,4283 +bitblas/3rdparty/tvm/python/tvm/contrib/__init__.py,sha256=x5N-C5mqUti9oZXEF9Ept9BPD_t_etSS9L-jXEg2Rj0,965 +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/__init__.cpython-310.pyc,sha256=4m5kEPyORqB-U8DEMbnHoxw1Cz98md4Oufkwt0_LObM,346 +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/__init__.cpython-38.pyc,sha256=-iaeJqTigVJGe8SECpSg0bkBJAS4qrYev4HDrLjw8FM,333 +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/cblas.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/cblas.cpython-310.pyc,sha256=vV4bQ2gZs1Ope77T9GHXB4--SO8l1EGQ-erUIyCDz8o,2254 +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/cblas.cpython-38.pyc,sha256=Faz0g7JgaaiBHFAbUiO2kA0m4-L-yBwzCgHUaP5ZSV0,2247 +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/cc.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/cc.cpython-310.pyc,sha256=uyqjiXecnLIqFYUeMuckd5bg-D2yUBdxMSzpi3lMZd8,9760 +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/cc.cpython-38.pyc,sha256=jBaDFWNPKyP5DniDN5KShTMhyi_BcQuUJD9mMvHtz4Y,9780 +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/clang.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/coreml_runtime.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/coreml_runtime.cpython-310.pyc,sha256=sC6o5BeNnSN4oAABaSPFww1H4jzdsvmo-Jw_Az7pO-k,2103 +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/coreml_runtime.cpython-38.pyc,sha256=oErTqoIG5F-UswGGpBV-Sr31npmNmF-IJx0k28-lt3Q,2104 +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/cublas.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/cublas.cpython-310.pyc,sha256=obX3_AGktMcDurvG-0j6SaXP5QAIHvkscNYscCfYKsY,2016 +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/cublas.cpython-38.pyc,sha256=kmevIJSH0w19OLkaIha_OMGAKf_jj8qPLoRueVwlhDk,2064 +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/cublaslt.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/cudnn.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/cudnn.cpython-310.pyc,sha256=4jS_a6UoVrRh7KpYBHOSLEH4O8Xhhm2ps6odjdVVtog,17551 +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/cudnn.cpython-38.pyc,sha256=-v8YE7OeWwjK-emfr9Ojqg1MWRjBExVH68do9Xd8K9w,18090 +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/dlpack.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/dlpack.cpython-310.pyc,sha256=HFPf4wEq0EDGWz1pnRmIRicS-okdHmlE8quhYI8ADR0,1770 +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/dnnl.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/dnnl.cpython-310.pyc,sha256=uqyW6S6OifG40IXFjAyoUUbRXmUGpsN7bAn-aRvcH7Q,3521 +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/dnnl.cpython-38.pyc,sha256=ypdOHrdDA-cjRMNPmcLVAHlKe3NJgSeyARt5-WnHvD0,3530 +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/download.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/download.cpython-310.pyc,sha256=J_CVtIhc5EbQsb7FJvl23oUN3VOr-UPf5vum9FM2rNQ,3940 +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/download.cpython-38.pyc,sha256=tBIp9BG7AyDZVMkKC0NnUaiM0ZJkeyOSQx0CaPBN7L8,3907 +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/emcc.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/emcc.cpython-310.pyc,sha256=dSfWc4n_aJernan26r1pRVugUT2vG3bW0bF8ytYgEsY,2030 +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/graph_executor.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/graph_executor.cpython-310.pyc,sha256=jQDCfe87MarpFdiO3RKw-EvjT00A_olZaeEll-V2BsQ,15669 +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/graph_executor.cpython-38.pyc,sha256=nNI-BjCJvU18kVRG9WGpoH1OZJf_goMl5Z_YSIyrNRA,15688 +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/graph_runtime.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/hipcc.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/hipcc.cpython-310.pyc,sha256=4G9lGrjce264PqyCOtIMmtt73nPpsPuYn1v0fYJ7YM0,2439 +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/hipcc.cpython-38.pyc,sha256=wZZ6X-5wMr3eL3tm13oE5CJFCQOx6iUpmER5Wixoaq8,2396 +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/miopen.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/miopen.cpython-310.pyc,sha256=nPpKLA2H8i_sjuKpfnZRY6CGxK1-p0aK5wXEHC3caGw,3710 +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/miopen.cpython-38.pyc,sha256=MPjhaftBu6b6JOyvOGIBet6Uc37mKtIWHra6dvVk_qU,3781 +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/mkl.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/mkl.cpython-310.pyc,sha256=EhpgYxaz2xXOw4aJw-kaWtlKzI0AFaJOuFT07yvEseI,2521 +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/mkl.cpython-38.pyc,sha256=k3iNRcR-hGM5KabI90oZFBO5_ze_CLphiVrKpjSbKuM,2680 +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/mps.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/mrvl.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/mrvl.cpython-310.pyc,sha256=y468nnuXqVuSXCEwNtf8peVVP7iZFENVDDpOgl512s4,10632 +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/mrvl.cpython-38.pyc,sha256=OtRCTK8__DWqbRp-MGeVE2Hd2z28LX3HNb4o-MoXKL8,10528 +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/mxnet.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/ndk.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/ndk.cpython-310.pyc,sha256=_x2gMkD6FIP2Wc34B7ydj0sqqLnQnxDcbVBVVxWIo1U,3570 +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/ndk.cpython-38.pyc,sha256=lx2N_TJ6SDSJQ7eCMfcRrrgCuEjIu29gyAX4jsyyscg,3559 +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/nnpack.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/nnpack.cpython-310.pyc,sha256=JfeZbNw3npHCtjN2XqwvnEyWKuFZt0fH7zhG6pG59Mc,6860 +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/nnpack.cpython-38.pyc,sha256=Z3auHR7qQQkGhdTftcWoAfnC51FENWlN6nTgv5wo9Io,6995 +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/nvcc.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/nvcc.cpython-310.pyc,sha256=4rJpLFdpNu2rcRaDxPF3ZL6ClbOWX9fIkRbYrRVn6as,10477 +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/nvcc.cpython-38.pyc,sha256=aXnvivPdom6Sf03HXPa3nhmWV4ccIuxbGcby2mUJX-4,10522 +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/peak.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/pickle_memoize.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/pickle_memoize.cpython-310.pyc,sha256=w8261m8jfGJ8jvyX_arfwoHJl3jHQfuFjs77_SbZkNM,3245 +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/pickle_memoize.cpython-38.pyc,sha256=b5tul9jFo7veyPz29lx8EpBv25FyF42cMOXGE-idytQ,3210 +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/pipeline_executor.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/pipeline_executor_build.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/popen_pool.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/popen_pool.cpython-310.pyc,sha256=SAvY7FYpoMw_s37ZVMhNpgGT5pyfCgqbcOpBV7nqUUU,11686 +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/popen_pool.cpython-38.pyc,sha256=YnlknftJJFYRT04hQjCb-fSbkLl7z_OLI0ik90Dendo,11661 +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/random.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/rocblas.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/rocblas.cpython-310.pyc,sha256=NEptC4e4Za_uDT8PEGLtnFDtQAlyq-wtGfDZMrJ0NDs,1960 +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/rocblas.cpython-38.pyc,sha256=BWA681ghebp7N-edaNSn-vKfaqeZ0z8W7qdFH1ztcGo,2035 +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/rocm.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/rocm.cpython-310.pyc,sha256=AWWFfoPavskRfBKr9EmhA-SsZr1U0sikP_mZ38sjNX0,6917 +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/rocm.cpython-38.pyc,sha256=sMk-DfZehEd2LAgS-3iZ70liaA3lIsZBRsrJ9Rh7-A4,6971 +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/rpc.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/sdaccel.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/sdaccel.cpython-310.pyc,sha256=KzXiBI5fmQSGOAYOiBTP02Tmius4RWF9Pqu1wAVIhPs,1977 +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/sdaccel.cpython-38.pyc,sha256=xkmUYZYd0HBl2M3rx-cXf43_JFceAikrPgycnIEKytw,1953 +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/sparse.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/spirv.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/stackvm.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/stackvm.cpython-310.pyc,sha256=xYfGR0cRQejoePqf7KiOGEibPwvHWB3KJwybdPF6ej4,804 +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/stackvm.cpython-38.pyc,sha256=SNqJD7CyimmMnI7hl7gJXkKQaGJsg3AclMEYggPsdE4,791 +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/tar.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/tar.cpython-310.pyc,sha256=FnO4kJQE1Ds-phOoOMqcEFA4kLVAT52boMQ9FfO3Qg4,2787 +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/tar.cpython-38.pyc,sha256=IlvYbnoE8kkgEnmj-GGdgygNZurYCSmWhhKX9xD-hPk,2766 +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/tedd.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/tflite_runtime.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/thrust.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/thrust.cpython-310.pyc,sha256=HCFvfZdmaX8mQ6FrJMIxUfL0IU1_TuH2dt9uvu34HfE,911 +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/thrust.cpython-38.pyc,sha256=-IbksmmX3TL98lSyMX9CP7p1RZPS0i09r1px7iQVkoQ,900 +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/tvmjs.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/tvmjs.cpython-310.pyc,sha256=IXUOehge4d8l7lz15inkOJRDs8efj-fbZO8k7Jn4z0o,9152 +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/utils.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/utils.cpython-310.pyc,sha256=ZG5AcTkxuPRExeSm3JTd68JIA9hbOXtcw3lxURQTDc8,6775 +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/utils.cpython-38.pyc,sha256=J8_XOR6_RlzS1IjMeGIiQNXqGk3YujrhTLkNzhtBBdI,6707 +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/xcode.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/xcode.cpython-310.pyc,sha256=8BVRR57Y995CJhb7TM9oPFU9BXXWMOGwPiwwEK6Rc38,4095 +bitblas/3rdparty/tvm/python/tvm/contrib/__pycache__/xcode.cpython-38.pyc,sha256=yZTxOO9DZQmcaqGP5Rr7sBks-XfqkPAx1crcU2aNOyA,4060 +bitblas/3rdparty/tvm/python/tvm/contrib/cblas.py,sha256=XW-c3pi4LTFYRoYhu0b2Zv1Ploo5w2YvhN45_9ZyBzA,2791 +bitblas/3rdparty/tvm/python/tvm/contrib/cc.py,sha256=imbiAkMlIotifvwbfWiRdpU4uDg39bo_0lJW7wR3OIA,12360 +bitblas/3rdparty/tvm/python/tvm/contrib/clang.py,sha256=3py_MYMC9VO-jyjAaLMJ6cIDDAkKp45mPASHBnjLaTw,3359 +bitblas/3rdparty/tvm/python/tvm/contrib/coreml_runtime.py,sha256=csq_nU6TnQd_T-tw7kbU7gWxS8XFf4ERDoG0SSzUIYk,2588 +bitblas/3rdparty/tvm/python/tvm/contrib/cublas.py,sha256=SUiSq_i8GH75KWZrn8JscSUUeP50dCls2VNA-H5U9tY,2614 +bitblas/3rdparty/tvm/python/tvm/contrib/cublaslt.py,sha256=4mkNre_3DHEeu8v_CJ8MKlaIxMAn3VbQMPuDFxyTo5M,1758 +bitblas/3rdparty/tvm/python/tvm/contrib/cuda_graph/__init__.py,sha256=9hdXHABrVpkbpjZgUft39kOFL2xSGeG4GEua0Hmelus,785 +bitblas/3rdparty/tvm/python/tvm/contrib/cuda_graph/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/cuda_graph/__pycache__/cuda_graph_executor.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/cuda_graph/cuda_graph_executor.py,sha256=eyStY6ZB62Wyq7pyhU5-NY78oginTSCs1xzgROuaL3s,4685 +bitblas/3rdparty/tvm/python/tvm/contrib/cudnn.py,sha256=ENpjWXHgLvmFuY0R60I8I6uKgJR-UUgCYL1M1A81JCA,23901 +bitblas/3rdparty/tvm/python/tvm/contrib/cutlass/__init__.py,sha256=x3_cwp8C2_O65BfpaiJouBo5XUpPHJoleo3zVI7jgrw,911 +bitblas/3rdparty/tvm/python/tvm/contrib/cutlass/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/cutlass/__pycache__/_ffi_api.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/cutlass/__pycache__/attention_operation.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/cutlass/__pycache__/build.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/cutlass/__pycache__/conv2d_operation.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/cutlass/__pycache__/conv2d_profiler.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/cutlass/__pycache__/gemm_operation.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/cutlass/__pycache__/gemm_profiler.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/cutlass/__pycache__/gen_conv2d.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/cutlass/__pycache__/gen_gemm.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/cutlass/__pycache__/gen_tensor_op.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/cutlass/__pycache__/layer_norm_operation.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/cutlass/__pycache__/library.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/cutlass/__pycache__/rms_norm_operation.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/cutlass/_ffi_api.py,sha256=QzO0BW5lhjLh0ZnZN26fOxA3298AcwL2HTWL53d4kuE,882 +bitblas/3rdparty/tvm/python/tvm/contrib/cutlass/attention_operation.py,sha256=qpLdMQvx4D3X_mUpFNuZiBeJIRdXJEukZvJDci2bLkg,11638 +bitblas/3rdparty/tvm/python/tvm/contrib/cutlass/build.py,sha256=IOayfUb1NzZwxl4RpPGOfaWLe5UEfaZsKlnJj0uExUw,40510 +bitblas/3rdparty/tvm/python/tvm/contrib/cutlass/conv2d_operation.py,sha256=17bopdXtFBtz3QcsQ_JY54bl9gdkjNZGLifk-pjPV64,21437 +bitblas/3rdparty/tvm/python/tvm/contrib/cutlass/conv2d_profiler.py,sha256=5_ey5qb3arX6_ntkbsMQ_QKTQJM6cNVrJEJ8KW-UMeU,8563 +bitblas/3rdparty/tvm/python/tvm/contrib/cutlass/gemm_operation.py,sha256=wUgk6Kw8SO8BWsckCi1H6t_0qOxVOg9aAyP5dmKFZuE,17803 +bitblas/3rdparty/tvm/python/tvm/contrib/cutlass/gemm_profiler.py,sha256=_gIkEWCz5YdpI1kbISE4v4vCO-BTYIuPjFnRRIVT7ZA,6593 +bitblas/3rdparty/tvm/python/tvm/contrib/cutlass/gen_conv2d.py,sha256=JZmzgOMbiHLkv3Idt-UrhWKCsHD5-yJBs-H7yDki5xI,12897 +bitblas/3rdparty/tvm/python/tvm/contrib/cutlass/gen_gemm.py,sha256=9okDnBWLBd8CieyY8m_oVLWPkS1t4I0nyi8IKq1S77s,11610 +bitblas/3rdparty/tvm/python/tvm/contrib/cutlass/gen_tensor_op.py,sha256=3gD1qAFY5pdORTaPQCJSIW5fQqRC17QobOdxIWTqqNg,37432 +bitblas/3rdparty/tvm/python/tvm/contrib/cutlass/layer_norm_operation.py,sha256=reOOL9mGTKoW-O8JGOPhXG-8s5YfTTc8Dc5VycX9icA,2013 +bitblas/3rdparty/tvm/python/tvm/contrib/cutlass/library.py,sha256=5kkbFVVDZMOG4ez9qsFpwVdPftg1E7tZkoSNdgby9Pg,8940 +bitblas/3rdparty/tvm/python/tvm/contrib/cutlass/rms_norm_operation.py,sha256=B1PlKsCV3m-7EcOSqkzQUm7mIDo3b8tmnilsBcEX410,1918 +bitblas/3rdparty/tvm/python/tvm/contrib/debugger/__init__.py,sha256=9hdXHABrVpkbpjZgUft39kOFL2xSGeG4GEua0Hmelus,785 +bitblas/3rdparty/tvm/python/tvm/contrib/debugger/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/debugger/__pycache__/__init__.cpython-310.pyc,sha256=Pn84tidMAwb8zeCzEZEhTyFimARse8WM-5UWIY6YWmA,170 +bitblas/3rdparty/tvm/python/tvm/contrib/debugger/__pycache__/debug_executor.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/debugger/__pycache__/debug_executor.cpython-310.pyc,sha256=1E8t2sww3dg0HaYam3cdz1uQ464-6Jl9VUuw9IvPRMw,15634 +bitblas/3rdparty/tvm/python/tvm/contrib/debugger/__pycache__/debug_result.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/debugger/__pycache__/debug_result.cpython-310.pyc,sha256=XJtT9TIjJt-NauVZVxgl7DFFnLzymSlMIwVjAWZ8MW4,9504 +bitblas/3rdparty/tvm/python/tvm/contrib/debugger/__pycache__/debug_runtime.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/debugger/debug_executor.py,sha256=5UUHQk8LWNiEolmhUa8yb9_YNZ3al74U90P8LhPHcOc,18352 +bitblas/3rdparty/tvm/python/tvm/contrib/debugger/debug_result.py,sha256=rv0uenYrrkkY2DNFupCU5pK38q-o2tFrZc4K5qXEdk0,10681 +bitblas/3rdparty/tvm/python/tvm/contrib/debugger/debug_runtime.py,sha256=CHzQtXVb1NMYJmmkK_EfwQtseYYTg84mxhgfhIyKGxI,1109 +bitblas/3rdparty/tvm/python/tvm/contrib/dlpack.py,sha256=nrhZoYvxXJNUOTws43Sb5gD8qL5G1Bn_ED8odQZqqcc,2115 +bitblas/3rdparty/tvm/python/tvm/contrib/dnnl.py,sha256=xd3FwjDmBqcScWNVwy_6sx3ll7gsS6ZSoGPt0tdbQss,4750 +bitblas/3rdparty/tvm/python/tvm/contrib/download.py,sha256=Jl7D9a9IQNIIDJYERnYJyMWkEPlE8m1AJn_GHshZ6jI,5836 +bitblas/3rdparty/tvm/python/tvm/contrib/emcc.py,sha256=aUQgC707xcaCpxtqraYFnL-ziub5QGO2p0rKVXiFGpc,3319 +bitblas/3rdparty/tvm/python/tvm/contrib/ethosu/__init__.py,sha256=Qx7hrFqbWwwZnzSPubD_EPy7cKu7xzmyL4id1_p34kI,850 +bitblas/3rdparty/tvm/python/tvm/contrib/ethosu/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/ethosu/cascader/__init__.py,sha256=ppQ0XajH3TL2rBU_az07imLhzSygUfDfeWaOBku-QVQ,1545 +bitblas/3rdparty/tvm/python/tvm/contrib/ethosu/cascader/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/ethosu/cascader/__pycache__/_ffi_api.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/ethosu/cascader/__pycache__/block_config.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/ethosu/cascader/__pycache__/cascader_options.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/ethosu/cascader/__pycache__/device_config.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/ethosu/cascader/__pycache__/graph.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/ethosu/cascader/__pycache__/logging.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/ethosu/cascader/__pycache__/pareto.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/ethosu/cascader/__pycache__/parts.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/ethosu/cascader/__pycache__/plan.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/ethosu/cascader/__pycache__/plan_generator.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/ethosu/cascader/__pycache__/propagator.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/ethosu/cascader/__pycache__/proposal.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/ethosu/cascader/__pycache__/proposal_generator.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/ethosu/cascader/__pycache__/scheduler.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/ethosu/cascader/__pycache__/stripe_config.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/ethosu/cascader/__pycache__/tensor_config.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/ethosu/cascader/_ffi_api.py,sha256=iaP4KYf_5xCN8gYaNJa3Y5v-G_a1tR_MtCeuMFw2KK8,896 +bitblas/3rdparty/tvm/python/tvm/contrib/ethosu/cascader/block_config.py,sha256=FCjvWe9FD-uAKZE6qF-kOgB4Dd8sOtma18jpoNqfIGA,2276 +bitblas/3rdparty/tvm/python/tvm/contrib/ethosu/cascader/cascader_options.py,sha256=KBjTxDRJvLq6vKiGw14UD51n3Pm5IJVPXO4Dso4epX4,3171 +bitblas/3rdparty/tvm/python/tvm/contrib/ethosu/cascader/device_config.py,sha256=0ezvbBd50CbD87u30MFV1uXz1deXnY-f9FtJmC4U5_s,34407 +bitblas/3rdparty/tvm/python/tvm/contrib/ethosu/cascader/graph.py,sha256=w0k91QGK1gV2E4I_6VEhqCDGNBVlfYVS4UzNh3omShQ,8135 +bitblas/3rdparty/tvm/python/tvm/contrib/ethosu/cascader/logging.py,sha256=HIns4egc4vhZTPBNYnoVTJxL1xXaop7dfXqi4CWRpeI,2767 +bitblas/3rdparty/tvm/python/tvm/contrib/ethosu/cascader/pareto.py,sha256=q9CJRp7KoeetqDt8INVE0XYrvHEKSqfbQWxrP89gPL4,1503 +bitblas/3rdparty/tvm/python/tvm/contrib/ethosu/cascader/parts.py,sha256=7St1Tclil5YMsc4i4UtAFPI6Fqy2AcIE6hQ-k-SpxTc,2501 +bitblas/3rdparty/tvm/python/tvm/contrib/ethosu/cascader/plan.py,sha256=IBzm21MViBoVS-pWM9fcE8wQCuZ3laW7M_ehwE9YiXw,6329 +bitblas/3rdparty/tvm/python/tvm/contrib/ethosu/cascader/plan_generator.py,sha256=S9MiULMLhmOsLZmAaAvhdmctahIYeOxnrelFaPgUOgk,2473 +bitblas/3rdparty/tvm/python/tvm/contrib/ethosu/cascader/propagator.py,sha256=vWqAUrfOQBSlFFMSeLoIot0bUJYc43yOY1bWHG7B8zA,1836 +bitblas/3rdparty/tvm/python/tvm/contrib/ethosu/cascader/proposal.py,sha256=Tw-iZBqpS9e9Q-YTB3iwnW6HVbx4mN9imlbLmZkvKBg,3704 +bitblas/3rdparty/tvm/python/tvm/contrib/ethosu/cascader/proposal_generator.py,sha256=-O9nepCefw2sNfLwpavpePIeZBF-Sk-SFia_bi0o5dw,1941 +bitblas/3rdparty/tvm/python/tvm/contrib/ethosu/cascader/scheduler.py,sha256=nD7lCEhSrCLFJX6pyXJo39QYjgpTtJgT-unVAiqYjpg,13214 +bitblas/3rdparty/tvm/python/tvm/contrib/ethosu/cascader/stripe_config.py,sha256=2Zuz6z5xhR7LtNYrIp3d4X0_TN8Jjpvuv_MUQBjOCjM,2716 +bitblas/3rdparty/tvm/python/tvm/contrib/ethosu/cascader/tensor_config.py,sha256=JmLQfRuFA2dmIKAAaC2S5UZscEU4nh-YmiLSooltuvc,7927 +bitblas/3rdparty/tvm/python/tvm/contrib/graph_executor.py,sha256=-FeJ30hg4PjZUcYyPO9yZaoPvj-BNnCIFdTkdz6l6Ng,17422 +bitblas/3rdparty/tvm/python/tvm/contrib/graph_runtime.py,sha256=QwDO6Rilrs3q2jxyrLpsqy8a1qSh_T_oF6UrLU5dnGg,1109 +bitblas/3rdparty/tvm/python/tvm/contrib/hexagon/__init__.py,sha256=IWxtOa4zE9kNu3aecNpn0XMs0xxpUQxLJ0kWgYxnl1Q,852 +bitblas/3rdparty/tvm/python/tvm/contrib/hexagon/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/hexagon/__pycache__/__init__.cpython-310.pyc,sha256=YqP1z7uhzSlnxVVk8vKTzO8k0lv8nN5lgy63WvQX0W4,242 +bitblas/3rdparty/tvm/python/tvm/contrib/hexagon/__pycache__/_ci_env_check.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/hexagon/__pycache__/_ci_env_check.cpython-310.pyc,sha256=KslWjpJxHuHmuAGJmqAeo7OvBxXNAv0NmmCSTdE0_hs,1351 +bitblas/3rdparty/tvm/python/tvm/contrib/hexagon/__pycache__/build.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/hexagon/__pycache__/hexagon_profiler.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/hexagon/__pycache__/meta_schedule.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/hexagon/__pycache__/pytest_plugin.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/hexagon/__pycache__/session.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/hexagon/__pycache__/tools.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/hexagon/__pycache__/tools.cpython-310.pyc,sha256=2-Wa6Ym-pwQct5oZnQLrkz7uAoLmQQxse9e8kq-pjLI,15627 +bitblas/3rdparty/tvm/python/tvm/contrib/hexagon/__pycache__/transform.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/hexagon/__pycache__/transform.cpython-310.pyc,sha256=ma1W5cZMTclqaK_PAsA3kflHStA8dmML9WxKI4898rE,16417 +bitblas/3rdparty/tvm/python/tvm/contrib/hexagon/_ci_env_check.py,sha256=dI_A-rmlzhZeau_gfX6jbxiLV_EBcoUmoJlMTU162n4,1970 +bitblas/3rdparty/tvm/python/tvm/contrib/hexagon/build.py,sha256=JfJJ0cjHV5kcblBUm60_Yjeh2ouY73g0lHNxF2njBLI,31892 +bitblas/3rdparty/tvm/python/tvm/contrib/hexagon/hexagon_profiler.py,sha256=DHSvHon1ggfq6ClKUHJMxmiW0a8-l8MbJLXmHkyzepY,5245 +bitblas/3rdparty/tvm/python/tvm/contrib/hexagon/meta_schedule.py,sha256=jSIT1lm9VhcNC2MmSV2l3BGMVkdKwe3rmOZKQ6T2Nak,6764 +bitblas/3rdparty/tvm/python/tvm/contrib/hexagon/profiling/__pycache__/process_lwp_data.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/hexagon/profiling/process_lwp_data.py,sha256=0zN2lbJHQePR-uS62jy2tmhJ5hkqme_Yhn_gVOLnngU,14799 +bitblas/3rdparty/tvm/python/tvm/contrib/hexagon/pytest_plugin.py,sha256=DZR23l40_OnW8Bd8SorYvbpohHFHEwxYhL75mihCGw8,12008 +bitblas/3rdparty/tvm/python/tvm/contrib/hexagon/session.py,sha256=7-jr5ZPSMS0CognfZYyhC5eeFgBV1GuLhiMLDCn44Vw,15626 +bitblas/3rdparty/tvm/python/tvm/contrib/hexagon/tools.py,sha256=4YfPABXadgpkGJ_QsUzYlL_bYOBbTzHXU4HebW_TSNY,19579 +bitblas/3rdparty/tvm/python/tvm/contrib/hexagon/transform.py,sha256=TctNeuuIzMnvMQgeQWypmd1rZBNXzL086_mt6gMoUjY,19228 +bitblas/3rdparty/tvm/python/tvm/contrib/hipcc.py,sha256=1uboQlHt3bv6Fd4zMzd403Brr0OQMsebNbC2rZ-07Pg,3313 +bitblas/3rdparty/tvm/python/tvm/contrib/micro/meta_schedule/__pycache__/local_builder_micro.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/micro/meta_schedule/__pycache__/rpc_runner_micro.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/micro/meta_schedule/local_builder_micro.py,sha256=BdF9A_sh9xRynqmJ4gBCvPTSjSwoy8r66Ew5WV5LnTI,3083 +bitblas/3rdparty/tvm/python/tvm/contrib/micro/meta_schedule/rpc_runner_micro.py,sha256=hhSYL7rZ3rOioSoDhPgmyzyJdfhAzq8s71vHd-y-l-U,8879 +bitblas/3rdparty/tvm/python/tvm/contrib/miopen.py,sha256=JAoS9DWja8gi9kHBn_5jA5bdNtwcOtgl4b1h2NPlpkQ,4399 +bitblas/3rdparty/tvm/python/tvm/contrib/mkl.py,sha256=tQ-xBgp6OStJmhhw2bvmO_iHG7YYs1-8eb9dbvue-QQ,3643 +bitblas/3rdparty/tvm/python/tvm/contrib/mps.py,sha256=r_ihC3eJ73PuGZrwGNuRctQQCrHVHj0BGIoQ80ACFHs,2671 +bitblas/3rdparty/tvm/python/tvm/contrib/mrvl.py,sha256=s2r1TD97RiY8W7anAlhdgVXpzlgZW4Xns9dLtpyifXQ,17840 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/__init__.py,sha256=00VWSesxcIsYq_SgRCE5TaGsXOAAT2RjBdYPOXie9SM,807 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/__init__.py,sha256=YjV_dH3JhFUDsJ0Aq9b6lZlWfaXlIuX9LJuNZm--hfE,812 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/__pycache__/_ffi_api.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/_ffi_api.py,sha256=08CXihcduZ1IsX_HkFubA0-0s4vtRhCvDv_E8-d8w8U,880 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/codegen/__init__.py,sha256=M9-NKlYoE-gtDZ_R8bmH4AM4WiFSfLsZzMxOUoWPGK0,867 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/codegen/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/codegen/__pycache__/codegen.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/codegen/__pycache__/sources.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/codegen/codegen.py,sha256=FpbSWAGnzoQ_gYXbC8qk1XDELSlMDLZgvDOx3fQv7Fw,9160 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/codegen/sources.py,sha256=vL_mgHaEenR4EZTLH9wIzO1_aXqrGnz0oJOOXkI0gng,5752 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/frontend/__init__.py,sha256=EY_Addg-tNul6Y5BvDI9litvQZrD0igAhC95RXXIoIs,847 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/frontend/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/frontend/__pycache__/translate.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/frontend/translate.py,sha256=pisvcoA5wpyZhAy0iT3DM11Zl67ummbdfr-T8uvJcpA,12661 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/gym/__init__.py,sha256=ltnOx_j8MjaKMOa4cf_qYtWgxbH07m4x_UDgAAaRWMg,888 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/gym/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/gym/__pycache__/namespace.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/gym/agent/__init__.py,sha256=1og5ZONDYT3K6DWm1sZ20la1IWA792o-QCDh3SIt9jA,873 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/gym/agent/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/gym/agent/__pycache__/base_agent.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/gym/agent/__pycache__/method.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/gym/agent/__pycache__/search_agent.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/gym/agent/base_agent.py,sha256=fAY7KzhgLSbgrRaol8nLuAo1JHeRmZOHlnlKeJSFRK4,9279 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/gym/agent/method.py,sha256=iXmXIG53wev90Q9A01GMEKf3XY62hapHMvixs8b8syI,2393 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/gym/agent/search_agent.py,sha256=2X32DxgAAFNLfgwqTxFtnfNIKfxlthFIRzhhQCSeaF4,5122 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/gym/control/__init__.py,sha256=TGh7AWL1LQ0TkePqkhwXFDWPBdogXhANCZLEe5zmvt0,875 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/gym/control/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/gym/control/__pycache__/configer.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/gym/control/__pycache__/controller.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/gym/control/__pycache__/namespace.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/gym/control/__pycache__/service.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/gym/control/__pycache__/worker.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/gym/control/configer.py,sha256=HCcyN2TILLuk0thZx-RD32rogbQ4-10ziK4yTZ8xviY,3025 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/gym/control/controller.py,sha256=_6MsFLz4WdEb-T48dn8k8sQPyIMzGT9W7TznVIskawU,3413 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/gym/control/namespace.py,sha256=3dyLl10tymeQyDrzrr845zuIat99rFVtQ4e-5fPwCDQ,1238 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/gym/control/service.py,sha256=65n4tuPvPnXeXRPkiCFcTeHMO_Xrwsx8t4bU66WKzmc,24719 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/gym/control/worker.py,sha256=c86Kni8VWwe7iCIaG4Nj0tXX0dkpFD0hTghfe1Eu4Es,6954 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/gym/environment/__init__.py,sha256=zh2vFEV2Agyn2P0nFySkf9dBnP3OXXMdtnkNvtYs418,904 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/gym/environment/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/gym/environment/__pycache__/base_env.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/gym/environment/__pycache__/method.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/gym/environment/__pycache__/prune_env.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/gym/environment/__pycache__/quantize_env.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/gym/environment/base_env.py,sha256=92mhA6fuPChjhUT8oMvUDmOlSgaAbuG6p78sWm3c0M8,12517 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/gym/environment/method.py,sha256=UjNtLkON3ayHBELYGZWIWJOxpW_5jw2AbeQMOkYqjZw,5759 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/gym/environment/prune_env.py,sha256=f33srbTRW9eVfr4jK8RKaaBClS9p59IgKi11AOcjdO0,3063 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/gym/environment/quantize_env.py,sha256=RvZEKeb8Fi3mk-uSfceAelwXO29_ucTJp_0Aa-s8HI0,2599 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/gym/namespace.py,sha256=u-wwzSsckftfqJJaus0MBZVIO6URiR2Aa0xBWYk69PI,1230 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/ir/__init__.py,sha256=KPXFeCTP9VtwESzWmg0a7-qQDs6__CiuAEORJW4F0Cw,837 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/ir/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/ir/__pycache__/graph.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/ir/__pycache__/translate.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/ir/graph.py,sha256=rJw0JlnjRW7_Ph6_OrGZe6r5O6zlA1MhgZMoourCpP4,25072 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/ir/translate.py,sha256=QMwccsHH1yN_L03Vdy5ygelE-9tv4Jh8uM-C9Bj6Jw4,12432 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/runtime/__init__.py,sha256=zY2iRH2ALGoDJvL9JWciorZpYYsXvwg9xHdlLlRgf94,862 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/runtime/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/runtime/__pycache__/hook.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/runtime/__pycache__/jit.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/runtime/__pycache__/runner.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/runtime/hook.py,sha256=E1PzwVPk-w4_NOEFIVeOYLGUGva69nJQvHgwRUJbGDM,5097 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/runtime/jit.py,sha256=2g6l1M-215I_ClKf5S9IfTgoMs548Axex7LWUqMt9lM,10604 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/runtime/runner.py,sha256=v60fpu4671Wx1_k5nwG3a1yZiwIGqS9EvTp0VUyA48I,47443 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/tools/__init__.py,sha256=T0pvtNOaEZ9ftc_TE57CuomdpXQO9hebL5U-xHQdSRg,951 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/tools/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/tools/__pycache__/configer.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/tools/__pycache__/execute.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/tools/__pycache__/tool.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/tools/configer.py,sha256=nkMrJ71bqJdUjAWOyv1XG0RI8I4KuG76P0g2IWd-cBw,2949 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/tools/distill/__init__.py,sha256=r4laopCGbyO-IjqZlIjjGftTJ_gzLu2-vhX5CcB8KQM,898 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/tools/distill/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/tools/distill/__pycache__/configer.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/tools/distill/__pycache__/distiller.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/tools/distill/__pycache__/method.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/tools/distill/configer.py,sha256=9bQTrhRUfD9rKO7jKj5CmlNfEtU80sNrUtnghxWl7pE,1766 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/tools/distill/distiller.py,sha256=ye8obp5qIk5lklvxHdXGuivDdn5fbirsNkecII8XK9E,7994 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/tools/distill/method.py,sha256=-axGt8qgQH_B86RDwiElzx8khdmw-ayS3XoAGZ7N_cM,2160 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/tools/execute.py,sha256=Au4CPLm0ilFpPj99sS2-xtvYnlfAq9ztzlMn3HJDOjc,10633 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/tools/prune/__init__.py,sha256=cQZwDCUAJUoMMRWvBiAeiRNUoNl2ivhcwxd1YoBjQTE,893 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/tools/prune/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/tools/prune/__pycache__/configer.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/tools/prune/__pycache__/method.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/tools/prune/__pycache__/pruner.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/tools/prune/configer.py,sha256=IVMsNYvoAlKYLOS7rd0-Z2SLTREf7YTZPLu6LTt9l0M,2836 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/tools/prune/method.py,sha256=Nk8Du1GhNTeqAGCexyYPzofxlecc-jCVk8l009f8kAM,3501 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/tools/prune/pruner.py,sha256=Hf8m2-qX3JbNeiSJeBxlFMraOdMzkLmEmZEJyIGs5bY,19016 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/tools/quantize/__init__.py,sha256=--aDVyklL8QQWSYGVD7OW08Vjw7hAD2ygmfri2SYRf4,899 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/tools/quantize/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/tools/quantize/__pycache__/configer.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/tools/quantize/__pycache__/method.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/tools/quantize/__pycache__/quantizer.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/tools/quantize/configer.py,sha256=BshJMcd6Op99k1VjL8iRoTAsXd5Wzr1L0HlEofUArt8,3863 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/tools/quantize/method.py,sha256=unrPhMzSxhwilVmYbLVwJNuzIp3e-0lZK09dGUv9oJQ,13908 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/tools/quantize/quantizer.py,sha256=AXYLPfF9iOAxBFpGRWHi0u6HCz5zM0kPrcctUDJNkbE,8047 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/tools/tool.py,sha256=bF20CGfIz6FhPGD8sDdaI18FQW5cCmDERTsgkrT6fH8,47281 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/tools/track/__init__.py,sha256=quKPyZIGnQoWGoGOMcQZuOZRJ4M7G6LwvLcFc5ya14I,894 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/tools/track/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/tools/track/__pycache__/configer.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/tools/track/__pycache__/method.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/tools/track/__pycache__/tracker.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/tools/track/configer.py,sha256=QcUSabJZ5Gx9jjOciR5b-vROrCtW4jDGGBqWyreET84,2161 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/tools/track/method.py,sha256=4dz3x8FS8PPPIQFHore2VdAkJoU95bjbHrRlsqbShs0,3405 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/tools/track/tracker.py,sha256=PlHjmpBunH7yFsrW9x5Ye-4vraHMTE59eM-n0j9VjqE,6029 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/transform/__init__.py,sha256=VR7-ID-d26pmCOb6RWcfemtqIHu9-U_6Ib2XQCpZH1U,871 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/transform/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/transform/__pycache__/pattern.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/transform/__pycache__/transform.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/transform/pattern.py,sha256=B2Cf35eyzXM2O6ZZzEO9BJTK7jsdoZwjufms67kZ8o0,29281 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/transform/transform.py,sha256=ftCpHo9QWTA7AOXgQ7bBYykbQVJ0FhBanzyloi6dJcQ,4409 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/utils/__init__.py,sha256=qHQOqYU3TfO0vFbUnMlWUqRX3Nfn4BoTW7d2uXLrcz0,1018 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/utils/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/utils/__pycache__/arguments.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/utils/__pycache__/dataset.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/utils/__pycache__/expr.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/utils/__pycache__/file.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/utils/__pycache__/info.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/utils/__pycache__/log.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/utils/__pycache__/message.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/utils/__pycache__/namespace.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/utils/__pycache__/register.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/utils/arguments.py,sha256=4LK8MDPV94Lo7goguvP_ZoEhxtVdQ_N5yrYk8WaVeHM,7677 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/utils/dataset.py,sha256=mSchocN-6KBjcf-g95OinA5tqX-MxhiwbSfpqLw5Z70,15802 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/utils/expr.py,sha256=xc1G8Goh0IgHAuhuMdV9KJFmHYB5_wzR3vXtL7QbXnI,6029 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/utils/file.py,sha256=e49m5w2y-TEZgc9oNJXShARX1MiZkArHzI-Oq4h41fE,14363 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/utils/info.py,sha256=Vj6ZP79Zfnt86dwC8YbGIOYF_s0vW3QN0LFKpnSf0EQ,13344 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/utils/log.py,sha256=p1u7xD5fK4ksrodsINoVUiDI6ZJYsFfnoTFK9IHYl7w,5120 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/utils/message.py,sha256=c09UJewt7WQO4RrZV2yB9fBwO2A0P9VpubAwWvFU5og,4982 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/utils/namespace.py,sha256=fCMF9o8QobMnDyIzEsfSLu8Rx0wp8YRTKEshbp5IrAQ,2081 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/core/utils/register.py,sha256=6J_T68dP7EAzyJd9NaMRLQGqVJ_rI3QLhUAgnudxti8,10681 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/__init__.py,sha256=OQgZn8H-RWIH0xff6reyBHNzJ0cwHVTJ6PNBgQb9rk0,821 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tensorflow/__init__.py,sha256=yRx8sLG6iV3lnwIi-5UbvIpBOFb4KzabYIDCt6iGG_M,937 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tensorflow/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tensorflow/__pycache__/_ffi_api.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tensorflow/_ffi_api.py,sha256=55Pz-S3T-VpdORMhYwxxCTnqbT7edKXUQksBDgA4yUc,912 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tensorflow/codegen/__init__.py,sha256=nKBdvpem20bKnbJnIU0EOdVxJ2cIOqSMuaCG370FVrI,860 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tensorflow/codegen/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tensorflow/codegen/__pycache__/codegen.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tensorflow/codegen/codegen.py,sha256=V-d90sJLzvQl8jEtgqy6xMZNM7z1HsDhfGUmz5Voyb4,2613 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tensorflow/frontend/__init__.py,sha256=9rO1wl0J5gEJIckfY9dUJCiohRX-phTNIFXl7AYeYgg,863 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tensorflow/frontend/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tensorflow/frontend/__pycache__/translate.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tensorflow/frontend/translate.py,sha256=00WOT5XRo2BMfK0C8-X7DwT8LdwE5EzA7FEBoox5rdE,3108 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tensorflow/runtime/__init__.py,sha256=F8BU1mdgRS1kUukXN89oGUwYYw-wnU1MUX2VjmiphVw,859 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tensorflow/runtime/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tensorflow/runtime/__pycache__/runner.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tensorflow/runtime/runner.py,sha256=g1zhQgjaSAVSlG1H-eXUZGiwMONZkQ_G1xOLXeCTajU,9206 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tensorflow/tools/__init__.py,sha256=19cNvUDwAWfcxTkWCpwKJzPJdOMRzisoLPeoXxKbm24,924 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tensorflow/tools/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tensorflow/tools/distill/__init__.py,sha256=xgBYrB6PVygofOvF99ghVglEO5W4sSo4ujpdfqKZG2c,868 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tensorflow/tools/distill/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tensorflow/tools/distill/__pycache__/distiller.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tensorflow/tools/distill/distiller.py,sha256=5r0HSnUGaFGumYdh1FLdXLQfyk6Za3xAzdoApcKr-Mw,1933 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tensorflow/tools/prune/__init__.py,sha256=bCK6F2yq5iaN55MVQ-ygCrODaT4mFw4t9XP1cFu0684,863 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tensorflow/tools/prune/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tensorflow/tools/prune/__pycache__/pruner.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tensorflow/tools/prune/pruner.py,sha256=4V0d1BUi77LGYb9TZ6RGA-pBc0jSKGC-0Mxnscxa_PU,1878 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tensorflow/tools/quantize/__init__.py,sha256=LVMX7ubu256twCpt9yS52KX4X_uCvB4n7IvyU32lAQ8,869 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tensorflow/tools/quantize/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tensorflow/tools/quantize/__pycache__/quantizer.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tensorflow/tools/quantize/quantizer.py,sha256=CexIHc5qGXa32G-wnaBSx8oywtZNE1H24OgCmEtW4z4,1935 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tensorflow/tools/track/__init__.py,sha256=5y9Mbx447SO8gcxrtTnaTtM5gHM0UTsrMUBvpXW76Fo,864 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tensorflow/tools/track/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tensorflow/tools/track/__pycache__/tracker.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tensorflow/tools/track/tracker.py,sha256=Df8OMWz1B65PxjAQc0osXW_1bookzL5yGI63Ev4uwCo,1895 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tensorrt/__init__.py,sha256=ZcMF8P9jLlRitf0gTClcUEOvnHiOHU2lBi-3IEUsNjI,826 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tensorrt/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tensorrt/__pycache__/_ffi_api.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tensorrt/_ffi_api.py,sha256=UehAioVaWkhipzjw1KR20kdac5x-yA_Oy19mhk3-J5A,908 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tensorrt/codegen/__init__.py,sha256=PO3qc-dttD6ba0WXpc2j8M4QRap8x9S8svxbjALMdl0,858 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tensorrt/codegen/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tensorrt/codegen/__pycache__/codegen.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tensorrt/codegen/__pycache__/sources.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tensorrt/codegen/__pycache__/utils.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tensorrt/codegen/codegen.py,sha256=cmXzBcvyOohfrsMxLPx719QjEHXeHA1kqUghnNajV6A,7760 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tensorrt/codegen/sources.py,sha256=8ucwEcsX4GZPoX60F4_CFFMlr65vWUyCMAkfozj8CsE,15536 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tensorrt/codegen/utils.py,sha256=0iBf6yrdhRq6pathsskE31h3F8tUvtwgYLFf-AmMChg,2432 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tensorrt/frontend/__init__.py,sha256=mYTUXQDpe19ShYN7Pa0htihes6-68NpN504WalFx194,861 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tensorrt/frontend/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tensorrt/frontend/__pycache__/translate.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tensorrt/frontend/translate.py,sha256=PRSREtvp-q_cAOLr7MhCtAwtYxcukC9qj7SaYFVW-6s,2798 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tensorrt/runtime/__init__.py,sha256=aSuWPnQ9WtWYfSBNmv11u4BqtL-gUwe2tPpYQdXKG5I,857 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tensorrt/runtime/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tensorrt/runtime/__pycache__/runner.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tensorrt/runtime/runner.py,sha256=Ss-vV0KyQJ4UOuVMh7_vsoZt7sYhbXkRzB-i-oeibGI,5874 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tensorrt/tools/__init__.py,sha256=q7l56_4rORindTcDffhAMUtmK171pOeaTLqPJuoITNQ,922 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tensorrt/tools/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tensorrt/tools/distill/__init__.py,sha256=57AuUKEBBxN6cCGjZWTtrvP7ghSSeBdDmoLP9Dj4tZU,866 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tensorrt/tools/distill/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tensorrt/tools/distill/__pycache__/distiller.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tensorrt/tools/distill/distiller.py,sha256=GXA5bOgkLZim_TAdYgXvUxwNfHdhxzVNGtIAuy_VOQs,1921 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tensorrt/tools/prune/__init__.py,sha256=7ExD-RUzxWisTYaqNPkxFOG08cTgK4W4IjB4y9olv38,861 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tensorrt/tools/prune/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tensorrt/tools/prune/__pycache__/pruner.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tensorrt/tools/prune/pruner.py,sha256=uFX5wnd6o7z27q_qlh2V2w6WIqNFHjn1RmJLNVDRK6k,1866 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tensorrt/tools/quantize/__init__.py,sha256=rF2N5J0-AOsRGCLaWNjG5cEsIP7OEvmnniHJTRXOv5Y,889 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tensorrt/tools/quantize/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tensorrt/tools/quantize/__pycache__/method.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tensorrt/tools/quantize/__pycache__/quantizer.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tensorrt/tools/quantize/method.py,sha256=DC2CtNMyrPpHeEjWueQgabpZNlYAEB17Batwjgn_UKI,4408 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tensorrt/tools/quantize/quantizer.py,sha256=gsl97uuKvTQv778w9Zk_QoftvwN5IeFzi6h1uWu-U1k,14308 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tensorrt/tools/track/__init__.py,sha256=7oCCkiS2IaJnVxjZvNssqW_cunWPDCI5dOhk_QsVw0Y,862 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tensorrt/tools/track/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tensorrt/tools/track/__pycache__/tracker.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tensorrt/tools/track/tracker.py,sha256=k2f0AAaP1WXkFn69ZWc2xWlD24Lfpa-Fhm1iUONvOBM,5596 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tensorrt/transform/__init__.py,sha256=CWOcj3SreBH-IliSQ3re6XyV9HZozSEQ_qyJIDVK0-4,885 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tensorrt/transform/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tensorrt/transform/__pycache__/pattern.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tensorrt/transform/__pycache__/transform.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tensorrt/transform/pattern.py,sha256=HR6KTGVIZoOhye6LxNtbPwAvw5FqQyVKaJECGE-jrzk,13953 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tensorrt/transform/transform.py,sha256=3g2W2f_PGo2rnjxR6iUzKV4atZIqaIGKUF1iK_qhfgY,1479 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/torch/__init__.py,sha256=-5_et35DscQRsZs85YDp_QJe8cYn_aGqA7O3pelIpec,823 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/torch/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/torch/__pycache__/_ffi_api.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/torch/_ffi_api.py,sha256=tZ0n2ZP6uxV0ml0GW4SBNJEScmNK8gsewL63Pvqr4yo,902 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/torch/codegen/__init__.py,sha256=ju_am2D4yGkmynhtPzCxXGULo_FdECesQWe0TzwAOr4,855 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/torch/codegen/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/torch/codegen/__pycache__/codegen.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/torch/codegen/codegen.py,sha256=CZJRknCuWdJlICfCXJ6fevQ_cN0kWIp28_Kfe1AYZmg,3007 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/torch/frontend/__init__.py,sha256=MDjoExxP7zzB0889dWUfxPeBCgm57Oh5bMtP0F7A91w,858 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/torch/frontend/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/torch/frontend/__pycache__/translate.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/torch/frontend/translate.py,sha256=Gy7zVWv77mPMWJ53yUqTl8NqciRYXpx7Hy9sF41zH6k,4817 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/torch/runtime/__init__.py,sha256=dww8HupsLfmaxHXeTAclefCyDJsUfKYkKHIVZ429Wqo,873 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/torch/runtime/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/torch/runtime/__pycache__/jit.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/torch/runtime/__pycache__/runner.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/torch/runtime/jit.py,sha256=CcWN-T4F1tjhe4Mdp6PYytPHNDoj-ykQ8tUYJPzqYK8,6430 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/torch/runtime/runner.py,sha256=xCWw0T19_N12cYHh_WSW_ZNgSHN2ycbWlOOtCLjmzGs,10947 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/torch/tools/__init__.py,sha256=ImnLaRH9BCVEtpY9XhOt7-EJemHPIQ3qmNudGEcr57w,919 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/torch/tools/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/torch/tools/distill/__init__.py,sha256=06myZQ8hTW6qwz9ToXeugmjvEXk-MptWviCGriaqyzA,885 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/torch/tools/distill/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/torch/tools/distill/__pycache__/distiller.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/torch/tools/distill/__pycache__/method.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/torch/tools/distill/distiller.py,sha256=XkF09iglSfwR5Ea5MMwpImuImBf_oFhOPyGKNApS9jA,5073 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/torch/tools/distill/method.py,sha256=gy3dsFI2cIDp19O0tYhkCpt-mFiXGq74TLwdmS5-W9o,3477 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/torch/tools/prune/__init__.py,sha256=NuYAEP6mE6bDraXY2xEBXfJD5g8MC04V7AfYyNCtR9Q,858 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/torch/tools/prune/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/torch/tools/prune/__pycache__/pruner.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/torch/tools/prune/pruner.py,sha256=UJC77J0cbUriXoFEQhHu6lXQBQBSszGR5LLibyGWPDQ,1848 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/torch/tools/quantize/__init__.py,sha256=ao0KiYPAeBnAnq4pIntkFXRiQR_pnxRZWsMdKCQYq0I,886 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/torch/tools/quantize/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/torch/tools/quantize/__pycache__/method.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/torch/tools/quantize/__pycache__/quantizer.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/torch/tools/quantize/method.py,sha256=t3mwAhiLpSMYW8p2wWayKDL1pbv2K_ZDOrPg-bbZbCA,8422 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/torch/tools/quantize/quantizer.py,sha256=PUSPzJadxYuIC6XrHsMMM05pSw52azBFJqJg3x_6q7I,1905 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/torch/tools/track/__init__.py,sha256=VZvQLUQZIimE7zoqYggLeQG9V5MJ4VLUt8t1U-joCMM,859 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/torch/tools/track/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/torch/tools/track/__pycache__/tracker.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/torch/tools/track/tracker.py,sha256=PKQnwHT6bHrwphez3fyta-L5V12lyvaVq0UnQx-m45s,1865 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tvm/__init__.py,sha256=OQgZn8H-RWIH0xff6reyBHNzJ0cwHVTJ6PNBgQb9rk0,821 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tvm/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tvm/__pycache__/_ffi_api.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tvm/_ffi_api.py,sha256=L58Z0HDozM4srZQCxa-xRSKvUKPKQMrrXVAQuZPRbFs,898 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tvm/codegen/__init__.py,sha256=upiJp1hHCpNdYXltZNIPhu84xvwtlzRxjb8uam_fC0c,853 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tvm/codegen/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tvm/codegen/__pycache__/codegen.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tvm/codegen/codegen.py,sha256=vD74xckjCLXIwG-MLbEQTIzSf2-XITVpu_J-R2ufDz8,1980 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tvm/runtime/__init__.py,sha256=3kzH9GC6iTa6viJotdoBp494eC-mvXqdwpQCIV-ZfAo,852 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tvm/runtime/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tvm/runtime/__pycache__/runner.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tvm/runtime/runner.py,sha256=61Pl5jct6ukrGlNSt9aFuuGsXVM8xkcVtK6ng6agehw,10278 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tvm/tools/__init__.py,sha256=fIxLxjcO9Kgrz8EXjfTkiRPVw7prN-57j50VsEnSJuc,917 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tvm/tools/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tvm/tools/distill/__init__.py,sha256=IklKS8Ve7BmP_9F2O04uDJM4oxJYgH0TBMjriioJbbQ,861 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tvm/tools/distill/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tvm/tools/distill/__pycache__/distiller.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tvm/tools/distill/distiller.py,sha256=Y0TEPTjJTLlK7dRjKfnb8jbEduldicLbcYn6yfxuLi8,1891 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tvm/tools/prune/__init__.py,sha256=oz3miF-6ZuEbuWY7SJ_59aW6BNi0Mda6yCHFVUxl09M,856 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tvm/tools/prune/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tvm/tools/prune/__pycache__/pruner.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tvm/tools/prune/pruner.py,sha256=GLYrCRK1P0p46ym3vjqAlDDmkZOCoS9pCnsqZemgzbA,1836 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tvm/tools/quantize/__init__.py,sha256=fLStiVw6sw90ZReM9b3ZUltPt38asyY7dBe_cyO2yc8,884 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tvm/tools/quantize/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tvm/tools/quantize/__pycache__/method.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tvm/tools/quantize/__pycache__/quantizer.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tvm/tools/quantize/method.py,sha256=ViFv6OOcg6xarONWZpeVGlwb9UOP2l6IM4B-tiCZVqU,6792 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tvm/tools/quantize/quantizer.py,sha256=oCowqovRJuNOq67fF02LQqdS7XXZRKubzae9zjA9kxo,6275 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tvm/tools/track/__init__.py,sha256=zj1DxSxRYxInEi_bAeKhlYVB5d8ABd1khD6rS5nAHTw,857 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tvm/tools/track/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tvm/tools/track/__pycache__/tracker.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/framework/tvm/tools/track/tracker.py,sha256=vgnLQbKo1IgHhgKJxC6mE_tBr0kNKrvYWk70jdHHm-k,5768 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/pipeline/__init__.py,sha256=0MoaqWsaMh3BKvTSQjekb-5fLjsJ2bGUYmFp5HyDRMo,863 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/pipeline/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/pipeline/__pycache__/config.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/pipeline/__pycache__/dynamic.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/pipeline/__pycache__/manager.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/pipeline/__pycache__/pipeline.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/pipeline/__pycache__/utils.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/pipeline/__pycache__/worker.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/pipeline/__pycache__/wrapper.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/pipeline/config.py,sha256=DgxZVhgDUFALU4yUcbViGIdhYuceuvzjICYwmYvISoE,5326 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/pipeline/dynamic.py,sha256=ZQZ8luMVy_cDpCLvlDSzIIGwUAOj7XbWB83RfUwTdBc,14848 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/pipeline/manager.py,sha256=SEGIoRi4W9Ihg60C_Z8TdH7JDWatAOkE6NlWON6QpZs,7425 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/pipeline/pipeline.py,sha256=KuacYW5HbL_JSF5EuADKgQ5DTaoO5vLJtp0wto-qf7w,27419 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/pipeline/utils.py,sha256=1-DeapNTPSMoqH4sjSY6FYPjiMBWE7e1OEdBoFXb4tE,6366 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/pipeline/worker.py,sha256=7djh_0VZlLFhn4expstka_-uzp32oV8Y2DOjWz0Wwcc,27309 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/pipeline/wrapper.py,sha256=iWLQJ3pmII8fxLZXT6myYoUcnmv-9GYtZQ5ql6sVBmQ,9267 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/plugin/__init__.py,sha256=ZIwXq-eQFJ78LOF2NXhxp7vaMP4BrMChbPJwksqQW9U,836 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/plugin/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/plugin/__pycache__/_ffi_api.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/plugin/__pycache__/build.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/plugin/__pycache__/register.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/plugin/__pycache__/utils.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/plugin/_ffi_api.py,sha256=V7-jD9v_XLNkHCBOJwwKSn93N7kCRWaHaf-IksEEBYY,884 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/plugin/build.py,sha256=ZxHOew9Ufmowvw-CKSY914iCusPMRfMx8DolNZT_lcg,9226 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/plugin/codegen/__init__.py,sha256=JFdZ8MRNEkJHeS467IOL5JGiDJPb_MoysYs6ajmvIRY,846 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/plugin/codegen/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/plugin/codegen/__pycache__/codegen.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/plugin/codegen/__pycache__/sources.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/plugin/codegen/codegen.py,sha256=h3w1nr0bWJ2-kNRTu_7EgNXtvW8gjAoEjIUjxEvzCuI,10197 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/plugin/codegen/sources.py,sha256=u3HOwzeXXbayVbW2-HLhYw_OmsCmS9IT5BORfQdFO9U,35249 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/plugin/op/__init__.py,sha256=V1p5FghEyNpA87_ftp2f6KNCEf8-t-TClM-lX0Fh0ag,817 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/plugin/op/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/plugin/op/__pycache__/_ffi_api.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/msc/plugin/op/_ffi_api.py,sha256=wwOEYOsH_r7NZvAGyHlwyyqVYwq6uHaDhNdEXqzx08w,890 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/plugin/register.py,sha256=PhxiyBDLDywZCe7c5xxEgRk20mtYrZmhPFBLVs1pruk,3124 +bitblas/3rdparty/tvm/python/tvm/contrib/msc/plugin/utils.py,sha256=m-q8ajUcvGUWvQhfDPz62sepA7etWnfzMR42nv1jfzs,2962 +bitblas/3rdparty/tvm/python/tvm/contrib/mxnet.py,sha256=QIvFlFFlZC3VV-Pwk-44kia0UIFXK14ytmuZ4qqA52E,2693 +bitblas/3rdparty/tvm/python/tvm/contrib/ndk.py,sha256=tAfVjWUhn4UTdQd4Za5H6AOzCChOgRuEROaABe9Yst4,4918 +bitblas/3rdparty/tvm/python/tvm/contrib/nnpack.py,sha256=shwgJJ3u4gSYlQ0Wl0QYQJ41WGLPPm3jE5wNbWFSwNw,7835 +bitblas/3rdparty/tvm/python/tvm/contrib/nvcc.py,sha256=QBnyCn_ly3V_KtkrGtmzPkomhDyZsGnhakzbifXcYU4,13788 +bitblas/3rdparty/tvm/python/tvm/contrib/peak.py,sha256=ay0wAhJHh7hLv6ZN_mtxfProeCpSw_obszXmLgxNmHc,11849 +bitblas/3rdparty/tvm/python/tvm/contrib/pickle_memoize.py,sha256=Yi9umD5GiNmXYwqzHGA-6I2k1ok_SIyhbCtBPp62w7A,3763 +bitblas/3rdparty/tvm/python/tvm/contrib/pipeline_executor.py,sha256=K6owVh44mVlRyubaJgH6ZfsqqqGo3n8jPxMBknbR9Eo,12024 +bitblas/3rdparty/tvm/python/tvm/contrib/pipeline_executor_build.py,sha256=49js-qA5fZjWH3WlISwLHDMShIrNnNCjJRdAG38PphE,27105 +bitblas/3rdparty/tvm/python/tvm/contrib/popen_pool.py,sha256=fjP8GcB7r_YjOd2Dpsw_vwAsVzHrMMtlAkd4oWglCko,13750 +bitblas/3rdparty/tvm/python/tvm/contrib/random.py,sha256=aTk82-xYyE3MkS9kb3mZmp4h6hI8MsbCEqF1upBcQbY,3498 +bitblas/3rdparty/tvm/python/tvm/contrib/relay_viz/__init__.py,sha256=mpHbFoor1QVfQR6LwANOcyOestkRnhxZJqsuoxi6t_o,3871 +bitblas/3rdparty/tvm/python/tvm/contrib/relay_viz/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/relay_viz/__pycache__/dot.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/relay_viz/__pycache__/interface.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/relay_viz/__pycache__/terminal.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/relay_viz/dot.py,sha256=9cLhAunf9hjm8qm5SXvCCthWhz0bfg42xDc7zc4Qu4o,7129 +bitblas/3rdparty/tvm/python/tvm/contrib/relay_viz/interface.py,sha256=j8MfUrZtjweFwP3aU0ZZdCiOK9zeYw6sDs8H0Zd8to8,10592 +bitblas/3rdparty/tvm/python/tvm/contrib/relay_viz/terminal.py,sha256=n5xFrLzf8wl4bJ03VztbLTBh53Okn7hC8A97yPFYV8s,7961 +bitblas/3rdparty/tvm/python/tvm/contrib/rocblas.py,sha256=tGl1QumEg_FKoDl5gwlAPW03080LQMJhR5t8r9OOB9E,2481 +bitblas/3rdparty/tvm/python/tvm/contrib/rocm.py,sha256=ICPVL1T121jehB_4zqeQwriP9fh58y4DI24Q60QyZyc,8589 +bitblas/3rdparty/tvm/python/tvm/contrib/rpc.py,sha256=KBug3uigP37xoJDR4Z6RFjSseFjMNq4fvVOVbfvB2kI,1144 +bitblas/3rdparty/tvm/python/tvm/contrib/sdaccel.py,sha256=KS_o_eUekIwR3fFtJ2mR4KBs8xJCtHk48U9HgN3oWpk,3086 +bitblas/3rdparty/tvm/python/tvm/contrib/sparse.py,sha256=eiCQmd021Lid9Xiq3MwJXVTurybYdeLquUuMJuLop6A,7089 +bitblas/3rdparty/tvm/python/tvm/contrib/spirv.py,sha256=aWs6nX06qNv3--WnSulR4_b3GH8wHGpjyXUdRXDve7M,1864 +bitblas/3rdparty/tvm/python/tvm/contrib/stackvm.py,sha256=gszmcr_tsrx3C15U9J7X_sdXDRCLvmblXasA65kOx-I,1428 +bitblas/3rdparty/tvm/python/tvm/contrib/tar.py,sha256=Jckuz0XCVnJzYdT389KOn12js8flrsI03qi5UKpyP98,3647 +bitblas/3rdparty/tvm/python/tvm/contrib/target/__init__.py,sha256=9hdXHABrVpkbpjZgUft39kOFL2xSGeG4GEua0Hmelus,785 +bitblas/3rdparty/tvm/python/tvm/contrib/target/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/target/__pycache__/__init__.cpython-310.pyc,sha256=QHlrMQcG963-1D_PI2v5y1e_VVYbmzaGSDvPdBp90bw,168 +bitblas/3rdparty/tvm/python/tvm/contrib/target/__pycache__/__init__.cpython-38.pyc,sha256=mOH96vbZpLXn59-NMbnoZeZtlmHJw8zLbVshZLoT7Ls,155 +bitblas/3rdparty/tvm/python/tvm/contrib/target/__pycache__/coreml.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/target/__pycache__/coreml.cpython-310.pyc,sha256=43Gp1F-Er2gUh-rUfo_zmiSM0GWbrCDMrhVeiD4Ia_w,7152 +bitblas/3rdparty/tvm/python/tvm/contrib/target/__pycache__/coreml.cpython-38.pyc,sha256=xHmW50JsZ3Lr_qSNVO8PbCvd7ZYaKcq2Z7-IMBpfXVw,7123 +bitblas/3rdparty/tvm/python/tvm/contrib/target/__pycache__/onnx.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/target/__pycache__/vitis_ai.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/target/__pycache__/vitis_ai.cpython-310.pyc,sha256=Bf8pmgw0p458d73K0xsEVB1TEB_0oLfbpkTLDzVM6ws,5430 +bitblas/3rdparty/tvm/python/tvm/contrib/target/coreml.py,sha256=QeCfYaQ9XY8dAHKsduFCuCRXerW_lCE2yWK7W2E79DQ,8042 +bitblas/3rdparty/tvm/python/tvm/contrib/target/onnx.py,sha256=bjooj7B3ZkaJgCeW447jn7jx7tudlA-K3eljB48KWX4,38189 +bitblas/3rdparty/tvm/python/tvm/contrib/target/vitis_ai.py,sha256=hVV1BMQ5nft7kQaKtOCyG9sKfj7UgE57I1PNN4tz3nQ,9073 +bitblas/3rdparty/tvm/python/tvm/contrib/tedd.py,sha256=nS94NF0yHnDt5t_mB6yWtaRisFSRJPUplOh2A9-wkjw,28579 +bitblas/3rdparty/tvm/python/tvm/contrib/tf_op/__init__.py,sha256=XfBafdZ1xMZZh1eXvzdVAVCPNhcL1MDkoVath7BHt7U,881 +bitblas/3rdparty/tvm/python/tvm/contrib/tf_op/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/tf_op/__pycache__/module.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/tf_op/module.py,sha256=ZK67DDHidRt4kDshGbvvp4uS26VddvU44NyFCyzHB-A,4901 +bitblas/3rdparty/tvm/python/tvm/contrib/tflite_runtime.py,sha256=G2l6Q1eS2Sl4A-B4V0KBZx1UfmESSg60Aq49ZAmvG3M,3725 +bitblas/3rdparty/tvm/python/tvm/contrib/thrust.py,sha256=ty2CzC5_hFJcb2jsQ5W8THF9wDf7-EbgdORr5hlE5co,1536 +bitblas/3rdparty/tvm/python/tvm/contrib/torch/__init__.py,sha256=4q4ZEwL0AulTpWOX9OG4ECpWdfTpsU3w5jplVR7kLDA,2535 +bitblas/3rdparty/tvm/python/tvm/contrib/torch/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/torch/__pycache__/as_torch.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/torch/__pycache__/module.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/torch/__pycache__/optimize_torch.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/torch/__pycache__/pytorch_tvm.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/contrib/torch/as_torch.py,sha256=75bmWDj7zIXtEOMOyf0d7kr7d4y9KPCQ3jhmo1Mppoo,5465 +bitblas/3rdparty/tvm/python/tvm/contrib/torch/module.py,sha256=uKdndJH7VyjuLQDoJ_EmnYNSlsBg9AHk_kA47m-xTO0,4823 +bitblas/3rdparty/tvm/python/tvm/contrib/torch/optimize_torch.py,sha256=f1enhFxyfyHcsfTvegk7AZvICCnwNwf5MTThbUyMr8c,6518 +bitblas/3rdparty/tvm/python/tvm/contrib/torch/pytorch_tvm.py,sha256=-iNtbTZoVFliwKyeTGBr48Z_NObTQRX10dFPM1wLwL4,11168 +bitblas/3rdparty/tvm/python/tvm/contrib/tvmjs.py,sha256=TZKbFsgw77HZTfkockJdTBs2VW2YD7pP1mtwlyGCv7U,11904 +bitblas/3rdparty/tvm/python/tvm/contrib/utils.py,sha256=R2AfBLQfC7TR5d6bLPQmljS4GFc4R3R8sAs6oVivv5A,7354 +bitblas/3rdparty/tvm/python/tvm/contrib/xcode.py,sha256=OPnu2gH5nGqk2IhCDOQYG32W3BnYBdNjgQWLNVntCxo,5618 +bitblas/3rdparty/tvm/python/tvm/dlight/__init__.py,sha256=N3u6AvuiTsYUdt-N7SOrIBXaggy7hLmAF-s5Rc8G1AU,1064 +bitblas/3rdparty/tvm/python/tvm/dlight/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/dlight/__pycache__/__init__.cpython-310.pyc,sha256=FaJL5bPCJVh7E5DQMTD7vZsFTLtvrzk2V-4rHkWNbt4,490 +bitblas/3rdparty/tvm/python/tvm/dlight/__pycache__/__init__.cpython-38.pyc,sha256=v1E4swRR7rk_7968bY4YvWChvBfzEooMvUWZ5A5v3UQ,477 +bitblas/3rdparty/tvm/python/tvm/dlight/base/__init__.py,sha256=x0wbzhtpP_wmR4OIpWEkcL23BsyQNEl4T0FGf7ewQ-g,1178 +bitblas/3rdparty/tvm/python/tvm/dlight/base/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/dlight/base/__pycache__/__init__.cpython-310.pyc,sha256=O7fej6JkMAU074RkDoEspEhfYiJjqxnnuzi31CSb2LY,638 +bitblas/3rdparty/tvm/python/tvm/dlight/base/__pycache__/__init__.cpython-38.pyc,sha256=7AEU_sSijl-W9UG_Kv-0O7gI2IgrklqDpDHzzDXH7KM,625 +bitblas/3rdparty/tvm/python/tvm/dlight/base/__pycache__/analysis.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/dlight/base/__pycache__/analysis.cpython-310.pyc,sha256=YTVm15FB1uhUmBegoxYi1o32330kemX0Y2lG0YRVxmI,9563 +bitblas/3rdparty/tvm/python/tvm/dlight/base/__pycache__/analysis.cpython-38.pyc,sha256=7SAlzExeKgAuCPD0q2PXf8rbt2Z_VOW3ZAxWcCqX1KQ,9648 +bitblas/3rdparty/tvm/python/tvm/dlight/base/__pycache__/common_schedules.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/dlight/base/__pycache__/common_schedules.cpython-310.pyc,sha256=E6nCVwDvfySSRZ5JuIM9tlrlh0jnoYoxKG3coqlBpng,1973 +bitblas/3rdparty/tvm/python/tvm/dlight/base/__pycache__/common_schedules.cpython-38.pyc,sha256=jDzj-0DrknGE7xUrpdknCKOrHYtqEKdKKqOr09PXGog,1957 +bitblas/3rdparty/tvm/python/tvm/dlight/base/__pycache__/schedule_rule.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/dlight/base/__pycache__/schedule_rule.cpython-310.pyc,sha256=NG8oElPkW7b9zapvIuVa3L2hUCfUF8ta3EPoS0Qzve0,4058 +bitblas/3rdparty/tvm/python/tvm/dlight/base/__pycache__/schedule_rule.cpython-38.pyc,sha256=ZP8TVCez3cwWJiABzOsO0pxfuibM4BCyeHCFcZPdQF8,4011 +bitblas/3rdparty/tvm/python/tvm/dlight/base/__pycache__/transform.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/dlight/base/__pycache__/transform.cpython-310.pyc,sha256=wI4qhIGDdOkLJPnPE_DquEM-ueo3GQ0llJetH1e78l8,2373 +bitblas/3rdparty/tvm/python/tvm/dlight/base/__pycache__/transform.cpython-38.pyc,sha256=vA1Fc_q6rmPq6jIoywD-08DstRcO6-Jk5rbfkSNeED4,2360 +bitblas/3rdparty/tvm/python/tvm/dlight/base/analysis.py,sha256=BTptDz8owV2BlGE88uizuj_MxvTW_wefj6hhYUXVa4s,8814 +bitblas/3rdparty/tvm/python/tvm/dlight/base/common_schedules.py,sha256=u5_M0elFb4VnqggR-bSwQDgN_K7nAJbqsVaE65M2v5U,2805 +bitblas/3rdparty/tvm/python/tvm/dlight/base/schedule_rule.py,sha256=nXso6Oj4E5K-NS7aQR7JPi5ia6mpH9TfbYQex7vPJ7Q,4271 +bitblas/3rdparty/tvm/python/tvm/dlight/base/transform.py,sha256=SDsKer9pbBnctI8KqQUuZdFwcuJECtpOP40mz-EgnRc,2945 +bitblas/3rdparty/tvm/python/tvm/dlight/benchmark/__init__.py,sha256=a9NT8nCXh1gfj0e2099m0T52OUgpkD76rEjzrIG05To,1048 +bitblas/3rdparty/tvm/python/tvm/dlight/benchmark/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/dlight/benchmark/__pycache__/bench.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/dlight/benchmark/__pycache__/extract.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/dlight/benchmark/__pycache__/utils.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/dlight/benchmark/bench.py,sha256=M2L3aY1_KdmHOHTO8JfXGEwObWm5Tv3gwQMAodi74Ro,12901 +bitblas/3rdparty/tvm/python/tvm/dlight/benchmark/extract.py,sha256=QN_N2kp1NEMbUXXhTHjxUI0B4RTyn_sBZR93yCMVa30,12881 +bitblas/3rdparty/tvm/python/tvm/dlight/benchmark/utils.py,sha256=mCR4tDw-Hojv8utPq0KT-1CDOJRzaEGa3FRFguHRDyA,5952 +bitblas/3rdparty/tvm/python/tvm/dlight/gpu/__init__.py,sha256=hmgp4tGvMy1jbTn1bc6e2Ju1QXNQOCswK53U3Os8EoY,1177 +bitblas/3rdparty/tvm/python/tvm/dlight/gpu/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/dlight/gpu/__pycache__/__init__.cpython-310.pyc,sha256=mWnRL8A92dEky8c2BTjiRlQCrN6dCu3S_7GJWc-FoBw,646 +bitblas/3rdparty/tvm/python/tvm/dlight/gpu/__pycache__/__init__.cpython-38.pyc,sha256=kQEIsw_2BNYw9DxcpcrYcztDOTno_bNbeJ2dMVuIt9k,633 +bitblas/3rdparty/tvm/python/tvm/dlight/gpu/__pycache__/base.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/dlight/gpu/__pycache__/base.cpython-310.pyc,sha256=MJ8T3PiDBZUxVNphW476RPiEPhWX4LQS1ez1yt6HQGk,1111 +bitblas/3rdparty/tvm/python/tvm/dlight/gpu/__pycache__/base.cpython-38.pyc,sha256=jjr3kQ9OTv9tiRSYPjd_k-0n52cbukxe0leOvODPQOk,1096 +bitblas/3rdparty/tvm/python/tvm/dlight/gpu/__pycache__/fallback.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/dlight/gpu/__pycache__/fallback.cpython-310.pyc,sha256=xBh6RNpP2deIhOWkFph5gnsrSHetB_CHyTyMC0-wWcQ,2077 +bitblas/3rdparty/tvm/python/tvm/dlight/gpu/__pycache__/fallback.cpython-38.pyc,sha256=ow0EXXWi93M4KIpssi-IPYq_honjMlUu2_rW86jabOU,2040 +bitblas/3rdparty/tvm/python/tvm/dlight/gpu/__pycache__/gemv.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/dlight/gpu/__pycache__/gemv.cpython-310.pyc,sha256=zNxAGCmlfwJB6xSlLgwfZqA2Nk4KhZAL8lmN6fseWi4,11697 +bitblas/3rdparty/tvm/python/tvm/dlight/gpu/__pycache__/gemv.cpython-38.pyc,sha256=bZpAANg_VN1l-AqK8GBkvb1XXoyuSOpi9pGQ1CuLhyI,11728 +bitblas/3rdparty/tvm/python/tvm/dlight/gpu/__pycache__/general_reduction.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/dlight/gpu/__pycache__/general_reduction.cpython-310.pyc,sha256=KOlo20eD8-EmbDxGc1EsV6yMlaLcQ4kBDg8FfiS2NHE,2962 +bitblas/3rdparty/tvm/python/tvm/dlight/gpu/__pycache__/general_reduction.cpython-38.pyc,sha256=dBcjj2fnHtKxEG43Xg34RIrTafgM7QQiqXdFQBast0A,2951 +bitblas/3rdparty/tvm/python/tvm/dlight/gpu/__pycache__/low_batch_gemv.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/dlight/gpu/__pycache__/low_batch_gemv.cpython-310.pyc,sha256=68vysydBFz3IcJkubZDt1uQQWb_60erpMJ18fcKcqJw,13525 +bitblas/3rdparty/tvm/python/tvm/dlight/gpu/__pycache__/low_batch_gemv.cpython-38.pyc,sha256=nveHhTXygMcjQ-pwkCZxNG9T3lw7mf4qEIJTTgBB18M,13607 +bitblas/3rdparty/tvm/python/tvm/dlight/gpu/__pycache__/matmul.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/dlight/gpu/__pycache__/matmul.cpython-310.pyc,sha256=qSu8ZqdDqDYdD80HkG1azmTQHQl13A4V3D2hF4GKj9Y,20416 +bitblas/3rdparty/tvm/python/tvm/dlight/gpu/__pycache__/matmul.cpython-38.pyc,sha256=iirYzRQdyui7R-yQ7FSuB327LdM1wp0LtMsai2CNlyk,20876 +bitblas/3rdparty/tvm/python/tvm/dlight/gpu/__pycache__/reduction.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/dlight/gpu/__pycache__/reduction.cpython-310.pyc,sha256=C2TbYZOi5cBwYqkQbjzdMxN9iIwgDF2m4MyywMmfZW8,6712 +bitblas/3rdparty/tvm/python/tvm/dlight/gpu/__pycache__/reduction.cpython-38.pyc,sha256=0HPxnvAHklS4crwlsXAqZfs0eGkRvTsskmX2zFF0Ahk,6782 +bitblas/3rdparty/tvm/python/tvm/dlight/gpu/__pycache__/rmsnorm.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/dlight/gpu/__pycache__/rmsnorm.cpython-310.pyc,sha256=JQRXREmzkBZdsK9JkGbGoCJw99dXHzVjHV6oXz_ld9w,3099 +bitblas/3rdparty/tvm/python/tvm/dlight/gpu/__pycache__/rmsnorm.cpython-38.pyc,sha256=J4J7aAUht_KvPBAZ8CqcJSIC9AEUAgy1KlO2go5zA5w,3074 +bitblas/3rdparty/tvm/python/tvm/dlight/gpu/__pycache__/transpose.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/dlight/gpu/__pycache__/transpose.cpython-310.pyc,sha256=9ANhzCxgcyP056orB0PPsOQytTpeSqyT_H92iivvPco,3359 +bitblas/3rdparty/tvm/python/tvm/dlight/gpu/__pycache__/transpose.cpython-38.pyc,sha256=BSPILFLURXXLOz2duvFrCOOTyC1bDquG_d4m7AnpuOw,3356 +bitblas/3rdparty/tvm/python/tvm/dlight/gpu/__pycache__/utils.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/dlight/gpu/__pycache__/utils.cpython-310.pyc,sha256=y40HG3UJE-UTfOuOuA7IVojIJYKVp5uF16_JSWpiMeE,1785 +bitblas/3rdparty/tvm/python/tvm/dlight/gpu/__pycache__/utils.cpython-38.pyc,sha256=QLH8v5vmSnokWds1xbfTVFQiIPkci9N6gn0Vt6Oc9lE,1758 +bitblas/3rdparty/tvm/python/tvm/dlight/gpu/base.py,sha256=DT1RDRDGUbAJwgds2loAiJt2HrFLA3FQWmvWgJsO2gA,1506 +bitblas/3rdparty/tvm/python/tvm/dlight/gpu/fallback.py,sha256=tGzrJLCa9HiqDHW32-min8HfhFj2ANZd9Cka8-OPwEo,3278 +bitblas/3rdparty/tvm/python/tvm/dlight/gpu/gemv.py,sha256=2XKYAwXIPF1AUAGcDQDQJyX6uP4khZ_U0E6EfDyCwXI,21670 +bitblas/3rdparty/tvm/python/tvm/dlight/gpu/general_reduction.py,sha256=f0H0YLgTlNbWCuFAipod1dyEuzLRMtN8Q6LWBRHRXkU,5508 +bitblas/3rdparty/tvm/python/tvm/dlight/gpu/low_batch_gemv.py,sha256=GyGjgXL-G0R8KaBomcwzzz2tzlBtX1oteCs-1Or7DSU,22792 +bitblas/3rdparty/tvm/python/tvm/dlight/gpu/matmul.py,sha256=dlVuQVWLmwuccUlc16CUHeI-TNLUWML4lJ-5a2lZCRc,33890 +bitblas/3rdparty/tvm/python/tvm/dlight/gpu/reduction.py,sha256=hhi8OF-3DR1MSarTjnhGrRl57u9f_JxoI9TlmGMXBPo,11545 +bitblas/3rdparty/tvm/python/tvm/dlight/gpu/rmsnorm.py,sha256=kMgd5S0dchL6YaxMajce63d4316I5hgBA_T3YH4fB9Q,4642 +bitblas/3rdparty/tvm/python/tvm/dlight/gpu/transpose.py,sha256=APDrqD0A3jP0WX5dSiaNPDUcWt1aUKX5QVZQznRgySE,4925 +bitblas/3rdparty/tvm/python/tvm/dlight/gpu/utils.py,sha256=VUjAmM9p99MoPFLaKGehKtgtchDZhIZuVOG3ktAI9ac,2848 +bitblas/3rdparty/tvm/python/tvm/driver/__init__.py,sha256=5yxEhzIY_TaD6EmebrMuaojUCtoP9W4t1HIvVCHQ5LI,856 +bitblas/3rdparty/tvm/python/tvm/driver/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/driver/__pycache__/__init__.cpython-310.pyc,sha256=KMH5zKUlhgUhU9xZmSobkbtgL012L1cxmUjrWbiLKNc,260 +bitblas/3rdparty/tvm/python/tvm/driver/__pycache__/__init__.cpython-38.pyc,sha256=Mneg5Tfdv6FGd48jDv9a2NNZ3iOy2VUODtAuhfMSU9A,247 +bitblas/3rdparty/tvm/python/tvm/driver/__pycache__/_ffi_api.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/driver/__pycache__/_ffi_api.cpython-310.pyc,sha256=_wxZwncdrIdlPHCxeRpuhK51zhf1mT6S94b9tXmPUr8,276 +bitblas/3rdparty/tvm/python/tvm/driver/__pycache__/_ffi_api.cpython-38.pyc,sha256=DDtc37j_wUui7ROka3j2GTdvJ_JxElB1ebhP5PSJrnk,263 +bitblas/3rdparty/tvm/python/tvm/driver/__pycache__/build_module.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/driver/__pycache__/build_module.cpython-310.pyc,sha256=FDA9o-fL609GVytXQtC27X3sc7uPNWFEv6OseMuBeNY,10082 +bitblas/3rdparty/tvm/python/tvm/driver/__pycache__/build_module.cpython-38.pyc,sha256=dFuMPbFoZBCoCGlcrJtiQJ8-njhGcZxcDYpKEMh5QQA,10057 +bitblas/3rdparty/tvm/python/tvm/driver/_ffi_api.py,sha256=E4hm-TGI57DzYZX2l7bB3W7vVGSjI78aaoTgDl4qpVo,871 +bitblas/3rdparty/tvm/python/tvm/driver/build_module.py,sha256=B7ww5GwA3Oj6NQKZwVkeYRe5HaC7DXT-cXq2gExrNcs,12807 +bitblas/3rdparty/tvm/python/tvm/driver/tvmc/__init__.py,sha256=YjKZxWlq1i8HFw5VK0tUJr3w-8ef6402FSiZPs8qhRY,1362 +bitblas/3rdparty/tvm/python/tvm/driver/tvmc/__main__.py,sha256=zSK7XaE3JondgpXeqzZr6ax38dhYMs4dSIl7xge38ZA,912 +bitblas/3rdparty/tvm/python/tvm/driver/tvmc/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/driver/tvmc/__pycache__/__init__.cpython-310.pyc,sha256=UN36fFk8r_Fh4ifBdBWoNPcrYZ4wE9Svpg6t6RMiAu8,974 +bitblas/3rdparty/tvm/python/tvm/driver/tvmc/__pycache__/__main__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/driver/tvmc/__pycache__/arguments.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/driver/tvmc/__pycache__/arguments.cpython-310.pyc,sha256=8gpZ7Sy0-6pm6190FTOxt4_vvmVlyUhyFvVInC8qG8Q,1422 +bitblas/3rdparty/tvm/python/tvm/driver/tvmc/__pycache__/autotuner.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/driver/tvmc/__pycache__/autotuner.cpython-310.pyc,sha256=5jQXEL7wUQQoQ0SFGDXT7etzRJ_YQ1UTHOSdYHXbHq8,22698 +bitblas/3rdparty/tvm/python/tvm/driver/tvmc/__pycache__/compiler.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/driver/tvmc/__pycache__/compiler.cpython-310.pyc,sha256=DxaPb4N5-HnOyW9mLQ18SFH1B2n0Sirzz2xpDT4zISs,20446 +bitblas/3rdparty/tvm/python/tvm/driver/tvmc/__pycache__/composite_target.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/driver/tvmc/__pycache__/composite_target.cpython-310.pyc,sha256=ubJDTplUz0kxhodiVDG8ihXfRFhi6Pkc3M5W2tJe8aI,2072 +bitblas/3rdparty/tvm/python/tvm/driver/tvmc/__pycache__/config_options.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/driver/tvmc/__pycache__/config_options.cpython-310.pyc,sha256=QykSmPnyW4a_-GkZtTXby4sCqRTc5022MmrCnHLgAxI,4625 +bitblas/3rdparty/tvm/python/tvm/driver/tvmc/__pycache__/fmtopt.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/driver/tvmc/__pycache__/fmtopt.cpython-310.pyc,sha256=6sq1gi8EjSOQMg6_Gcy5vNbSMncK4LfEuC39eaNwOu0,1892 +bitblas/3rdparty/tvm/python/tvm/driver/tvmc/__pycache__/frontends.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/driver/tvmc/__pycache__/frontends.cpython-310.pyc,sha256=YksITHHXB0Z0U4W6HddNOfGPo0RAN778Y8u9mbnKH4g,14281 +bitblas/3rdparty/tvm/python/tvm/driver/tvmc/__pycache__/main.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/driver/tvmc/__pycache__/main.cpython-310.pyc,sha256=LvlBCcJf--qCrlBQGndkFL5THhmKlWJZdck4fo-t1Ko,2722 +bitblas/3rdparty/tvm/python/tvm/driver/tvmc/__pycache__/micro.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/driver/tvmc/__pycache__/micro.cpython-310.pyc,sha256=207MOdYPrHbQxfnQVBAa4zXQOWug-URVuFZsXTkq-ms,7149 +bitblas/3rdparty/tvm/python/tvm/driver/tvmc/__pycache__/model.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/driver/tvmc/__pycache__/model.cpython-310.pyc,sha256=coVC-ao1CPnk3GFdG-AI1AGZ1qqvkZoZqMl69vXJvLE,16076 +bitblas/3rdparty/tvm/python/tvm/driver/tvmc/__pycache__/pass_config.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/driver/tvmc/__pycache__/pass_config.cpython-310.pyc,sha256=i1cYfnm-Vx_yQtk1k3hYEg8DZEfIevvP0LOOUq5CZrY,4059 +bitblas/3rdparty/tvm/python/tvm/driver/tvmc/__pycache__/pass_list.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/driver/tvmc/__pycache__/pass_list.cpython-310.pyc,sha256=WGgmDyWGk8z8dn4Sm-TEe2V1fqmSe33KoR47sHhZI_w,1366 +bitblas/3rdparty/tvm/python/tvm/driver/tvmc/__pycache__/project.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/driver/tvmc/__pycache__/project.cpython-310.pyc,sha256=nmzngiMrvOhLg84gtUSN9ZIOXqlgmjNeEZ0xTw4KMGA,6206 +bitblas/3rdparty/tvm/python/tvm/driver/tvmc/__pycache__/registry.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/driver/tvmc/__pycache__/registry.cpython-310.pyc,sha256=KIYXAbF2cARM8WwLaDkZYieTFh6yQOhfteXLYw-DDVg,2449 +bitblas/3rdparty/tvm/python/tvm/driver/tvmc/__pycache__/result_utils.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/driver/tvmc/__pycache__/result_utils.cpython-310.pyc,sha256=F6GjGzBnPUTMd3RyH-R9YKpC3VQNaeMVuyUE_Mo4o8Q,1529 +bitblas/3rdparty/tvm/python/tvm/driver/tvmc/__pycache__/runner.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/driver/tvmc/__pycache__/runner.cpython-310.pyc,sha256=-1qdSvNZQVc8-52Zlwga_KHlLZf-F9bCrQbh8WpWZ5Y,17903 +bitblas/3rdparty/tvm/python/tvm/driver/tvmc/__pycache__/shape_parser.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/driver/tvmc/__pycache__/shape_parser.cpython-310.pyc,sha256=YbqmPLtDU0ijczbKiKEgEFyTwOJXUitLUHC0JC-kXDs,1565 +bitblas/3rdparty/tvm/python/tvm/driver/tvmc/__pycache__/target.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/driver/tvmc/__pycache__/target.cpython-310.pyc,sha256=tx54DVFC_nr2hfIr82gVImxcz3UsWssFQczDXiGa30Y,10725 +bitblas/3rdparty/tvm/python/tvm/driver/tvmc/__pycache__/tracker.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/driver/tvmc/__pycache__/tracker.cpython-310.pyc,sha256=AO5ExETzULqMSiPKMmI5J2SbNUzaFJOzk8Ct4F5Ij6Q,1202 +bitblas/3rdparty/tvm/python/tvm/driver/tvmc/__pycache__/transform.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/driver/tvmc/__pycache__/transform.cpython-310.pyc,sha256=faSbrzr2lWEWgEIBqbIbUVpAHFDW7lXx00OxdX88wuc,7019 +bitblas/3rdparty/tvm/python/tvm/driver/tvmc/__pycache__/workspace_pools.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/driver/tvmc/__pycache__/workspace_pools.cpython-310.pyc,sha256=sBwnI80qJYV-FMGOo9uU6cyBa2rKmeLlSfcTMKmkJGE,6702 +bitblas/3rdparty/tvm/python/tvm/driver/tvmc/arguments.py,sha256=bvuoI_POpzxu17QEOx56GQ4e_Zzimv25FZd1Kpwplok,2586 +bitblas/3rdparty/tvm/python/tvm/driver/tvmc/autotuner.py,sha256=ndhYCcf3HurCPvaOUtV-cRHfO07cZVZp1m3pQoYZir4,31628 +bitblas/3rdparty/tvm/python/tvm/driver/tvmc/compiler.py,sha256=ufNn90tyJA9G48uSNopsj24ZM8XyysOq_GFR3-QyCLs,29029 +bitblas/3rdparty/tvm/python/tvm/driver/tvmc/composite_target.py,sha256=3rAsG4ZVGfHNkhgtR2HrAz1naw3DRJeIMXNvbjcq0M8,3440 +bitblas/3rdparty/tvm/python/tvm/driver/tvmc/config_options.py,sha256=5Y0j5bvq2r0CXp74v5vPEPyNujv3YWZaAGgg3GkPC5I,6464 +bitblas/3rdparty/tvm/python/tvm/driver/tvmc/fmtopt.py,sha256=ra-eyeRGZNHZsMINxHtM45MHVlw0xY9A3Pwa5YiDu_Y,4074 +bitblas/3rdparty/tvm/python/tvm/driver/tvmc/frontends.py,sha256=PmditnsLQgae6LJmCbgmxaClbnLoQ7qZ9rjkD2dOYH0,14237 +bitblas/3rdparty/tvm/python/tvm/driver/tvmc/main.py,sha256=oOrzwJkhI-3hIHkOHEVmOwjLeQe5U6rUK7vC27ibT60,3853 +bitblas/3rdparty/tvm/python/tvm/driver/tvmc/micro.py,sha256=_-X0vhulS0WLFYEcbPZfkcGxs2r90d0BHO-UFeuAEq8,11318 +bitblas/3rdparty/tvm/python/tvm/driver/tvmc/model.py,sha256=sMaLdK-0n5nE94q1jsSdgH7WT5j9tPu1HifglNJyZDU,19344 +bitblas/3rdparty/tvm/python/tvm/driver/tvmc/pass_config.py,sha256=uainLWA2LbiCCoNXh7Owu73t3BbgP2eXEBu12obxFwQ,6850 +bitblas/3rdparty/tvm/python/tvm/driver/tvmc/pass_list.py,sha256=yLiOP4zPDaAChhUSryqiqnlq7IjAt8BLwvT1cmH10QE,1748 +bitblas/3rdparty/tvm/python/tvm/driver/tvmc/project.py,sha256=mVG64eNXQ-Xk_kEBM4Or9YXUd3PAH0XYOeiOYm2iEMU,8132 +bitblas/3rdparty/tvm/python/tvm/driver/tvmc/registry.py,sha256=7JeQSRaaNq9zYaxyRiDBgBU4CCGfipF9qG9JUisD-gQ,3863 +bitblas/3rdparty/tvm/python/tvm/driver/tvmc/result_utils.py,sha256=vCo3G22_Yyv8p7H6KSPawSBuxDampZFe5f8dPbMQ1YU,2072 +bitblas/3rdparty/tvm/python/tvm/driver/tvmc/runner.py,sha256=QBzCes8OsuwBJgSAi7IxKEx52jkNADxXBftmK7WNpJI,26506 +bitblas/3rdparty/tvm/python/tvm/driver/tvmc/shape_parser.py,sha256=AsllrH_6EaciZQbDLRGfZs7hwitGfBAhKTUFCBaeGiA,2590 +bitblas/3rdparty/tvm/python/tvm/driver/tvmc/target.py,sha256=Mwm5mqpJ8ptV0KP9u8VipfBVzaA0wZub_UQVucPjwug,14781 +bitblas/3rdparty/tvm/python/tvm/driver/tvmc/tracker.py,sha256=SpY9O-T_r4J0nFkpKnca7p02xzwbgp_2O_GHoDjvisM,1840 +bitblas/3rdparty/tvm/python/tvm/driver/tvmc/transform.py,sha256=wiLx4nd1h1Zyxx4UINSk598zqjgXq-My1J4N6e9z-BM,8154 +bitblas/3rdparty/tvm/python/tvm/driver/tvmc/workspace_pools.py,sha256=FUhBPZAfnXLQorMoty9XwWHrIXr-f6bmy-QuA0GZUsM,8938 +bitblas/3rdparty/tvm/python/tvm/error.py,sha256=el92sF1U4j_IRsR5Ra6MKbxKCG87l8MJFdlkVzrjpFE,3728 +bitblas/3rdparty/tvm/python/tvm/exec/__init__.py,sha256=VT2rq_Q4GLN5znpgtbRKVrMTIhg4WT1LOKvTgpslngg,857 +bitblas/3rdparty/tvm/python/tvm/exec/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/exec/__pycache__/__init__.cpython-310.pyc,sha256=kI1_ajEI1bgwL0RxMOCdcpum9jTP3-Ep0dU6iOKH6cE,224 +bitblas/3rdparty/tvm/python/tvm/exec/__pycache__/autotvm_log_editor.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/exec/__pycache__/disco_worker.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/exec/__pycache__/gpu_memory_bandwidth.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/exec/__pycache__/measure_peak.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/exec/__pycache__/microtvm_debug_shell.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/exec/__pycache__/popen_worker.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/exec/__pycache__/popen_worker.cpython-310.pyc,sha256=R1eUuBbuV67i5-wkAmDnPfHkSaZ6iMkhEUUHC9qCFg0,2517 +bitblas/3rdparty/tvm/python/tvm/exec/__pycache__/query_rpc_tracker.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/exec/__pycache__/rpc_proxy.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/exec/__pycache__/rpc_server.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/exec/__pycache__/rpc_tracker.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/exec/autotvm_log_editor.py,sha256=1j0NJ1bOPNWv59BlAfGOgicVrC-GaRze-UHK1NJhSqM,2419 +bitblas/3rdparty/tvm/python/tvm/exec/disco_worker.py,sha256=6Ey1Fr004x8XhxA4-sMrSkXsWJXCk0cheZ-9CN7i2bY,3818 +bitblas/3rdparty/tvm/python/tvm/exec/gpu_memory_bandwidth.py,sha256=-qyJDVmYc3ejDotD9XRQsJv2Ftnqe1EYVuAleTJNS28,8092 +bitblas/3rdparty/tvm/python/tvm/exec/measure_peak.py,sha256=85YDJaEli1VsI7dw202MjvpX8FCX5b_TIf-Wl7aKFzQ,1969 +bitblas/3rdparty/tvm/python/tvm/exec/microtvm_debug_shell.py,sha256=Cx2GtnHJ0ocozOBgX1fY_-xU-D1qHl_733VUzgG_zVc,5790 +bitblas/3rdparty/tvm/python/tvm/exec/popen_worker.py,sha256=7pGZPP3A4Ji1w7tTTwocWyCUXyKPcsau5cHfEGlJLh0,3340 +bitblas/3rdparty/tvm/python/tvm/exec/query_rpc_tracker.py,sha256=EdZAV-yDNVeaEpphjVlxp0s1L2jFIbxKXR8dVReCy-E,1723 +bitblas/3rdparty/tvm/python/tvm/exec/rpc_proxy.py,sha256=iA58vk4h1xesksq9X0VMRzS4CKWiNrRJOYPxzPQ1Jjk,4199 +bitblas/3rdparty/tvm/python/tvm/exec/rpc_server.py,sha256=xCK1CSFESEh40MwGgzAgGrYlhc1SwFCZUN4oHuP2NEk,3616 +bitblas/3rdparty/tvm/python/tvm/exec/rpc_tracker.py,sha256=KpMpgoGpako43AeL_MrYRirVZgZn8gvSzKPvHmgNXJ8,1658 +bitblas/3rdparty/tvm/python/tvm/generic.py,sha256=PiGQlyad5PNbZZyeLqFrwUVQH7iGglq78ARPQRQOng0,894 +bitblas/3rdparty/tvm/python/tvm/ir/__init__.py,sha256=PrSiDd2rxgsX2DeEYT41N3L4t6aOWTfpLmiMdvl_Tng,2001 +bitblas/3rdparty/tvm/python/tvm/ir/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/ir/__pycache__/__init__.cpython-310.pyc,sha256=_N3tXV015v4-i0Qw_iEH5NRlgaekpTBa-Xj7enr5f8g,1746 +bitblas/3rdparty/tvm/python/tvm/ir/__pycache__/__init__.cpython-38.pyc,sha256=uFhH3zqhqrKz3azr79csce8RSdcnJkXSw2gUipgLJaU,1733 +bitblas/3rdparty/tvm/python/tvm/ir/__pycache__/_ffi_api.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/ir/__pycache__/_ffi_api.cpython-310.pyc,sha256=2HhDSD46tnXFG3i324o7ioGIduYt_vZWsPAQXgGP46Y,264 +bitblas/3rdparty/tvm/python/tvm/ir/__pycache__/_ffi_api.cpython-38.pyc,sha256=ecwsugHl5WwM1euCbunKhD6ZEbgEblDTa3W35dKmwLU,251 +bitblas/3rdparty/tvm/python/tvm/ir/__pycache__/_ffi_instrument_api.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/ir/__pycache__/_ffi_instrument_api.cpython-310.pyc,sha256=xciCsBiOoU4rjM3Jidwk9aIAnhC8wpDFidx9QbRq7LI,291 +bitblas/3rdparty/tvm/python/tvm/ir/__pycache__/_ffi_instrument_api.cpython-38.pyc,sha256=drkj2hWlzuafPLWuhR5LOlsuRhlKb_OLSGTicqp1l1Q,278 +bitblas/3rdparty/tvm/python/tvm/ir/__pycache__/_ffi_transform_api.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/ir/__pycache__/_ffi_transform_api.cpython-310.pyc,sha256=iHwTqiKC_HGXvANwH6ZFoElUj0WLjeCi7XkuoeBhe1U,288 +bitblas/3rdparty/tvm/python/tvm/ir/__pycache__/_ffi_transform_api.cpython-38.pyc,sha256=dUlHWbHla5Nm2qDDs1soPzgOGzklmW8US72AQtlLmtw,275 +bitblas/3rdparty/tvm/python/tvm/ir/__pycache__/adt.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/ir/__pycache__/adt.cpython-310.pyc,sha256=hINqVdqqNlQz26ah3kNbKCzBceHdoASBy5BsCCrE86w,2465 +bitblas/3rdparty/tvm/python/tvm/ir/__pycache__/adt.cpython-38.pyc,sha256=OJCGE0kwco-yelSvBBp9YVfV11VP_n09iF81zCiWYyg,2472 +bitblas/3rdparty/tvm/python/tvm/ir/__pycache__/affine_type.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/ir/__pycache__/affine_type.cpython-310.pyc,sha256=DBcigPAKkivLUj0XX4YiKbfNvdqw8LbrmSLfl70cI5k,2272 +bitblas/3rdparty/tvm/python/tvm/ir/__pycache__/affine_type.cpython-38.pyc,sha256=3BpLvRSO5fnvHfTmLKCmLYgMNysBEUByGAys82Ma710,2261 +bitblas/3rdparty/tvm/python/tvm/ir/__pycache__/attrs.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/ir/__pycache__/attrs.cpython-310.pyc,sha256=f8DGg1oJ0AakGIEJE_8y0crxo633gT4Badwl9a9pmKI,4735 +bitblas/3rdparty/tvm/python/tvm/ir/__pycache__/attrs.cpython-38.pyc,sha256=y8oqtsdbSwo3bZqrmcdTe4OsRWwTtQdISDKm2OOtrD0,4798 +bitblas/3rdparty/tvm/python/tvm/ir/__pycache__/base.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/ir/__pycache__/base.cpython-310.pyc,sha256=pYy53wHlJl9jzgBUoe00BpSLWwIZK1vUBpjbfIwhKgk,9446 +bitblas/3rdparty/tvm/python/tvm/ir/__pycache__/base.cpython-38.pyc,sha256=IdljPWK1URUB9HX490cZmxTAcd0ctGkajkTiVJcXro8,9526 +bitblas/3rdparty/tvm/python/tvm/ir/__pycache__/container.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/ir/__pycache__/container.cpython-310.pyc,sha256=i5bgSaZSfGuznRS-ItaquOTpGAAhTKPllEQ8IhFjN5U,3860 +bitblas/3rdparty/tvm/python/tvm/ir/__pycache__/container.cpython-38.pyc,sha256=wlmhJ1Yvn1Gw7X1qDHcMInvPfPpmgzBcslJq8mSJX1A,3943 +bitblas/3rdparty/tvm/python/tvm/ir/__pycache__/expr.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/ir/__pycache__/expr.cpython-310.pyc,sha256=4kFXXXVxg2m-vTmfuuhkrWjhaU7zpzvlDWbVxmZ070s,7845 +bitblas/3rdparty/tvm/python/tvm/ir/__pycache__/expr.cpython-38.pyc,sha256=RP_6uU7o_JU1oztkY5iF7SbHrPPRqy-LNSdDU893xf0,7826 +bitblas/3rdparty/tvm/python/tvm/ir/__pycache__/function.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/ir/__pycache__/function.cpython-310.pyc,sha256=w01AuN8C8apy9tQzu8z-4GLhniKd_A5uVAypdGRUIVE,2969 +bitblas/3rdparty/tvm/python/tvm/ir/__pycache__/function.cpython-38.pyc,sha256=B2N8JnLpHjnAYTySMqVQvuYTBj5DLX13UNzT6B5HwOc,2960 +bitblas/3rdparty/tvm/python/tvm/ir/__pycache__/global_info.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/ir/__pycache__/global_info.cpython-310.pyc,sha256=rPIHQd4rFZnQJ_FYqWviKUWfRG1X0_OR3N0jIKdVt4s,1898 +bitblas/3rdparty/tvm/python/tvm/ir/__pycache__/global_info.cpython-38.pyc,sha256=uHwQ1vVZGP4HozIOaFubab0wGkwz8TfbaYSSeJx7iVw,1865 +bitblas/3rdparty/tvm/python/tvm/ir/__pycache__/instrument.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/ir/__pycache__/instrument.cpython-310.pyc,sha256=HDxKBvSA_NIgCvwGSaERL7TPT-1drkqIPlkddHzpLzM,8888 +bitblas/3rdparty/tvm/python/tvm/ir/__pycache__/instrument.cpython-38.pyc,sha256=RCqI9ggSf5IbCmNJCoW5AAuuFAxyaoqSPjshrYjb45o,8977 +bitblas/3rdparty/tvm/python/tvm/ir/__pycache__/json_compact.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/ir/__pycache__/json_compact.cpython-310.pyc,sha256=S65lqkf6boIkWlBApLyxkqIfCZtkI-_xtXX_K8gmfec,9000 +bitblas/3rdparty/tvm/python/tvm/ir/__pycache__/json_compact.cpython-38.pyc,sha256=MdPx7hn5hfQ-jvw7abHcG60YtcaM41NzxXlC4TF3HLY,8688 +bitblas/3rdparty/tvm/python/tvm/ir/__pycache__/memory_pools.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/ir/__pycache__/memory_pools.cpython-310.pyc,sha256=31eUMWmROQGtPUyzcuG3ZCNxDTqpl7bwoeoABeE9z2Q,7542 +bitblas/3rdparty/tvm/python/tvm/ir/__pycache__/memory_pools.cpython-38.pyc,sha256=34-MWq5bnLMpcShbn23guyZyB2elJIqpigW8Os41LL8,7557 +bitblas/3rdparty/tvm/python/tvm/ir/__pycache__/module.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/ir/__pycache__/module.cpython-310.pyc,sha256=xopB-ZV40O4glsFM9hvU5xyNdFYOe8PxEC6Bvz1L4eY,12011 +bitblas/3rdparty/tvm/python/tvm/ir/__pycache__/module.cpython-38.pyc,sha256=tiKWv7WwEuOMBas5RWLDHM-sEC_ZfkfTWgctnPt1b_k,12102 +bitblas/3rdparty/tvm/python/tvm/ir/__pycache__/op.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/ir/__pycache__/op.cpython-310.pyc,sha256=7Pq2592nqbBcecalyID68oNUtBXKWUiYvT9eQy0I2Co,7702 +bitblas/3rdparty/tvm/python/tvm/ir/__pycache__/op.cpython-38.pyc,sha256=LaDivorgXZsjqdMY8EX-FoGXbLagtVJG9Wg6aYzEMQc,7819 +bitblas/3rdparty/tvm/python/tvm/ir/__pycache__/supply.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/ir/__pycache__/supply.cpython-310.pyc,sha256=tjN2ANwpNCTUNF_vMZ_tMAp7jnU1O9dZN5o6IzuYCRU,5035 +bitblas/3rdparty/tvm/python/tvm/ir/__pycache__/tensor_type.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/ir/__pycache__/tensor_type.cpython-310.pyc,sha256=00bwz1RIVom_lrDLsnDpQ0YSvsalu5qA_0oCJ8pMCZo,1818 +bitblas/3rdparty/tvm/python/tvm/ir/__pycache__/tensor_type.cpython-38.pyc,sha256=kG7m4feyuhlEB-U_E3TOq6gnaUbaf_65O4vM18RVuiM,1801 +bitblas/3rdparty/tvm/python/tvm/ir/__pycache__/transform.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/ir/__pycache__/transform.cpython-310.pyc,sha256=48is2FBoAoCY314MNtsOTpPKH9fWgd4xxLSbxSPrvD0,16538 +bitblas/3rdparty/tvm/python/tvm/ir/__pycache__/transform.cpython-38.pyc,sha256=BIzL__yr5VkEGu6oMYwrWT8gsfvi3JUia51_0VrwFus,16615 +bitblas/3rdparty/tvm/python/tvm/ir/__pycache__/type.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/ir/__pycache__/type.cpython-310.pyc,sha256=1aKUBGEIPWr-9e50Ren2NQm03uld-8FqLycA5qfMbt8,6804 +bitblas/3rdparty/tvm/python/tvm/ir/__pycache__/type.cpython-38.pyc,sha256=cFa6-9WoCmdGnkDv189sqKxFeQvGwSoe4i8H3PKt1SM,7005 +bitblas/3rdparty/tvm/python/tvm/ir/__pycache__/type_relation.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/ir/__pycache__/type_relation.cpython-310.pyc,sha256=LmkXHrcHCebXGuP5nx3GFXOfrwSB5zL-0gAF_LYKnp8,1903 +bitblas/3rdparty/tvm/python/tvm/ir/__pycache__/type_relation.cpython-38.pyc,sha256=bo4zpHZwoVy423223Hw34PMThsRnHF4Sbm2tBDvCtJU,1910 +bitblas/3rdparty/tvm/python/tvm/ir/_ffi_api.py,sha256=TEPW10TxPjgPpBUpIb9w7Nv681opziUhGKoxr7zNUvE,864 +bitblas/3rdparty/tvm/python/tvm/ir/_ffi_instrument_api.py,sha256=YgYdj4SaU11Phva7SA9MbUrqHfQLz7mYjiE-JqTgL50,879 +bitblas/3rdparty/tvm/python/tvm/ir/_ffi_transform_api.py,sha256=SA3g7XnfzVaDrBqlexsCNrZy6sB0tvB3aJiTWz5Tc5s,878 +bitblas/3rdparty/tvm/python/tvm/ir/adt.py,sha256=RhZdix03SxZZh0Y4VG4k2xiqO44D6Gv2Y6qcrxlcFP8,2758 +bitblas/3rdparty/tvm/python/tvm/ir/affine_type.py,sha256=E2nJRYrnob-6Ck57RRpqmjBsKi6uMOHAaPNR3oJIAL4,2308 +bitblas/3rdparty/tvm/python/tvm/ir/attrs.py,sha256=ZJMEUd0hNWcSfHPWHQBV1OOxYduKt7EIUWPnzBQCClI,4244 +bitblas/3rdparty/tvm/python/tvm/ir/base.py,sha256=LH6yuyPIxXU8YCoVHqEAKfHtP0e0OzVlHbAVM5RTBmg,9382 +bitblas/3rdparty/tvm/python/tvm/ir/container.py,sha256=bUfu9dIwDXETp1t6Ri9dAmAOOFvqGVNhuX2TNdJg1x8,3531 +bitblas/3rdparty/tvm/python/tvm/ir/diagnostics/__init__.py,sha256=oVQJxXph81eMPKEyqfmMKe3KfV9Yu5_w9xIYeZj4KCA,3547 +bitblas/3rdparty/tvm/python/tvm/ir/diagnostics/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/ir/diagnostics/__pycache__/__init__.cpython-310.pyc,sha256=8lbpjGJ6LUnaCwICedhHyOCNz1ASKodvsgatQ5Uzwv0,3847 +bitblas/3rdparty/tvm/python/tvm/ir/diagnostics/__pycache__/__init__.cpython-38.pyc,sha256=63eJjQLn8rOPr_JelmQb76W72vqFVUEV2M_YpMfiFgY,3824 +bitblas/3rdparty/tvm/python/tvm/ir/diagnostics/__pycache__/_ffi_api.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/ir/diagnostics/__pycache__/_ffi_api.cpython-310.pyc,sha256=DSgvLQJQ9XPOgmliWjk0c2aJBbuDcKpBv9KwVfrxy10,290 +bitblas/3rdparty/tvm/python/tvm/ir/diagnostics/__pycache__/_ffi_api.cpython-38.pyc,sha256=8Q3rwvFHTkbafhovce-lehQpQny05uVgsEOVSq9mTjs,277 +bitblas/3rdparty/tvm/python/tvm/ir/diagnostics/_ffi_api.py,sha256=3f6xJfcKqMYXiNA0vIdg9CMxlKtKhZpm5ASHDXbdz1Y,878 +bitblas/3rdparty/tvm/python/tvm/ir/expr.py,sha256=o7_J5gEz0c-ncQ4to0JxJO8-v41a5i4kzvrMp6qfMNw,7421 +bitblas/3rdparty/tvm/python/tvm/ir/function.py,sha256=pBbteqyxOr-P5LcBwRY3mUrnI6YqRylgN-tDKnddJ0o,3342 +bitblas/3rdparty/tvm/python/tvm/ir/global_info.py,sha256=4ELJ4jXpGhy8nPzdZ70a1eAr3uzPlcj1F20Mg_dObJY,1837 +bitblas/3rdparty/tvm/python/tvm/ir/instrument.py,sha256=Yv-YUOfFm2-35YpduUaSmv_E7rKbrte78kI0pXgSVB0,8828 +bitblas/3rdparty/tvm/python/tvm/ir/json_compact.py,sha256=Hg1bU6alfJeNM9sbJfS12d6gP4DAPG2TStmXS95B22o,10968 +bitblas/3rdparty/tvm/python/tvm/ir/memory_pools.py,sha256=Fka9xckDrIrg9OsMG868TK6ogl1thSL2EYADK6yN5vo,8194 +bitblas/3rdparty/tvm/python/tvm/ir/module.py,sha256=CK8_DAgVeJwaticO0ija-cdzL6vPt4vHK9DBVO4HL9Y,12257 +bitblas/3rdparty/tvm/python/tvm/ir/op.py,sha256=Pve6Zk5deqLCSBwnqYvbvuEPuUJzPbXmRba1AMDgTHc,7522 +bitblas/3rdparty/tvm/python/tvm/ir/supply.py,sha256=II27VzXRaNeYOyOUP2jm-TwQZGIjNGgc_r-GCYzDxGY,5319 +bitblas/3rdparty/tvm/python/tvm/ir/tensor_type.py,sha256=wGX9X-L54ojThRVXvaRlU81HilnXHPxTbZP1q__ihbE,1916 +bitblas/3rdparty/tvm/python/tvm/ir/transform.py,sha256=ONqw50JddrdOyYwUwW5U277T3ZhEUDjlwtieg0X2iRE,16937 +bitblas/3rdparty/tvm/python/tvm/ir/type.py,sha256=QxQD3MWwP8oYAcy6fJh4UOiCz7L3TmhgFU0PrqYVJ4U,6479 +bitblas/3rdparty/tvm/python/tvm/ir/type_relation.py,sha256=lZWNoDmtLH4EGL-fN8hCMlks8wgHds6TT7jpArIfSu0,2206 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/__init__.py,sha256=Qa9M2l8ES8u9_iXiAVGCnoyzmFD783_b7194sdgxjSw,1903 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/__pycache__/__init__.cpython-310.pyc,sha256=dVWqaBGrTbuu5aZ7UKcceMxRrrk1GL33vmLCegWCviI,1395 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/__pycache__/__init__.cpython-38.pyc,sha256=VdGbMAxCZTQmr7aM7kxixw1sGfbEPmDcCTCYMRJOois,1382 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/__pycache__/_ffi_api.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/__pycache__/_ffi_api.cpython-310.pyc,sha256=pT5by8vouE_0JLQ1PCZZZOpLZbv1Xhan1PapaN4nTcU,289 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/__pycache__/_ffi_api.cpython-38.pyc,sha256=Prn0xrtk-1mYGxMgLCCAxDpX_wv49sxUq-iIYpB-YjM,276 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/__pycache__/arg_info.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/__pycache__/arg_info.cpython-310.pyc,sha256=SYwjX0z9axaQHvXQAT3bwRtzAmpQUN6j99qpkhuHWkk,3550 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/__pycache__/arg_info.cpython-38.pyc,sha256=NOZKSRxULN-VT7tcSBnDg6u6JDh3fjyfvPGG-lszWho,3562 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/__pycache__/extracted_task.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/__pycache__/extracted_task.cpython-310.pyc,sha256=nwyoprgolgqfvnIS6RgWGHwSBgwd7ae6itcfnN_23ZY,1501 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/__pycache__/extracted_task.cpython-38.pyc,sha256=_bsB5ZjqfBXdjM-D4bpic50fkxf1KjfF1yg5xBDiDiQ,1486 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/__pycache__/logging.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/__pycache__/logging.cpython-310.pyc,sha256=1EZLEMrdnAMnQqb3sWcuYRn9t2JlgYuSj6oU9oQ0uVQ,6186 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/__pycache__/logging.cpython-38.pyc,sha256=WEENkSMChayHcTaR6gu5hn19dIfWUOIQyKXS_wbUbI4,6139 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/__pycache__/profiler.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/__pycache__/profiler.cpython-310.pyc,sha256=WmfvwqIbWXe4BzDgixCZFI8nVU7WNfPJflTCSA7UrEU,2292 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/__pycache__/profiler.cpython-38.pyc,sha256=zw09wMyl1acGQrZECKyuYOp6hgSkd9WPiO4n40f_rF8,2259 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/__pycache__/relax_integration.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/__pycache__/relax_integration.cpython-310.pyc,sha256=G_0hw_YXqd7d12LdRqoL-puw45xBGD0eNMVAvwp5AlU,12481 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/__pycache__/relax_integration.cpython-38.pyc,sha256=rX9uWf-9oXPr7cfrYEa3A_G82l3NtJrbvRhtpMcpo_U,12228 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/__pycache__/relay_integration.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/__pycache__/relay_integration.cpython-310.pyc,sha256=lcWhmaFlw_o_KjJDgJvWuvV6jU_XgBcaGQ83CQMcfLM,13639 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/__pycache__/relay_integration.cpython-38.pyc,sha256=1oOyz1BG-mJXG5dgkz4_v3WYtPg4w0lLEbUv7rGiqXo,13298 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/__pycache__/tir_integration.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/__pycache__/tir_integration.cpython-310.pyc,sha256=G7fV-nOlGhUo6M7J_h7ZgII51957jvLl3pqpA2uq0tM,7468 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/__pycache__/tir_integration.cpython-38.pyc,sha256=ZIBIi5nznK4eNJl726U5im6X6q7HGA9xGQjuJcWEsE8,7415 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/__pycache__/trace_apply.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/__pycache__/trace_apply.cpython-310.pyc,sha256=GZf19zy8xBpEnNryrLHj_X80ZmPvkrYG48hjFKJujAc,1242 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/__pycache__/trace_apply.cpython-38.pyc,sha256=sSCNlJR4f2Wk3jZzQXgfJLG9HTCJYW9ICUc0uWB92xM,1225 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/__pycache__/tune.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/__pycache__/tune.cpython-310.pyc,sha256=OY3QXADFSb_aavjEib8trB_gyxLAQYxZ728jj76gp-4,3662 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/__pycache__/tune.cpython-38.pyc,sha256=iEwZ4ccXZtckIQMb0JsdpJ0RnCVp869GLXpCQ6IyAIM,3601 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/__pycache__/tune_context.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/__pycache__/tune_context.cpython-310.pyc,sha256=YNU7ktFn2M__gb2NUPkPOJjxZT9ZcDhsJWm4AG9Rz7E,8232 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/__pycache__/tune_context.cpython-38.pyc,sha256=wLWi-1oP-4B1ENXEGrfQg3x4nsYbwS7N3gdP9RMSfew,8223 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/__pycache__/utils.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/__pycache__/utils.cpython-310.pyc,sha256=R-TyIKk9OQwnGuC6mijzOt2VLy7JokLsY4_ZK0lp-rI,12607 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/__pycache__/utils.cpython-38.pyc,sha256=H5RpJzs2KhnNlITefcxQ0-yCfVCnGb_clgBU6kCOfOg,12642 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/_ffi_api.py,sha256=p23UnySUuneETL9VGFx67rNahH7o66PQipVgl6pVxxo,925 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/arg_info.py,sha256=1226iDFCLkXdW0JuCNpJJOXjp4U-zCdJ0CpnlG8hClo,3887 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/builder/__init__.py,sha256=sH9A7ztKAkTkh-VT3FNhiY1fNP-O7lM9YQHYIEVBNjg,1031 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/builder/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/builder/__pycache__/__init__.cpython-310.pyc,sha256=SabwLQA6VBFtp11sZb5ZwKDHWQ6s81fq-uX5SKJf6t8,487 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/builder/__pycache__/__init__.cpython-38.pyc,sha256=Axs8mwI-kLK_sCE83Z9poH26jBBaCdcN66Kh8sIHDOc,474 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/builder/__pycache__/builder.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/builder/__pycache__/builder.cpython-310.pyc,sha256=V6pONx6ydwEitqbGUm4MMSHgsQfX7FyDtXUTlswQxeI,5132 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/builder/__pycache__/builder.cpython-38.pyc,sha256=bir0s0PxMsxUkyYDXBTT76HjDdE3giyKlD3pRqexLvs,5116 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/builder/__pycache__/local_builder.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/builder/__pycache__/local_builder.cpython-310.pyc,sha256=NGum4XxX61MFn0HvCkZUTIkvp6y676D5BMWiFcRoTx4,7948 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/builder/__pycache__/local_builder.cpython-38.pyc,sha256=8C5CBMrOyf4UJ1FtLyMCQ-untWN7mi78afuXDfw-6dY,7983 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/builder/builder.py,sha256=1BOEK4JJQNLXNyJuek5YqdICkN_M9wK1ZhaIPuskiMU,5664 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/builder/local_builder.py,sha256=k_519nkLktJPLtjxF9b5xAl59KBN_PTqLibH5mK8l8M,9790 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/cost_model/__init__.py,sha256=S0-geOSGd9665Ley1rJ9FieBaco-UskIxR2gz62sCmc,952 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/cost_model/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/cost_model/__pycache__/__init__.cpython-310.pyc,sha256=49VSV07xVRFSvfvXl-iFxaUXq72Zw6R7n6hwQ6A4nsQ,394 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/cost_model/__pycache__/__init__.cpython-38.pyc,sha256=6gMqcxI-8H6OpeI958afG3DFRhlcTARgd-O6-AcmiQg,381 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/cost_model/__pycache__/cost_model.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/cost_model/__pycache__/cost_model.cpython-310.pyc,sha256=8bImv3apY3ZK4aoXHG769G77Xs39i5fCESITWnotkmA,6654 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/cost_model/__pycache__/cost_model.cpython-38.pyc,sha256=IlRq12DQRthsUQ9NA4EwlDlAXWWFx0Ygho3bg4qcnIQ,6632 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/cost_model/__pycache__/metric.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/cost_model/__pycache__/metric.cpython-310.pyc,sha256=EjK840BWxkJUG7XP9_1t-r3Y4I_TtP-qqORmNCBJVOs,748 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/cost_model/__pycache__/metric.cpython-38.pyc,sha256=EGbM7bNraGD63hTlS6Nj_6nOUp5wmx-jGI3Z5t2ZxlU,735 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/cost_model/__pycache__/mlp_model.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/cost_model/__pycache__/random_model.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/cost_model/__pycache__/random_model.cpython-310.pyc,sha256=brQ0mf9Tma0jnT_WQRAobosptO9j_rWG8Qsye9i7F30,3642 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/cost_model/__pycache__/random_model.cpython-38.pyc,sha256=VzvjLRTEmf4tMBMdBUsjWH41GrgARVKvcQR0GTxx2_s,3612 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/cost_model/__pycache__/xgb_model.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/cost_model/__pycache__/xgb_model.cpython-310.pyc,sha256=U0do0fpHhKqrv2tPQQmJRNf3FLCNQHiwv6POwrASHiI,24560 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/cost_model/__pycache__/xgb_model.cpython-38.pyc,sha256=SMbhm6j78r2baOzDTWA9pjkV_mUWrT_VTL25T4ybNJw,24471 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/cost_model/cost_model.py,sha256=aNFjTmodosXK5huACSeWFeGfj2-A58Mg4HBhSJzQEpQ,8063 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/cost_model/metric.py,sha256=J815Is_i90xopAWIj69G03vS3D2cL_YrjCzFt8X43NM,1321 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/cost_model/mlp_model.py,sha256=AkWxE4Jjl4XbqwLM78f7e3TL5NRABQhtZd0oWx_-MqU,34492 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/cost_model/random_model.py,sha256=ZrKggwQK776zNyUj7hhw3FLauYlyqK6027sizf7PoXY,4437 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/cost_model/xgb_model.py,sha256=nG1i-X0nY7_jInlVcWFxGdyl5TEV89LuQN4opfP5JHk,29351 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/database/__init__.py,sha256=VBtglp8rGTERj_GLeEg39jTsZs3u3hyxYZU2u6Zt2vM,1209 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/database/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/database/__pycache__/__init__.cpython-310.pyc,sha256=-8mC2kSLnqHUcnZQyFaYlGwFc82IJ34OkuuE9JbFtJA,706 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/database/__pycache__/__init__.cpython-38.pyc,sha256=Xyzjf44rZELN01qCeRewpwJibD0TJP4wy-lEPwXoe8s,693 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/database/__pycache__/database.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/database/__pycache__/database.cpython-310.pyc,sha256=OGCih_7REQTNHv43GB4zQtWFNqsMliUS23OinlN0iec,17048 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/database/__pycache__/database.cpython-38.pyc,sha256=YlnBrCOChtiSnmgY8u4xVG5fkEhELtyPjawatmtUyVc,17185 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/database/__pycache__/json_database.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/database/__pycache__/json_database.cpython-310.pyc,sha256=TG0W5ZN5qXbQcDNYlx3vvop2HDh2p5sVD-r_1Zed6SA,3087 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/database/__pycache__/json_database.cpython-38.pyc,sha256=-R2LjrMQCYxZkUG4Ke1QGahlNCiXGtQ0YbpwqLio1KY,3060 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/database/__pycache__/memory_database.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/database/__pycache__/memory_database.cpython-310.pyc,sha256=XyKiAyB_MgUsvJSL2x8mNnvr981AiGB7gP8MvJnoyCs,1654 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/database/__pycache__/memory_database.cpython-38.pyc,sha256=SWJipa5DSaERmGatpcT3i9iXasTY8YuUfcQOmrjkDi4,1635 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/database/__pycache__/ordered_union_database.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/database/__pycache__/ordered_union_database.cpython-310.pyc,sha256=YUxJI-ws96Fz0zZV9nJiML3Dp1SI193I6QcQL8lGtVo,3345 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/database/__pycache__/ordered_union_database.cpython-38.pyc,sha256=Y31UQZaKJ_c4ZJosTX8XETFlok-5Gc6KHRlb7CX7ZKs,3330 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/database/__pycache__/schedule_fn_database.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/database/__pycache__/schedule_fn_database.cpython-310.pyc,sha256=HtvVD0yXzBKK3cgrai-9FZ2LMh1ZfDwqSlHkNyhQlLM,2055 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/database/__pycache__/schedule_fn_database.cpython-38.pyc,sha256=LgYdhkm6XZFvqwYbmMnQzZwKKQN8HGeG96_7v8tmchQ,2032 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/database/__pycache__/union_database.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/database/__pycache__/union_database.cpython-310.pyc,sha256=O7WiLUqwU7V6CQRHSZASJd8KbkCsEsqZHOQWFhCD4C8,3293 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/database/__pycache__/union_database.cpython-38.pyc,sha256=ddNMGvz63Kd-tfc3q3EYLflC1oC7Kn6JjY-L1r4ewzc,3278 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/database/database.py,sha256=Yz7Tk2XPRA2d4AMkGeRqg3L0D6VhZPliiCkdnzFOitE,20190 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/database/json_database.py,sha256=VaaTMtwsiWXus7CZ7gzeFyDYKuyYxE1KAQlo5fMiWN4,3827 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/database/memory_database.py,sha256=oTHhx2IuG4lj3wKFInOukP1IchMA_bd-eCMnmIheA34,2067 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/database/ordered_union_database.py,sha256=M1pj4E_zbbGylC1qzfXonrpLX6QrIZQs1-9nmiRw24g,3752 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/database/schedule_fn_database.py,sha256=EvxRFJClsGMm8WTTqde9dSGOoiSQZUFOzep0efVxG9A,2455 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/database/union_database.py,sha256=E4Bync32EX_FSLocWjimnQ8mZUHF_XuUKhya6wQcRHU,3715 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/extracted_task.py,sha256=HklftMXyDudleAcmXWmCKt0z2l4zYE3SjAAsy2n80p0,1989 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/feature_extractor/__init__.py,sha256=gw6zRrGCLTZgd9hb91WWZ0mYDNwCWAVqzxQQFsArvsQ,1121 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/feature_extractor/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/feature_extractor/__pycache__/__init__.cpython-310.pyc,sha256=USVaqnc4rFBWDFVsKGhoBhdoD1UKaQMVvI0WTK9hsYA,570 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/feature_extractor/__pycache__/__init__.cpython-38.pyc,sha256=BuAXBAoHEj8fEd0EBwFtE_gUjobGWBSwvREMlBne3pg,557 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/feature_extractor/__pycache__/feature_extractor.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/feature_extractor/__pycache__/feature_extractor.cpython-310.pyc,sha256=drB3RX0Iei08ppYg-cruYt1kigGZ_bZukboUhiiiT5I,3595 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/feature_extractor/__pycache__/feature_extractor.cpython-38.pyc,sha256=vcBQ8kVT70kqjnusEvWT9qWLUcNKAfMMZodanEDksvo,3566 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/feature_extractor/__pycache__/per_store_feature.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/feature_extractor/__pycache__/per_store_feature.cpython-310.pyc,sha256=Cm57LS1HTWuI09q0qWH4VevtdA2x7gX4XIGn9dHHsf4,1749 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/feature_extractor/__pycache__/per_store_feature.cpython-38.pyc,sha256=CPbZnusSZbxRh2-88YRzZj244vXt1XfvT7IUhisazA0,1716 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/feature_extractor/__pycache__/random_feature_extractor.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/feature_extractor/__pycache__/random_feature_extractor.cpython-310.pyc,sha256=lKqQiD-j35tGlw9WjkbJ8VuIde_PQB0ROZBPTVp4SDA,2380 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/feature_extractor/__pycache__/random_feature_extractor.cpython-38.pyc,sha256=SDBW3pSbB4WT5XDnKEjwDsWk5JzJd0vWZclJK0LacTE,2381 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/feature_extractor/feature_extractor.py,sha256=YNpXnWoaCVCIidFb1GrNmfsq46zK_9_I9yG3Yp5SFWU,4206 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/feature_extractor/per_store_feature.py,sha256=4yzxt_G7-AgxqPDfiXr7Vav-QmGE3Hhn8tof3G1hO9I,2665 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/feature_extractor/random_feature_extractor.py,sha256=jQS3AEi4lpdw-OdqO2IA960spmfIBNOpK-_SMb6Ft4E,2411 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/logging.py,sha256=yg356jXMR6xlxWytVkwjx_xu2bFQ0F4dTpszE5zgWd8,7979 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/measure_callback/__init__.py,sha256=TpeF6Ggfe-MTR7nWD7Ea6sH8k3sWw0eHdBz0XISDhAU,1049 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/measure_callback/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/measure_callback/__pycache__/__init__.cpython-310.pyc,sha256=MK3vyWrOPxHxqCqTubWfRjLtjgWKDmZNoOTTcbIHcbE,507 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/measure_callback/__pycache__/__init__.cpython-38.pyc,sha256=oU_7r4gJP54vJ8HmD0i9Fi1OSSkBMnqGVADY4hExIys,494 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/measure_callback/__pycache__/add_to_database.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/measure_callback/__pycache__/add_to_database.cpython-310.pyc,sha256=KFDnGZb7XGm5Rx__v2qU9aY3L_hmg7vrfp-f3FXMmyM,846 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/measure_callback/__pycache__/add_to_database.cpython-38.pyc,sha256=Fl7htVmjPLnJnpM_XUf9PxLxi1ZnR8Lerxi9FyCyqRU,829 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/measure_callback/__pycache__/measure_callback.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/measure_callback/__pycache__/measure_callback.cpython-310.pyc,sha256=maNHXkRd4x7YWx5iKpAFqs8oK0YDIi8YtNTy8fKb2HA,3840 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/measure_callback/__pycache__/measure_callback.cpython-38.pyc,sha256=RBZoM6_UiEoPV22Oe8XRPZgKYDDk2kxNTVZjbUPypb4,3776 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/measure_callback/__pycache__/remove_build_artifact.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/measure_callback/__pycache__/remove_build_artifact.cpython-310.pyc,sha256=nEzi8r86iW4YYhBRQS9jLiX06JfDt1Bspkda0GwETes,871 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/measure_callback/__pycache__/remove_build_artifact.cpython-38.pyc,sha256=GVbxGKaMdvxEl_ZIQx4aA4ou_FIIxJ99V1DzE5Pyp08,854 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/measure_callback/__pycache__/update_cost_model.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/measure_callback/__pycache__/update_cost_model.cpython-310.pyc,sha256=P1Gb2dbd4t91YxSCbXwHpA1m43bayz043aWAFQXIipI,840 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/measure_callback/__pycache__/update_cost_model.cpython-38.pyc,sha256=hpM2UEfCP4PngjwiPxS_pLE4s4mF_8JHYgmdj0RGIlw,823 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/measure_callback/add_to_database.py,sha256=7YJO_j20ImIGgApu9_J6CJVtyoIEpGjnXrE5EfGKpJc,1309 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/measure_callback/measure_callback.py,sha256=HrESmvvpRTF7md0guSSG_vE15OgDgqrRPBj1mGvSTvM,4756 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/measure_callback/remove_build_artifact.py,sha256=fdWDnxdL7dy5THROtHtlptz_aleHO5bLadiEEHmuS5o,1317 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/measure_callback/update_cost_model.py,sha256=R0livWxRA9Gb8cdKb_2HfhFW77r4_57gpfAXGK8t7LA,1283 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/mutator/__init__.py,sha256=cjmd3uhb14ek2px9k_PTsTQJgc9wQn5gmf40RxX98co,1189 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/mutator/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/mutator/__pycache__/__init__.cpython-310.pyc,sha256=c6JpBFawgm7ydyJJJYlIMlNiUQMfwTp7P6hfykUNnIA,658 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/mutator/__pycache__/__init__.cpython-38.pyc,sha256=erjERbAtrUog6vWEbLSZdhN6duhd5WIbNz5zBWcwY_4,645 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/mutator/__pycache__/mutate_compute_location.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/mutator/__pycache__/mutate_compute_location.cpython-310.pyc,sha256=j01psi7Ooj8GNjOTeitwA1v7jhIV8nQ0vb6JHW5-ApI,890 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/mutator/__pycache__/mutate_compute_location.cpython-38.pyc,sha256=snI5AAVikNZTkwLpbqQI0_E9RH-pwSk63CMhwl0oLQQ,873 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/mutator/__pycache__/mutate_parallel.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/mutator/__pycache__/mutate_parallel.cpython-310.pyc,sha256=UUrRifkp_Yao7BgjbSvFXRv4GU05TTSntBNpgOZo7eE,852 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/mutator/__pycache__/mutate_parallel.cpython-38.pyc,sha256=lVCsTUqadhYQXTz8Siw-pQCJxlCICTNFbRBZna8WLio,837 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/mutator/__pycache__/mutate_thread_binding.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/mutator/__pycache__/mutate_thread_binding.cpython-310.pyc,sha256=9uXhe3T9tBGlvNTw0KcF4sM3nFdSIBQb8I2fWQZmsKA,864 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/mutator/__pycache__/mutate_thread_binding.cpython-38.pyc,sha256=OHX55Aw7XYmQGnWfTwkh61DvEFCLHEJVguNs-zP0-B0,847 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/mutator/__pycache__/mutate_tile_size.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/mutator/__pycache__/mutate_tile_size.cpython-310.pyc,sha256=zhP0ZEhchJCV7jz2RAAswcv0UqirPayaYgkJYI3N-OM,843 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/mutator/__pycache__/mutate_tile_size.cpython-38.pyc,sha256=PigTVandX6oCCVUUeWb7wf8ac11_O8AJ5SgCNxlW0qw,826 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/mutator/__pycache__/mutate_unroll.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/mutator/__pycache__/mutate_unroll.cpython-310.pyc,sha256=j7l6TEwfiqUoVd5VyqqaDljnWh_FydADgAHDLqJuCjA,801 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/mutator/__pycache__/mutate_unroll.cpython-38.pyc,sha256=sgUu9rPMZHfSuRbkHaGNAGVmf6x3OCuI1GkTvRK-uoQ,784 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/mutator/__pycache__/mutator.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/mutator/__pycache__/mutator.cpython-310.pyc,sha256=Q2wd8_JRbj98-YP3ft3JlqQ0R-xMFOJshkwXcsv36_0,4755 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/mutator/__pycache__/mutator.cpython-38.pyc,sha256=NZO9k0uoLXHL_NZR9FQ8i50EydlR0T9DLzxB0DRZ5rg,4743 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/mutator/mutate_compute_location.py,sha256=UHlF-BCBhXLt71UPJuH6ejyQImCHBBAIWiL60l0IPDM,1342 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/mutator/mutate_parallel.py,sha256=Y68BenqUf-EMDKahA-Cv3oZAJ-XHzdkQB3h82dvu-BQ,1351 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/mutator/mutate_thread_binding.py,sha256=Yq5SeI8ZQ5bNx8_hK4Qpe28MmabDXO8GnEHv2r4F0nM,1308 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/mutator/mutate_tile_size.py,sha256=xhlVY2CUBuur048vDrui5h7xif5kepTf7vnyRQBAx14,1297 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/mutator/mutate_unroll.py,sha256=F70JzzRi3QllFP-eF_-IucQml1IKWSvUTB6DEMZBZHM,1229 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/mutator/mutator.py,sha256=dd-L3TV868CKBq8HEV0_HrUhJTPOQ8xgiyBDZ-OYdxU,5779 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/postproc/__init__.py,sha256=_xSwrgRJYbmtU9vQhOlmCzvOaKJXBJPBVhR9H_r72c4,1437 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/postproc/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/postproc/__pycache__/__init__.cpython-310.pyc,sha256=WCW-3H4zmGLWXwGkI3nRsc5s7orXh_6N19ntMAQnn_g,957 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/postproc/__pycache__/__init__.cpython-38.pyc,sha256=SCoBBTwgurhu2GSMG8Tu3SPFKSx0-LOiWKNREnYDZgQ,944 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/postproc/__pycache__/disallow_async_strided_mem_copy.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/postproc/__pycache__/disallow_async_strided_mem_copy.cpython-310.pyc,sha256=GxTuFaoxNOzj36YCfZ1_GWRIKm7n-Y7gEwDdQRhmXHo,991 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/postproc/__pycache__/disallow_async_strided_mem_copy.cpython-38.pyc,sha256=o9WviWEiMjhcsqGpJzBIczrMTjIsrAglB5DoRPYhbJ4,974 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/postproc/__pycache__/disallow_dynamic_loop.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/postproc/__pycache__/disallow_dynamic_loop.cpython-310.pyc,sha256=Ir-Bad3hCoXlsIe29PJxhkcVAts-0XCc7JetCmjdVeY,885 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/postproc/__pycache__/disallow_dynamic_loop.cpython-38.pyc,sha256=hOFzXF6izP5VWC9VuUH3dcpzFUonqyXheisG7YO0uwY,868 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/postproc/__pycache__/postproc.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/postproc/__pycache__/postproc.cpython-310.pyc,sha256=jz2diBsXoDGl_oQV6rWZtU_tyLx2cvpodJNrIjfA0Ak,5087 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/postproc/__pycache__/postproc.cpython-38.pyc,sha256=BDWpEbOSed1oE3h2tYgomvjkluy81apmgxN9yOL6l3I,5079 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/postproc/__pycache__/rewrite_cooperative_fetch.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/postproc/__pycache__/rewrite_cooperative_fetch.cpython-310.pyc,sha256=uPtrRATlh3q61Xcw-q-1F026yeTnvUIDW-fJ6Z1pdTw,1074 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/postproc/__pycache__/rewrite_cooperative_fetch.cpython-38.pyc,sha256=hACKg3xIIA5tPTwIswZGF0pYfJuIf7n-a5_o4PkCJmU,1057 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/postproc/__pycache__/rewrite_layout.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/postproc/__pycache__/rewrite_layout.cpython-310.pyc,sha256=kdTGqn36BmDAijwlDKRQFD16Aietcs5t1PGA_IaPgsk,829 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/postproc/__pycache__/rewrite_layout.cpython-38.pyc,sha256=SDdQiN8aum1gGOU31FmY8vGs_crUxmqdpZG9x8f4KPw,812 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/postproc/__pycache__/rewrite_parallel_vectorize_unroll.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/postproc/__pycache__/rewrite_parallel_vectorize_unroll.cpython-310.pyc,sha256=XIDca10vGlXA2LccZ4eo9CogqgjlbFQWa9QSTHdtKH0,1101 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/postproc/__pycache__/rewrite_parallel_vectorize_unroll.cpython-38.pyc,sha256=PlAqxc1przTaRkNzdcjcohB6lp4K9lBizjKT-Kgat1o,1084 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/postproc/__pycache__/rewrite_reduction_block.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/postproc/__pycache__/rewrite_reduction_block.cpython-310.pyc,sha256=8U1mCfaUtJ1nfoG2vbDGbBiwEIhAQRkEO8HhzkDQwoY,889 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/postproc/__pycache__/rewrite_reduction_block.cpython-38.pyc,sha256=-XQwXOStZW35GC_elnMYPrZX1aWGuhhpQDXXhPBlBec,872 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/postproc/__pycache__/rewrite_tensorize.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/postproc/__pycache__/rewrite_tensorize.cpython-310.pyc,sha256=lreaUh7110MiWZtF9GNnBWP3UW2oDUtH_Ku_KM_VfsY,1083 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/postproc/__pycache__/rewrite_tensorize.cpython-38.pyc,sha256=rL4Ng5aIhRwLghC-hltOXV6SGUzAil4unYGa4XVW8as,1066 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/postproc/__pycache__/rewrite_unbound_block.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/postproc/__pycache__/rewrite_unbound_block.cpython-310.pyc,sha256=wjZK2RNng0SQMlDDB2UBcsIfqGCNNrxS62_mxfRauU0,908 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/postproc/__pycache__/rewrite_unbound_block.cpython-38.pyc,sha256=So9yWa_RGuv_Z7ZglMRkxzRiupFIeSJ57Sqytxd_0-U,893 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/postproc/__pycache__/verify_gpu_code.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/postproc/__pycache__/verify_gpu_code.cpython-310.pyc,sha256=UxTsWnFDxmj4v6FP8oUVNIn-CEvZml2B-2jr34OOkyQ,830 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/postproc/__pycache__/verify_gpu_code.cpython-38.pyc,sha256=D2BgjjXWBIDvnDtVg4Oq3s9AlpqrG4_FEhtB2Kz159o,813 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/postproc/__pycache__/verify_vtcm_limit.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/postproc/__pycache__/verify_vtcm_limit.cpython-310.pyc,sha256=qdEXFqaIZrvfRE0R-7kMpAKlL0cnWplQbxOkEg_Jpd8,924 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/postproc/__pycache__/verify_vtcm_limit.cpython-38.pyc,sha256=0mSRZiZxJP48nrq0zD9ia-8jb5fX1JoPaY8qv05vZSU,907 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/postproc/disallow_async_strided_mem_copy.py,sha256=pAsNOfH6s3lQ3G1GKmLStYMoqnyjVy6jEEZSbAzgQGo,1352 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/postproc/disallow_dynamic_loop.py,sha256=0zkK8T5UUwZRhLM4J8LYJLfRWHj9Y5FrtQn96hGn_Yk,1342 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/postproc/postproc.py,sha256=ZgTVP3OTAEGzq5d6s-qEzR0Quwk9aA5DlElaVnyASPY,5802 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/postproc/rewrite_cooperative_fetch.py,sha256=yNwffMXVm6fdLNk2xeNXUxZi6Y-4wy-NFMGapy-7dGU,1445 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/postproc/rewrite_layout.py,sha256=yAi47PH-oNQp7SXi60qWxvEMAwlOinkz00b9pX93TrY,1275 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/postproc/rewrite_parallel_vectorize_unroll.py,sha256=fRxKFEIkK8Qx8N1ph245a3DJe5cQgqghVI4tMMl9hks,1457 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/postproc/rewrite_reduction_block.py,sha256=6EejWxW-xjGyzELBbvAEHzTJF4HVzFQ7ZxzVvJII-Yw,1336 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/postproc/rewrite_tensorize.py,sha256=IXzANBLKt02h9Cxof7IkLamj7JKWduZNKskFkchkPoA,1498 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/postproc/rewrite_unbound_block.py,sha256=C4vPf22FyBlOsNx6w7V6M3mg6DBdvy8FZFEhhLHhl10,1356 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/postproc/verify_gpu_code.py,sha256=VW-6CtkYPgQfb_DUfrUbq8mm1JKvI1txLPom8WYm1Kg,1274 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/postproc/verify_vtcm_limit.py,sha256=SO9VRbSPpfuSfqd4L_g7stTDgrCLI2plJG5B50t8TsA,1311 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/profiler.py,sha256=QlotU8jSkwZCqCoUvEOrsIoXcVAXjqozl0sa9nBOrnY,2636 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/relax_integration.py,sha256=Ihj-KJvhO88J7UdqnFGkoO34XzQMv9VVKxUrMnqYGJs,15059 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/relay_integration.py,sha256=284oPnvU9vzUFJVRg8D8jmnRAw200gG7B-oNLzMt4w8,16300 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/runner/__init__.py,sha256=0mP7Tdz-NR-FGHuJBNvIfaq_ho2W-M44p-IvYgzsGao,1192 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/runner/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/runner/__pycache__/__init__.cpython-310.pyc,sha256=sFhjJurWWabodFJCmrHpbFhEGyv2YhOmCcI5ziaktTw,670 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/runner/__pycache__/__init__.cpython-38.pyc,sha256=kEqbUh8OPCz7VQqAlOj0ldGfNNfpxJnsfN6icEqAsA8,657 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/runner/__pycache__/config.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/runner/__pycache__/config.cpython-310.pyc,sha256=Px_gF6u7ncMQFncDvDks07VRV5oY2YeWF7gHzK4zT58,5906 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/runner/__pycache__/config.cpython-38.pyc,sha256=TiC-ZsrgD8jj1TQ1FqgJZf0Ulm88GKOB6pH4_wUbFXk,5833 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/runner/__pycache__/local_runner.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/runner/__pycache__/local_runner.cpython-310.pyc,sha256=WCACUAytWkuQAB4qqat9mr3mrB85pFNVdkjhUTxCgsg,10651 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/runner/__pycache__/local_runner.cpython-38.pyc,sha256=uNKnUd-4ISfibjhD_JjbObrG4nqbOfrxWbnjz5uk3Bs,10417 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/runner/__pycache__/rpc_runner.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/runner/__pycache__/rpc_runner.cpython-310.pyc,sha256=KJ_0_Rq65XtDnzX9XhHgHTotw6O7NMT5i4-SWha0px8,13745 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/runner/__pycache__/rpc_runner.cpython-38.pyc,sha256=tVW2V9NWFBmGH1eK02plACcRNl_SZVHs2J88I6YK4zs,13469 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/runner/__pycache__/runner.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/runner/__pycache__/runner.cpython-310.pyc,sha256=9urRTXRCWYbmwK7KUrZafmTdl6s95-fylZazSW_3Vss,6621 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/runner/__pycache__/runner.cpython-38.pyc,sha256=wuc2EXzj8AoHKZPUCjTg2WWvj13NTCZVsfojS-n8fnQ,6656 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/runner/__pycache__/utils.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/runner/__pycache__/utils.cpython-310.pyc,sha256=Mfo39X6cTfslvCJMLgZ8gau3-yqV1p_r_C4yxVweZBY,3061 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/runner/__pycache__/utils.cpython-38.pyc,sha256=tn_bp_BjIcV0coBMW1CKcx0oOFhB6QBxr3U-X75IEJI,3030 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/runner/config.py,sha256=aUWkmLt74yGwUPHBTtiAhXxcj1sW3Zo1wTDxaF3qBzk,7373 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/runner/local_runner.py,sha256=KBjaTarZMIUP-1g-ZtOLFFRN1Knh_Ah4Ws5KrlZibD0,13051 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/runner/rpc_runner.py,sha256=lNiXR4ydSraKFU_2CelTW-rSoN8MN_DQ62vkesoyUtQ,17682 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/runner/runner.py,sha256=QJ7Iu3Ucvv6AhdK5lfJryX4CgIbo0cJ_dxICNQXDmSA,7196 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/runner/utils.py,sha256=TzKv8I_nc0Lq9HwphYrG5lmJIR1QD7RF6bM3k6x7JBw,3820 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/schedule/__init__.py,sha256=Q1Nv9WNMVnNq_7-0G85kDTcKymnBA1tqw9acKEDSjWc,870 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/schedule/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/schedule/__pycache__/__init__.cpython-310.pyc,sha256=eL4cazQ9zmNZtPzoZFn0A_wvtHL5eDIV3JuNUmnhE_Q,308 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/schedule/__pycache__/__init__.cpython-38.pyc,sha256=QdZC55HPAfN_TQfx9omBDOh-leArhTIiP87we-fugKo,295 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/schedule/cpu/__init__.py,sha256=nmnM0tOa99xlupCmCwsI3MPuHzptNi_0VmJevH4fC7c,853 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/schedule/cpu/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/schedule/cpu/__pycache__/__init__.cpython-310.pyc,sha256=dYa8jYEMRZLp9nswqndJvLVBIKThRalqHw5tUaMMK1g,253 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/schedule/cpu/__pycache__/__init__.cpython-38.pyc,sha256=3BGKzTDReP52sRVGzckKBjH5YFBsV8WOctn8OUeNrPI,240 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/schedule/cuda/__init__.py,sha256=mKDO_1k_qhcWB6M2E6WGU0QoSMnF1bnOkFAunBr3FJ0,886 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/schedule/cuda/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/schedule/cuda/__pycache__/__init__.cpython-310.pyc,sha256=Tn-cls_Bfqd--gdA8tk2kHxtO9hNRbjpTKVKNF3Gyvk,301 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/schedule/cuda/__pycache__/__init__.cpython-38.pyc,sha256=V-78h_tKAUoBf68CsfH6iYQQ_zP0PnsfDNn00iz2UUo,288 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/schedule/cuda/__pycache__/layout_transform.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/schedule/cuda/__pycache__/layout_transform.cpython-310.pyc,sha256=v1r4FjALRNYf0aNh50uLL1Q5t5G9SakGFxI_zq9M4v0,14875 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/schedule/cuda/__pycache__/layout_transform.cpython-38.pyc,sha256=LnDJqwBs6jK2OHT25l45K3meUlB4j7I2ou3Fhm6jFU0,14794 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/schedule/cuda/layout_transform.py,sha256=rnR751AqNs-MczKFLoRHmvKPFLZEogrlufVF-xkKz0U,23824 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/schedule/generic/__init__.py,sha256=dPLPd0Royg1-IQ1diTy3qI-uIpFQajwj_3VlNrWI-sk,850 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/schedule/generic/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/schedule/generic/__pycache__/__init__.cpython-310.pyc,sha256=wppWHz7e4BqT3Q84RaA4hvA3IZQ2CEwW9Zto7OII0pY,254 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/schedule/generic/__pycache__/__init__.cpython-38.pyc,sha256=-fomnCt0R6ON2pQm89nfZy1rqF2hy3TV1trkiuloAU4,241 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/schedule/x86/__init__.py,sha256=u8rAl76PnBDJd37gqqKc0DbNom1a9Qwz-rVAeZXkJ0k,853 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/schedule/x86/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/schedule/x86/__pycache__/__init__.cpython-310.pyc,sha256=AlFfNBTF7iluZSmC0iVOFj6_LVvrDS_g-bf84zqj9Ko,253 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/schedule/x86/__pycache__/__init__.cpython-38.pyc,sha256=xUMa44dU9WFkU3xOOrard8hRo5WiPh7zSgY4dFSLt5I,240 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/schedule_rule/__init__.py,sha256=oM8khui9KfgXIuFnhxk8UVllb_Nxr7lGeRmhIWeE4kA,1524 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/schedule_rule/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/schedule_rule/__pycache__/__init__.cpython-310.pyc,sha256=3oAQIpsCYu0qqXSqmYLZd4rxBN5IgN2MXOgX8ykbIvw,1049 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/schedule_rule/__pycache__/__init__.cpython-38.pyc,sha256=1VVdeLKTDrRF-DVE5AmJeJnLpbZyxe2ouji0OqeWsWk,1036 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/schedule_rule/__pycache__/add_rfactor.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/schedule_rule/__pycache__/add_rfactor.cpython-310.pyc,sha256=fqZEgMz6-5RPoznR7ruMCWcG8rqh2_ZAUYlet0sE_KQ,1393 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/schedule_rule/__pycache__/add_rfactor.cpython-38.pyc,sha256=m3K3iY15P873wbfoH4hU7VARaYO8IRNapChTrgCBsZA,1368 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/schedule_rule/__pycache__/apply_custom_rule.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/schedule_rule/__pycache__/apply_custom_rule.cpython-310.pyc,sha256=jEWN29SZOYJRB7m17e1Vg2ijhmlV6ULVWTEDW_xc6b8,1081 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/schedule_rule/__pycache__/apply_custom_rule.cpython-38.pyc,sha256=P6SQMtX9s2BatvQhc8minLiR08UB-QJM_42beASt6d8,1064 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/schedule_rule/__pycache__/auto_bind.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/schedule_rule/__pycache__/auto_bind.cpython-310.pyc,sha256=AwE-H_aBTz2lz6j0746kyhz2P-dpt2dvA78ga29CSFM,1467 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/schedule_rule/__pycache__/auto_bind.cpython-38.pyc,sha256=pwpOE87VDVKSg7nxdsMtRBP0x_bqq9aCIlllNVRIEFs,1442 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/schedule_rule/__pycache__/auto_inline.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/schedule_rule/__pycache__/auto_inline.cpython-310.pyc,sha256=Rg-P_o9TRKnBArio2GVpt5z1JCllgSKHpIIgFb9-ab4,2576 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/schedule_rule/__pycache__/auto_inline.cpython-38.pyc,sha256=PTYZOoayad9GXWEvrm1ZcafcTyeAmkaWiDsGXdRh7OI,2521 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/schedule_rule/__pycache__/cross_thread_reduction.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/schedule_rule/__pycache__/cross_thread_reduction.cpython-310.pyc,sha256=RPQFugtLgpeIaRJeaYSrSM90Otd-5VEUytPudSmakyk,1236 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/schedule_rule/__pycache__/cross_thread_reduction.cpython-38.pyc,sha256=T9rxgU4MmNgbEfbskjeICWL494Oz-VWpuFa5BTF-FS4,1221 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/schedule_rule/__pycache__/multi_level_tiling.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/schedule_rule/__pycache__/multi_level_tiling.cpython-310.pyc,sha256=0dCCe-6dmYS4cVBe8KCEvK64yxeN5-mOGzeMuocVl9M,8465 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/schedule_rule/__pycache__/multi_level_tiling.cpython-38.pyc,sha256=chXxjiFTMy6D5ajuuqR1SfG8ybxio-Z4ecyNkE_Zqgc,8284 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/schedule_rule/__pycache__/parallel_vectorize_unroll.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/schedule_rule/__pycache__/parallel_vectorize_unroll.cpython-310.pyc,sha256=gTkq50g0ZzIOgH41GqQj508kF9KbyE2xXaw8rqwD9cE,2095 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/schedule_rule/__pycache__/parallel_vectorize_unroll.cpython-38.pyc,sha256=lLojs0bJVgIit1sr7CU00rqL_3uhcsjbu96oBHhJTOk,2058 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/schedule_rule/__pycache__/random_compute_location.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/schedule_rule/__pycache__/random_compute_location.cpython-310.pyc,sha256=3KDqL8bkRVvOq8C1PjqUffC6NhEPFSEOPN3etZWWHcg,950 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/schedule_rule/__pycache__/random_compute_location.cpython-38.pyc,sha256=ipOPTmC9nbZm8raiwYLsG6B5-s76Za12T7OsN_GtBL0,933 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/schedule_rule/__pycache__/schedule_rule.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/schedule_rule/__pycache__/schedule_rule.cpython-310.pyc,sha256=cpouwk3bdm0XoBGRw4ze88_ijT3oRihrI3cfaAtuPjA,5610 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/schedule_rule/__pycache__/schedule_rule.cpython-38.pyc,sha256=kswuj-99pUj2VcIykFXhxDTinXxn-WzFYQJvcoYgXhg,5597 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/schedule_rule/add_rfactor.py,sha256=atsU6b3-HKiHxtGGbnkep3o29FktJptYXJJwar9Wty4,1834 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/schedule_rule/apply_custom_rule.py,sha256=7v4pyLh6k-orYeKQ5bQbfiRJvqxJLgbNh-v_07qDMRE,1467 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/schedule_rule/auto_bind.py,sha256=3s1xJe6v4mguRwrunviKQ64l6Ho_bO_Pt52ymVQrzkI,1958 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/schedule_rule/auto_inline.py,sha256=DLn54Fu6zqpiVJ7-FWts1nfTi0OmrIQF95dELOaMHFc,3027 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/schedule_rule/cross_thread_reduction.py,sha256=SnLtlnJoiisDjjdZN6N_8JzokNcHFOLgMnD-lEBui9I,1618 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/schedule_rule/multi_level_tiling.py,sha256=-YRccTJRZhNxUEaAijJaaccxnCxdNdR1DE4btgbqw3U,9398 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/schedule_rule/parallel_vectorize_unroll.py,sha256=R63h35wR6lFNunrEpYlhKp6uzBTWoAdcPNfgH4ZST1A,2592 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/schedule_rule/random_compute_location.py,sha256=yOHwwCbOpuhvXa3PZTBLqAwv1PFhtDyW2enaf-SpKp4,1324 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/schedule_rule/schedule_rule.py,sha256=0YKDOtsJxpewGOL2yfVIuCtg18Zb9673P0ahRABVq0M,6338 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/search_strategy/__init__.py,sha256=fBGcQfZgm2RuEiWOn2Qg6crL4YwdOP0Oy-LtCygTEEg,1150 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/search_strategy/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/search_strategy/__pycache__/__init__.cpython-310.pyc,sha256=uPA2eS8vAgZmoO9EaPu6sHk1Znx4wqNciwL_3vKl9G8,624 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/search_strategy/__pycache__/__init__.cpython-38.pyc,sha256=jPW5BdGK3xKVwMYU-4UG1o485pjioMkDad0K8onyMns,611 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/search_strategy/__pycache__/evolutionary_search.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/search_strategy/__pycache__/evolutionary_search.cpython-310.pyc,sha256=HcdwPtT3R5fCj3_1Pw6hSGJ8T67Q6wfY9wGNU5-cPro,2307 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/search_strategy/__pycache__/evolutionary_search.cpython-38.pyc,sha256=2gTacrTXyEd10WlEc1TQZQTRYmeLQPbiGE5Yk36GFSU,2297 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/search_strategy/__pycache__/replay_func.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/search_strategy/__pycache__/replay_func.cpython-310.pyc,sha256=nvlTsPGMw7qRN7SHhkjuNSIYco8DcrhZS5I2xsz55nQ,1137 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/search_strategy/__pycache__/replay_func.cpython-38.pyc,sha256=v1Pmkgn4qJ-pWQaSXuiPnzRyvrUt0wlnGVt1MYOpUh0,1122 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/search_strategy/__pycache__/replay_trace.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/search_strategy/__pycache__/replay_trace.cpython-310.pyc,sha256=2NisTR6bp3iZnuJkPYiGzK-JvbBNR8GMRUdrfS16Lg0,1166 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/search_strategy/__pycache__/replay_trace.cpython-38.pyc,sha256=1FiGSjGAotUcXOJOD8plkzxKNkvmUkuRNHYzydz1r1M,1158 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/search_strategy/__pycache__/search_strategy.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/search_strategy/__pycache__/search_strategy.cpython-310.pyc,sha256=K2BguylSfrnriWyDBfOvKcCWPdzzR-XEIEozTEvfYak,8228 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/search_strategy/__pycache__/search_strategy.cpython-38.pyc,sha256=SiuclsRJCnKO7Eh51Cw1zU0kStSPvtH1PZa4GjAA8NA,8157 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/search_strategy/evolutionary_search.py,sha256=qfPjXWB5q4rHg2kGFzbChrsW8a3CwdCGhjNGaYci9ho,2954 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/search_strategy/replay_func.py,sha256=WOBL_qM1mVhb05uZ89OmBms3mDoGWlSAV2DSB4Hyi9s,1554 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/search_strategy/replay_trace.py,sha256=KnEEX09ft4sW_WhKxY4lfnPq47_nTz8J4_sakD4CvHw,1582 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/search_strategy/search_strategy.py,sha256=LXjIZW25Q7UxVuuH0-ebkP1_-DodtVH1Nr379j0CAA0,9872 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/space_generator/__init__.py,sha256=Y2WV70vSIOptK3g6F9hqYE0oM8gfX-LTla72PykDIHs,1193 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/space_generator/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/space_generator/__pycache__/__init__.cpython-310.pyc,sha256=idLBJmGBweWFBX0COFljobMf3LbUgYfPzwdkvPfVo24,680 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/space_generator/__pycache__/__init__.cpython-38.pyc,sha256=k0DnfPbfV3Xk0i_5v9UsD7tv6IDIbuIBi2J1DXTIxIo,667 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/space_generator/__pycache__/post_order_apply.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/space_generator/__pycache__/post_order_apply.cpython-310.pyc,sha256=2SzEWlI7q2ceESy4mqWiS65dOoYJ0FNB9dVx0XLTVXY,1670 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/space_generator/__pycache__/post_order_apply.cpython-38.pyc,sha256=u7fdA7ucV3Ie7td5CfljiV6kzZZsz7hfQqMMF9SGM5k,1641 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/space_generator/__pycache__/schedule_fn.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/space_generator/__pycache__/schedule_fn.cpython-310.pyc,sha256=HDuIgVimQM0iRrJ8RHk53NhjhlcLdZ1Y4k2kwuY3e4Q,1666 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/space_generator/__pycache__/schedule_fn.cpython-38.pyc,sha256=6UhyFTEHb1jSQyUJUSzvcEHt_kMcslt0yWtHHF0Ctn4,1635 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/space_generator/__pycache__/space_generator.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/space_generator/__pycache__/space_generator.cpython-310.pyc,sha256=78AEn7ZSZuOcUxI6bUtPQXo5GNIYsctyE07jWS9IZEc,6244 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/space_generator/__pycache__/space_generator.cpython-38.pyc,sha256=f1nQO4WyuYKarC6Tn4PbzQB2xMiR2VyLUp2s4es079A,6224 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/space_generator/__pycache__/space_generator_union.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/space_generator/__pycache__/space_generator_union.cpython-310.pyc,sha256=DsiqzgVmSQb-cNFvRCiHg_jYVjBGy385JHljUmnrsVY,1414 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/space_generator/__pycache__/space_generator_union.cpython-38.pyc,sha256=I5DGOLk50naxsNaC26uWVMBhJDZAxEdCkYdi_X96LF0,1383 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/space_generator/post_order_apply.py,sha256=v2PbOkW5YyL-dHFWH0cdKnYTPQ2CjSMGZA_DtuE7RAA,2271 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/space_generator/schedule_fn.py,sha256=in_k_TVA1VH03sE44I9_1y0ll4l4RQ2eSuKWEm0LN1w,2263 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/space_generator/space_generator.py,sha256=mXGEHUAXWbVIhtwqmwTVzD7Atj-IclNHoKj_mZetE80,8726 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/space_generator/space_generator_union.py,sha256=fr4tr2Shiai79gyeILUxp2qzg0m_oscAxgTN5eF8_rY,1995 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/task_scheduler/__init__.py,sha256=RWjBbbvISeYypRUC-bwkVoQeSGiiHYfS7zShCIxKBwI,1131 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/task_scheduler/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/task_scheduler/__pycache__/__init__.cpython-310.pyc,sha256=82dOaakhrhPAcuAa4wNYBOFugoFURBe2fdRgqo0IdK0,586 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/task_scheduler/__pycache__/__init__.cpython-38.pyc,sha256=eZIy7Y8mW3mG1Cgq4F64nXhcpzfnTQyp0qLhn3Xp4j0,573 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/task_scheduler/__pycache__/gradient_based.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/task_scheduler/__pycache__/gradient_based.cpython-310.pyc,sha256=3mf3t6Wd--sUZ1rvNoDZaZuR8bjUcHXHHGTXqowIzRw,1382 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/task_scheduler/__pycache__/gradient_based.cpython-38.pyc,sha256=cdW-vzhG-k6ofvUtwHktc8LgXjHK9KzXrlX55bq5SSQ,1357 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/task_scheduler/__pycache__/round_robin.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/task_scheduler/__pycache__/round_robin.cpython-310.pyc,sha256=Myd4owbp6QeRYCgwAFBTe0Q4ufQRROGRkM3V-dF95XM,921 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/task_scheduler/__pycache__/round_robin.cpython-38.pyc,sha256=h87Bk0r1pKnP948oBC81UVbbbuBfTH_78YNF_Bwrn_Q,904 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/task_scheduler/__pycache__/task_scheduler.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/task_scheduler/__pycache__/task_scheduler.cpython-310.pyc,sha256=GCpD9PGHqaNa4mHnyKFcZ1bCjTnA45jXYq1dWzw2whw,7732 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/task_scheduler/__pycache__/task_scheduler.cpython-38.pyc,sha256=UDXGWkswLlpP3QVEE65H02P4TxxLjPcmKEnWPpyDSHw,7669 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/task_scheduler/gradient_based.py,sha256=2iLWzqlMBH7SUZjidJluJLtq-jK_lOn7CX2TI6IvUmg,1880 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/task_scheduler/round_robin.py,sha256=mGWeqtcgTgctEM4uxospaw_Bi7CdGWlGnzF87iwj_SA,1396 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/task_scheduler/task_scheduler.py,sha256=5sVx-Z__KeUqQO65lOK8cmCn68uMbI5L3u5AwhxHuTY,8661 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/testing/__init__.py,sha256=FDodOOFrpuJuOsU_Rj6zy7xhO8ihKTUOle3ZdNSLoJI,876 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/testing/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/testing/__pycache__/custom_builder_runner.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/testing/__pycache__/dataset_collect_models.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/testing/__pycache__/dataset_extract_tasks.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/testing/__pycache__/dataset_sample_candidates.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/testing/__pycache__/distributed_measure_candidates.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/testing/__pycache__/dummy_object.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/testing/__pycache__/local_rpc.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/testing/__pycache__/relay_workload.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/testing/__pycache__/space_generation.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/testing/__pycache__/te_workload.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/testing/__pycache__/tlcbench.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/testing/__pycache__/tune_onnx.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/testing/__pycache__/tune_relay.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/testing/__pycache__/tune_te.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/testing/__pycache__/tune_utils.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/testing/__pycache__/validate_database.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/testing/custom_builder_runner.py,sha256=7fHelVVkWYyx-wra_XF6ubsYDR-ttjWT1eMJL7MATQQ,5457 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/testing/dataset_collect_models.py,sha256=kKmvbhnTH2jQY6hMlT_tjXz2CHZr3gTgJm5kWjuXEc8,3050 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/testing/dataset_extract_tasks.py,sha256=tP8rkjB998KDdUdba4I3RxBcHCH-1CblQSaGwMeVJMc,3657 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/testing/dataset_sample_candidates.py,sha256=xBVe6m8GnBVTL0HYbSAF26J49IADLYdFvIsRNPPRMmI,6498 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/testing/distributed_measure_candidates.py,sha256=Nq2E61bu-TrCkSw7FY7xNlwl9Dlp_GOZqL6kG8Vee1g,7702 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/testing/dummy_object.py,sha256=7lTAX_96PcNNo6N3P7lVwLa4DoP5LbeU0AFZMf1ykQ0,2182 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/testing/local_rpc.py,sha256=oVQo7qPin6ODrkQHd71nj1_9om2DQg-I_kx2es4UIG4,2186 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/testing/relay_workload.py,sha256=sAs-HeZjWZKRlrs8T53geMqhtZanmeIBW6TkBQVdceI,10611 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/testing/space_generation.py,sha256=SCmMQ8sSWyjA6jVV6dslp10IVZHJdEBpfPYS-BmkLwo,5121 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/testing/te_workload.py,sha256=FBSDmXDDZGjnawbo1-eKbKmYUmHXDil0eBjFebR1pZY,29336 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/testing/tlcbench.py,sha256=Azh_-3ZYuHtgUdf9DKhRNCjwQghTOjOz8SQSaDCMV3A,4266 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/testing/torchbench/__init__.py,sha256=9hdXHABrVpkbpjZgUft39kOFL2xSGeG4GEua0Hmelus,785 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/testing/torchbench/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/testing/torchbench/__pycache__/run.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/testing/torchbench/__pycache__/utils.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/meta_schedule/testing/torchbench/run.py,sha256=hqjUn9TMtIUF0xlyz97vfzPnYWotCvRVIjuGMY-RwrA,25562 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/testing/torchbench/utils.py,sha256=pdwerIgKRMbLfx4qJnooMJiQjnXlYU-9tLptQHgvPcg,5837 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/testing/tune_onnx.py,sha256=mnAkCZWKY-xu_7WUOjhj4S1_H8YL1oRx8Fccg88Wlmg,5537 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/testing/tune_relay.py,sha256=_Ssf13rR2nqmrNkkkKQpu1oUrPO3OSa4W6hk8YZ_SjM,5867 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/testing/tune_te.py,sha256=gAq_gMjQWwBW9f2hnx19HQSsq5c69y-L10OQvjfpuR0,4191 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/testing/tune_utils.py,sha256=Byl7GgLa8OhZDL29cWUjWis7dAOQaQs1Gm1-0yjEHJ4,8124 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/testing/validate_database.py,sha256=g-X_DLImrfDNmgtYDcZMcclf0ndBAMb4kA-kU_9EP9A,25351 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/tir_integration.py,sha256=DZN-rd1sWRG71EIeVAuHY-tCTLP6qoxfo2AqK46wWnM,9280 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/trace_apply.py,sha256=CRMUji5pQ_AlKlZgWV6qGvux31WLHvrvR9nVOYuNYzQ,1761 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/tune.py,sha256=ttKA1-K0xUNb6qEVqHrgh1Ef0LEkS-AxSewAwAIInIU,5072 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/tune_context.py,sha256=xY52Uc7sGCjcN3RVWjn6iQthR4wnXkDIlnkJ24kyOtw,10981 +bitblas/3rdparty/tvm/python/tvm/meta_schedule/utils.py,sha256=aP8q0Ddbs6IED3PicT88423CguRMAAMgjxVPhbS0LyM,13195 +bitblas/3rdparty/tvm/python/tvm/micro/__init__.py,sha256=ebO0AdaF5FW0548EMQfdBOVTtuNjai7errnSa3UlgeA,1431 +bitblas/3rdparty/tvm/python/tvm/micro/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/micro/__pycache__/__init__.cpython-310.pyc,sha256=xQ240RWYp9WLt4J9ZxhGqMXOxltTRiM1sG5cwokXzF4,901 +bitblas/3rdparty/tvm/python/tvm/micro/__pycache__/base.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/micro/__pycache__/base.cpython-310.pyc,sha256=FF17XLDx1cHYrOFvV8bBjQniY_8-falQlTe8HcoMcAA,296 +bitblas/3rdparty/tvm/python/tvm/micro/__pycache__/build.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/micro/__pycache__/build.cpython-310.pyc,sha256=t-gUj5P9EuD5FNQ5NODNf4qffPX2wm5W9CFiS0Ns-sA,5667 +bitblas/3rdparty/tvm/python/tvm/micro/__pycache__/class_factory.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/micro/__pycache__/debugger.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/micro/__pycache__/model_library_format.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/micro/__pycache__/model_library_format.cpython-310.pyc,sha256=SIb3I2cPI6vCOclKOCNOV42aQIhuGZB42gijV2p6Nws,18027 +bitblas/3rdparty/tvm/python/tvm/micro/__pycache__/project.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/micro/__pycache__/project.cpython-310.pyc,sha256=Hi7eKnEMh0UVZt5tqjDwpCRmb_40Oe3k-6zRZ2oD8YA,8673 +bitblas/3rdparty/tvm/python/tvm/micro/__pycache__/session.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/micro/__pycache__/session.cpython-310.pyc,sha256=Xsgl11roSlDtwCU9HZT3wJUTn_1nNqys2bOBKJ2zCMk,10666 +bitblas/3rdparty/tvm/python/tvm/micro/__pycache__/transport.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/micro/__pycache__/transport.cpython-310.pyc,sha256=oHFMAOoYajqfW53W8OEAj7GHmR4JRkiqUlMjMtpviBE,8385 +bitblas/3rdparty/tvm/python/tvm/micro/base.py,sha256=Bf48UqQlm5dBVHpO6CMvh5AEmXvxiWx4GjW89-omDyU,900 +bitblas/3rdparty/tvm/python/tvm/micro/build.py,sha256=1Sj6r7koeZNIPwGZwZT8jtJFhO_R-KW3EEsUTBaIIgo,6590 +bitblas/3rdparty/tvm/python/tvm/micro/class_factory.py,sha256=drfRZlaCawrUj0fN9Vl93AnEqTnofwVSe_z-SoFjL50,3350 +bitblas/3rdparty/tvm/python/tvm/micro/contrib/stm32/__init__.py,sha256=Tpieoh0ggqX_2UMibXFWkYqkY62NEWtYG9OB8rnBWXQ,915 +bitblas/3rdparty/tvm/python/tvm/micro/contrib/stm32/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/micro/contrib/stm32/__pycache__/emitter.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/micro/contrib/stm32/emitter.py,sha256=hcweblK5Yxhv66tSQKM1GiaZNgl1bvk15jFjaQYPpkw,42638 +bitblas/3rdparty/tvm/python/tvm/micro/debugger.py,sha256=YUUJRHmxe_rg0dRcvN23n7LxPx_B4NHosvc853Kc1Mg,12966 +bitblas/3rdparty/tvm/python/tvm/micro/model_library_format.py,sha256=1AyS4xkiMgn709pi6K8Ze4cxlLeEVy-ivsGp3-KCPsQ,23962 +bitblas/3rdparty/tvm/python/tvm/micro/project.py,sha256=b5_miK6k7BQ8Jnx3ammtxR1Kokbd5gOcDHJP46pZcmw,8163 +bitblas/3rdparty/tvm/python/tvm/micro/project_api/__init__.py,sha256=6px3flxAZi1qignE96v4MnNi0swF8q_06OODSpKBbq4,830 +bitblas/3rdparty/tvm/python/tvm/micro/project_api/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/micro/project_api/__pycache__/__init__.cpython-310.pyc,sha256=P8xBOeO1qc4mBPMy_dgMhAh7AX03P9eT86pkcJ57SMc,221 +bitblas/3rdparty/tvm/python/tvm/micro/project_api/__pycache__/client.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/micro/project_api/__pycache__/client.cpython-310.pyc,sha256=erklvJEblGwr3bpsFzNnI44S31nfaozZ8R6yzu6O63Y,7070 +bitblas/3rdparty/tvm/python/tvm/micro/project_api/__pycache__/server.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/micro/project_api/__pycache__/server.cpython-310.pyc,sha256=uuEmMDIXBF2ohoHyFbGuPtX6iNtTqWB4Szazb27a1Cc,25402 +bitblas/3rdparty/tvm/python/tvm/micro/project_api/client.py,sha256=jrgsGn2IN6jsLaHy_cFHnUfR1A1sxFbyf9erdKL12JQ,8189 +bitblas/3rdparty/tvm/python/tvm/micro/project_api/server.py,sha256=FtZnyV6PGHfhZE_wbVUIm3L8954YRXZSVW71TsI4XIM,30727 +bitblas/3rdparty/tvm/python/tvm/micro/session.py,sha256=Rv13vh4C81Sw_236k3Khi0ZO_rWkZubuq0FaFadW9AU,12041 +bitblas/3rdparty/tvm/python/tvm/micro/testing/__init__.py,sha256=Wta9lfPfFXBzta9sEDvDz3Zdu7GTkYz6mrouE6cxA6s,999 +bitblas/3rdparty/tvm/python/tvm/micro/testing/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/micro/testing/__pycache__/aot_test_utils.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/micro/testing/__pycache__/evaluation.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/micro/testing/__pycache__/pytest_plugin.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/micro/testing/__pycache__/utils.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/micro/testing/aot_test_utils.py,sha256=WIjo2Ne3dwXF6wiMkSOsNqJvXegYzql0WOj4Qc_0vPQ,3280 +bitblas/3rdparty/tvm/python/tvm/micro/testing/evaluation.py,sha256=S7H33y5T3LSFcLA2xETS-6ontJo0AFyCIsa1hp5_dXk,5904 +bitblas/3rdparty/tvm/python/tvm/micro/testing/pytest_plugin.py,sha256=L_DNEgESLUzOpGIiPbjQ7g58Jrz-thj57AuUM5k35nI,5268 +bitblas/3rdparty/tvm/python/tvm/micro/testing/utils.py,sha256=w_u_oLW_h1ZimX_JwcUPCk257U2v5y1D48mMVXnoXyo,6414 +bitblas/3rdparty/tvm/python/tvm/micro/transport.py,sha256=pY51CaV7Nmgq61-5UIkm3rwzoid7p9-JMKYu-LTGkBw,9424 +bitblas/3rdparty/tvm/python/tvm/parser.py,sha256=nGweaSphrjEg_vEvix7KQaBSiI6H5HQQCRPKtxHLIDE,1816 +bitblas/3rdparty/tvm/python/tvm/relax/__init__.py,sha256=KSlWDaq8f_9gHQ5BAvpauu8aPBlJjnmmhAZxlYmb34Q,2583 +bitblas/3rdparty/tvm/python/tvm/relax/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/__pycache__/__init__.cpython-310.pyc,sha256=IZhk621nTQmKUHrm0m-IKYizi-Z1rVvXMsdZ_jf3wFo,2143 +bitblas/3rdparty/tvm/python/tvm/relax/__pycache__/__init__.cpython-38.pyc,sha256=twVdg7rHUX6d0-NjOcJsmC8i8q6sjf8g8pqFM62rjHE,2130 +bitblas/3rdparty/tvm/python/tvm/relax/__pycache__/_ffi_api.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/__pycache__/_ffi_api.cpython-310.pyc,sha256=6Mm_8C430Kwe_XkNVA-RfIJuXwLZY3Y4p38AupJQYh8,269 +bitblas/3rdparty/tvm/python/tvm/relax/__pycache__/_ffi_api.cpython-38.pyc,sha256=YO878uGjQ4QF7x_31_zw02IdoXWEr_T1L_X91SDACKw,256 +bitblas/3rdparty/tvm/python/tvm/relax/__pycache__/binding_rewrite.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/__pycache__/binding_rewrite.cpython-310.pyc,sha256=Xu__HnXiI-Lo1f2rNvJOcePODhIT4M1v7empZ0XA7QI,5497 +bitblas/3rdparty/tvm/python/tvm/relax/__pycache__/binding_rewrite.cpython-38.pyc,sha256=F26usudA5M0eOyxDVVEvYOuzdwV1_CG3VS87o3lZ_DA,5521 +bitblas/3rdparty/tvm/python/tvm/relax/__pycache__/block_builder.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/__pycache__/block_builder.cpython-310.pyc,sha256=9_X0DlHPVxzBZ7RSSBOXu-eqzY08zbdT4xn1Cw6s-Ts,26634 +bitblas/3rdparty/tvm/python/tvm/relax/__pycache__/block_builder.cpython-38.pyc,sha256=gJ7L0W3cdorlaV3LgShJBCyNL8qtjbIZFJfeUWKySF0,26928 +bitblas/3rdparty/tvm/python/tvm/relax/__pycache__/exec_builder.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/__pycache__/exec_builder.cpython-310.pyc,sha256=Me3eq-zOU4MFvExLGAQmVpw38kHCkahLQ3oJLTBrXSw,5840 +bitblas/3rdparty/tvm/python/tvm/relax/__pycache__/exec_builder.cpython-38.pyc,sha256=GPuI3ivb6MpRdjOo-E4FyUT1IMjxUGlzTBgLLgA5qkY,5969 +bitblas/3rdparty/tvm/python/tvm/relax/__pycache__/expr.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/__pycache__/expr.cpython-310.pyc,sha256=wAxWm4llSxC9Gko3_sPGuPLgr4Mc36ATdMzQk15aBlQ,38017 +bitblas/3rdparty/tvm/python/tvm/relax/__pycache__/expr.cpython-38.pyc,sha256=Qe5mVqYrRxpetlNIP4QSKEdBcu0_ROu5hlbUwO8m4r0,39124 +bitblas/3rdparty/tvm/python/tvm/relax/__pycache__/expr_functor.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/__pycache__/expr_functor.cpython-310.pyc,sha256=hQAWT6U1zHHC1s_gH5RtxkxLE53sByvaTmN4vlRVNJQ,39808 +bitblas/3rdparty/tvm/python/tvm/relax/__pycache__/expr_functor.cpython-38.pyc,sha256=xShjrPPKhMzIFkExE3pM6lpm7Wi_GMpGpqN-P7jDgNg,41202 +bitblas/3rdparty/tvm/python/tvm/relax/__pycache__/pipeline.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/__pycache__/pipeline.cpython-310.pyc,sha256=sEO9UhZdLECih6vOT5DadAGRLfp1L2TXXYhsw26wWxM,3822 +bitblas/3rdparty/tvm/python/tvm/relax/__pycache__/pipeline.cpython-38.pyc,sha256=ZiyP0zVwXJ0usXJYNxw024XX8eTB8BjVxxBGVZ1wFSo,3795 +bitblas/3rdparty/tvm/python/tvm/relax/__pycache__/struct_info.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/__pycache__/struct_info.cpython-310.pyc,sha256=x87ZtLO_XWuzyFa9JkR0hU5x7ks7Wb0aO3TjnV5Ft0s,7332 +bitblas/3rdparty/tvm/python/tvm/relax/__pycache__/struct_info.cpython-38.pyc,sha256=6xHHEypD6W9CDr3JQjDj2Th6QzrUEqwK2l99eBvfCj4,7368 +bitblas/3rdparty/tvm/python/tvm/relax/__pycache__/ty.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/__pycache__/ty.cpython-310.pyc,sha256=vjPgEkJ8fG12Pwvfxkf_sstwG7fIdbwYAEQ1rSLS4BI,2401 +bitblas/3rdparty/tvm/python/tvm/relax/__pycache__/ty.cpython-38.pyc,sha256=LhcH9rgPjY1HyDmI5HLWrFbYKpUSOmk5wglHvGsF4Pc,2422 +bitblas/3rdparty/tvm/python/tvm/relax/__pycache__/utils.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/__pycache__/utils.cpython-310.pyc,sha256=BsCNLP9S3EYeQXRd_ZbcoVQAvmeup4D2vXPi2fKe-z0,17183 +bitblas/3rdparty/tvm/python/tvm/relax/__pycache__/utils.cpython-38.pyc,sha256=VwmN11-zF1ndmD2o83TaFytfnFqtpDgglTVStciiDKQ,17228 +bitblas/3rdparty/tvm/python/tvm/relax/__pycache__/vm_build.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/__pycache__/vm_build.cpython-310.pyc,sha256=HM1qkrficyo_FBU0dY7G-lSJG2gUf8_FwdD3eRIomW4,10148 +bitblas/3rdparty/tvm/python/tvm/relax/__pycache__/vm_build.cpython-38.pyc,sha256=Mhs5oGtGGMxVzdR9CINAQJ0cIP6ebZLvmGQIaEUjcAA,10102 +bitblas/3rdparty/tvm/python/tvm/relax/_ffi_api.py,sha256=jzUvF50d-qPi1iDa12jqphHYoCJT_hao0Jj6Um6Ep4c,865 +bitblas/3rdparty/tvm/python/tvm/relax/analysis/__init__.py,sha256=X76slFdmYYWaII3r44O6HekYwO9iDVgLSXr7VXH1gyo,1480 +bitblas/3rdparty/tvm/python/tvm/relax/analysis/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/analysis/__pycache__/__init__.cpython-310.pyc,sha256=4UMISM52c7tVJKqXnghewwHMwRFL97a56gpeNt7gXB4,980 +bitblas/3rdparty/tvm/python/tvm/relax/analysis/__pycache__/__init__.cpython-38.pyc,sha256=rKarSrItqILGOS4H7uhfTp2e5j-2OGg1XSm7rcW8Qus,967 +bitblas/3rdparty/tvm/python/tvm/relax/analysis/__pycache__/_ffi_api.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/analysis/__pycache__/_ffi_api.cpython-310.pyc,sha256=qvHwdQyo_PLpxJRu19skXrS-ELcREhzA1QeQUGKg6k4,277 +bitblas/3rdparty/tvm/python/tvm/relax/analysis/__pycache__/_ffi_api.cpython-38.pyc,sha256=YB1nq4oq7Ur18gy_6SdXqcd6Mg8diKEnfGRr6lZ1nDI,264 +bitblas/3rdparty/tvm/python/tvm/relax/analysis/__pycache__/analysis.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/analysis/__pycache__/analysis.cpython-310.pyc,sha256=UkhxZ4rHYCtFKU-AmM6oWYrEWauuP0n2umHQxraz7PA,16430 +bitblas/3rdparty/tvm/python/tvm/relax/analysis/__pycache__/analysis.cpython-38.pyc,sha256=lVZ83UFK95EscgVDXTCiAACcVXW5WCiIxlGbQ1DkYs4,16654 +bitblas/3rdparty/tvm/python/tvm/relax/analysis/__pycache__/estimate_memory_usage.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/analysis/__pycache__/estimate_memory_usage.cpython-310.pyc,sha256=6qlFfZCUnT5NPkFZ4HS5TbelFBudvRHIcuvDgXUTTMU,6297 +bitblas/3rdparty/tvm/python/tvm/relax/analysis/__pycache__/estimate_memory_usage.cpython-38.pyc,sha256=tbm_i9eWzJ3IU3XFdJ2Min90jeM6LkBf_zs-Mudszbg,6284 +bitblas/3rdparty/tvm/python/tvm/relax/analysis/_ffi_api.py,sha256=crkCusAEHJFHyWShg6OnR27TEnxTQmEflesG7WbfP1s,843 +bitblas/3rdparty/tvm/python/tvm/relax/analysis/analysis.py,sha256=8MEO7ymY3E0LvL002Wjc9AcxnpZz4SObcTyUc5SrEdA,16578 +bitblas/3rdparty/tvm/python/tvm/relax/analysis/estimate_memory_usage.py,sha256=I5tVlMPuSwel7pzdpcPf76KdlSNT4Ov2vAIbUKk55oE,7391 +bitblas/3rdparty/tvm/python/tvm/relax/backend/__init__.py,sha256=m4p1YB4HmIHuhmLyLmsLAnRxuglBBSF7p_3h57aEmdA,946 +bitblas/3rdparty/tvm/python/tvm/relax/backend/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/backend/__pycache__/__init__.cpython-310.pyc,sha256=I0h58SI8Lxo5ATZ9Q_XBnZStmbY8JxcMMV5By4Y4Ig4,376 +bitblas/3rdparty/tvm/python/tvm/relax/backend/__pycache__/__init__.cpython-38.pyc,sha256=45i2KIKxTTlMlmI6iyVOJ7mn9rM4pvh54-VdCgvvpyg,363 +bitblas/3rdparty/tvm/python/tvm/relax/backend/__pycache__/_ffi_api.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/backend/__pycache__/_ffi_api.cpython-310.pyc,sha256=blSd-MZi96NGcsS0rWuOITeDTnujxskmBcUR6k3eG-A,293 +bitblas/3rdparty/tvm/python/tvm/relax/backend/__pycache__/_ffi_api.cpython-38.pyc,sha256=1qN3woEnav3pLqJKbMus3EwZdWyD-0gTgqAcX2txjU0,280 +bitblas/3rdparty/tvm/python/tvm/relax/backend/__pycache__/dispatch_sort_scan.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/backend/__pycache__/dispatch_sort_scan.cpython-310.pyc,sha256=kOvqkm0glrmZldJc8dfW6G06moKXjSrw0xwjrUXQrP0,7067 +bitblas/3rdparty/tvm/python/tvm/relax/backend/__pycache__/dispatch_sort_scan.cpython-38.pyc,sha256=PWqfd6SlinmLOgGMsl3j9RnIzXuaxMfKzbzQ5xfTaWQ,6996 +bitblas/3rdparty/tvm/python/tvm/relax/backend/__pycache__/pattern_registry.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/backend/__pycache__/pattern_registry.cpython-310.pyc,sha256=50Vq5RtvhrGEmRM-ppIXPI4LEsBFW2D9GtCj3iSpGpk,3158 +bitblas/3rdparty/tvm/python/tvm/relax/backend/__pycache__/pattern_registry.cpython-38.pyc,sha256=L6VciY-sK6_eEzO25KxHFrvbXEf26oqgfWMWzjthADA,3160 +bitblas/3rdparty/tvm/python/tvm/relax/backend/__pycache__/patterns.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/backend/__pycache__/utils.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/backend/_ffi_api.py,sha256=n2nQB5BUHCQrSluscDQa1GDz96tSfXiapVS32mw5DeM,882 +bitblas/3rdparty/tvm/python/tvm/relax/backend/contrib/__init__.py,sha256=37OKdv6IDuhOyCGoPyyHoIVdDUd6kKUmLsXb9Zzfuk8,814 +bitblas/3rdparty/tvm/python/tvm/relax/backend/contrib/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/backend/contrib/__pycache__/__init__.cpython-310.pyc,sha256=KSke2yPF4EEubclkl3IYsTVcLEJ0iDYLn-g5i9jbMIk,209 +bitblas/3rdparty/tvm/python/tvm/relax/backend/contrib/__pycache__/__init__.cpython-38.pyc,sha256=XGx3Gv5_J0wPHXIn8_i081_wJWHr0kP8IesA70buhJo,196 +bitblas/3rdparty/tvm/python/tvm/relax/backend/contrib/__pycache__/coreml.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/backend/contrib/__pycache__/cublas.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/backend/contrib/__pycache__/cudnn.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/backend/contrib/__pycache__/cutlass.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/backend/contrib/coreml.py,sha256=Gd8bG6U5izuB0k6U2fAup8LnHbtJPpcEWfp5O2ABMgE,15317 +bitblas/3rdparty/tvm/python/tvm/relax/backend/contrib/cublas.py,sha256=MAciWvrLR4hNn-aCcSyEAs_n5HCV2cdb6cgf1KgTAdA,7156 +bitblas/3rdparty/tvm/python/tvm/relax/backend/contrib/cudnn.py,sha256=od4YKVJVFEsghtNSh6bdLr-eTILcYlBJ5-p9duBPwIQ,3504 +bitblas/3rdparty/tvm/python/tvm/relax/backend/contrib/cutlass.py,sha256=nIDkxNEN3rnonvrmTaHZHXellaGff9nhk4ssybaocWs,19926 +bitblas/3rdparty/tvm/python/tvm/relax/backend/dispatch_sort_scan.py,sha256=TQ-NZhKq5ujw8uB0P6dxE0VNYpCxd6NG30eD5vHY55k,10836 +bitblas/3rdparty/tvm/python/tvm/relax/backend/pattern_registry.py,sha256=9wueUIUoiww_XhQwphJ7aoWAtSyfX_o7OT_whiln2VY,3755 +bitblas/3rdparty/tvm/python/tvm/relax/backend/patterns.py,sha256=grZn1UzIDIc3xf4PqfN-Vkui1YeSA6GY0dVOP4O9Gvc,17853 +bitblas/3rdparty/tvm/python/tvm/relax/backend/utils.py,sha256=lfOtg0RU40geNpdCZkgb_J0oI353nQta8_LFT-55oqw,1822 +bitblas/3rdparty/tvm/python/tvm/relax/backend_tir/__init__.py,sha256=2W5lPPuurl1w2XWvd-CNvPiRIDRYIWquQnCJCRNa52Y,922 +bitblas/3rdparty/tvm/python/tvm/relax/backend_tir/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/backend_tir/__pycache__/cumsum.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/backend_tir/__pycache__/pattern.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/backend_tir/contrib/__init__.py,sha256=frjs1BlcSTIVqZ3bWFFRG3v7t3Nhdc1IWKGnKlnGZa8,886 +bitblas/3rdparty/tvm/python/tvm/relax/backend_tir/contrib/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/backend_tir/contrib/__pycache__/cutlass.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/backend_tir/contrib/cutlass.py,sha256=cw8h_0NCQ1pgK54BZby_-tIsN8_7VPtCcjUm4axKRYM,25924 +bitblas/3rdparty/tvm/python/tvm/relax/backend_tir/cumsum.py,sha256=9UiiLYMoAt2J0JPRc_7dDlgaCU_MVmTP7q3toh43q34,8077 +bitblas/3rdparty/tvm/python/tvm/relax/backend_tir/pattern.py,sha256=mhEQTjPryFfkSd2KG68toVSD1ZYf4oJOQxwBXWrZPdY,19776 +bitblas/3rdparty/tvm/python/tvm/relax/binding_rewrite.py,sha256=k_2mGrnMyXTDYcNK0NmobvqGOTeGl98bPt5Df3MtuoE,5496 +bitblas/3rdparty/tvm/python/tvm/relax/block_builder.py,sha256=sXIERxTlk7wjEdXMsu3CuCGbPUvPEqvyWcs6MpZhkM8,28004 +bitblas/3rdparty/tvm/python/tvm/relax/distributed/__init__.py,sha256=ByyLMCPOofjipM2LMUvLhGWwOxL0HJVRj8pofS-4PR8,991 +bitblas/3rdparty/tvm/python/tvm/relax/distributed/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/distributed/__pycache__/__init__.cpython-310.pyc,sha256=OldanMo3YCwwjXetfJOFTel1YMy_hLwqxIwecH17VyA,441 +bitblas/3rdparty/tvm/python/tvm/relax/distributed/__pycache__/__init__.cpython-38.pyc,sha256=dqiZ2iKZ6gIq1-BkCXFPrOxIXQtleWYmDKpbGbOrtmM,428 +bitblas/3rdparty/tvm/python/tvm/relax/distributed/__pycache__/_ffi_api.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/distributed/__pycache__/_ffi_api.cpython-310.pyc,sha256=TAjAPxmUxNOP-u1E7K611OerMURh4-1LS9lazVikic0,309 +bitblas/3rdparty/tvm/python/tvm/relax/distributed/__pycache__/_ffi_api.cpython-38.pyc,sha256=kOl2Lxwf6fWUso-2zGkC4_fAx3QokPG1lTfX9-JwL9g,296 +bitblas/3rdparty/tvm/python/tvm/relax/distributed/__pycache__/global_info.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/distributed/__pycache__/global_info.cpython-310.pyc,sha256=BQhnOVzxhzfyUhDchb0rvhn_ym_7C8tULpkE-0evmMQ,1908 +bitblas/3rdparty/tvm/python/tvm/relax/distributed/__pycache__/global_info.cpython-38.pyc,sha256=A4ef3Dd5Uv6oVRoZpKZTHrdXi9o-gyMDZxcB2qQC6Jw,1886 +bitblas/3rdparty/tvm/python/tvm/relax/distributed/__pycache__/struct_info.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/distributed/__pycache__/struct_info.cpython-310.pyc,sha256=wDyrEOtYFuBM-cRUg6rbKSeivJ8WC9ap9U4tmzFsI7U,4209 +bitblas/3rdparty/tvm/python/tvm/relax/distributed/__pycache__/struct_info.cpython-38.pyc,sha256=E8W_r7F0P0GfwNAVppvdhYoCRZpEb_t5g6z5SX89cxs,4215 +bitblas/3rdparty/tvm/python/tvm/relax/distributed/_ffi_api.py,sha256=jjS4ggIs-8uR3DUQzHdZeNpBwa2PQUWPBBk_y4-c_fU,893 +bitblas/3rdparty/tvm/python/tvm/relax/distributed/global_info.py,sha256=7-E4Y8FoYkfAUqt_MVWwNCOtiG0dbtPw1a_dutWixDo,2432 +bitblas/3rdparty/tvm/python/tvm/relax/distributed/struct_info.py,sha256=TmM6l7-MN4bNs96UUo1Ty_dLuG8RReqqxONiGs4sWGw,4079 +bitblas/3rdparty/tvm/python/tvm/relax/distributed/transform/__init__.py,sha256=QFZqypVUqxGV0CysL0JejE0oOl46PiO_PMFszFSeSFQ,961 +bitblas/3rdparty/tvm/python/tvm/relax/distributed/transform/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/distributed/transform/__pycache__/__init__.cpython-310.pyc,sha256=-zH8I9jc3ICcD7b11KuvxaQcpnF2Gm5iEWgiH8X77yo,382 +bitblas/3rdparty/tvm/python/tvm/relax/distributed/transform/__pycache__/__init__.cpython-38.pyc,sha256=dmrTKSR4tueTe0Kvkt2h5vxv3FhKqpaR1Wjgee-MtsU,369 +bitblas/3rdparty/tvm/python/tvm/relax/distributed/transform/__pycache__/_ffi_api.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/distributed/transform/__pycache__/_ffi_api.cpython-310.pyc,sha256=9gyVFvrVD6fpAR4NbE_Z_JyhuMFFN_gnrX43UO5qbfY,339 +bitblas/3rdparty/tvm/python/tvm/relax/distributed/transform/__pycache__/_ffi_api.cpython-38.pyc,sha256=QyLuY-ZTIw8TCj5MQrCJ4dI-NEOpevZYDzxgRpddYyM,326 +bitblas/3rdparty/tvm/python/tvm/relax/distributed/transform/__pycache__/transform.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/distributed/transform/__pycache__/transform.cpython-310.pyc,sha256=exN2BH4l3g5KNVn0tPi-E5k9wAe23AsWiydNVJ_xKtc,1402 +bitblas/3rdparty/tvm/python/tvm/relax/distributed/transform/__pycache__/transform.cpython-38.pyc,sha256=sQ-eA4RLoTDz5q3YLsoLXH6FO4nObkyQHywL5-cJ3zQ,1419 +bitblas/3rdparty/tvm/python/tvm/relax/distributed/transform/_ffi_api.py,sha256=mtiU1tFHrdz8UugZQGJWxjOvlKLv5gpmy1dDXorNDnw,892 +bitblas/3rdparty/tvm/python/tvm/relax/distributed/transform/transform.py,sha256=hmsJEsikGlH7v4J3Kfa9A9qo93qNuB1cMNhkqmJqGOU,1940 +bitblas/3rdparty/tvm/python/tvm/relax/dpl/__init__.py,sha256=Vp6eqfOo0advATHW2j4u7Dx-UT8TigK3lvDzQcZa5BQ,928 +bitblas/3rdparty/tvm/python/tvm/relax/dpl/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/dpl/__pycache__/__init__.cpython-310.pyc,sha256=gWCEYYOJqojdVWOycsjHbYlOLNJQS2H2qkYP_G0J2B4,330 +bitblas/3rdparty/tvm/python/tvm/relax/dpl/__pycache__/__init__.cpython-38.pyc,sha256=eG_9fFFUPPonWKgOZpp1liwUld9hiEan-TByP-6BzSc,317 +bitblas/3rdparty/tvm/python/tvm/relax/dpl/__pycache__/_ffi.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/dpl/__pycache__/_ffi.cpython-310.pyc,sha256=pfOHOOE-T63NOnLtH5BujDKH21TtegDfVdruOQpdwPw,294 +bitblas/3rdparty/tvm/python/tvm/relax/dpl/__pycache__/_ffi.cpython-38.pyc,sha256=UsQIPamjh74ah9YBkdAbRbI4QZNPKcEs3LcW4-r3gws,281 +bitblas/3rdparty/tvm/python/tvm/relax/dpl/__pycache__/context.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/dpl/__pycache__/context.cpython-310.pyc,sha256=aOa9u4zE19doeLDXTheZWfGee174ISbyOwB5qgU1koM,2320 +bitblas/3rdparty/tvm/python/tvm/relax/dpl/__pycache__/context.cpython-38.pyc,sha256=HGlaxK6CsIoGNbCZQcRnLXoVixL9fWu5mfrhNt7Q5nE,2300 +bitblas/3rdparty/tvm/python/tvm/relax/dpl/__pycache__/pattern.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/dpl/__pycache__/pattern.cpython-310.pyc,sha256=jGwSCrWxxGd7-ls0wfbhy2ymEs3ixaKDpjiaRHU0Hhw,34730 +bitblas/3rdparty/tvm/python/tvm/relax/dpl/__pycache__/pattern.cpython-38.pyc,sha256=EmTtRAt_P1U2UX82FQjHTrQS_LbfqeWDV2oaFvZZVs8,35489 +bitblas/3rdparty/tvm/python/tvm/relax/dpl/__pycache__/rewrite.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/dpl/__pycache__/rewrite.cpython-310.pyc,sha256=on_NQHQsss2oqS3eTohP2UeJ28OEoWFP0K1irRtL2kc,4130 +bitblas/3rdparty/tvm/python/tvm/relax/dpl/__pycache__/rewrite.cpython-38.pyc,sha256=VFFYvBoYfIgHT4EhgxjpyyjocN2ZR0hVW_DA0MbrLNs,4122 +bitblas/3rdparty/tvm/python/tvm/relax/dpl/_ffi.py,sha256=ZtfjTTjP8bzmuTx4AZZnYxSt8uwO3hLicXie3RE_bwA,890 +bitblas/3rdparty/tvm/python/tvm/relax/dpl/context.py,sha256=F8VT843rbhyKm7eptPqJUl5Icu9E05IZ03r7rzPfKxc,2472 +bitblas/3rdparty/tvm/python/tvm/relax/dpl/pattern.py,sha256=mwFQFCUdGZRyrZCwZpzEhP42ip1SVxZ8fcqGlXEMqXw,32647 +bitblas/3rdparty/tvm/python/tvm/relax/dpl/rewrite.py,sha256=84-JHKMD4BgSMNJqjktClVc1Y7-8F2bDJATSCoMDy48,4656 +bitblas/3rdparty/tvm/python/tvm/relax/exec_builder.py,sha256=-PQbd5FJN_HfpS8byNt-HobEYiWvTUWl4X_2-YCK9Rg,5284 +bitblas/3rdparty/tvm/python/tvm/relax/expr.py,sha256=oYG_2622NofZBesL9Gb_bv8h9cFH6qYQfS-1yfaTo2g,38552 +bitblas/3rdparty/tvm/python/tvm/relax/expr_functor.py,sha256=nuxQbRhuw5aFDadC_-Hixr624-mxsTii8LREGHel0XY,49023 +bitblas/3rdparty/tvm/python/tvm/relax/frontend/__init__.py,sha256=YBRVEscO79LHrh0iOaEmrpLtZPO9fNb2ZfqKhR8B4sE,910 +bitblas/3rdparty/tvm/python/tvm/relax/frontend/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/frontend/__pycache__/__init__.cpython-310.pyc,sha256=FkftA4bKRebHKKVWGXcx6iXcnKV9omwVNYUMvHCCFFM,323 +bitblas/3rdparty/tvm/python/tvm/relax/frontend/__pycache__/__init__.cpython-38.pyc,sha256=EEIdvvR28evnTjP1QKpDVz4fiKBxcIlkd5cizDSjyC0,310 +bitblas/3rdparty/tvm/python/tvm/relax/frontend/__pycache__/common.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/frontend/__pycache__/common.cpython-310.pyc,sha256=3l4eo6AXs4P8wjx9H3yRBOAnFpKbLBWbZ0PR2a_rk_w,1548 +bitblas/3rdparty/tvm/python/tvm/relax/frontend/__pycache__/common.cpython-38.pyc,sha256=cAB4OIDxxUR3w6TIkoJwatR5z931KS0Xs1xmIAH6hMM,1537 +bitblas/3rdparty/tvm/python/tvm/relax/frontend/common.py,sha256=g0KwioLy_LJmlKlludioAgeST-CTpoU2Ref-YhzI_e4,2147 +bitblas/3rdparty/tvm/python/tvm/relax/frontend/nn/__init__.py,sha256=09gV3Oi95_TqiLcJOh_hielz41Bv6B4EP25A0g1zmXM,1327 +bitblas/3rdparty/tvm/python/tvm/relax/frontend/nn/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/frontend/nn/__pycache__/__init__.cpython-310.pyc,sha256=gm4KSs_6YB-ggDuR6qdRhoSh0cSwUIvcGxdNJfrTDBY,872 +bitblas/3rdparty/tvm/python/tvm/relax/frontend/nn/__pycache__/__init__.cpython-38.pyc,sha256=wOIohjVdZzJNzXuAJb6niIjySrFm3YLqHqfUKX8vErM,859 +bitblas/3rdparty/tvm/python/tvm/relax/frontend/nn/__pycache__/_tensor_op.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/frontend/nn/__pycache__/_tensor_op.cpython-310.pyc,sha256=bO2Sa2w7gGBHDzQcMRBZRTPKdb5VerY6i9zHWosQhho,3238 +bitblas/3rdparty/tvm/python/tvm/relax/frontend/nn/__pycache__/_tensor_op.cpython-38.pyc,sha256=rX-w3uKODPTHCNXnuZ4nw0F8CGWikErjHV2cNDOmpLI,3559 +bitblas/3rdparty/tvm/python/tvm/relax/frontend/nn/__pycache__/core.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/frontend/nn/__pycache__/core.cpython-310.pyc,sha256=wN0RtKOSVjZC-4LAdGmXmCeIur-uzkQbfxIzsKRdick,22650 +bitblas/3rdparty/tvm/python/tvm/relax/frontend/nn/__pycache__/core.cpython-38.pyc,sha256=_VQOOzAp4jJpSdzb45sJWxaHWtRVc-__uYi5U34e5OE,22725 +bitblas/3rdparty/tvm/python/tvm/relax/frontend/nn/__pycache__/exporter.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/frontend/nn/__pycache__/exporter.cpython-310.pyc,sha256=D_KX0onPHiH21UZwxja_6PpJUgnpXnVKdYG6fxVP104,11046 +bitblas/3rdparty/tvm/python/tvm/relax/frontend/nn/__pycache__/exporter.cpython-38.pyc,sha256=P19sZzahOsm4pC16vCuw5Yhf71hnmvfYW_mpXh9vilk,11041 +bitblas/3rdparty/tvm/python/tvm/relax/frontend/nn/__pycache__/extern.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/frontend/nn/__pycache__/extern.cpython-310.pyc,sha256=gz0iTPu6mQjLPDfzrwQt8OVVDZllnkKxxgdmT8C324c,14159 +bitblas/3rdparty/tvm/python/tvm/relax/frontend/nn/__pycache__/extern.cpython-38.pyc,sha256=1oJPm2ZrToeQlFd8UCLxv5qy7E1N4Dd3okJFJ9PQJXw,14120 +bitblas/3rdparty/tvm/python/tvm/relax/frontend/nn/__pycache__/modules.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/frontend/nn/__pycache__/modules.cpython-310.pyc,sha256=7egxjd_BPcbfAcgthWxDwjbbcbngDTys-0zfgIDOC5Y,23766 +bitblas/3rdparty/tvm/python/tvm/relax/frontend/nn/__pycache__/modules.cpython-38.pyc,sha256=-zleo9XnlwrOAXwfHqfFyaLqC-c5wQOJe-vzA5FtGrQ,23605 +bitblas/3rdparty/tvm/python/tvm/relax/frontend/nn/__pycache__/op.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/frontend/nn/__pycache__/op.cpython-310.pyc,sha256=MzQ49hlF8czhsIAE5i6lVMcVIl3k1uEEUIXXHiLC9PA,67684 +bitblas/3rdparty/tvm/python/tvm/relax/frontend/nn/__pycache__/op.cpython-38.pyc,sha256=MheqccWidF1U00nO74H2NVLQqhTOhRzIZ7z524OqyBY,68017 +bitblas/3rdparty/tvm/python/tvm/relax/frontend/nn/__pycache__/spec.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/frontend/nn/__pycache__/spec.cpython-310.pyc,sha256=DwQAh6IZ16BAPTEnNVga0slzK6GEJ67-FNI8vnkbHRs,8159 +bitblas/3rdparty/tvm/python/tvm/relax/frontend/nn/__pycache__/spec.cpython-38.pyc,sha256=3pShn8S_7zUbLQWs7gsvRC3xMiKhzWoVFfHjuyRvlwc,8224 +bitblas/3rdparty/tvm/python/tvm/relax/frontend/nn/__pycache__/subroutine.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/frontend/nn/__pycache__/subroutine.cpython-310.pyc,sha256=WkWvEf5rAt44_AoAUeY_v92ySM6S6FVUAol8Ykq0kuA,5742 +bitblas/3rdparty/tvm/python/tvm/relax/frontend/nn/__pycache__/subroutine.cpython-38.pyc,sha256=YAoL0fNvXM9f8-d9U86RxcGPfmARaCMOS25313OgjE0,5686 +bitblas/3rdparty/tvm/python/tvm/relax/frontend/nn/__pycache__/torch.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/frontend/nn/__pycache__/visitor.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/frontend/nn/__pycache__/visitor.cpython-310.pyc,sha256=mI6ZLvrEo0xLVR1UdcoVWZh4kG0wpSVQ2Q5ui444uhI,4172 +bitblas/3rdparty/tvm/python/tvm/relax/frontend/nn/__pycache__/visitor.cpython-38.pyc,sha256=AQ51xDOosvrUSDwASk17aUbKDs8ZkxNdR2zYIomuBcs,4182 +bitblas/3rdparty/tvm/python/tvm/relax/frontend/nn/_tensor_op.py,sha256=i-U17gPIfBqA-GzMoX1APr-Iy6LQoCJGnE3fioSn6x0,3303 +bitblas/3rdparty/tvm/python/tvm/relax/frontend/nn/core.py,sha256=3WLZjKuoG_pIETGrMvQ2jWYFqjF8dfsnK3IiEXXjvZk,23529 +bitblas/3rdparty/tvm/python/tvm/relax/frontend/nn/exporter.py,sha256=UaRkwv1IQEaqjIFFYOuD9v2wVHZCuLUSXVGF9TdB5Fc,13040 +bitblas/3rdparty/tvm/python/tvm/relax/frontend/nn/extern.py,sha256=YWd3d5SQnB0lotleXEQEAVKvsgyDXFA79E_soe3mp7I,16152 +bitblas/3rdparty/tvm/python/tvm/relax/frontend/nn/modules.py,sha256=ljOZgSovhayWdJGzshnxw4Le_mzL5BMOULDvbrsc1e8,26767 +bitblas/3rdparty/tvm/python/tvm/relax/frontend/nn/op.py,sha256=C5xLAcgDICVz-xAfV6_xE4NeuYJzbyCiVLTpXO0Glos,73913 +bitblas/3rdparty/tvm/python/tvm/relax/frontend/nn/spec.py,sha256=WxDQY5_TbmHZz9EmM67TCQqNQvABQoo5lkcvhLPkrJw,8644 +bitblas/3rdparty/tvm/python/tvm/relax/frontend/nn/subroutine.py,sha256=ag4TTlJJA2g2UYofJvrYQoy_cxs8sj_Bb5pwv3QBMuE,6658 +bitblas/3rdparty/tvm/python/tvm/relax/frontend/nn/torch.py,sha256=yUn06YPi3fYEW8iFHNTnpEg5UWuaEkpi7FnK-aMWXEk,5084 +bitblas/3rdparty/tvm/python/tvm/relax/frontend/nn/visitor.py,sha256=CCFwnJ8YMHczS3k_3q2aLCZPcEnZv7irk55qCnwvMrc,5086 +bitblas/3rdparty/tvm/python/tvm/relax/frontend/onnx/__init__.py,sha256=Kp51YwLrBfKN36O2UvK5kPbohA673UqbK5CuGUlSxh0,882 +bitblas/3rdparty/tvm/python/tvm/relax/frontend/onnx/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/frontend/onnx/__pycache__/onnx_frontend.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/frontend/onnx/onnx_frontend.py,sha256=DKZSY0mmEAUq020fjLvl8I_ziUTiuaIlYQfXSTo-q-A,89635 +bitblas/3rdparty/tvm/python/tvm/relax/frontend/stablehlo/__init__.py,sha256=g_yueq3I9iVkjGwnhYmSRJb29hgqSNeKRqyq3rriBEA,920 +bitblas/3rdparty/tvm/python/tvm/relax/frontend/stablehlo/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/frontend/stablehlo/__pycache__/stablehlo_translator.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/frontend/stablehlo/stablehlo_translator.py,sha256=tTUkwFevphX4xnLzrwYV0xHh9z3-Nx4SG2aUYibFhtw,17984 +bitblas/3rdparty/tvm/python/tvm/relax/frontend/torch/__init__.py,sha256=RUgwAJ0EkJgHrnk9Wm_ASjslNesDi1L4iBdjMKU6pl8,963 +bitblas/3rdparty/tvm/python/tvm/relax/frontend/torch/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/frontend/torch/__pycache__/dynamo.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/frontend/torch/__pycache__/fx_translator.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/frontend/torch/dynamo.py,sha256=_4Rxe0D87FCQgitxCiGX2EhNysh0IA8PFXnguuEO4kE,7224 +bitblas/3rdparty/tvm/python/tvm/relax/frontend/torch/fx_translator.py,sha256=z7i0Su-b2DgZi7NaOBoaiozJhbMSVcJKbuRTh-Sgh5A,66279 +bitblas/3rdparty/tvm/python/tvm/relax/ir/__pycache__/instrument.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/ir/instrument.py,sha256=NH4KoXxglA5fv0kxrYV3N-7IuhQIKi1S71BftNcob8k,2306 +bitblas/3rdparty/tvm/python/tvm/relax/op/__init__.py,sha256=dyNu4MMPrsK5W0PmKwmcwbFvqTSBXHBjNS9LapZwnNI,3096 +bitblas/3rdparty/tvm/python/tvm/relax/op/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/op/__pycache__/__init__.cpython-310.pyc,sha256=utBJNz-Z72Lm4cHp9xD96axed_mX8oKQhvhrgSe1na8,3208 +bitblas/3rdparty/tvm/python/tvm/relax/op/__pycache__/__init__.cpython-38.pyc,sha256=RILvkmjiYqn2cPs04rrCQPT9LYF12pVBVfEujbFSgYE,3195 +bitblas/3rdparty/tvm/python/tvm/relax/op/__pycache__/_ffi_api.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/op/__pycache__/_ffi_api.cpython-310.pyc,sha256=1Zi0X_1G4FiVgRx3lF439LBsZ_07Kg0xqWk6hxByrn4,282 +bitblas/3rdparty/tvm/python/tvm/relax/op/__pycache__/_ffi_api.cpython-38.pyc,sha256=vjH_je2o2Hq03Oq2gN7UiNqIWzkjEJRZhBLXiphlOxM,269 +bitblas/3rdparty/tvm/python/tvm/relax/op/__pycache__/_op_gradient.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/op/__pycache__/_op_gradient.cpython-310.pyc,sha256=gMOeTG6fapsJeQoSGteCjZ2sj6i_TzF_o0mAg6x5QfI,26826 +bitblas/3rdparty/tvm/python/tvm/relax/op/__pycache__/_op_gradient.cpython-38.pyc,sha256=vwTv-PuPYANSSs-rWzev_BQx8qFV5bf6ueBzuq4wV-c,26488 +bitblas/3rdparty/tvm/python/tvm/relax/op/__pycache__/base.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/op/__pycache__/base.cpython-310.pyc,sha256=VyEY8-p2FHag41zH49aWV93LM4CJE_KSzlik6UAPCzc,22650 +bitblas/3rdparty/tvm/python/tvm/relax/op/__pycache__/base.cpython-38.pyc,sha256=uVZnEo6hUYB4q7Uj2PnkJc7Wmct7tDZbrSFs1bQI4Gs,22748 +bitblas/3rdparty/tvm/python/tvm/relax/op/__pycache__/binary.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/op/__pycache__/binary.cpython-310.pyc,sha256=-HTMNLAaCAzvQSBWDWnRi9MdwIj-Ma4oaIPwhZZeADw,8055 +bitblas/3rdparty/tvm/python/tvm/relax/op/__pycache__/binary.cpython-38.pyc,sha256=bzexHL-N4wfghED0AcBBfJyVjC1XRl3y-J54tlY34KY,8233 +bitblas/3rdparty/tvm/python/tvm/relax/op/__pycache__/create.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/op/__pycache__/create.cpython-310.pyc,sha256=qTZQuFMe_elufqmmeetZly38JVPc6Elf6Y4UMnFLLuk,7221 +bitblas/3rdparty/tvm/python/tvm/relax/op/__pycache__/create.cpython-38.pyc,sha256=AFp7noCLdDk-dYR65kjRTtXz3kQ8tCLyhrOFYjhXACM,7335 +bitblas/3rdparty/tvm/python/tvm/relax/op/__pycache__/datatype.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/op/__pycache__/datatype.cpython-310.pyc,sha256=PFmqMNXQRgvsjdJYt210sLvOMKJXMuy9XhNvig86ufk,1313 +bitblas/3rdparty/tvm/python/tvm/relax/op/__pycache__/datatype.cpython-38.pyc,sha256=kf_FLLX13wEzqwABDCoRig-GIMwbCicG6vyEhzYSkd8,1318 +bitblas/3rdparty/tvm/python/tvm/relax/op/__pycache__/index.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/op/__pycache__/index.cpython-310.pyc,sha256=itKxQpfBCEJBplGPXtu-I3S_wPjZc9Fy62NF9YW_QAo,3618 +bitblas/3rdparty/tvm/python/tvm/relax/op/__pycache__/index.cpython-38.pyc,sha256=fQQEf9o5lxybHHcmDKIpzJI4L6sKjsxa6otGo-YTqHw,3594 +bitblas/3rdparty/tvm/python/tvm/relax/op/__pycache__/linear_algebra.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/op/__pycache__/linear_algebra.cpython-310.pyc,sha256=qCs2rOkClP25IvQssUGoJQRn-WnEJoLd4Yppi8sU28w,2748 +bitblas/3rdparty/tvm/python/tvm/relax/op/__pycache__/linear_algebra.cpython-38.pyc,sha256=1QTz50I2Iwn3XDnmpEQERxzDkedexnp2kqr4vaAuVVo,2723 +bitblas/3rdparty/tvm/python/tvm/relax/op/__pycache__/manipulate.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/op/__pycache__/manipulate.cpython-310.pyc,sha256=3gHQ3zgP9NQaLFd8a2m2k8oTfdHg0Nro9sRqh5_ykAE,14180 +bitblas/3rdparty/tvm/python/tvm/relax/op/__pycache__/manipulate.cpython-38.pyc,sha256=VKvnIDFeMEbJMjlvKgZhFkU0EVTk7EwRP0rGitrUvKQ,14344 +bitblas/3rdparty/tvm/python/tvm/relax/op/__pycache__/mask.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/op/__pycache__/mask.cpython-310.pyc,sha256=ri-EElkkStgkcyPgTLBPG-tCfVU_8hjJ0u1kHBJkKGA,837 +bitblas/3rdparty/tvm/python/tvm/relax/op/__pycache__/mask.cpython-38.pyc,sha256=458HFo8ImBkjWQTwnp_aVrfvrqgUVjzCqF9Znkc3J-0,822 +bitblas/3rdparty/tvm/python/tvm/relax/op/__pycache__/op_attrs.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/op/__pycache__/op_attrs.cpython-310.pyc,sha256=Et0q4Y4vvodY32O4vI3-E2hAuT6I1W9wJuPzqXpjxmM,6711 +bitblas/3rdparty/tvm/python/tvm/relax/op/__pycache__/op_attrs.cpython-38.pyc,sha256=ika6cgLMRmcLbPFIKCPyJ7jBAfNGUmKDZ9OKjLH8i24,7272 +bitblas/3rdparty/tvm/python/tvm/relax/op/__pycache__/qdq.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/op/__pycache__/qdq.cpython-310.pyc,sha256=F-BBrAbfhXAr1jhu2TNifAqptRL9sx7yBvDLhZEDSBk,2207 +bitblas/3rdparty/tvm/python/tvm/relax/op/__pycache__/qdq.cpython-38.pyc,sha256=jho9pz02JqsOVAEpGUuyPqS285WPmU8bFykmSdnXEMs,2168 +bitblas/3rdparty/tvm/python/tvm/relax/op/__pycache__/search.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/op/__pycache__/search.cpython-310.pyc,sha256=vVDu5JAnlTE89EOmxPwkPh_4HiN5PmWvHzaai2wa-3s,2882 +bitblas/3rdparty/tvm/python/tvm/relax/op/__pycache__/search.cpython-38.pyc,sha256=zR76bPOkYHXVeZa8myL36tehjhPhA6J46YW45H98YHQ,2894 +bitblas/3rdparty/tvm/python/tvm/relax/op/__pycache__/set.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/op/__pycache__/set.cpython-310.pyc,sha256=QUJn_GNsBYFvK_x80l1dLRedEwhNr-wWSn-iFCZnWk0,2953 +bitblas/3rdparty/tvm/python/tvm/relax/op/__pycache__/set.cpython-38.pyc,sha256=6fiy9ArqH2haEyVMYCAqEWFpKMnbUJp7cTOKUvkVPKs,2930 +bitblas/3rdparty/tvm/python/tvm/relax/op/__pycache__/sorting.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/op/__pycache__/sorting.cpython-310.pyc,sha256=3kwuMgGa5DI1L3hKQffyR5phc0Xjzc5P9HfWdzdnRyk,2892 +bitblas/3rdparty/tvm/python/tvm/relax/op/__pycache__/sorting.cpython-38.pyc,sha256=NbhYbrBNojYx0Yx9_CPF_VCv0y4PpP_mn1hzgBMAxQU,2814 +bitblas/3rdparty/tvm/python/tvm/relax/op/__pycache__/statistical.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/op/__pycache__/statistical.cpython-310.pyc,sha256=KG4clUI6HAK3CZ-yWfBc2UQUGNUNNLoGv2df486F-MQ,9860 +bitblas/3rdparty/tvm/python/tvm/relax/op/__pycache__/statistical.cpython-38.pyc,sha256=4Em-XtTQ0QznAeYuY85wPdKWBG2-3LUi9IaAAxMc8fA,10024 +bitblas/3rdparty/tvm/python/tvm/relax/op/__pycache__/ternary.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/op/__pycache__/ternary.cpython-310.pyc,sha256=pmMxDVplBmGJTHGB1Qnd3SPt-vV_jCIgD6k4rGSjP4U,870 +bitblas/3rdparty/tvm/python/tvm/relax/op/__pycache__/ternary.cpython-38.pyc,sha256=289NP0i_QgnbMJKIiV9Oi5bpO0X9e0uIDMEUvYrLNHw,853 +bitblas/3rdparty/tvm/python/tvm/relax/op/__pycache__/unary.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/op/__pycache__/unary.cpython-310.pyc,sha256=zKqlZE34JT8ceY6DYUFc-oyhEUpYJllXj1ZNwHpuf7Y,11524 +bitblas/3rdparty/tvm/python/tvm/relax/op/__pycache__/unary.cpython-38.pyc,sha256=gGCqyKbsMQzKdSoklBfFcUi-f07CyGMNoTFJy8680T4,11803 +bitblas/3rdparty/tvm/python/tvm/relax/op/_ffi_api.py,sha256=dWObOT2JD_m0JPF0U1aXIgrBPQtwt46nWNTfqhGocCs,854 +bitblas/3rdparty/tvm/python/tvm/relax/op/_op_gradient.py,sha256=hyayzrUskE4eBnQYVqoaG4mJUdiSVc1UmNOvcxE2-2Y,33121 +bitblas/3rdparty/tvm/python/tvm/relax/op/base.py,sha256=DT6SLXQ3LJMRuUgEwSywxCAlXthBRe2PCQT3_dt3tnk,25880 +bitblas/3rdparty/tvm/python/tvm/relax/op/binary.py,sha256=m2E-O2okrq5rY7-W2xhYhGph2POGcdHNvC_ultROh-g,8550 +bitblas/3rdparty/tvm/python/tvm/relax/op/builtin/__init__.py,sha256=cnWHbcSZMIxjLjZYKrJGPWtd0u8o_INfQz9tFRzMdfE,869 +bitblas/3rdparty/tvm/python/tvm/relax/op/builtin/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/op/builtin/__pycache__/__init__.cpython-310.pyc,sha256=PniLV_pG9TOBI08VP_xEwoFgVqEcoLis_5bBzRxLH34,282 +bitblas/3rdparty/tvm/python/tvm/relax/op/builtin/__pycache__/__init__.cpython-38.pyc,sha256=yVooi989Z5CB_7WTNDhX7-relDoVgAlAOcqHs3Z1GOo,269 +bitblas/3rdparty/tvm/python/tvm/relax/op/builtin/__pycache__/_ffi_api.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/op/builtin/__pycache__/_ffi_api.cpython-310.pyc,sha256=rSS9vt2ddynnaJoiQzF55CWmHGTIrgT8SA90kecHD3A,306 +bitblas/3rdparty/tvm/python/tvm/relax/op/builtin/__pycache__/_ffi_api.cpython-38.pyc,sha256=7lm5MvT-QPQTOJhpIRdMHi90ACUDAW6zx7cxjOzi1aE,293 +bitblas/3rdparty/tvm/python/tvm/relax/op/builtin/__pycache__/builtin.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/op/builtin/__pycache__/builtin.cpython-310.pyc,sha256=Bq46jJ3Jy76fcS1c3rww_A8fDvzGXby8oH_xOcGtj9I,2081 +bitblas/3rdparty/tvm/python/tvm/relax/op/builtin/__pycache__/builtin.cpython-38.pyc,sha256=Q0_LQ5UW2ZvKQnSzP6Y3G7pQxL8hiOQWGFOnFbGtcpQ,2053 +bitblas/3rdparty/tvm/python/tvm/relax/op/builtin/_ffi_api.py,sha256=6l5anhZuUVIDxrl3JjkPPVQIIKS2QJLd3JB6i3siiCM,870 +bitblas/3rdparty/tvm/python/tvm/relax/op/builtin/builtin.py,sha256=KId25S_TjBykGMO9NX9NkRBNckeSxY9rkweZ7pPGU_A,2772 +bitblas/3rdparty/tvm/python/tvm/relax/op/ccl/__init__.py,sha256=roSNiJbqVvGS6OCzMTY0TqRrjgyAp5Sm0UukAcLDM5o,898 +bitblas/3rdparty/tvm/python/tvm/relax/op/ccl/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/op/ccl/__pycache__/__init__.cpython-310.pyc,sha256=Z5UjoCqjL9h5RG4CmX9Ts076wtnMFduqKPS_2WRmkm0,326 +bitblas/3rdparty/tvm/python/tvm/relax/op/ccl/__pycache__/__init__.cpython-38.pyc,sha256=B0RDLTlwKDQHe223CfODJg0YY12Lw6IiQ19DAXhpBIs,313 +bitblas/3rdparty/tvm/python/tvm/relax/op/ccl/__pycache__/_ffi_api.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/op/ccl/__pycache__/_ffi_api.cpython-310.pyc,sha256=zsWdCpbFgbbBLwhlJhBKmK2EY-9QNAr6_CkcU9alDac,336 +bitblas/3rdparty/tvm/python/tvm/relax/op/ccl/__pycache__/_ffi_api.cpython-38.pyc,sha256=400O0_0OhTfQTXCq1EmPkLeFI1uOfkizBFr70V8OoKw,323 +bitblas/3rdparty/tvm/python/tvm/relax/op/ccl/__pycache__/ccl.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/op/ccl/__pycache__/ccl.cpython-310.pyc,sha256=8YzgAEbFdpvd3EwwW7YwKVcp_gt7JlNRvnD-wH7-d00,2703 +bitblas/3rdparty/tvm/python/tvm/relax/op/ccl/__pycache__/ccl.cpython-38.pyc,sha256=zc_U4cTwxqiBQu4JKytez4wcy6x6AcDjFD1yP4EoTyA,2717 +bitblas/3rdparty/tvm/python/tvm/relax/op/ccl/_ffi_api.py,sha256=2XZ1gDpYTcYzdnNK_fKonTC-k5npV4iR48qStVufxCE,925 +bitblas/3rdparty/tvm/python/tvm/relax/op/ccl/ccl.py,sha256=oIjKWT21o3aA-JJK_DyGCbSmbaHlZaW7qdDC06-KGho,3325 +bitblas/3rdparty/tvm/python/tvm/relax/op/create.py,sha256=ptBccaXDAijMmB02ZtQ_ZXd5BtYnigq5E2xlF83qXEs,8003 +bitblas/3rdparty/tvm/python/tvm/relax/op/datatype.py,sha256=aU3-pdY0SZuveca-htgSpO_kfsb4MtcThWpNp9cIqNc,1814 +bitblas/3rdparty/tvm/python/tvm/relax/op/distributed/__init__.py,sha256=0D6aa5B3HI7FKyyWhRse9JUpaAEgoXcEVPJHfWah178,963 +bitblas/3rdparty/tvm/python/tvm/relax/op/distributed/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/op/distributed/__pycache__/__init__.cpython-310.pyc,sha256=4TW6XZTgzqnb-9KdAXa6edTA07kI1BJULY3D_9sfqk4,377 +bitblas/3rdparty/tvm/python/tvm/relax/op/distributed/__pycache__/__init__.cpython-38.pyc,sha256=CZmundjthBTd57e1Rp3jj45rPwHJ8QK3xaJ7TAKmzUg,364 +bitblas/3rdparty/tvm/python/tvm/relax/op/distributed/__pycache__/_ffi_api.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/op/distributed/__pycache__/_ffi_api.cpython-310.pyc,sha256=zTE4g-l1_A3xESydLghis8geexkPb43aPnRcSgcHGZY,311 +bitblas/3rdparty/tvm/python/tvm/relax/op/distributed/__pycache__/_ffi_api.cpython-38.pyc,sha256=7EdilWv6SDhMNQ1LeeChhq8m-sFq4yN0b0ZVxx5U-Iw,298 +bitblas/3rdparty/tvm/python/tvm/relax/op/distributed/__pycache__/distributed.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/op/distributed/__pycache__/distributed.cpython-310.pyc,sha256=1k6raFMQyKoZZXh1ToEurlchsMewEf6eWEANRZ0KQzA,3870 +bitblas/3rdparty/tvm/python/tvm/relax/op/distributed/__pycache__/distributed.cpython-38.pyc,sha256=5FK3rikuzIXe8cycTj4tOvIGeIUffVsNnvfXty3A9cI,3870 +bitblas/3rdparty/tvm/python/tvm/relax/op/distributed/_ffi_api.py,sha256=z7RDC2h3irV6Nw8vipoIrMBsBkACodHQx_LhiOY7hQw,892 +bitblas/3rdparty/tvm/python/tvm/relax/op/distributed/distributed.py,sha256=D6zixJ9OcVZHVch9jLianb7JEgKaZCqQkf4ot1gargo,4598 +bitblas/3rdparty/tvm/python/tvm/relax/op/grad/__init__.py,sha256=xkmRD21XMT4dVu5sqMuK561r29z_0AGd__AXGtqBZ7s,871 +bitblas/3rdparty/tvm/python/tvm/relax/op/grad/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/op/grad/__pycache__/__init__.cpython-310.pyc,sha256=aofmAAAy8kRiwicFGApWETGpU_1kq_7FoKtQSiVNzfU,263 +bitblas/3rdparty/tvm/python/tvm/relax/op/grad/__pycache__/__init__.cpython-38.pyc,sha256=FuU5-XehKDfPnp5gj_IW0ArlIQwHMn4vRHfcZ_hK7nw,250 +bitblas/3rdparty/tvm/python/tvm/relax/op/grad/__pycache__/_ffi_api.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/op/grad/__pycache__/_ffi_api.cpython-310.pyc,sha256=fkNLsy5iVxtrfhX8Z6OPtjC6HxZwemiS8TUVNXdzrqI,297 +bitblas/3rdparty/tvm/python/tvm/relax/op/grad/__pycache__/_ffi_api.cpython-38.pyc,sha256=BEl4htDLbfDf6xVLCJC_22mErl8UwRrm58mUCPJdFY0,284 +bitblas/3rdparty/tvm/python/tvm/relax/op/grad/__pycache__/grad.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/op/grad/__pycache__/grad.cpython-310.pyc,sha256=pKDtthh_Qlnkc918JfIgLPlpE27b5mTFN4AH_AZUPVc,5319 +bitblas/3rdparty/tvm/python/tvm/relax/op/grad/__pycache__/grad.cpython-38.pyc,sha256=kpIhJLxf4BcFY7swR3zpzmmsU9npXOLeTFCTftOyqS8,5297 +bitblas/3rdparty/tvm/python/tvm/relax/op/grad/_ffi_api.py,sha256=NKEq292vixeqpMqNutS3oLz2tyfx91l1usLfQw9rLzU,885 +bitblas/3rdparty/tvm/python/tvm/relax/op/grad/grad.py,sha256=Gyla0ehZ3AZ_zrB_poDPXZ5TAPdtvO3fAgEbSx9seeA,6289 +bitblas/3rdparty/tvm/python/tvm/relax/op/image/__init__.py,sha256=e8HaWiXhw5DHzJE0ZqLSEKpcF6NrhS51J_rYC51pn6M,836 +bitblas/3rdparty/tvm/python/tvm/relax/op/image/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/op/image/__pycache__/__init__.cpython-310.pyc,sha256=m7Y-GZeO0oTOEm7HnnnGsD2eljmFCD1Kr8A2FquE8uY,239 +bitblas/3rdparty/tvm/python/tvm/relax/op/image/__pycache__/__init__.cpython-38.pyc,sha256=XtMU9GWYfzfCFE5fgpo0BUO8cxLHvQkZdz8_m3VpbDY,226 +bitblas/3rdparty/tvm/python/tvm/relax/op/image/__pycache__/_ffi_api.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/op/image/__pycache__/_ffi_api.cpython-310.pyc,sha256=WCMVrb5sG_VVahVA1OQNvyBmlb3GbHKPSUNzeu3fkh0,285 +bitblas/3rdparty/tvm/python/tvm/relax/op/image/__pycache__/_ffi_api.cpython-38.pyc,sha256=nxty9Fix4wZn41f_yFYvHq8_pEUkbCHKPRoLHHRQafM,272 +bitblas/3rdparty/tvm/python/tvm/relax/op/image/__pycache__/image.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/op/image/__pycache__/image.cpython-310.pyc,sha256=KqI0M1yVraYvltkbnCCbRqd4rFYscCy-yLMW3nWWXTw,3491 +bitblas/3rdparty/tvm/python/tvm/relax/op/image/__pycache__/image.cpython-38.pyc,sha256=SchdmbUTnemvgYUUf_1dCkZkdpW2ksmN7AlSi9oZ6QM,3418 +bitblas/3rdparty/tvm/python/tvm/relax/op/image/_ffi_api.py,sha256=fJS8pq2nceHfNFyEbAS7npAxmNV7tOgFG5B9S3TELBU,872 +bitblas/3rdparty/tvm/python/tvm/relax/op/image/image.py,sha256=Yf8fIyOmug9XUPEv8ortIY0T-WhQJLMrmifg7-e47sU,4294 +bitblas/3rdparty/tvm/python/tvm/relax/op/index.py,sha256=batr_-tmKmZ8YsDx2zawnM-av9aGrxKLXGbFcJ686sA,4140 +bitblas/3rdparty/tvm/python/tvm/relax/op/linear_algebra.py,sha256=FoghNxX09w0IztMbfyfiVXXLP8pN9TAVn7dD10sr8fA,3352 +bitblas/3rdparty/tvm/python/tvm/relax/op/manipulate.py,sha256=FpSpkpdYHGqkkyikHyDA0qRF676BtLOM-kTr4Q3gwyI,15233 +bitblas/3rdparty/tvm/python/tvm/relax/op/mask.py,sha256=WN3w7dG_RULF6GaIBK71nokQVWhc4E5W8M-uPwvTLnw,1406 +bitblas/3rdparty/tvm/python/tvm/relax/op/memory/__init__.py,sha256=KHEmRqCoPmjRyzPAfhq99a4oCbNl1p8m4jLVpiZB1ck,892 +bitblas/3rdparty/tvm/python/tvm/relax/op/memory/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/op/memory/__pycache__/__init__.cpython-310.pyc,sha256=n7mXgb5an3ugD9R0A2tSERqZM72fHYuapstdsGCWvIk,322 +bitblas/3rdparty/tvm/python/tvm/relax/op/memory/__pycache__/__init__.cpython-38.pyc,sha256=UaOlGwBd_5oxx0Kj64za-R9VTvlCzeJy2PwhDB54XoQ,309 +bitblas/3rdparty/tvm/python/tvm/relax/op/memory/__pycache__/_ffi_api.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/op/memory/__pycache__/_ffi_api.cpython-310.pyc,sha256=91AHNq6p5Zmov8TswFjVe3Yw0BuvhZtx8dtWLGjxOGk,303 +bitblas/3rdparty/tvm/python/tvm/relax/op/memory/__pycache__/_ffi_api.cpython-38.pyc,sha256=43x5TIP9oB7zlvsTCjjGr-8d34cd8mRk2xPVVKX-vpM,290 +bitblas/3rdparty/tvm/python/tvm/relax/op/memory/__pycache__/memory.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/op/memory/__pycache__/memory.cpython-310.pyc,sha256=fD0lPNsFPIBEMGNOX86M0gjNa3FuGyC5PiyHkwGFvh0,3025 +bitblas/3rdparty/tvm/python/tvm/relax/op/memory/__pycache__/memory.cpython-38.pyc,sha256=FAeqB3AmtddewWvfTQQpbieIo37hm0Z-xAz_knQbjKM,3017 +bitblas/3rdparty/tvm/python/tvm/relax/op/memory/_ffi_api.py,sha256=5cWRSLE4S_9glLpWf3jJ59m-4KVH0gdPln7THkUb3RU,868 +bitblas/3rdparty/tvm/python/tvm/relax/op/memory/memory.py,sha256=D9rYU3eh0b8bmN0TQgpq_8j1geQFPv8EUQhj8pp63G0,3721 +bitblas/3rdparty/tvm/python/tvm/relax/op/nn/__init__.py,sha256=P066CpE155Z2FTebPIUftwnNA1SfvAi9iUDn7dj1-hw,1353 +bitblas/3rdparty/tvm/python/tvm/relax/op/nn/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/op/nn/__pycache__/__init__.cpython-310.pyc,sha256=Xj7-_kqMYKOMJRHGHMsGsTPuWkPin8_wU6Y7boUSHZI,894 +bitblas/3rdparty/tvm/python/tvm/relax/op/nn/__pycache__/__init__.cpython-38.pyc,sha256=GNXpVBf7aKB9f8OOuwiSG6M3MhDAVGV1_APGQLtFU1g,881 +bitblas/3rdparty/tvm/python/tvm/relax/op/nn/__pycache__/_ffi_api.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/op/nn/__pycache__/_ffi_api.cpython-310.pyc,sha256=lzAr65Q1z2GJXHgkfX91yf3hRJsV1iT_DpUM2KFA08U,279 +bitblas/3rdparty/tvm/python/tvm/relax/op/nn/__pycache__/_ffi_api.cpython-38.pyc,sha256=kfupz-04zAZvLSkhWgcufOZIJGdlhG-0BRtHOksfxXg,266 +bitblas/3rdparty/tvm/python/tvm/relax/op/nn/__pycache__/nn.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/op/nn/__pycache__/nn.cpython-310.pyc,sha256=OP5pqLP0R7qrV_pAI4gZ4JKzvQNfKR-m0CBc3EpdwMk,53202 +bitblas/3rdparty/tvm/python/tvm/relax/op/nn/__pycache__/nn.cpython-38.pyc,sha256=O_as45bP3PDcKke5HqDtEpqLwa0jND65whfbbxY70NQ,53150 +bitblas/3rdparty/tvm/python/tvm/relax/op/nn/_ffi_api.py,sha256=xHnHXVkAVYm966UrTiBo-9iRjFKA6XCfyVNN6YYPWFA,869 +bitblas/3rdparty/tvm/python/tvm/relax/op/nn/nn.py,sha256=FQOEcNF58Cnpw3Mm8Fz6EzPm26kt0ogp8pRrnPtWQcI,59218 +bitblas/3rdparty/tvm/python/tvm/relax/op/op_attrs.py,sha256=SmFBGYXmxpmg0b94gGpnzHfSp7SsWzFGKKOCXyLi67o,5177 +bitblas/3rdparty/tvm/python/tvm/relax/op/qdq.py,sha256=TlOXhE2Ako5dDi7jgRpnZF3oFWFWLi6W7L0lhrwoBzQ,2753 +bitblas/3rdparty/tvm/python/tvm/relax/op/search.py,sha256=7RXByhoLJ721nJy9kW8bhLcLj2GwzShK8_WeROq4ElM,3444 +bitblas/3rdparty/tvm/python/tvm/relax/op/set.py,sha256=TMbl61-X1_KStD9ftH5rHDbq0JhRtN7C_HACUdM5qmc,4016 +bitblas/3rdparty/tvm/python/tvm/relax/op/sorting.py,sha256=t8_GTSgMDE2HaFwNcSifz_2waQ7Ep5GqOr7VLhkExB4,3358 +bitblas/3rdparty/tvm/python/tvm/relax/op/statistical.py,sha256=DBGk1iRcVjKFvEntXVhuBUgLPGSOF_jgZAmR1IpThos,10902 +bitblas/3rdparty/tvm/python/tvm/relax/op/ternary.py,sha256=qv4F8K-Ieg-cUAjd1rnUxUPaOmcOj2kiinC50EFnUGM,1459 +bitblas/3rdparty/tvm/python/tvm/relax/op/unary.py,sha256=tXxyEt2Y3swpzqq0xI12KX1ChCcD1c9KYJDAd-O9x9o,11390 +bitblas/3rdparty/tvm/python/tvm/relax/op/vm/__init__.py,sha256=_lwQnQevdSrjDhLRG0FdyztE53ZNtWFwu0dzE_1A17w,884 +bitblas/3rdparty/tvm/python/tvm/relax/op/vm/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/op/vm/__pycache__/_ffi_api.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/op/vm/__pycache__/vm.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/op/vm/_ffi_api.py,sha256=WH3EIm8rDi3g173p8SW_iGICc5idDRY53k49HaqRVeI,860 +bitblas/3rdparty/tvm/python/tvm/relax/op/vm/vm.py,sha256=-NsgUxBIRtemB4nzYo5w1xnbw29ao0xr9tsqgm_LqD0,4103 +bitblas/3rdparty/tvm/python/tvm/relax/pipeline.py,sha256=XHoTxgZ9Jug2ESUybR_RsDJ7lFD7pebihetI_B_6aPM,4661 +bitblas/3rdparty/tvm/python/tvm/relax/struct_info.py,sha256=Mo-Yxf9L2yuXi_0iaGjfVMc6Lsq0HmDEgF5xc8YSdPM,8473 +bitblas/3rdparty/tvm/python/tvm/relax/testing/__init__.py,sha256=C8cGKCeU_uIkq7e7ZcHkosQUg4Vi06XoTnJnUvxqNwc,1009 +bitblas/3rdparty/tvm/python/tvm/relax/testing/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/testing/__pycache__/ast_printer.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/testing/__pycache__/lib_comparator.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/testing/__pycache__/matmul.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/testing/__pycache__/nn.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/testing/__pycache__/relay_translator.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/testing/__pycache__/runtime_builtin.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/testing/__pycache__/transform.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/testing/__pycache__/vm.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/testing/ast_printer.py,sha256=uSZfW1O1s5mKHPclsp-iAV9tjCmu-j2cunofmLotxz4,15524 +bitblas/3rdparty/tvm/python/tvm/relax/testing/lib_comparator.py,sha256=wmjHXuXfCZJsDyfX2xD3myWUO1OrDFHY1vDa-2WKI48,4381 +bitblas/3rdparty/tvm/python/tvm/relax/testing/matmul.py,sha256=UNFSzLRIST2as6HjEwQZj3_oWxL2XPJ6EQFfl4v88ww,2428 +bitblas/3rdparty/tvm/python/tvm/relax/testing/nn.py,sha256=d_FEKjJJ9UYAmpW0b3EGbPMzuscRtUAafzuLyaRgXjw,12387 +bitblas/3rdparty/tvm/python/tvm/relax/testing/relay_translator.py,sha256=v3EV0SLFb1ctExtyM5KJfKWYT2wTioJejPYVG16RtWs,11175 +bitblas/3rdparty/tvm/python/tvm/relax/testing/runtime_builtin.py,sha256=IfwjEa8Lu819OXmUfxkzn8pnNeiR4wdY62Yk1Wuu3Yk,1182 +bitblas/3rdparty/tvm/python/tvm/relax/testing/transform.py,sha256=wXv01HHVS68iu1CEQZfyT6pKCNofa8KrJMRcfKTsTsI,8496 +bitblas/3rdparty/tvm/python/tvm/relax/testing/vm.py,sha256=HVELSlwvDWWdLc28d6yU4Rf3gIY6iQ2wJkFSEgXooAc,2616 +bitblas/3rdparty/tvm/python/tvm/relax/training/__init__.py,sha256=8MFIwijIk49LLhSx_XRS4zJb9OdGK-2kD8q--zHnF2s,1002 +bitblas/3rdparty/tvm/python/tvm/relax/training/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/training/__pycache__/__init__.cpython-310.pyc,sha256=fhnch-dZ4_cluyGsRXB6JR5ypyrRWdSWV_Vymw3QEv8,441 +bitblas/3rdparty/tvm/python/tvm/relax/training/__pycache__/__init__.cpython-38.pyc,sha256=zUsAem8Ibno7kAXL-iPwWnMAz4jSubXOXFwSSJX3NXc,428 +bitblas/3rdparty/tvm/python/tvm/relax/training/__pycache__/_ffi_api.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/training/__pycache__/_ffi_api.cpython-310.pyc,sha256=NnPt1FLRCPReNFQD6M1YkNj6fViM2Vt7v-JZAW73_2Q,300 +bitblas/3rdparty/tvm/python/tvm/relax/training/__pycache__/_ffi_api.cpython-38.pyc,sha256=3ysaZm3DDxpHbp93zq9DQBuBLdb6sisAlnugOq7A0cA,287 +bitblas/3rdparty/tvm/python/tvm/relax/training/__pycache__/loss.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/training/__pycache__/loss.cpython-310.pyc,sha256=xX93SbArLnNh9mbPLKXuHo0E2JPdrQF6oXyrOSy0dpY,12118 +bitblas/3rdparty/tvm/python/tvm/relax/training/__pycache__/loss.cpython-38.pyc,sha256=Gm1XdHjr6AM4linYCaKd1ZlcPp7_BjLktBx0qZHNDOM,12126 +bitblas/3rdparty/tvm/python/tvm/relax/training/__pycache__/optimizer.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/training/__pycache__/optimizer.cpython-310.pyc,sha256=t0gLJ9thaoFFikO9yd10kYoOat1IqxJ6MRS3brLFS-g,23371 +bitblas/3rdparty/tvm/python/tvm/relax/training/__pycache__/optimizer.cpython-38.pyc,sha256=WBalMH5f3DNfSKN8QSfPLRX9yODZ4De9N0DzRQ9xvGc,23432 +bitblas/3rdparty/tvm/python/tvm/relax/training/__pycache__/setup_trainer.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/training/__pycache__/setup_trainer.cpython-310.pyc,sha256=SzsHIhzxUzhy9SFu5WM7l3_gVsSOFhCuKIj_fh5ZOz0,6646 +bitblas/3rdparty/tvm/python/tvm/relax/training/__pycache__/setup_trainer.cpython-38.pyc,sha256=NM5XOR8oNGigYZBn8wOPN3iy4pAaUQJIFI0gLt6QMs4,6631 +bitblas/3rdparty/tvm/python/tvm/relax/training/__pycache__/trainer.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/training/__pycache__/trainer.cpython-310.pyc,sha256=1gRSAdqZcTRYhisoFQbD_TbM4QQ8PwRrN1V0jXKOm4Q,14516 +bitblas/3rdparty/tvm/python/tvm/relax/training/__pycache__/trainer.cpython-38.pyc,sha256=zvQ7S5qR8O1QMMBWAzNcGyVGA8ld8fiMsZA9JR-K-kI,15047 +bitblas/3rdparty/tvm/python/tvm/relax/training/__pycache__/utils.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/training/__pycache__/utils.cpython-310.pyc,sha256=Q0ndWz0O8SWCBbH6u6PUtMdUqe3zudmPX3A1Sb8oZMo,6433 +bitblas/3rdparty/tvm/python/tvm/relax/training/__pycache__/utils.cpython-38.pyc,sha256=kC3ENlcuJZZd7zYgcssQhmls7O62FTZFeB_CsB9iEdU,6380 +bitblas/3rdparty/tvm/python/tvm/relax/training/_ffi_api.py,sha256=jhadAC69N26XFc770piyVl5FrOxnzF6i1B5dONs2awE,887 +bitblas/3rdparty/tvm/python/tvm/relax/training/loss.py,sha256=F7tW5B2ZBW-2fiTvq87IipL6nJ338HbAB5zyQPW8Bl0,13687 +bitblas/3rdparty/tvm/python/tvm/relax/training/optimizer.py,sha256=VjSDrVuAr-0bk4vi_zyqzquOp7pihZQzbI0nXlT02nU,28249 +bitblas/3rdparty/tvm/python/tvm/relax/training/setup_trainer.py,sha256=YuB1OtblXQ26CrBK011WXMMKJwHQlrbdzAIlGENCdXk,8452 +bitblas/3rdparty/tvm/python/tvm/relax/training/trainer.py,sha256=3A9XR8MAkDYMx9b75N1QD1cwaZF1YWlbBCQsbm_vgak,15529 +bitblas/3rdparty/tvm/python/tvm/relax/training/utils.py,sha256=l3BbaCd54JZt1MDP4p1CM8WegRAabCtS5-OKAa_RMxw,7136 +bitblas/3rdparty/tvm/python/tvm/relax/transform/__init__.py,sha256=nc5fqdt1ocBQtV9go-Aa9Q0--xOMPzJhgHKGPAw_8cg,2804 +bitblas/3rdparty/tvm/python/tvm/relax/transform/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/transform/__pycache__/__init__.cpython-310.pyc,sha256=9zb4XWwhGf1LHAxPogpOsG6gdM0oHctz50yG0SMBE6Y,2558 +bitblas/3rdparty/tvm/python/tvm/relax/transform/__pycache__/__init__.cpython-38.pyc,sha256=sgui7nU0XRGTDK5D_iwMXGPhU6jBctNpJBKVfISZUXo,2545 +bitblas/3rdparty/tvm/python/tvm/relax/transform/__pycache__/_ffi_api.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/transform/__pycache__/_ffi_api.cpython-310.pyc,sha256=3-cOWyAZXKNNeWTQ6P4UCCesfk0wszaGRd8zAHx7Wp4,297 +bitblas/3rdparty/tvm/python/tvm/relax/transform/__pycache__/_ffi_api.cpython-38.pyc,sha256=Yc4e7wZchD2s1UvztBotwewA1yacjHj5emdPwvW7IP4,284 +bitblas/3rdparty/tvm/python/tvm/relax/transform/__pycache__/attach_external_modules.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/transform/__pycache__/attach_external_modules.cpython-310.pyc,sha256=FCSoZ665jFdfyRUJC_Acx8MmUbpEijNh9WFr_i-gQDg,1719 +bitblas/3rdparty/tvm/python/tvm/relax/transform/__pycache__/attach_external_modules.cpython-38.pyc,sha256=FF1paA3j_xxhXQ6idVpzP20QzKwhk7wBuqcrOBOQXg0,1718 +bitblas/3rdparty/tvm/python/tvm/relax/transform/__pycache__/fast_math.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/transform/__pycache__/fast_math.cpython-310.pyc,sha256=VVRC7uzqkM1_OYbM0ixIqAZyexU9pg4lqzjHgTa5T9o,2223 +bitblas/3rdparty/tvm/python/tvm/relax/transform/__pycache__/fast_math.cpython-38.pyc,sha256=G2AGn2nABVKRvAxUPlnU-GvftTMvXYVskKvWetBfn1s,2202 +bitblas/3rdparty/tvm/python/tvm/relax/transform/__pycache__/ipc_allreduce_rewrite.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/transform/__pycache__/ipc_allreduce_rewrite.cpython-310.pyc,sha256=NJvwPsl5iDUpkmUFV6Cl7EZgSFIOQo9F6kMBGTgTraU,4727 +bitblas/3rdparty/tvm/python/tvm/relax/transform/__pycache__/ipc_allreduce_rewrite.cpython-38.pyc,sha256=1-RqNStDd8l7cKVreso9olp1VOhK6eAPi0j4cJAkXCA,4713 +bitblas/3rdparty/tvm/python/tvm/relax/transform/__pycache__/lazy_transform_params.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/transform/__pycache__/lazy_transform_params.cpython-310.pyc,sha256=G8rW1JBlRS-jCkojraaWKdSZ-zIcctXcgc30D6eLViI,11675 +bitblas/3rdparty/tvm/python/tvm/relax/transform/__pycache__/lazy_transform_params.cpython-38.pyc,sha256=tcNswuzhb0A5QwQT1DhU8IT6NTDZtxlewlHN2CNXIjQ,11605 +bitblas/3rdparty/tvm/python/tvm/relax/transform/__pycache__/lower_gpu_ipc_alloc_storage.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/transform/__pycache__/lower_gpu_ipc_alloc_storage.cpython-310.pyc,sha256=W1Ukw9HTHaGP-PPFqa6gIzCIat4KuD2A6XkaNtlCmj8,3013 +bitblas/3rdparty/tvm/python/tvm/relax/transform/__pycache__/lower_gpu_ipc_alloc_storage.cpython-38.pyc,sha256=egbcoG3SnrwPT9wjXbpFF4vewa5SWotLjjp1DlPD0w8,3004 +bitblas/3rdparty/tvm/python/tvm/relax/transform/__pycache__/optimize_layout_transform.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/transform/__pycache__/optimize_layout_transform.cpython-310.pyc,sha256=CpsFnCpf83tu4pc8Ix9stkUvRjVSTxyrwWtHv__qXQI,2354 +bitblas/3rdparty/tvm/python/tvm/relax/transform/__pycache__/optimize_layout_transform.cpython-38.pyc,sha256=UeAiCxNfzmGZw8xUWxj0g_enUJh3XtcG8maMS9McUl4,2335 +bitblas/3rdparty/tvm/python/tvm/relax/transform/__pycache__/remove_redundant_reshape.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/transform/__pycache__/remove_redundant_reshape.cpython-310.pyc,sha256=_4SNcmq8BBvCtYK7n9E8DEyy-BKhKst9czLo07xWEP0,2231 +bitblas/3rdparty/tvm/python/tvm/relax/transform/__pycache__/remove_redundant_reshape.cpython-38.pyc,sha256=Vy5flnEV7jC2u9ZAb_92jr_c_mMWKVfUkuQYUVroqGg,2212 +bitblas/3rdparty/tvm/python/tvm/relax/transform/__pycache__/transform.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/transform/__pycache__/transform.cpython-310.pyc,sha256=jFxUY5MNVVxVMVwsPSi_OqX_wKQsH2o1X3xJ5Zwsavw,63131 +bitblas/3rdparty/tvm/python/tvm/relax/transform/__pycache__/transform.cpython-38.pyc,sha256=QrOTyBNq73KeZkNu6MVeARdbDNuNEphLpg8OOE2vKpQ,64109 +bitblas/3rdparty/tvm/python/tvm/relax/transform/_ffi_api.py,sha256=xindQ1lgpZfZNxCoan01dJ_reIOglWgwb_zeA9IfBxA,862 +bitblas/3rdparty/tvm/python/tvm/relax/transform/attach_external_modules.py,sha256=L3oMuOQhIYv3eIBSFXsEHDkQs1PGANMDq2v3l5Ia-rg,2134 +bitblas/3rdparty/tvm/python/tvm/relax/transform/fast_math.py,sha256=FkYIV123yQZjBtWsd74059pCaw5vOH8jVkOUiQnIGBo,2536 +bitblas/3rdparty/tvm/python/tvm/relax/transform/ipc_allreduce_rewrite.py,sha256=S3ZrhoC9ca7EIsQaPstrDgU8X483Yr3AViREYiZXTwc,5980 +bitblas/3rdparty/tvm/python/tvm/relax/transform/lazy_transform_params.py,sha256=NH7T-xCTHCTDv1DJZ4tEBiQmXbeewvzmlNQ-yluXk94,15241 +bitblas/3rdparty/tvm/python/tvm/relax/transform/legalize_ops/__init__.py,sha256=mk5Kfc9q-Ei4-X89_Bfs4zc7FuZgaqP9L62IIXqfhFA,1207 +bitblas/3rdparty/tvm/python/tvm/relax/transform/legalize_ops/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/transform/legalize_ops/__pycache__/__init__.cpython-310.pyc,sha256=F1FlAJwTDtalQISxW6sbpwc_H99Wm6ec88s3Jg2MNZU,744 +bitblas/3rdparty/tvm/python/tvm/relax/transform/legalize_ops/__pycache__/__init__.cpython-38.pyc,sha256=acE7VSRb2OKxy-9tVgfkzk_0OysXtSbrdJly4ferKPc,731 +bitblas/3rdparty/tvm/python/tvm/relax/transform/legalize_ops/__pycache__/binary.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/transform/legalize_ops/__pycache__/binary.cpython-310.pyc,sha256=oPISQNTDqU6N1W_WLCPBiAsCXeech5UjkKf4nj1psTI,2066 +bitblas/3rdparty/tvm/python/tvm/relax/transform/legalize_ops/__pycache__/binary.cpython-38.pyc,sha256=erlqVRRQTTLonaKExKyRlMmJvNDGDJKRx38XLLYLa9w,2051 +bitblas/3rdparty/tvm/python/tvm/relax/transform/legalize_ops/__pycache__/ccl.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/transform/legalize_ops/__pycache__/ccl.cpython-310.pyc,sha256=jmmPQb0lDM9zXKRYPZ8BYRsfKdilXobxJU-IRU7XipQ,3359 +bitblas/3rdparty/tvm/python/tvm/relax/transform/legalize_ops/__pycache__/ccl.cpython-38.pyc,sha256=-HmMNSw_d7g0sUxXtXUE7Lvwnt-lNxwQFRx5nRV2ieg,3346 +bitblas/3rdparty/tvm/python/tvm/relax/transform/legalize_ops/__pycache__/common.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/transform/legalize_ops/__pycache__/common.cpython-310.pyc,sha256=71abSjp45aLHUEhaThFcdjocJGR3QrKZYIJspmVmWR4,3490 +bitblas/3rdparty/tvm/python/tvm/relax/transform/legalize_ops/__pycache__/common.cpython-38.pyc,sha256=qveaGd5Kb2xRdY2y6TdFeCA8qKy-3h406jXdtjEH208,3464 +bitblas/3rdparty/tvm/python/tvm/relax/transform/legalize_ops/__pycache__/create.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/transform/legalize_ops/__pycache__/create.cpython-310.pyc,sha256=8OKlQ3gByCI7l-RuPjFBdH_l1mBCdEprCM-XgZZVS3Q,2942 +bitblas/3rdparty/tvm/python/tvm/relax/transform/legalize_ops/__pycache__/create.cpython-38.pyc,sha256=aWa4alAqt3GG3qxPixADRFB9GKC1sJmwtnCcAlJYB7g,2934 +bitblas/3rdparty/tvm/python/tvm/relax/transform/legalize_ops/__pycache__/datatype.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/transform/legalize_ops/__pycache__/datatype.cpython-310.pyc,sha256=jCzmTKQeW0tOTwiSBk-8vsZbXzoeoi2BIons_dzuc3E,825 +bitblas/3rdparty/tvm/python/tvm/relax/transform/legalize_ops/__pycache__/datatype.cpython-38.pyc,sha256=rMIsSbAR5WB_yhOC0b7k7V3FQSioncZhnGOMW84IJkQ,814 +bitblas/3rdparty/tvm/python/tvm/relax/transform/legalize_ops/__pycache__/distributed.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/transform/legalize_ops/__pycache__/distributed.cpython-310.pyc,sha256=anUcpy-CPKlq3ZFFtcTrbGF6jysGjmaFZMZSmsDBZ8Y,1188 +bitblas/3rdparty/tvm/python/tvm/relax/transform/legalize_ops/__pycache__/distributed.cpython-38.pyc,sha256=6h6KTcm7HCSF2H3qBAHKlsnz06Sz_muuyh8ngmjME64,1173 +bitblas/3rdparty/tvm/python/tvm/relax/transform/legalize_ops/__pycache__/grad.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/transform/legalize_ops/__pycache__/grad.cpython-310.pyc,sha256=Iem9bTs2WGooJsEss-SkgOGSU5HEjbzmrh4Xf73mbmU,6292 +bitblas/3rdparty/tvm/python/tvm/relax/transform/legalize_ops/__pycache__/grad.cpython-38.pyc,sha256=mzHpp75vpDhyvbbZoUXu_VJAdm3sTJ8kC7jLBH4TUBk,6315 +bitblas/3rdparty/tvm/python/tvm/relax/transform/legalize_ops/__pycache__/image.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/transform/legalize_ops/__pycache__/image.cpython-310.pyc,sha256=DK2uZkAn1trkC10sCuMLXFyxypIHHyJVyXudvF1mD1E,955 +bitblas/3rdparty/tvm/python/tvm/relax/transform/legalize_ops/__pycache__/image.cpython-38.pyc,sha256=gnsez5mtjzdHkXwaUnRJUewMVbwDslTGgdcZ9nZ_RmA,940 +bitblas/3rdparty/tvm/python/tvm/relax/transform/legalize_ops/__pycache__/index.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/transform/legalize_ops/__pycache__/index.cpython-310.pyc,sha256=8itYegfh9Vu7cE3xByk5OaZ8qHnnR-sxLO5bqMqyFYw,3287 +bitblas/3rdparty/tvm/python/tvm/relax/transform/legalize_ops/__pycache__/index.cpython-38.pyc,sha256=YXzCPDh4etxiac4nkMWJV5NZ4IQdMpvz6wrNhz8dFUo,3286 +bitblas/3rdparty/tvm/python/tvm/relax/transform/legalize_ops/__pycache__/inspect_op.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/transform/legalize_ops/__pycache__/inspect_op.cpython-310.pyc,sha256=loA_gOSpiQE4Xa3tOkONBfSFuet7px6dFWuixUKlf14,3634 +bitblas/3rdparty/tvm/python/tvm/relax/transform/legalize_ops/__pycache__/inspect_op.cpython-38.pyc,sha256=raQjPwqsHZQTTZcVVB2TDKD2AoFedtByizFykt2eiM8,3722 +bitblas/3rdparty/tvm/python/tvm/relax/transform/legalize_ops/__pycache__/linear_algebra.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/transform/legalize_ops/__pycache__/linear_algebra.cpython-310.pyc,sha256=GeheEUcttuj0-bB6a2rKnsBOuhFsu0iDOn-oZX8Vx28,3793 +bitblas/3rdparty/tvm/python/tvm/relax/transform/legalize_ops/__pycache__/linear_algebra.cpython-38.pyc,sha256=pVXxgLiWdAf5mYetZ5ZfRvTx3fONelVmK_01Kya4JIU,3763 +bitblas/3rdparty/tvm/python/tvm/relax/transform/legalize_ops/__pycache__/manipulate.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/transform/legalize_ops/__pycache__/manipulate.cpython-310.pyc,sha256=dywS8pnM5v0nKDgvr9Yt28QmqANgz0-_TixmNNDUa_E,7251 +bitblas/3rdparty/tvm/python/tvm/relax/transform/legalize_ops/__pycache__/manipulate.cpython-38.pyc,sha256=sb8DMjx8F5qzi7-C3cJzsUyFdCYU2fa_6ieSS8xeO2Q,7259 +bitblas/3rdparty/tvm/python/tvm/relax/transform/legalize_ops/__pycache__/nn.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/transform/legalize_ops/__pycache__/nn.cpython-310.pyc,sha256=2pLGgwZdUgPbhqwjdKN5EVIZaug1lm2JrGlpk4H9QHo,17034 +bitblas/3rdparty/tvm/python/tvm/relax/transform/legalize_ops/__pycache__/nn.cpython-38.pyc,sha256=3LsHMVZFaYeJEvzFBER3PP5ayAQjYlrYAZZJZRxapD8,18479 +bitblas/3rdparty/tvm/python/tvm/relax/transform/legalize_ops/__pycache__/qdq.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/transform/legalize_ops/__pycache__/qdq.cpython-310.pyc,sha256=32kn38BbgYsZcpzEZrV7j5dZe5-KBbXdI6O6pCVR9Lk,3649 +bitblas/3rdparty/tvm/python/tvm/relax/transform/legalize_ops/__pycache__/qdq.cpython-38.pyc,sha256=BvGrHsN1nRuY64b5m6GrDB-97TZnlke7n3_GrK2n-FM,3756 +bitblas/3rdparty/tvm/python/tvm/relax/transform/legalize_ops/__pycache__/search.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/transform/legalize_ops/__pycache__/search.cpython-310.pyc,sha256=6mZtVC4zlN4h_8t56nkHZ26cQbMz_vZ1gPfEOW8fezE,1091 +bitblas/3rdparty/tvm/python/tvm/relax/transform/legalize_ops/__pycache__/search.cpython-38.pyc,sha256=5JB0K_Dm8xNwGBU_wWIKdfxNkkADqJlNosN1xBt3FTM,1076 +bitblas/3rdparty/tvm/python/tvm/relax/transform/legalize_ops/__pycache__/statistical.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/transform/legalize_ops/__pycache__/statistical.cpython-310.pyc,sha256=HEJ8oSz1WGVUe8EQiwt0khHz_xmRXPsXb7OTUmVMUkQ,2874 +bitblas/3rdparty/tvm/python/tvm/relax/transform/legalize_ops/__pycache__/statistical.cpython-38.pyc,sha256=0haLLDXAg5RgIiVSxTrydjlDHY3QaXSczTEFI_e-nKc,2881 +bitblas/3rdparty/tvm/python/tvm/relax/transform/legalize_ops/__pycache__/unary.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/transform/legalize_ops/__pycache__/unary.cpython-310.pyc,sha256=Nol8oodSslOSvh13YkYzNkVLhfLB3wAKMV-sYugZb6Y,2421 +bitblas/3rdparty/tvm/python/tvm/relax/transform/legalize_ops/__pycache__/unary.cpython-38.pyc,sha256=Owb9_n0BOZ1d6qyWCGEzgozWs7W2j-19nzZz2MhQOq8,2400 +bitblas/3rdparty/tvm/python/tvm/relax/transform/legalize_ops/binary.py,sha256=2EsOupawz7BDwjjZQWUz1URyj-acOypkaEzoJXBAV78,3060 +bitblas/3rdparty/tvm/python/tvm/relax/transform/legalize_ops/ccl.py,sha256=3__uEK_evuFuA8VJgx3wVkAtUAPInHZZPhZ7FN7aGEo,4915 +bitblas/3rdparty/tvm/python/tvm/relax/transform/legalize_ops/common.py,sha256=t9I3WIJ_y8GG0IWdhUARd-BzG9nq3y-JJnSsM2eMa8I,4455 +bitblas/3rdparty/tvm/python/tvm/relax/transform/legalize_ops/create.py,sha256=LnfctUfpUMiY2OmGcKzkbbPeYtQk47wfDQTRRPkIn9o,3398 +bitblas/3rdparty/tvm/python/tvm/relax/transform/legalize_ops/datatype.py,sha256=8_Y3SNEIn_MfNFmwHXXPryUB3tRXCo6M5jL4V5qr4Z0,1372 +bitblas/3rdparty/tvm/python/tvm/relax/transform/legalize_ops/distributed.py,sha256=oU55uIS3F87Dq5RRZyk4PYKqVAtvNb4lBtEPs9DvfFg,1836 +bitblas/3rdparty/tvm/python/tvm/relax/transform/legalize_ops/grad.py,sha256=XugfxSPT69R3xtsdhpyXMqD8TLcJFfrsDchg91ZbqUw,8323 +bitblas/3rdparty/tvm/python/tvm/relax/transform/legalize_ops/image.py,sha256=Gs7_5jc0yby2Ymaoq9gBkdCdTQYbQfq9dBoiaczSVoc,1602 +bitblas/3rdparty/tvm/python/tvm/relax/transform/legalize_ops/index.py,sha256=J7VKsAdVNoIvKmy9I3NPTaMbycq5Di3C8563dkWUrxg,4446 +bitblas/3rdparty/tvm/python/tvm/relax/transform/legalize_ops/inspect_op.py,sha256=lapqklD5AsUWW2KknQWx85sIAFSSPN09aq17vYQsgYA,4936 +bitblas/3rdparty/tvm/python/tvm/relax/transform/legalize_ops/linear_algebra.py,sha256=IY0nGHBvld60aI9bb2LomUnfHmb6F6cEhJRL4s4SWoI,4975 +bitblas/3rdparty/tvm/python/tvm/relax/transform/legalize_ops/manipulate.py,sha256=QGmP1U5JnPIx-LSGa4nCeJqJp7zI_VDOnDDYF1cDkEU,8188 +bitblas/3rdparty/tvm/python/tvm/relax/transform/legalize_ops/nn.py,sha256=r79hB-3YmiAtzcADpVM85QjLM71aAQ8JIIBIsckS7YA,24532 +bitblas/3rdparty/tvm/python/tvm/relax/transform/legalize_ops/qdq.py,sha256=_iHX2JLJuujfwo0TIQ02RSSFXFLIj3qY-jCHCEMPbmI,4451 +bitblas/3rdparty/tvm/python/tvm/relax/transform/legalize_ops/search.py,sha256=32ePcTQVyoIa2cIl8b3xGmzPa4UY0DC4pp8OhPD5Gik,1618 +bitblas/3rdparty/tvm/python/tvm/relax/transform/legalize_ops/statistical.py,sha256=HoFPKUo5M7f1LhtUapO0XJFVjRIYAgywVDEZVbE4Pz0,3279 +bitblas/3rdparty/tvm/python/tvm/relax/transform/legalize_ops/unary.py,sha256=wz3CL-euQQQ5o_j2TwqrqIHR1GGN1Jn3GP7udO64EFk,3802 +bitblas/3rdparty/tvm/python/tvm/relax/transform/lower_gpu_ipc_alloc_storage.py,sha256=7F62_a9BOo2_wcpnAuCMgPKTGs7oqw9om9tx5qgcnhA,3362 +bitblas/3rdparty/tvm/python/tvm/relax/transform/optimize_layout_transform.py,sha256=E6or3qvx_zzoVfD9hwLFe-o0FFSyKem2JbNtAtSyXmQ,3103 +bitblas/3rdparty/tvm/python/tvm/relax/transform/remove_redundant_reshape.py,sha256=zp8z00Ai826boXwiNha4Tqm9MzEBqljDhxRjYYYVBsU,2942 +bitblas/3rdparty/tvm/python/tvm/relax/transform/transform.py,sha256=qFsth4GpzMDrLic7dKJgAp9JTGrOPtlgVTvoYR8T750,64877 +bitblas/3rdparty/tvm/python/tvm/relax/transform/tuning_api/__init__.py,sha256=dWMdbdF0nBfrxpYxGgX-hwfLydVudlm6SZW6eENJ19Q,950 +bitblas/3rdparty/tvm/python/tvm/relax/transform/tuning_api/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/transform/tuning_api/__pycache__/__init__.cpython-310.pyc,sha256=W6v6mRXPrEhFuOPNWdhbWkohN8urN94B5ox-o3AlWe0,294 +bitblas/3rdparty/tvm/python/tvm/relax/transform/tuning_api/__pycache__/__init__.cpython-38.pyc,sha256=lmODvbGc_kG7PGnNE2OZ3yiAm8onQtEdP2V1DjaEAQI,281 +bitblas/3rdparty/tvm/python/tvm/relax/transform/tuning_api/__pycache__/_ffi_api.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/transform/tuning_api/__pycache__/_ffi_api.cpython-310.pyc,sha256=ck27FoCNtGpFU8cac1NdcgZ0VVbkLg-2dFV5ko08BNE,312 +bitblas/3rdparty/tvm/python/tvm/relax/transform/tuning_api/__pycache__/_ffi_api.cpython-38.pyc,sha256=OXgtMgYPvTsBYEvk2Agup9N2L9O6qn6TNWEv7sRac_c,299 +bitblas/3rdparty/tvm/python/tvm/relax/transform/tuning_api/__pycache__/database.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/transform/tuning_api/__pycache__/database.cpython-310.pyc,sha256=ilKm_jZ0ufJMZmIe7rm_td9x4oQA09s3aPeDZ4LnXG4,8776 +bitblas/3rdparty/tvm/python/tvm/relax/transform/tuning_api/__pycache__/database.cpython-38.pyc,sha256=WHKmgzgThLll_mdmerUkCtzXdmnQLSfUSjvWKlCOws4,8840 +bitblas/3rdparty/tvm/python/tvm/relax/transform/tuning_api/__pycache__/default_functions.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/transform/tuning_api/__pycache__/default_functions.cpython-310.pyc,sha256=V621Z1Okwci1SaQ0eRcUWHLPks4-fKZeU8ihvt2BkuI,8171 +bitblas/3rdparty/tvm/python/tvm/relax/transform/tuning_api/__pycache__/default_functions.cpython-38.pyc,sha256=ex4bWa5LuAADXHmlFUEp1yps6OXNj4mDoEeDcaef8JQ,8195 +bitblas/3rdparty/tvm/python/tvm/relax/transform/tuning_api/__pycache__/primitives.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relax/transform/tuning_api/__pycache__/primitives.cpython-310.pyc,sha256=I7IHbE3zFmEtxUot_BIUDh_cdksULLl0lZJvooKbtW8,13061 +bitblas/3rdparty/tvm/python/tvm/relax/transform/tuning_api/__pycache__/primitives.cpython-38.pyc,sha256=jCw8NcNLuj5-uDUI57RjI5sqWY10mF7cZ4swjckC8Eo,13221 +bitblas/3rdparty/tvm/python/tvm/relax/transform/tuning_api/_ffi_api.py,sha256=v3SLCfedGhAC6Kh2uN2IKckVBaXZmlMfZHNDMCXvs1s,866 +bitblas/3rdparty/tvm/python/tvm/relax/transform/tuning_api/database.py,sha256=JxGPwBEDFQylLn9BP3gPO_mjK2K38IKZ9FPCTbaaYZQ,9203 +bitblas/3rdparty/tvm/python/tvm/relax/transform/tuning_api/default_functions.py,sha256=WHdbkuueTEZbCAiWqYMy7FKP7hpucD7kuajripDw5qc,11160 +bitblas/3rdparty/tvm/python/tvm/relax/transform/tuning_api/primitives.py,sha256=3MneB5RN7usTBtLLvKZlJFbCl191IBwAiVUnEyg0aoI,13682 +bitblas/3rdparty/tvm/python/tvm/relax/ty.py,sha256=n0ra5mq-4J4gtxy0qRVnCWz0vT0Js4Jzi1adMHvN1nk,2530 +bitblas/3rdparty/tvm/python/tvm/relax/utils.py,sha256=YsuGhJvAwnqUaHm-fNkmP4j8VVbq4YIERUipxZUG5zs,19224 +bitblas/3rdparty/tvm/python/tvm/relax/vm_build.py,sha256=zkha1HlcMcJOMAKpTbi6t1FDu1KTcOyDGzPlU7TLxdY,11409 +bitblas/3rdparty/tvm/python/tvm/relay/__init__.py,sha256=1r0UKuKB6VYklR0z4JdnjQ3_DRK0FxmTVJUXLsSYyKQ,3690 +bitblas/3rdparty/tvm/python/tvm/relay/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/__pycache__/__init__.cpython-310.pyc,sha256=vDIENt7zd3qLMBcIO41qtbuTXz1N84muN_7Z3NWtqYs,2593 +bitblas/3rdparty/tvm/python/tvm/relay/__pycache__/__init__.cpython-38.pyc,sha256=xWNmbgie4oOQEornjfObp2H586eOnPPV9SHZx2CHX10,2580 +bitblas/3rdparty/tvm/python/tvm/relay/__pycache__/_build_module.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/__pycache__/_build_module.cpython-310.pyc,sha256=jiThmwmbhcYkqH7fG-PKoiIPRje8dY-pfWM0FS4upPo,329 +bitblas/3rdparty/tvm/python/tvm/relay/__pycache__/_build_module.cpython-38.pyc,sha256=Nfy4HIWOlqGBRR_3o34-pXjmyQaMSNHu5_S1j_fra9s,316 +bitblas/3rdparty/tvm/python/tvm/relay/__pycache__/_ffi_api.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/__pycache__/_ffi_api.cpython-310.pyc,sha256=Yra_FMIHxgEdHPpdqG0Y7jhR8boycH4g4DGg8tVCQrQ,284 +bitblas/3rdparty/tvm/python/tvm/relay/__pycache__/_ffi_api.cpython-38.pyc,sha256=hcDmpChnAxuPANMzHDJDVhFKpwOWAM1jjmrihB8oljQ,271 +bitblas/3rdparty/tvm/python/tvm/relay/__pycache__/_ffi_api_parser.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/__pycache__/_ffi_api_parser.cpython-310.pyc,sha256=dAp-7st2RLIgnpixNWgHYI101kdnBoTHImD7Fyfr7MQ,291 +bitblas/3rdparty/tvm/python/tvm/relay/__pycache__/_ffi_api_parser.cpython-38.pyc,sha256=L7i4QabV4rvVz4-Q8L_vLcMuhma3BT4m_2KM6jhyXxE,278 +bitblas/3rdparty/tvm/python/tvm/relay/__pycache__/_make.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/__pycache__/_make.cpython-310.pyc,sha256=dL2jNUh0b3hVjMgcW9dht4k3J6hpJDguoFSVLim8HCI,389 +bitblas/3rdparty/tvm/python/tvm/relay/__pycache__/_make.cpython-38.pyc,sha256=FUHjc-d2cuMAFAPXC55oNulHZCNTMLHd2RIjpFsPu8M,376 +bitblas/3rdparty/tvm/python/tvm/relay/__pycache__/adt.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/__pycache__/adt.cpython-310.pyc,sha256=dkqTZlVhhJjDq5uVP9O3meEQOS5QynYNylFEFE0U2yI,5045 +bitblas/3rdparty/tvm/python/tvm/relay/__pycache__/adt.cpython-38.pyc,sha256=FxV3-SZwNI6eVMKINurS9Vk0lRhSmDs5YodPdW6p0J0,5114 +bitblas/3rdparty/tvm/python/tvm/relay/__pycache__/base.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/__pycache__/base.cpython-310.pyc,sha256=itCP4P2s5ZDEuwcOxiBJx2IZfAVNeuorvizgDL3tGps,2189 +bitblas/3rdparty/tvm/python/tvm/relay/__pycache__/base.cpython-38.pyc,sha256=AjJ34o3PXzzMbbbRvQOb8ZtAYmg0PQWOL7369NyIF10,2183 +bitblas/3rdparty/tvm/python/tvm/relay/__pycache__/build_module.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/__pycache__/build_module.cpython-310.pyc,sha256=fez-qlHgbB5qXYcvvHZngQ2lUDScUtgYHBYbT6bJgZ0,19879 +bitblas/3rdparty/tvm/python/tvm/relay/__pycache__/build_module.cpython-38.pyc,sha256=TxGdu6ywKOz3nbCJJeE-IdIlmO2jtiY-29XXKxBhofY,20235 +bitblas/3rdparty/tvm/python/tvm/relay/__pycache__/debug.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/__pycache__/debug.cpython-310.pyc,sha256=grQDm5jBSf19PsW7JpxZ79znJ3C4c9pQyVArFlmCGSI,1026 +bitblas/3rdparty/tvm/python/tvm/relay/__pycache__/debug.cpython-38.pyc,sha256=F9hrntkqwBWZL1SUsOcqjwyXqNtbNr1GlrICyN0SwQ0,1013 +bitblas/3rdparty/tvm/python/tvm/relay/__pycache__/expr.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/__pycache__/expr.cpython-310.pyc,sha256=bcSEaVQ_hzY7lSI9LGZRXGCYL8QHvDhEBHJhVdRHHz4,23277 +bitblas/3rdparty/tvm/python/tvm/relay/__pycache__/expr.cpython-38.pyc,sha256=ft8TrkaZ1Mo1x6kHve1mfbWsmqTW4BUz6fgyer23TPs,24581 +bitblas/3rdparty/tvm/python/tvm/relay/__pycache__/expr_functor.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/__pycache__/expr_functor.cpython-310.pyc,sha256=NXw4tOTQ7Td5joP3vjiUUXenqR0D60bPBqgUhrpdDbw,10446 +bitblas/3rdparty/tvm/python/tvm/relay/__pycache__/expr_functor.cpython-38.pyc,sha256=SOa7qGMr42EhhNMWrL7AAaVuzMkwuBQifvb-2CgEeN4,10939 +bitblas/3rdparty/tvm/python/tvm/relay/__pycache__/function.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/__pycache__/function.cpython-310.pyc,sha256=tY4MEAIqmDx78vWFoBEJQsJv9NcjVTec82uvzsw4EKw,3291 +bitblas/3rdparty/tvm/python/tvm/relay/__pycache__/function.cpython-38.pyc,sha256=Rw12-iTBN8dIwnA1R2HtbJoYHx8ymaMJUHRuB8an2_o,3288 +bitblas/3rdparty/tvm/python/tvm/relay/__pycache__/loops.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/__pycache__/loops.cpython-310.pyc,sha256=4PXAjBz4m7_RXcNHkzhGkyTYCcsIE-pv-thUWjSA40Q,1580 +bitblas/3rdparty/tvm/python/tvm/relay/__pycache__/loops.cpython-38.pyc,sha256=MfCYAjnD3o8r5SCYrdt-ovChEaoaz5aXIdgxmomfl-s,1522 +bitblas/3rdparty/tvm/python/tvm/relay/__pycache__/param_dict.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/__pycache__/param_dict.cpython-310.pyc,sha256=s9AuSPvDhsxjY9u7NWp-XI5mwgl0CaP63P9ooR8a4_E,1664 +bitblas/3rdparty/tvm/python/tvm/relay/__pycache__/param_dict.cpython-38.pyc,sha256=lmxDqtV4nfc5hu9mehLN5kjuxY1aG19AB4YWZYlPX7U,1663 +bitblas/3rdparty/tvm/python/tvm/relay/__pycache__/parser.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/__pycache__/parser.cpython-310.pyc,sha256=SQSm-Dax_BRwbgIpJtvtTULJJ3TmKfVbUzKHmau2xOQ,905 +bitblas/3rdparty/tvm/python/tvm/relay/__pycache__/parser.cpython-38.pyc,sha256=xRP3eooFFHdEarbgvgmSkpHuXUDgKGGykZoeGkrMP5g,892 +bitblas/3rdparty/tvm/python/tvm/relay/__pycache__/prelude.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/__pycache__/prelude.cpython-310.pyc,sha256=87aQKRtv1PeiFWNC7GVgmi2PBeXCVuPCVM3dVVm3pXE,39751 +bitblas/3rdparty/tvm/python/tvm/relay/__pycache__/prelude.cpython-38.pyc,sha256=1DG0ndoWc2FGNjdkXom2P6UlYH3CDcDWUe86WKADppA,40166 +bitblas/3rdparty/tvm/python/tvm/relay/__pycache__/scope_builder.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/__pycache__/scope_builder.cpython-310.pyc,sha256=yDOuTd3_spERsCSM7B4JS6qkevUcqa4BcWhDVsgMoB0,6193 +bitblas/3rdparty/tvm/python/tvm/relay/__pycache__/scope_builder.cpython-38.pyc,sha256=3C5JsXP3Gckdp0meeV-s4SG2wcxFtCOswLy3ZX20BY4,6176 +bitblas/3rdparty/tvm/python/tvm/relay/__pycache__/ty.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/__pycache__/ty.cpython-310.pyc,sha256=ff4lTLSuq1uY6a6MxrZ0PqQ8kQDtC51tqoygYQOX2r8,1624 +bitblas/3rdparty/tvm/python/tvm/relay/__pycache__/ty.cpython-38.pyc,sha256=CR4t-rpb5IiDAPgKluf1IyShDZ0bBOTxeuo8XG3FzwM,1611 +bitblas/3rdparty/tvm/python/tvm/relay/__pycache__/type_functor.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/__pycache__/type_functor.cpython-310.pyc,sha256=SLMryymJxSuXUkXLGS8tuJkgJxgiyQJWzylqJ3EaFNk,7375 +bitblas/3rdparty/tvm/python/tvm/relay/__pycache__/type_functor.cpython-38.pyc,sha256=eqAbizjAruUsEwcaEstc09kb41diLuP_AqWKRUoz6aM,7845 +bitblas/3rdparty/tvm/python/tvm/relay/_build_module.py,sha256=uejlD961q3gvUW-oSJuYMuFCy0PAd8-omJ6JUiyPWh8,996 +bitblas/3rdparty/tvm/python/tvm/relay/_ffi_api.py,sha256=G2mj1Kkqxprchw7-kJ68l5qko5mDfkyjnXVSOJzNVDc,880 +bitblas/3rdparty/tvm/python/tvm/relay/_ffi_api_parser.py,sha256=Owt0d4xQYljaoiMDL330BTbxzMr7Qz30YVzErth-m6Q,880 +bitblas/3rdparty/tvm/python/tvm/relay/_make.py,sha256=eaMN1_0rSvNSnrqn8wJlOWJJEvWM8Bbxa8vRZNU1nWA,988 +bitblas/3rdparty/tvm/python/tvm/relay/adt.py,sha256=g1TlLvrMCeFGaeIROtxVZeD6DI-JYwwNm5q91M9_4bc,4992 +bitblas/3rdparty/tvm/python/tvm/relay/analysis/__init__.py,sha256=yYIYi67uRZgI2FNE1BPqbSLOVKRHkcP2b8rtb1a2Wis,1233 +bitblas/3rdparty/tvm/python/tvm/relay/analysis/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/analysis/__pycache__/__init__.cpython-310.pyc,sha256=uFZA4yJ0m8tz32HgXZk-qC93C9S7twwEdr5sEbptgp4,527 +bitblas/3rdparty/tvm/python/tvm/relay/analysis/__pycache__/__init__.cpython-38.pyc,sha256=dKLnSQ0LPwjLuA91swvQyZGCrBIqaRICDgNUDLIpmVY,514 +bitblas/3rdparty/tvm/python/tvm/relay/analysis/__pycache__/_ffi_api.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/analysis/__pycache__/_ffi_api.cpython-310.pyc,sha256=OrZFkS1mGguFysZVYK1FaaGLuU_cgt6U7PXlqUrcQHk,305 +bitblas/3rdparty/tvm/python/tvm/relay/analysis/__pycache__/_ffi_api.cpython-38.pyc,sha256=L5gVHNqpt-3fve7q6xGDn7X5pv_oTsj1BN7vyDqZ8dw,292 +bitblas/3rdparty/tvm/python/tvm/relay/analysis/__pycache__/analysis.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/analysis/__pycache__/analysis.cpython-310.pyc,sha256=WZzszj74TFHTbYOsS2GQ661wlIn719NcwDU8eNqlgLo,12179 +bitblas/3rdparty/tvm/python/tvm/relay/analysis/__pycache__/analysis.cpython-38.pyc,sha256=IR447kaN7YfJUcu0v87nAjVf40lM4gfIP9qjdRH5xFo,12361 +bitblas/3rdparty/tvm/python/tvm/relay/analysis/__pycache__/annotated_regions.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/analysis/__pycache__/annotated_regions.cpython-310.pyc,sha256=Z3p0bqjh8VpoWOWRwPBS20WhXIiDU8UVZCucitFRlRA,1675 +bitblas/3rdparty/tvm/python/tvm/relay/analysis/__pycache__/annotated_regions.cpython-38.pyc,sha256=VkVLgmKGYysyqEu-JEsU-6QYe_pm6gL_EVSJLa9Rol0,1666 +bitblas/3rdparty/tvm/python/tvm/relay/analysis/__pycache__/call_graph.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/analysis/__pycache__/call_graph.cpython-310.pyc,sha256=It1YjDX-kAhzynoNVY55OgKo00QKfWuEkORguygGK7s,3844 +bitblas/3rdparty/tvm/python/tvm/relay/analysis/__pycache__/call_graph.cpython-38.pyc,sha256=XTObbEDVJJ-TblMZomZoKAxLLIiIHrZmVV0XdqZMdBY,3918 +bitblas/3rdparty/tvm/python/tvm/relay/analysis/__pycache__/count_layers.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/analysis/__pycache__/count_layers.cpython-310.pyc,sha256=caX_FAjwYzEkADCnzW6iflgcNQOamqYMdfE8W9xyNWQ,2275 +bitblas/3rdparty/tvm/python/tvm/relay/analysis/__pycache__/count_layers.cpython-38.pyc,sha256=oYfWEgF2ouHS0AHJOIGiKkCZarUa2YI5tiCMUG_K6c8,2260 +bitblas/3rdparty/tvm/python/tvm/relay/analysis/__pycache__/feature.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/analysis/__pycache__/feature.cpython-310.pyc,sha256=s-nMpukJFCYDrfQxAoSyHEI9FV1mMPQD3IuUqWKK5AY,816 +bitblas/3rdparty/tvm/python/tvm/relay/analysis/__pycache__/feature.cpython-38.pyc,sha256=NbrScYyhijSWeN7intEgjEAzOb_PVUcgV08SKB-yHmM,793 +bitblas/3rdparty/tvm/python/tvm/relay/analysis/__pycache__/operations_distribution.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/analysis/__pycache__/operations_distribution.cpython-310.pyc,sha256=09gMl5J_0JvJYcpcVAo7_dNy7eYYvx0npKIx0ucvjrM,3816 +bitblas/3rdparty/tvm/python/tvm/relay/analysis/__pycache__/sparse_conv2d.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/analysis/__pycache__/sparse_conv2d.cpython-310.pyc,sha256=0ZkCc6pUi7OJT-cch3b3DHr2ifPgDSVginTPQy1x6qY,3267 +bitblas/3rdparty/tvm/python/tvm/relay/analysis/__pycache__/sparse_conv2d.cpython-38.pyc,sha256=er2ajOzpO4cmMNVt3pGnYhdyVXCBOqe3zsVWLbE-B3g,3262 +bitblas/3rdparty/tvm/python/tvm/relay/analysis/__pycache__/sparse_dense.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/analysis/__pycache__/sparse_dense.cpython-310.pyc,sha256=4N0uyOnlzZUWtnDDe2IM5Z75F5lpYPo440keSM_fRbc,2659 +bitblas/3rdparty/tvm/python/tvm/relay/analysis/__pycache__/sparse_dense.cpython-38.pyc,sha256=G0_M8V5Ppe9FxI6mtEpNKjaO8KTaZ4EOQKfhOwn2p2E,2646 +bitblas/3rdparty/tvm/python/tvm/relay/analysis/_ffi_api.py,sha256=r2D_PHaSv_HPt0UARWluhZe-a-O1S1f5ZSuCzmAuj9o,892 +bitblas/3rdparty/tvm/python/tvm/relay/analysis/analysis.py,sha256=kfZJFaCjU086UNfMbDBODEfQqmyrrkDTDKnd04uKrGI,12154 +bitblas/3rdparty/tvm/python/tvm/relay/analysis/annotated_regions.py,sha256=wDeMTCWmg83Cparn14o2c0WkFX4skT8LKft1jqOvZs8,2024 +bitblas/3rdparty/tvm/python/tvm/relay/analysis/call_graph.py,sha256=QhGhwOficL3-6xgio7XjfG0cw5W2wpDuWpxSRTH_j48,4135 +bitblas/3rdparty/tvm/python/tvm/relay/analysis/count_layers.py,sha256=90EyqyaXx3_I8VnRqKsExt2yc5OsQjZEiLv02m28zMo,2445 +bitblas/3rdparty/tvm/python/tvm/relay/analysis/feature.py,sha256=XRSU7qj5exJuOJ38VTQUi3JQYhcSezJY9pOiO8V0g3U,1439 +bitblas/3rdparty/tvm/python/tvm/relay/analysis/operations_distribution.py,sha256=i8a-uDweoOCxXDexlz4UwHc9zFxfLTCTXZlFn2IQCF4,4132 +bitblas/3rdparty/tvm/python/tvm/relay/analysis/sparse_conv2d.py,sha256=D3DErJ27GZxlq7KLHaqxcuGDPz5V41xegOD9lFB_tWM,5862 +bitblas/3rdparty/tvm/python/tvm/relay/analysis/sparse_dense.py,sha256=vfxy7l6Pf9sTtVDVHh-scA46A_2f8Jy-cp6igF4RR1Q,4439 +bitblas/3rdparty/tvm/python/tvm/relay/backend/__init__.py,sha256=qz8PulfY5HJx0dy5klS_b09wx2NHaApkR345_o8ZoSc,912 +bitblas/3rdparty/tvm/python/tvm/relay/backend/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/backend/__pycache__/__init__.cpython-310.pyc,sha256=pLLfK3-WDWspdELIh25UMIg1vLpjCTa0ZYipM7OsdqE,334 +bitblas/3rdparty/tvm/python/tvm/relay/backend/__pycache__/__init__.cpython-38.pyc,sha256=w_FqvyIlr1BaNcdv8zB_eJYsvYzBakvRPIuPp0SVqCQ,321 +bitblas/3rdparty/tvm/python/tvm/relay/backend/__pycache__/_aot.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/backend/__pycache__/_backend.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/backend/__pycache__/_backend.cpython-310.pyc,sha256=__-wybNceDvMfqwpwCKVVmAgFUzKs-Sl4voyR_RK7RI,1423 +bitblas/3rdparty/tvm/python/tvm/relay/backend/__pycache__/_backend.cpython-38.pyc,sha256=AU2Ta9tvs-hZtlQPjTdbDCpG-g3zzG_YXNYxjE-qyS4,1408 +bitblas/3rdparty/tvm/python/tvm/relay/backend/__pycache__/_vm.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/backend/__pycache__/_vm.cpython-310.pyc,sha256=1BW9lT8ZNv5AdPcWVT1F756pERmKKh-pYQ-6IORdb2o,299 +bitblas/3rdparty/tvm/python/tvm/relay/backend/__pycache__/_vm.cpython-38.pyc,sha256=O8q7uqj_lkSaok8UYCsz33Vw5H-UQV0cIQNKSNYadCQ,286 +bitblas/3rdparty/tvm/python/tvm/relay/backend/__pycache__/aot.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/backend/__pycache__/executor.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/backend/__pycache__/executor.cpython-310.pyc,sha256=hJa6ouj1_-fAs4PcexH9bVsnJmfyIpoJK8VpQmQOp-A,2144 +bitblas/3rdparty/tvm/python/tvm/relay/backend/__pycache__/executor.cpython-38.pyc,sha256=zzMzcg6PaLbBdO79LtBkbeBb6kD2mbQ2ZUN2xRONYM0,2123 +bitblas/3rdparty/tvm/python/tvm/relay/backend/__pycache__/executor_factory.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/backend/__pycache__/executor_factory.cpython-310.pyc,sha256=hqByTZEzvrelUzXnt2AAnOHHjoUXvgMSAA9wwBOC_Ac,6833 +bitblas/3rdparty/tvm/python/tvm/relay/backend/__pycache__/executor_factory.cpython-38.pyc,sha256=zdCGMT6LZF2kFh1z6g7f-x4kdumIxIaKXIKHBoV0PeQ,6930 +bitblas/3rdparty/tvm/python/tvm/relay/backend/__pycache__/graph_executor_codegen.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/backend/__pycache__/interpreter.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/backend/__pycache__/interpreter.cpython-310.pyc,sha256=cX-qvdCcVcDcYNGO0rhaHC4H0Ww8RtwnR8x9H4iK9IU,7503 +bitblas/3rdparty/tvm/python/tvm/relay/backend/__pycache__/interpreter.cpython-38.pyc,sha256=ROq_Zt1jpuR0ImLCwZ8vMIHKTP060pQp-jJhpEM_xcE,7583 +bitblas/3rdparty/tvm/python/tvm/relay/backend/__pycache__/name_transforms.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/backend/__pycache__/name_transforms.cpython-310.pyc,sha256=FfolqHACbYkJYqJGnahaB3CRYZyI1N6KKDj36SfnIwU,2564 +bitblas/3rdparty/tvm/python/tvm/relay/backend/__pycache__/runtime.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/backend/__pycache__/runtime.cpython-310.pyc,sha256=z4-VIGkEFHxd6e8XniUcfZfnLS8kamMaUTRBUFnGWvg,1752 +bitblas/3rdparty/tvm/python/tvm/relay/backend/__pycache__/runtime.cpython-38.pyc,sha256=LYUvzaHL8_5lR8VOB0vdk_99f0N1qs4hxxp55OXLA6k,1733 +bitblas/3rdparty/tvm/python/tvm/relay/backend/__pycache__/te_compiler.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/backend/__pycache__/te_compiler.cpython-310.pyc,sha256=4o0LQYtgr0Ze7ltnCCEYhVDU4pnnWC_OFLldLKO8plI,11491 +bitblas/3rdparty/tvm/python/tvm/relay/backend/__pycache__/te_compiler.cpython-38.pyc,sha256=fNkeIbOG5hxxuUdrV4gZlhmLCKOMNPm3KhRnbUaYMqk,11562 +bitblas/3rdparty/tvm/python/tvm/relay/backend/__pycache__/utils.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/backend/__pycache__/utils.cpython-310.pyc,sha256=Rrydbig9zNnCQ81CdtsfJWirvIv4HLKfx4nO-7Fe-gM,949 +bitblas/3rdparty/tvm/python/tvm/relay/backend/__pycache__/utils.cpython-38.pyc,sha256=bKFraU1_4X0NgBnJMGQh7LWHEtLVylEIEARLwaC5JzE,934 +bitblas/3rdparty/tvm/python/tvm/relay/backend/__pycache__/vm.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/backend/__pycache__/vm.cpython-310.pyc,sha256=_w11CVMWpLUdW9t8d6vumvi4mlxlEGIPe4dY3cQyFBU,7582 +bitblas/3rdparty/tvm/python/tvm/relay/backend/__pycache__/vm.cpython-38.pyc,sha256=U4eX2tdayWTPenJ5UJ6GWG-Ypp3hDdcdpHEncTIjyqU,7537 +bitblas/3rdparty/tvm/python/tvm/relay/backend/_aot.py,sha256=UyNnBi97ADHUshy4t4acB8NPJVFa5U_ev9W2Y0k-_nI,882 +bitblas/3rdparty/tvm/python/tvm/relay/backend/_backend.py,sha256=WUVQU1gVvLO0PJ0FvOHBhSBwXWokMBo4NYMyy0utObA,1902 +bitblas/3rdparty/tvm/python/tvm/relay/backend/_vm.py,sha256=Yr0F8BDxdsaj_UWGflErh25TRXFqUKMyEmwBOzheR80,892 +bitblas/3rdparty/tvm/python/tvm/relay/backend/aot.py,sha256=IVFGpq06olwvbS9vOY5w35M_BvVL9MbBNgp-ngwpPfY,2988 +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/__init__.py,sha256=M8MCIMWvYTWURCX_mbRwsh3Qz2KMznwBh13CelqS1CU,835 +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/__init__.py,sha256=77vmwsVSV6-JQMx49Hy4O1VUWA_cfav7BauBZ_TntlA,1019 +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/__pycache__/_ffi_api.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/__pycache__/codegen.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/__pycache__/legalize.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/__pycache__/preprocess.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/__pycache__/softmax_rewriter.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/__pycache__/tir_to_cs_translator.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/__pycache__/util.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/__pycache__/vela_api.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/_ffi_api.py,sha256=I2jbRWohAu7fB2xTcAKwrgwIkOy-ofi2hOmcUXvulAo,968 +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/codegen.py,sha256=vOl9aS-jKJZaA9ImkZ_TAZikBIJO1tfzATvMYFaKV2E,26984 +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/legalize.py,sha256=iYnsrjENZP6sNSIgNj1_gF37cYMoBfBe8V0YFxMqVwg,68098 +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/op/__init__.py,sha256=ZOu4HBMiZsn0C5FeJvD4bkqOEruqOqCRw9WqRReEqfE,1109 +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/op/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/op/__pycache__/binary_elementwise.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/op/__pycache__/convolution.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/op/__pycache__/depthwise.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/op/__pycache__/identity.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/op/__pycache__/op_attrs.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/op/__pycache__/pooling.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/op/__pycache__/unary_elementwise.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/op/binary_elementwise.py,sha256=7L2LyOvA3_9hkZyKkS3TDcbwwaxAIXLUiakNrAXQv2o,8243 +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/op/convolution.py,sha256=26g3PViYRnqOQFYutHDlgEGK_yJgxOTQR_ICexCqclc,7246 +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/op/depthwise.py,sha256=dFsAPNy59JYMcVqBL7Ln8f2twWu2SfCSTDFAK0Jn7O8,7603 +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/op/identity.py,sha256=pDag_EfW1TncD1qL-gthRv6KD4dFM57ATSMS3SIMy-4,3909 +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/op/op_attrs.py,sha256=G-zufHhq2xuB1Aar29zVFKSfHoKHTYFtTk7wgOmwDMg,1849 +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/op/pooling.py,sha256=8V-49r5Vik5JCiDGvBglKkIA325yxGd-RnUv4ajIOH0,6685 +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/op/unary_elementwise.py,sha256=NwBbBHqcdXZvow16qZkRhusFu5vhI4GJyEV_tmplRs8,5647 +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/preprocess.py,sha256=bSx0_4wp8LahJKIHv2poU13ZnpA2UW_ZMijie44C43I,1622 +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/softmax_rewriter.py,sha256=XV8hF0h1TkhKnfUt2qiTSs-kq3hRlH0RcAPakZ8nNTI,18046 +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/te/__init__.py,sha256=WId4OHuSCcUE1NJeTOUw2e49OCyQHHM6Ud_VmZFOZ9s,1011 +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/te/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/te/__pycache__/binary_elementwise.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/te/__pycache__/common.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/te/__pycache__/convolution.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/te/__pycache__/depthwise.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/te/__pycache__/dma.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/te/__pycache__/identity.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/te/__pycache__/inline.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/te/__pycache__/pooling.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/te/__pycache__/unary_elementwise.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/te/binary_elementwise.py,sha256=XrsBkNXVnRKlvX6haAOZGI8TfD9E1GSSn4Jm_eRn1LQ,12374 +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/te/common.py,sha256=3Oj5L8vsuE6fdoo2_BSIVaqSuCeU_J3vBx4iAWYXWZI,3361 +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/te/convolution.py,sha256=OWuDBDP5SmWJJd1su_fCjXkZCIRAAM-Pp8mju81wjO8,11391 +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/te/depthwise.py,sha256=CKc2eTXj7YVb7O9ZSGhpfoXVNFBJ3kXEdo6c3aR2ojw,10992 +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/te/dma.py,sha256=8p3Gcs8-7SKdum8mV3iq52xbRA14-KqJCGfPwga6YNY,11174 +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/te/identity.py,sha256=K6uVZDPnnR522i4wRxuWi0Geomd36qOa63Nk8-AsI0w,5646 +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/te/inline.py,sha256=J0RZxb-_SwmqZ1CRHjbDwoi9XE6chF08p_xzfvVuhnc,2758 +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/te/pooling.py,sha256=JB-uVB8lqPiUc1uyYbgIy-3abG-sZcd_BH4soS7mxdw,9835 +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/te/unary_elementwise.py,sha256=pZ6mhd4wQpM2L5_pjnPPypgv0klKIGAIbJH_1SHgWiU,7763 +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/tir/__init__.py,sha256=jFB0tdxmfc5SaBE5exXB2D-ydZxkXKercTTOUxDehd8,835 +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/tir/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/tir/__pycache__/binary_elementwise.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/tir/__pycache__/compiler.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/tir/__pycache__/convolution.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/tir/__pycache__/depthwise.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/tir/__pycache__/dma.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/tir/__pycache__/identity.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/tir/__pycache__/passes.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/tir/__pycache__/pooling.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/tir/__pycache__/producers_consumers.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/tir/__pycache__/scheduler.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/tir/__pycache__/spec.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/tir/__pycache__/transform.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/tir/__pycache__/unary_elementwise.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/tir/__pycache__/utils.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/tir/binary_elementwise.py,sha256=OjJSZO9h1Yy4_-VqZ86Q3LkXEMdCTW4yzHwGDdG4oLg,3787 +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/tir/compiler.py,sha256=2i6IrWYDG2cGa3vCvQqnsDZgv4XIPRgiBVyoIcGvXg0,8450 +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/tir/convolution.py,sha256=M3fxie0iKQKP4HS-xFW2MXXLDOFBt7ni47JDdlaCJGc,6379 +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/tir/depthwise.py,sha256=QpOZysTzpdRAqivr0mI_scjA4BjSdf16ghjUDin-EjE,4526 +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/tir/dma.py,sha256=GVp5Sq1T9BdZKyfKGLyLVjedabC_jafMSqr7qvWI-Oc,17994 +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/tir/identity.py,sha256=nsoFyxXRzt6Zub-GuaAIL_9F15qaRIZ1B4r1Brzv-cQ,6061 +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/tir/passes.py,sha256=oqyT-M437-jyac2VxvzP9-YGblMbABYmmdWPBzvEzr8,45493 +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/tir/pooling.py,sha256=nr69BHaHYNc7JCETxddMeOi9cdfCwW841sCvSQipj1c,3612 +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/tir/producers_consumers.py,sha256=SjTpOIlAcsoIvsbsIePfdWGz8Sgjx-vsJdlsXYjQg8k,3379 +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/tir/scheduler.py,sha256=Y2EM9SSR_VS1vLeWbFsEK5zF_1W_4N-5BcGyDz4M5Fw,12641 +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/tir/spec.py,sha256=h54JUs4B9gODmnzEuFrn0PZVdcWXL2jXRBvIG3CwJFg,11643 +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/tir/transform.py,sha256=ELCNIKIjav-UBFda1g_ULeN_6wxIbcHUa0P2tDGwd1g,2369 +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/tir/unary_elementwise.py,sha256=L4z9gu1bKYQ-38ZLsOKkEAhW6tHDEbhwDPZ1eBsMfCg,3189 +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/tir/utils.py,sha256=3lPSMQdyFyNBRqQziw2_eta-1CRUeCbyqBvTougN1j8,6268 +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/tir_to_cs_translator.py,sha256=O9iPd36RPx0CEd2bT9MYaHH0vnZw7dF9fnoaQOOu-qs,43746 +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/util.py,sha256=ZhAoXVOe9R5lI17ibzZJu_VlhdT8QrTMRjE3s3q4aAQ,10443 +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/ethosu/vela_api.py,sha256=259WG759Rof_i6WNUALZGYUIFDtKRjRCYuk6jr8Q3y0,19025 +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/uma/__init__.py,sha256=T963IH9v_LOJFwB9fbBDXvq7h5G571MRQBEsNH-clgY,928 +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/uma/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/uma/__pycache__/backend.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/uma/api/__init__.py,sha256=cxOxXvWOJmPP5AfGHaWMK2ua-qlFOCqGMBFVhgwxEEE,999 +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/uma/api/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/uma/api/__pycache__/_ffi_api.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/uma/api/__pycache__/codegen.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/uma/api/__pycache__/lower.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/uma/api/__pycache__/partitioner.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/uma/api/__pycache__/utils.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/uma/api/_ffi_api.py,sha256=f-VmkaE2CtndDC-7N-ok5mbzxDKzQEo3SrFUrdU7xTo,912 +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/uma/api/codegen.py,sha256=Mmup5DCmmL7T4S_j-PEYmWoflL5Brlodnn2OIvaQ6hM,2326 +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/uma/api/lower.py,sha256=cIAANlB3SzWWqxhsyYue5MMdF-0TJ_YpL1sWad0wrr0,5316 +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/uma/api/partitioner.py,sha256=D_REEadl3aXnYncEEpZKW9R5Rs7QuREeBGDMSboSzvE,4304 +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/uma/api/utils.py,sha256=2TMllPf9dorva-3nHPFZqDssTVXC09a_WP4bVMg9VkM,2462 +bitblas/3rdparty/tvm/python/tvm/relay/backend/contrib/uma/backend.py,sha256=nwmSOxmzNlSHPHnf9tOsQqDFM18ZF74PWQk5dWfw_6I,10541 +bitblas/3rdparty/tvm/python/tvm/relay/backend/executor.py,sha256=_fZxLCHYduy1bw2zPToASwmrJPFkjcZrKJGI7ViiNUI,2416 +bitblas/3rdparty/tvm/python/tvm/relay/backend/executor_factory.py,sha256=2iQnLC8pvaJ5AaXmEM3NvaZSICcEoVnRTnRsik_lRGA,6715 +bitblas/3rdparty/tvm/python/tvm/relay/backend/graph_executor_codegen.py,sha256=Nko3_x7BDGa3AkUVSSmPZCo4rEbQFyQKzu2Vwk7FpYs,3534 +bitblas/3rdparty/tvm/python/tvm/relay/backend/interpreter.py,sha256=rk8-ngwisoWsM_mFnY4eWAUkXtVlsolrfyVjIwLMglw,8343 +bitblas/3rdparty/tvm/python/tvm/relay/backend/name_transforms.py,sha256=NhDmkR6Mb1Ay52jzsB7R4AVokoHv1eSVBilPHR6BjKA,2942 +bitblas/3rdparty/tvm/python/tvm/relay/backend/runtime.py,sha256=6ej4zTKwcWfJ0DfZHJczoKjze_6_iFwq-0CDsq2VTRU,1939 +bitblas/3rdparty/tvm/python/tvm/relay/backend/te_compiler.py,sha256=eeXf0NxCUKLTwGnnKrVt91L5OWnnIns1uXjIKgcNXD4,14759 +bitblas/3rdparty/tvm/python/tvm/relay/backend/utils.py,sha256=FVaORCRAILN18mNIMesENJ4-fQyPemz_W8fAeRS8JFY,1411 +bitblas/3rdparty/tvm/python/tvm/relay/backend/vm.py,sha256=sV9eoTz7iARey5dSh5h5RI0Vxew83qXwfXYubA0O7RQ,7968 +bitblas/3rdparty/tvm/python/tvm/relay/base.py,sha256=2YO9ioVcT4TKCx7jSROfdDUu1EDEBNuqne5zyQ4Iyds,2508 +bitblas/3rdparty/tvm/python/tvm/relay/build_module.py,sha256=SIVJLxArifGOV6N9UJc2upOypDvq6G7XD0DQanYDj7s,24808 +bitblas/3rdparty/tvm/python/tvm/relay/collage/__init__.py,sha256=d_MaryZMAuYqlZDDYgP_SWltSKrv56fKEp8_Rp3On54,971 +bitblas/3rdparty/tvm/python/tvm/relay/collage/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/collage/__pycache__/__init__.cpython-310.pyc,sha256=XwWoI7hObo5GQI_1YrV8qYma9LXzFS-cUeZKn5TMVEE,389 +bitblas/3rdparty/tvm/python/tvm/relay/collage/__pycache__/__init__.cpython-38.pyc,sha256=p2sA8Xp1ILZosqwi8uTRa66LS3EPetoFgQY62jTlHgw,376 +bitblas/3rdparty/tvm/python/tvm/relay/collage/__pycache__/_ffi_api.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/collage/__pycache__/_ffi_api.cpython-310.pyc,sha256=Hick4Re_10k2bkz9CEkTItsz_1GSlgXkAJPcuTYq7s0,304 +bitblas/3rdparty/tvm/python/tvm/relay/collage/__pycache__/_ffi_api.cpython-38.pyc,sha256=ekGBQVQGBztkzTll4nwfD8czMeBHTekVroGHpnmHlZA,291 +bitblas/3rdparty/tvm/python/tvm/relay/collage/__pycache__/collage.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/collage/__pycache__/collage.cpython-310.pyc,sha256=mhK9HJW3hS0f6Or6U3V9sDJGlXPxtV_3GDP7F0ZsZmM,5170 +bitblas/3rdparty/tvm/python/tvm/relay/collage/__pycache__/collage.cpython-38.pyc,sha256=L-RSaMHH4aKY6wjHe0ITbI-IL9e6R30GtNGGvw-wMO0,5221 +bitblas/3rdparty/tvm/python/tvm/relay/collage/_ffi_api.py,sha256=2wltEokWMhQ5qEkyp5cpZ3lIOLPjMwzIO1fRgYjePho,893 +bitblas/3rdparty/tvm/python/tvm/relay/collage/collage.py,sha256=VnqXTUG3Nn9sPdK66YZDuzCjILYWpQ-4D8U6lbVdXiU,5831 +bitblas/3rdparty/tvm/python/tvm/relay/data_dep_optimization/__init__.py,sha256=8G3w3QPWe-mDNB-MXeBmeWWrozFZUj7dINb5LcAtic0,977 +bitblas/3rdparty/tvm/python/tvm/relay/data_dep_optimization/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/data_dep_optimization/__pycache__/__init__.cpython-310.pyc,sha256=NmYvL_Ghf2WBB5CLpUR05-wxmwYh5FDXdL4aJeA2lIY,353 +bitblas/3rdparty/tvm/python/tvm/relay/data_dep_optimization/__pycache__/__init__.cpython-38.pyc,sha256=4dNq8YOU-OnAMx6LihvogM3LfRhIFtNsZs54AqYYalw,340 +bitblas/3rdparty/tvm/python/tvm/relay/data_dep_optimization/__pycache__/bsr_conv2d.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/data_dep_optimization/__pycache__/bsr_conv2d.cpython-310.pyc,sha256=u-9E8s8CYiKbsEkb5a_YK1SYvbGDgmUjU8AykcdHsAo,2498 +bitblas/3rdparty/tvm/python/tvm/relay/data_dep_optimization/__pycache__/bsr_conv2d.cpython-38.pyc,sha256=lXrvZOVHr4sGttyyC-K01w3CVObKhyfmDB2EczWVF90,2493 +bitblas/3rdparty/tvm/python/tvm/relay/data_dep_optimization/__pycache__/bsr_dense.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/data_dep_optimization/__pycache__/bsr_dense.cpython-310.pyc,sha256=XdIgSqElteA4nfhjp2o0ca-shU1UheuirClRrHs1oF0,1361 +bitblas/3rdparty/tvm/python/tvm/relay/data_dep_optimization/__pycache__/bsr_dense.cpython-38.pyc,sha256=z_V_UPtiQb9MN-HibCk07VZI8EbJGO0of8Yk5JLzW0A,1350 +bitblas/3rdparty/tvm/python/tvm/relay/data_dep_optimization/__pycache__/simplify_fc_transpose.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/data_dep_optimization/__pycache__/simplify_fc_transpose.cpython-310.pyc,sha256=3Tuq9la9kmuHncsrkqMX93tWsiy-qtdFw8OdpLEU-gs,1327 +bitblas/3rdparty/tvm/python/tvm/relay/data_dep_optimization/__pycache__/simplify_fc_transpose.cpython-38.pyc,sha256=5Q5ai6Uz1vAK31MVGLItxqx1fj16qmdrMrSKJZtVWms,1314 +bitblas/3rdparty/tvm/python/tvm/relay/data_dep_optimization/__pycache__/utils.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/data_dep_optimization/__pycache__/utils.cpython-310.pyc,sha256=5Z-LWX7j4ZHyNUxMpejMjMKDPSH87SoQiZcAev8JTy4,735 +bitblas/3rdparty/tvm/python/tvm/relay/data_dep_optimization/__pycache__/utils.cpython-38.pyc,sha256=R0Ssc68KK5MlG23ITlgEuD-gcVKt59X1e9sKOI2c92o,738 +bitblas/3rdparty/tvm/python/tvm/relay/data_dep_optimization/bsr_conv2d.py,sha256=uS7YiiCwY1WWImlKfwKHqPHl4esyY5ScP6Iwucj5FOA,3234 +bitblas/3rdparty/tvm/python/tvm/relay/data_dep_optimization/bsr_dense.py,sha256=1eg1BWj0Q2d4s8IZamxSohPFLr8I77k6rJk62Y-Kj6k,1996 +bitblas/3rdparty/tvm/python/tvm/relay/data_dep_optimization/simplify_fc_transpose.py,sha256=2VzTNJ4tyfpUG2d9v44OI9KBivj0HSSXQTvwm_78u-Q,1980 +bitblas/3rdparty/tvm/python/tvm/relay/data_dep_optimization/utils.py,sha256=By9WomOpdmqELoiMJYV7Yng2ScTk01lM9PR3vvHsghY,1334 +bitblas/3rdparty/tvm/python/tvm/relay/dataflow_pattern/__init__.py,sha256=bj1iKW70IQAeSUBZ1pkNtaKsO0WG1XcV_OePlrqmKEw,26007 +bitblas/3rdparty/tvm/python/tvm/relay/dataflow_pattern/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/dataflow_pattern/__pycache__/__init__.cpython-310.pyc,sha256=Dnevjf2N-PzV7DfleaMv581_NuwwVJO7IEIjnSDVO2s,29191 +bitblas/3rdparty/tvm/python/tvm/relay/dataflow_pattern/__pycache__/__init__.cpython-38.pyc,sha256=CMhzNyO7pA6qdVLiOusfkqY-_Zcw1tgAXEWr-KagMJg,29692 +bitblas/3rdparty/tvm/python/tvm/relay/dataflow_pattern/__pycache__/_ffi.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/dataflow_pattern/__pycache__/_ffi.cpython-310.pyc,sha256=C7cDiRmI-Rt19AoksDHnhLTKpCLh2ZGZrimkmQUr498,320 +bitblas/3rdparty/tvm/python/tvm/relay/dataflow_pattern/__pycache__/_ffi.cpython-38.pyc,sha256=H7ITriLa2bdJ6zkO4mv2HuiKVzRtBTfkNEXTCKwiI-s,307 +bitblas/3rdparty/tvm/python/tvm/relay/dataflow_pattern/_ffi.py,sha256=JKfDuw4PFWZgYERdi_MQ838hBrd8g6UPkx_ZOvujI2M,903 +bitblas/3rdparty/tvm/python/tvm/relay/debug.py,sha256=A8XOvVy1a8E8e9IDPYDDOeJuO5YcuMP3mQqLTuLdqbo,1616 +bitblas/3rdparty/tvm/python/tvm/relay/expr.py,sha256=dlRnsuOvNJFgbBHaHPq9EXeejf5ZwlVkonTyun_a3ds,23020 +bitblas/3rdparty/tvm/python/tvm/relay/expr_functor.py,sha256=asG0ykX0UBeEKkdohDF1SO36la2ugHmiyQ0PRUyZlFo,8457 +bitblas/3rdparty/tvm/python/tvm/relay/frontend/__init__.py,sha256=IzcJOBUg4uNGzCvjvtiJlwmBLKReFi4Cwrcg9tijw2A,1400 +bitblas/3rdparty/tvm/python/tvm/relay/frontend/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/frontend/__pycache__/__init__.cpython-310.pyc,sha256=C7jk92RMGPoqBshhpjlaVQkmV6ENsxnds6atk45OTZw,933 +bitblas/3rdparty/tvm/python/tvm/relay/frontend/__pycache__/__init__.cpython-38.pyc,sha256=q2LeLWJoGMgXHamCi8GUNhg29Apadb-EmoLDen_4Udg,920 +bitblas/3rdparty/tvm/python/tvm/relay/frontend/__pycache__/caffe.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/frontend/__pycache__/caffe.cpython-310.pyc,sha256=U4-AetvkBH3rP0koGGU4_UDTI3iFDmAmhqAfshHrEas,24483 +bitblas/3rdparty/tvm/python/tvm/relay/frontend/__pycache__/caffe.cpython-38.pyc,sha256=EVFwz35h1lMsHIsy2b0HXS8T5QEX1lHeJg2t2MDMFPw,24488 +bitblas/3rdparty/tvm/python/tvm/relay/frontend/__pycache__/caffe2.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/frontend/__pycache__/caffe2.cpython-310.pyc,sha256=6iS81_q_HGMMUqhDEOGQO8Jva6EMsqm-Cx1b3E98OrI,16533 +bitblas/3rdparty/tvm/python/tvm/relay/frontend/__pycache__/caffe2.cpython-38.pyc,sha256=t-CYzj_nQ0itzy0qHrws8odg4yU2FBOz6BNE9DhZ5uQ,16945 +bitblas/3rdparty/tvm/python/tvm/relay/frontend/__pycache__/change_datatype.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/frontend/__pycache__/change_datatype.cpython-310.pyc,sha256=uuO6fuHXL8ol6E29EauYp1dewo-SW48KuanMFwdzepk,2753 +bitblas/3rdparty/tvm/python/tvm/relay/frontend/__pycache__/change_datatype.cpython-38.pyc,sha256=NxhytCfn6In5mgiLC73qBIytDHCEe1sKcqIJnOZBPZ4,2738 +bitblas/3rdparty/tvm/python/tvm/relay/frontend/__pycache__/common.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/frontend/__pycache__/common.cpython-310.pyc,sha256=eeC4GQBWo-3nPpbiDQ3dZJJuZPmJBsTu-1e6clMSMUM,35023 +bitblas/3rdparty/tvm/python/tvm/relay/frontend/__pycache__/common.cpython-38.pyc,sha256=vQt7B18MneY4RWlii6SEQobH1D5h_0pOFXyZKn2JfQs,35432 +bitblas/3rdparty/tvm/python/tvm/relay/frontend/__pycache__/coreml.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/frontend/__pycache__/coreml.cpython-310.pyc,sha256=SJHHZDZLehe02xp-rYVbpYAB78df6u2AftinsyyZnNc,16904 +bitblas/3rdparty/tvm/python/tvm/relay/frontend/__pycache__/coreml.cpython-38.pyc,sha256=FCc6EbtIqWkzMhOP0QE-z6K0sTd0cg_m4FE1bX-KeYI,16964 +bitblas/3rdparty/tvm/python/tvm/relay/frontend/__pycache__/darknet.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/frontend/__pycache__/darknet.cpython-310.pyc,sha256=K3dkJmlcuGuputceShP5JJ9is8X1T6HFXtkY5QpTUwM,22556 +bitblas/3rdparty/tvm/python/tvm/relay/frontend/__pycache__/darknet.cpython-38.pyc,sha256=PwxF7u8mHn7kn9JYnHLx44knvw1RvnXGPGARwa-5Tr8,22444 +bitblas/3rdparty/tvm/python/tvm/relay/frontend/__pycache__/keras.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/frontend/__pycache__/keras.cpython-310.pyc,sha256=kLRVt0OH2zemcNkWT6wV3YsIrwuflKQfSveEqrJ58CE,35194 +bitblas/3rdparty/tvm/python/tvm/relay/frontend/__pycache__/keras.cpython-38.pyc,sha256=tFd-fxllwecPYqka1yHt9tMZ8aV0EWBOAghGgmBICJM,35077 +bitblas/3rdparty/tvm/python/tvm/relay/frontend/__pycache__/mxnet.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/frontend/__pycache__/mxnet.cpython-310.pyc,sha256=gK4eP3ugfBad16C6v7F3klrEn31398wGz14yJAD1Xk8,79127 +bitblas/3rdparty/tvm/python/tvm/relay/frontend/__pycache__/mxnet.cpython-38.pyc,sha256=MCpHQOBWYDSRwCgdH6i6pJy0QrKwXwDmOzH6qiy8atM,78905 +bitblas/3rdparty/tvm/python/tvm/relay/frontend/__pycache__/mxnet_qnn_op_utils.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/frontend/__pycache__/mxnet_qnn_op_utils.cpython-310.pyc,sha256=SHtMtwYnJQU40F_o9vJMf-Zz0kOALR2wTTsIHcGL8SY,14141 +bitblas/3rdparty/tvm/python/tvm/relay/frontend/__pycache__/mxnet_qnn_op_utils.cpython-38.pyc,sha256=kRBUOXM7rmQOffVK_TD0MkZVAAImvPCkHzjc4oqnQ-k,14245 +bitblas/3rdparty/tvm/python/tvm/relay/frontend/__pycache__/nnvm_common.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/frontend/__pycache__/nnvm_common.cpython-310.pyc,sha256=X00Kp8qFmKB82a63PSm-N5TMigIGNQAvcpIbM_EKzyE,5628 +bitblas/3rdparty/tvm/python/tvm/relay/frontend/__pycache__/nnvm_common.cpython-38.pyc,sha256=gLenA8AEQXkJsy0UfDaqVmyx2-QXg-xnIZ3u68hnZTg,5754 +bitblas/3rdparty/tvm/python/tvm/relay/frontend/__pycache__/oneflow.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/frontend/__pycache__/oneflow.cpython-310.pyc,sha256=dYf7rFTcr2rMsXbUYyY0NokwCJrblV1leTdPxLOwCfc,51743 +bitblas/3rdparty/tvm/python/tvm/relay/frontend/__pycache__/oneflow.cpython-38.pyc,sha256=S92t1_7aQJYZyzbdR9URwOyaGFPl2z4Q4OacIEsGJfM,54168 +bitblas/3rdparty/tvm/python/tvm/relay/frontend/__pycache__/onnx.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/frontend/__pycache__/onnx.cpython-310.pyc,sha256=8Iw57d0NQjiE5gtyKC6mm0-K1NKhCXq1GuWtBmn0DQc,180547 +bitblas/3rdparty/tvm/python/tvm/relay/frontend/__pycache__/onnx.cpython-38.pyc,sha256=O9ukS4teeg3bNE7kDr-a_CO8qO4icoenSQk-TrIqX40,186666 +bitblas/3rdparty/tvm/python/tvm/relay/frontend/__pycache__/paddlepaddle.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/frontend/__pycache__/paddlepaddle.cpython-310.pyc,sha256=9ToVU71gwnsVSmCxAgC-T0yWG0l9k8y58EPZoViN29I,77353 +bitblas/3rdparty/tvm/python/tvm/relay/frontend/__pycache__/paddlepaddle.cpython-38.pyc,sha256=BOyqKO1OSNiHPU9OiE7eiKTU1Ia3VMXtXUolvhsb0qo,76193 +bitblas/3rdparty/tvm/python/tvm/relay/frontend/__pycache__/pytorch.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/frontend/__pycache__/pytorch.cpython-310.pyc,sha256=H3JOhh65Fj-KkmHw7N0aASfH_a1plptxGKFLN7Q0NPI,145908 +bitblas/3rdparty/tvm/python/tvm/relay/frontend/__pycache__/pytorch.cpython-38.pyc,sha256=dnDcIu_gvUgYx7o7dDS08CdanqOY1a6H-6G2qA3rpIY,145242 +bitblas/3rdparty/tvm/python/tvm/relay/frontend/__pycache__/pytorch_utils.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/frontend/__pycache__/pytorch_utils.cpython-310.pyc,sha256=TtBCRDmsUYR2-EOA1sL8CxTXY_obLRaKv2F2NmllT9c,11878 +bitblas/3rdparty/tvm/python/tvm/relay/frontend/__pycache__/pytorch_utils.cpython-38.pyc,sha256=nZW1H8GXvsi-mn3GkINfWrj8YAzNlW7jNJkL_nAsFPk,12098 +bitblas/3rdparty/tvm/python/tvm/relay/frontend/__pycache__/qnn_torch.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/frontend/__pycache__/qnn_torch.cpython-310.pyc,sha256=C7kvinmW2Oeb8rz1iijDfkEDbuQbCccAvgT7qt1eq10,27782 +bitblas/3rdparty/tvm/python/tvm/relay/frontend/__pycache__/qnn_torch.cpython-38.pyc,sha256=g_HlkrnDOisSuNurjNsRhqUkQJwT215uBq_ekS-QWZQ,27849 +bitblas/3rdparty/tvm/python/tvm/relay/frontend/__pycache__/tensorflow.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/frontend/__pycache__/tensorflow.cpython-310.pyc,sha256=h9uTbyA6s42zBY57mspdpkEQs-pyLQeG_q8RiQ16zAE,32408 +bitblas/3rdparty/tvm/python/tvm/relay/frontend/__pycache__/tensorflow.cpython-38.pyc,sha256=2FeCQTUg7vGw8jiK7ny1dzpp_Jouw2PqhZGd8O_LALo,32540 +bitblas/3rdparty/tvm/python/tvm/relay/frontend/__pycache__/tensorflow2.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/frontend/__pycache__/tensorflow2_ops.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/frontend/__pycache__/tensorflow_ops.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/frontend/__pycache__/tensorflow_ops.cpython-310.pyc,sha256=RhFMc5d-eSEM8J2ITqMZZYh8Z6BORG1Vfk6XYfWtPX8,80290 +bitblas/3rdparty/tvm/python/tvm/relay/frontend/__pycache__/tensorflow_ops.cpython-38.pyc,sha256=a6HAdbuaISJYiV0uXFnM4K_r6jjKFAKn8yZ-Cu-t9ek,81318 +bitblas/3rdparty/tvm/python/tvm/relay/frontend/__pycache__/tensorflow_parser.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/frontend/__pycache__/tflite.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/frontend/__pycache__/tflite.cpython-310.pyc,sha256=5oVo7upnQ0CcJBf_-jfKyo0qvmMdgfJGvAW6oogtVHE,101213 +bitblas/3rdparty/tvm/python/tvm/relay/frontend/__pycache__/tflite.cpython-38.pyc,sha256=OGZDxwmrc7vufk5rhhwGqbkyMcelBU8dsG05Wkl2chM,102768 +bitblas/3rdparty/tvm/python/tvm/relay/frontend/__pycache__/tflite_flexbuffer.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/frontend/__pycache__/tflite_flexbuffer.cpython-310.pyc,sha256=Hiu2QgRZkb1lWfkaxDRSUAcVgoZ07KcaG3zI2N29zbI,4476 +bitblas/3rdparty/tvm/python/tvm/relay/frontend/__pycache__/tflite_flexbuffer.cpython-38.pyc,sha256=sO35S837dtyhBT3wkQDefXY7WmUHY_wsJ1WB99XKO8U,4483 +bitblas/3rdparty/tvm/python/tvm/relay/frontend/caffe.py,sha256=8_9b89pl-Rrs2hw8nr6gZzYWWr33LXu7CpF4_ff7KBY,37920 +bitblas/3rdparty/tvm/python/tvm/relay/frontend/caffe2.py,sha256=czMPH7GpLw3b4jOA-QLBxUlGCGj8NG8g2ICAiI0rpaY,19850 +bitblas/3rdparty/tvm/python/tvm/relay/frontend/change_datatype.py,sha256=5EtD8dUYaH4strE4qlCQqKJS7Edm7oYKLmMk8OLciFY,3473 +bitblas/3rdparty/tvm/python/tvm/relay/frontend/common.py,sha256=1VmjSTEGeHxeAQzpd6xJPUBSbPTf2h-kAQRtnl6S5R0,40194 +bitblas/3rdparty/tvm/python/tvm/relay/frontend/coreml.py,sha256=wnK2o9CI8WfP_6d1dLfmaAOBpDQv1gAL1KZvkpX5eD0,22188 +bitblas/3rdparty/tvm/python/tvm/relay/frontend/darknet.py,sha256=PSZ97or9ZfeoANMh-j3Htozv-NB_9accOuO0dNcdG20,31385 +bitblas/3rdparty/tvm/python/tvm/relay/frontend/keras.py,sha256=JTmuyRYVgU2XnmsTURnC45KEKfArnKFAges0ng4k3VY,61080 +bitblas/3rdparty/tvm/python/tvm/relay/frontend/mxnet.py,sha256=QXfbBFzz3wfwzZ9puPpuukDhn92Y-6z4i24G1ThaDYg,112462 +bitblas/3rdparty/tvm/python/tvm/relay/frontend/mxnet_qnn_op_utils.py,sha256=_fesWmtxdKB8asvkVj5fQAgDmF-xR9TvdOyYh-DUjSg,16337 +bitblas/3rdparty/tvm/python/tvm/relay/frontend/nnvm_common.py,sha256=Gyds2UGmIo40w-E6EVtHrK4KXzcb15mt07fvMlr87nc,6744 +bitblas/3rdparty/tvm/python/tvm/relay/frontend/oneflow.py,sha256=xzXA_-sUNLPr7OzxP1trst5ho_-QRR-8w8JDaKqhPeE,65053 +bitblas/3rdparty/tvm/python/tvm/relay/frontend/onnx.py,sha256=s242cyGLA7WiB2tw3k5yMNMdfI1C5hI8si7ciyu50ew,270204 +bitblas/3rdparty/tvm/python/tvm/relay/frontend/paddlepaddle.py,sha256=JQIMaKHVLpadH6Oa2UksLNEYHs2br2UShq81miAt31Q,105196 +bitblas/3rdparty/tvm/python/tvm/relay/frontend/pytorch.py,sha256=ohD4zEtgZi7iz3KwFjSSmDSsX3KQXmsZ02ixY_gCoQ8,210700 +bitblas/3rdparty/tvm/python/tvm/relay/frontend/pytorch_utils.py,sha256=_KI5psyQPL7vYmFeDv-QOR98VEgVij1R_hy2LswILWM,15098 +bitblas/3rdparty/tvm/python/tvm/relay/frontend/qnn_torch.py,sha256=-j7I4-_UvdO58uHiTBJKV-Dj_1o5W3AQy288ITsI6DM,42448 +bitblas/3rdparty/tvm/python/tvm/relay/frontend/tensorflow.py,sha256=aZpNx0hyZJtjyugDTiomvqfFgxEcuXmH3PCen_mxFI4,48452 +bitblas/3rdparty/tvm/python/tvm/relay/frontend/tensorflow2.py,sha256=EQ8nt3hvr74ZKa9l6HMrQi__3r6_TfBCZNP2F8qhe1M,31603 +bitblas/3rdparty/tvm/python/tvm/relay/frontend/tensorflow2_ops.py,sha256=YJuZ-Ap4uvt2fRaXh3dLbuP8Yzcexf5zEOG9mX0iahI,7711 +bitblas/3rdparty/tvm/python/tvm/relay/frontend/tensorflow_ops.py,sha256=MLT_aXPCkWwvp6pHUSrZBK4TLzYquBWPYN1YSr9v89c,117378 +bitblas/3rdparty/tvm/python/tvm/relay/frontend/tensorflow_parser.py,sha256=lwVUhkoNBI412nG6Eo7PaEx7SZQ3shtAzjSH-CGH0jg,7324 +bitblas/3rdparty/tvm/python/tvm/relay/frontend/tflite.py,sha256=r8rnb60j-97RJWQArAAJA6OyyYF99T5u1rkwB-IMUus,177491 +bitblas/3rdparty/tvm/python/tvm/relay/frontend/tflite_flexbuffer.py,sha256=lNQBlevIHgqpB-L_TAY10GulDVbbaY2aoKKLpjUdbM8,6304 +bitblas/3rdparty/tvm/python/tvm/relay/function.py,sha256=nuYy8jBvXNxSYxIiKvHGklwB4NBr8zmiHmoiBGwzMgY,3718 +bitblas/3rdparty/tvm/python/tvm/relay/loops.py,sha256=DBvumjIuvSX-fowxyvvrQwhxvhuhkD3ywuQIwc_2Mt4,2218 +bitblas/3rdparty/tvm/python/tvm/relay/op/__init__.py,sha256=4ESSHnVEkFsmXSG0VkHvhq4ZL9vFtodUmxwarRqjN9Q,1869 +bitblas/3rdparty/tvm/python/tvm/relay/op/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/__pycache__/__init__.cpython-310.pyc,sha256=3ytAvDZyEIiVZNzSqUHbMhUDNN8HDy7QPppj_VFXLUg,1364 +bitblas/3rdparty/tvm/python/tvm/relay/op/__pycache__/__init__.cpython-38.pyc,sha256=k3OUlXlhu3qjsdfVdN2ri9mj6Dm7wriT0FkUEdGDn74,1351 +bitblas/3rdparty/tvm/python/tvm/relay/op/__pycache__/_algorithm.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/__pycache__/_algorithm.cpython-310.pyc,sha256=6TrGcMwTEuBu3lGjuIW-8rbn1DmuSOpqeECrfCATlmw,2402 +bitblas/3rdparty/tvm/python/tvm/relay/op/__pycache__/_algorithm.cpython-38.pyc,sha256=ZGb-NMCoWz7dyGOqLH41ciI123aZKurpWAzHNybzPPI,2401 +bitblas/3rdparty/tvm/python/tvm/relay/op/__pycache__/_make.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/__pycache__/_make.cpython-310.pyc,sha256=6bWr3bSCN4h-T6r0yFXoqzHesVtk8Zw8rcDCKcAbikg,276 +bitblas/3rdparty/tvm/python/tvm/relay/op/__pycache__/_make.cpython-38.pyc,sha256=2ReOlvUoJWzD9QIiV7GEisIAY5bTBmHbfzeeTpSuSBY,263 +bitblas/3rdparty/tvm/python/tvm/relay/op/__pycache__/_math.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/__pycache__/_math.cpython-310.pyc,sha256=i-OXyYOoTBbzrM05thyb2ahg8j82Cn-5qpaLUQ825uU,345 +bitblas/3rdparty/tvm/python/tvm/relay/op/__pycache__/_math.cpython-38.pyc,sha256=CNp1JWYK4U3oTug9EySd_53UAabufuXzZGRyTcOVHHY,332 +bitblas/3rdparty/tvm/python/tvm/relay/op/__pycache__/_reduce.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/__pycache__/_reduce.cpython-310.pyc,sha256=6AQK1h3iwNyfwAMemQ87YXpoG2cLruEj63L9JDPuTcI,1946 +bitblas/3rdparty/tvm/python/tvm/relay/op/__pycache__/_reduce.cpython-38.pyc,sha256=7T6ecPOC1LJUDHGyRMDUAsA9gLLdT3sCvDYztu-Vsy0,1927 +bitblas/3rdparty/tvm/python/tvm/relay/op/__pycache__/_tensor.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/__pycache__/_tensor.cpython-310.pyc,sha256=Z5tWkRYjZEG1AlDLpnAzGzkmgkfyyZJSo1SGizynDWk,6549 +bitblas/3rdparty/tvm/python/tvm/relay/op/__pycache__/_tensor.cpython-38.pyc,sha256=jNA1jyvCOq40KInBepECnnFgBpZG8HKkhhv9XS0Atos,6675 +bitblas/3rdparty/tvm/python/tvm/relay/op/__pycache__/_tensor_grad.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/__pycache__/_tensor_grad.cpython-310.pyc,sha256=4BxxCCRfH5odXbwNr5IomQXiNgKwXyrDJp_TRUYSCaQ,24415 +bitblas/3rdparty/tvm/python/tvm/relay/op/__pycache__/_tensor_grad.cpython-38.pyc,sha256=LZWwdVzdD-oxHvcltqz1S36gkI52asteMHFAcOjT9Fg,24887 +bitblas/3rdparty/tvm/python/tvm/relay/op/__pycache__/_transform.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/__pycache__/_transform.cpython-310.pyc,sha256=ra8NIeDESO1TJpOm1VcFgWBl-X9jFhAsA_0mJIVO7i8,28092 +bitblas/3rdparty/tvm/python/tvm/relay/op/__pycache__/_transform.cpython-38.pyc,sha256=6STLuUNVM4tyEWzB1X7vmKs3wj792Bn1JYHx4dh2E9Y,28217 +bitblas/3rdparty/tvm/python/tvm/relay/op/__pycache__/algorithm.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/__pycache__/algorithm.cpython-310.pyc,sha256=Ue749nEf-9G8UhZvV0XUbm0ng2VCj-HmaEbrJeXAYLA,4491 +bitblas/3rdparty/tvm/python/tvm/relay/op/__pycache__/algorithm.cpython-38.pyc,sha256=D5sIPKzfmk_4vh9GNiMaK0GBcwKedZaRa1KgM7K33Xk,4494 +bitblas/3rdparty/tvm/python/tvm/relay/op/__pycache__/op.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/__pycache__/op.cpython-310.pyc,sha256=qjCA-xFfzo3gKSNlbE-lncVCAX4Igb75BlFjrU1GEyU,15935 +bitblas/3rdparty/tvm/python/tvm/relay/op/__pycache__/op.cpython-38.pyc,sha256=893j-NRJYQPoG3R5vBh57v0U8fhv0xOuWAI-Q0Ssp2Y,16292 +bitblas/3rdparty/tvm/python/tvm/relay/op/__pycache__/op_attrs.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/__pycache__/op_attrs.cpython-310.pyc,sha256=6Bqq__6t25KOZtJTRInVIdjOw27vm2ZpIsnqa1Cdlus,26738 +bitblas/3rdparty/tvm/python/tvm/relay/op/__pycache__/op_attrs.cpython-38.pyc,sha256=xrCTOAa-lsgx3X4y7lwvBkPG3QvzucGUO9H5Pb1N25g,29045 +bitblas/3rdparty/tvm/python/tvm/relay/op/__pycache__/reduce.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/__pycache__/reduce.cpython-310.pyc,sha256=Aacsr7wSNdy0ew7k42jt0PWiiu8lAxmN8qUSFiL5THo,16951 +bitblas/3rdparty/tvm/python/tvm/relay/op/__pycache__/reduce.cpython-38.pyc,sha256=M4bbPpx3polB_sCEReKOt5QNPh1Ucd3KU5mF3qPwe74,17265 +bitblas/3rdparty/tvm/python/tvm/relay/op/__pycache__/tensor.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/__pycache__/tensor.cpython-310.pyc,sha256=TxKHwwkKo8K4WKfZnYHIfe_NO2BrDgrlHFZZpS3kyII,27705 +bitblas/3rdparty/tvm/python/tvm/relay/op/__pycache__/tensor.cpython-38.pyc,sha256=zTl8zR4fPWVlToihl9cKA7aKvRLKf7U__dYsdm0iFe8,28615 +bitblas/3rdparty/tvm/python/tvm/relay/op/__pycache__/transform.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/__pycache__/transform.cpython-310.pyc,sha256=K7qshOk0dtwrHP08i04GyP4Swi-9ZLhbIZAeTCRUxMU,59986 +bitblas/3rdparty/tvm/python/tvm/relay/op/__pycache__/transform.cpython-38.pyc,sha256=Jo4105g1QmQaCgjH2cZrGBLVQI4kbB3iJbU6fUfg-y8,60337 +bitblas/3rdparty/tvm/python/tvm/relay/op/_algorithm.py,sha256=aW5PIvzCTMRF6111KWZN5L01TrLXfNR7-eChAW0VR5A,3763 +bitblas/3rdparty/tvm/python/tvm/relay/op/_make.py,sha256=v1edrbBEYdKHjuTpJ1lZk3o21qfhmHDYcKkSHE5BYbI,872 +bitblas/3rdparty/tvm/python/tvm/relay/op/_math.py,sha256=OgKNOo2P7OA0EAXzEg0vVRba-3UFJ4UUwSDuyqU6ayA,954 +bitblas/3rdparty/tvm/python/tvm/relay/op/_reduce.py,sha256=1G3J5gRvhD4wjeHajGpCY-yW7oeCiYVlQvHHoqD45x4,3362 +bitblas/3rdparty/tvm/python/tvm/relay/op/_tensor.py,sha256=qZneDO9qcsYwlSrSOHRiwWZ0bALmC6T8oNsstA5kx9Q,11405 +bitblas/3rdparty/tvm/python/tvm/relay/op/_tensor_grad.py,sha256=ayoQ0e466bun_JO96KSNoUlJ-4JB49TQryUJGXOKRy8,29368 +bitblas/3rdparty/tvm/python/tvm/relay/op/_transform.py,sha256=bZm2etQlcPMNTslCOAbuhMvICUZWiObjnavJabRENRI,40977 +bitblas/3rdparty/tvm/python/tvm/relay/op/algorithm.py,sha256=jlNTgzvsxbPtRtkcwd7QMw99rPshZCxCRCHIfOprbBc,5009 +bitblas/3rdparty/tvm/python/tvm/relay/op/annotation/__init__.py,sha256=19EuVrtDaWaINXJ_HiEZAX6lD2Iut3l9vl-yCG7Nx_A,928 +bitblas/3rdparty/tvm/python/tvm/relay/op/annotation/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/annotation/__pycache__/__init__.cpython-310.pyc,sha256=WYT5217FkwL6qoMfgY1CI_5OMYJS821mPltYykQm8Wo,307 +bitblas/3rdparty/tvm/python/tvm/relay/op/annotation/__pycache__/__init__.cpython-38.pyc,sha256=FEjBXgR9gZRT6h5exvyPkAEPOhqCBZFK8YDHsUz0oac,294 +bitblas/3rdparty/tvm/python/tvm/relay/op/annotation/__pycache__/_make.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/annotation/__pycache__/_make.cpython-310.pyc,sha256=x-thBMhJXfQ1YqC4L138KXOnrDQ363coZZWZxY2MnaQ,298 +bitblas/3rdparty/tvm/python/tvm/relay/op/annotation/__pycache__/_make.cpython-38.pyc,sha256=AT4qUCHh7vjKXjyqsUWUSH_aW0L3L-3ByvMCUpHvJWI,285 +bitblas/3rdparty/tvm/python/tvm/relay/op/annotation/__pycache__/annotation.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/annotation/__pycache__/annotation.cpython-310.pyc,sha256=KCzzUDepLsEBaQfniyfxwR94fY8rfjv-Mvt2A30RrKY,4593 +bitblas/3rdparty/tvm/python/tvm/relay/op/annotation/__pycache__/annotation.cpython-38.pyc,sha256=cXqC0-nOujIBjK4ECYkHUmLQxFoGzk2cBtFuxQ8ZrLc,4612 +bitblas/3rdparty/tvm/python/tvm/relay/op/annotation/_make.py,sha256=JquIrUezHhd-dlw5IgR1adw7ZrN_nni0CuiL4DWYcFw,883 +bitblas/3rdparty/tvm/python/tvm/relay/op/annotation/annotation.py,sha256=rekF7k8ce0jyG6T0ghvaT9GEzfDmVSjT0aizW8HWbI4,4899 +bitblas/3rdparty/tvm/python/tvm/relay/op/contrib/__init__.py,sha256=g4QRVVQ9v7rjOPbmNWlWRd01dZWRPLbiqh_Vn8QkIfQ,1133 +bitblas/3rdparty/tvm/python/tvm/relay/op/contrib/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/contrib/__pycache__/__init__.cpython-310.pyc,sha256=CjCf3sFBqZls3qNIICeSbiSKGGwNxIkCC777-CsjF90,477 +bitblas/3rdparty/tvm/python/tvm/relay/op/contrib/__pycache__/__init__.cpython-38.pyc,sha256=RJ3rv7aOQlcU1c_a63c1-gYXZOBlAdnBdzSzQ_Hn-ck,464 +bitblas/3rdparty/tvm/python/tvm/relay/op/contrib/__pycache__/_ethosn.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/contrib/__pycache__/_ethosn.cpython-310.pyc,sha256=5hABAic2TIScaYMtiFKQQ1wgGXwA2LeYuzAVJmzL7SM,366 +bitblas/3rdparty/tvm/python/tvm/relay/op/contrib/__pycache__/_ethosn.cpython-38.pyc,sha256=kJzAz_RmupITYTKHTDvslkwkRcDQmE5I3iD4WQiI9ss,353 +bitblas/3rdparty/tvm/python/tvm/relay/op/contrib/__pycache__/arm_compute_lib.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/contrib/__pycache__/arm_compute_lib.cpython-310.pyc,sha256=DhvvgzIwVUxHalblaOc3YLuzqwYRSpHeCQTo1PL5s4w,16501 +bitblas/3rdparty/tvm/python/tvm/relay/op/contrib/__pycache__/arm_compute_lib.cpython-38.pyc,sha256=zI-GxQ3TPutjXpPR5rZQlmj_Tu53W12iC-fM_QHzjEo,16655 +bitblas/3rdparty/tvm/python/tvm/relay/op/contrib/__pycache__/bnns.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/contrib/__pycache__/bnns.cpython-310.pyc,sha256=x6KcWVSjxmdjpy6nhGxHiZP-C5SFdWEOTP49UQq3q-c,7713 +bitblas/3rdparty/tvm/python/tvm/relay/op/contrib/__pycache__/bnns.cpython-38.pyc,sha256=BZGsX16Jhove7UnapnkKWFavRE7iiFIZ6AlMfgUO2ZU,7966 +bitblas/3rdparty/tvm/python/tvm/relay/op/contrib/__pycache__/clml.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/contrib/__pycache__/clml.cpython-310.pyc,sha256=KFt7EHmtlIn1N14ODo39WcfaDS6nLm0F5L-a3wM0HJ8,36451 +bitblas/3rdparty/tvm/python/tvm/relay/op/contrib/__pycache__/clml.cpython-38.pyc,sha256=yRs_GKV0tdhsSmOtRcDv1hTBL9ktEInDwcBDoT6NPpQ,36958 +bitblas/3rdparty/tvm/python/tvm/relay/op/contrib/__pycache__/cmsisnn.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/contrib/__pycache__/cmsisnn.cpython-310.pyc,sha256=5TMcr8GVzyE6hSEqGTGpbxk1tfkBqnDTK051ZxxV3JQ,8986 +bitblas/3rdparty/tvm/python/tvm/relay/op/contrib/__pycache__/coreml.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/contrib/__pycache__/coreml.cpython-310.pyc,sha256=1nqe9pBAXyTiMHG9_bc9E7eQg5GkbOQNtugCKVOWAAU,1052 +bitblas/3rdparty/tvm/python/tvm/relay/op/contrib/__pycache__/coreml.cpython-38.pyc,sha256=ZVNECnp6C1DiaIuQ3k3MKqwUAJPZIvX5NULkZzoijOU,1037 +bitblas/3rdparty/tvm/python/tvm/relay/op/contrib/__pycache__/cublas.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/contrib/__pycache__/cudnn.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/contrib/__pycache__/cutlass.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/contrib/__pycache__/cutlass.cpython-310.pyc,sha256=7SefrBd_tAdiI62zot8G7smLZh6APgpO9zIFdOjxc3o,7583 +bitblas/3rdparty/tvm/python/tvm/relay/op/contrib/__pycache__/cutlass.cpython-38.pyc,sha256=YUBev5Fxt4C1pvh4YJWi2V3lH4P7DIlnnmxWRqe2SSs,7632 +bitblas/3rdparty/tvm/python/tvm/relay/op/contrib/__pycache__/dnnl.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/contrib/__pycache__/dnnl.cpython-310.pyc,sha256=fJr4xhfl6huov4sji3kETviJnzOJSAe3Dol7XlyBOE8,38515 +bitblas/3rdparty/tvm/python/tvm/relay/op/contrib/__pycache__/dnnl.cpython-38.pyc,sha256=hvquisqIrZa0_C1bT71QSBOcwF1ioiy8ivHnpVtdXNc,39097 +bitblas/3rdparty/tvm/python/tvm/relay/op/contrib/__pycache__/ethosn.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/contrib/__pycache__/ethosn.cpython-310.pyc,sha256=Y1U4hL7UMyQHgWp85p8TVChUG5Oco5M4f0vii2rCkQs,13102 +bitblas/3rdparty/tvm/python/tvm/relay/op/contrib/__pycache__/ethosn.cpython-38.pyc,sha256=fI63S8iGfT_O2Ofub33eWuIgFhFLVbA1FuGMFn2SBWQ,13862 +bitblas/3rdparty/tvm/python/tvm/relay/op/contrib/__pycache__/ethosu.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/contrib/__pycache__/ethosu.cpython-310.pyc,sha256=Y6vVkjcGrzS0Ak6I-HZOQ9uEq86ZhC0ICXBT1CXeAlc,63241 +bitblas/3rdparty/tvm/python/tvm/relay/op/contrib/__pycache__/libtorch.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/contrib/__pycache__/libtorch.cpython-310.pyc,sha256=YUiGwwUEA7DW1-YOpWMuD0gmwSwBNz5DTrcQlnJowX0,908 +bitblas/3rdparty/tvm/python/tvm/relay/op/contrib/__pycache__/libtorch.cpython-38.pyc,sha256=BNi_lNoQP5Wjdy9bo-VO_KB_K4rqixwkQ4qeql3txyo,899 +bitblas/3rdparty/tvm/python/tvm/relay/op/contrib/__pycache__/mrvl.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/contrib/__pycache__/mrvl.cpython-310.pyc,sha256=CiepoY3EqOYEmA7kvtH_5oSYeHmo-3clXMrU6aS3ca0,24656 +bitblas/3rdparty/tvm/python/tvm/relay/op/contrib/__pycache__/mrvl.cpython-38.pyc,sha256=OvxsUXAZYfKfX7KAkm3Ha1lsWFScwGgVfwCGzlj-a8o,25495 +bitblas/3rdparty/tvm/python/tvm/relay/op/contrib/__pycache__/register.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/contrib/__pycache__/register.cpython-310.pyc,sha256=hzWa7jj4LWf6E_mZSyVqHHPb1J-nSswJnEDEHSzDbb8,1203 +bitblas/3rdparty/tvm/python/tvm/relay/op/contrib/__pycache__/register.cpython-38.pyc,sha256=8qqKVhr_kKqkfWyC91jurGmhfelS13Ka0fz-By9tAfI,1190 +bitblas/3rdparty/tvm/python/tvm/relay/op/contrib/__pycache__/te_target.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/contrib/__pycache__/tensorrt.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/contrib/__pycache__/tensorrt.cpython-310.pyc,sha256=_pH-0pL0IkzbMVfPRLi71S6g2zOm6hsreXv_hcYmJy4,33406 +bitblas/3rdparty/tvm/python/tvm/relay/op/contrib/__pycache__/tensorrt.cpython-38.pyc,sha256=oI61-uh-DOFiIfq8pO5c-Fo023NE2IeI-q5Fv1mmH_8,33475 +bitblas/3rdparty/tvm/python/tvm/relay/op/contrib/__pycache__/vitis_ai.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/contrib/__pycache__/vitis_ai.cpython-310.pyc,sha256=tmJ3kowWmpt33yNvppteqxvSDm_YUz6Bbi-ik3OmJmo,6228 +bitblas/3rdparty/tvm/python/tvm/relay/op/contrib/_ethosn.py,sha256=hBqR4qo9gHXb28Lf5DyA2a86CXWHKP-CP8uqqJ-v4-g,969 +bitblas/3rdparty/tvm/python/tvm/relay/op/contrib/arm_compute_lib.py,sha256=hQjGiV0UIYs1lt9HtRdGD0cGys3wTLxiFPrbytQaMMA,19162 +bitblas/3rdparty/tvm/python/tvm/relay/op/contrib/bnns.py,sha256=WhQkC8fRSloGoV9_7YAr90Hagbv0MuBVyJWDp_u41Zk,10485 +bitblas/3rdparty/tvm/python/tvm/relay/op/contrib/clml.py,sha256=ZZTWVgjVja2F-Yh0t9gJZKpdRlWk_d0j-tr9WD-tUZk,55020 +bitblas/3rdparty/tvm/python/tvm/relay/op/contrib/cmsisnn.py,sha256=K65t61xzk_HQUT6df31huzkXDD9_rtiEn_oKjDIq0Dk,14438 +bitblas/3rdparty/tvm/python/tvm/relay/op/contrib/coreml.py,sha256=CqkxKKqzTDhNa_zwnIFvWMwUouLY-UEH2eSKXN2fr8E,1633 +bitblas/3rdparty/tvm/python/tvm/relay/op/contrib/cublas.py,sha256=x4AaXWX15kUt-yxPmClnsXapVETPngPMogJMzVwo4fI,4822 +bitblas/3rdparty/tvm/python/tvm/relay/op/contrib/cudnn.py,sha256=T1RLYPhfyliEV06Nagju-YTfcGebLP7SQZdCsjf90Os,6461 +bitblas/3rdparty/tvm/python/tvm/relay/op/contrib/cutlass.py,sha256=3nbKkAcELVvigJI9Twx-HtdceibQOD0kOjbG3jaunyU,10781 +bitblas/3rdparty/tvm/python/tvm/relay/op/contrib/dnnl.py,sha256=QzWyc3oO8wGG1ekG5BpyKM5ORdAQXZDH5Dx2DGwwoCY,48261 +bitblas/3rdparty/tvm/python/tvm/relay/op/contrib/ethosn.py,sha256=btwnaVfq0_y7FDCylOXAwq_l8XCdU6bnWyKCktOqhyM,15281 +bitblas/3rdparty/tvm/python/tvm/relay/op/contrib/ethosu.py,sha256=eXJOZGoIb1WOnJ3aMc-zdw2owuDNweIMGk61YCeMV0s,86879 +bitblas/3rdparty/tvm/python/tvm/relay/op/contrib/libtorch.py,sha256=m4WuylIUXFIyuGz9baO578TAdglhXbVvGqMryBBCuUM,1427 +bitblas/3rdparty/tvm/python/tvm/relay/op/contrib/mrvl.py,sha256=ySTNkFntfQINLihmFbq53Iuzl2c_MlOPEo79hxdGLGQ,30332 +bitblas/3rdparty/tvm/python/tvm/relay/op/contrib/register.py,sha256=OSoRKGzkpZO3JHABtq3NN_djOIzI4BDE282EThjnNL4,1708 +bitblas/3rdparty/tvm/python/tvm/relay/op/contrib/te_target.py,sha256=gW2HDxu9rFCYhyLSmAg-8XBJystTPg6a5koo9sWdV7g,2648 +bitblas/3rdparty/tvm/python/tvm/relay/op/contrib/tensorrt.py,sha256=FoTU7f8KmWtNZKdV8hQCjGMsZUtn0UjDxcfKoBNAiQg,43978 +bitblas/3rdparty/tvm/python/tvm/relay/op/contrib/vitis_ai.py,sha256=RE04jJdPkQGnUyZhxlAWYJOhIiq3rtuxsrljf-cMUZk,7525 +bitblas/3rdparty/tvm/python/tvm/relay/op/dyn/__init__.py,sha256=sOhCfSG4eji4zFGt7W8rc0mIP1ll0Ime1LFPhfp0tBM,996 +bitblas/3rdparty/tvm/python/tvm/relay/op/dyn/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/dyn/__pycache__/__init__.cpython-310.pyc,sha256=PRdUDKo2gGqFtR-dEqwMDxMCdCtHvrYelsL3ub77Vsw,352 +bitblas/3rdparty/tvm/python/tvm/relay/op/dyn/__pycache__/__init__.cpython-38.pyc,sha256=1CEU6CqaQ5s7-Ql3PGE1V2ODRAwGE27K_176wicxpDM,339 +bitblas/3rdparty/tvm/python/tvm/relay/op/dyn/__pycache__/_algorithm.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/dyn/__pycache__/_algorithm.cpython-310.pyc,sha256=jdDaqar5kDbc5KJ9KCj_3S-zwtv6Ko0D-EbklEf8mRY,1424 +bitblas/3rdparty/tvm/python/tvm/relay/op/dyn/__pycache__/_algorithm.cpython-38.pyc,sha256=HVHTSb32Cy58ymlSuohdo3XC14JACFgWLxOlpv6y6-o,1403 +bitblas/3rdparty/tvm/python/tvm/relay/op/dyn/__pycache__/_make.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/dyn/__pycache__/_make.cpython-310.pyc,sha256=lz1NIbsXScaEyRRxYvUBTQLioumiHZ3gj-wu1D-qj0A,284 +bitblas/3rdparty/tvm/python/tvm/relay/op/dyn/__pycache__/_make.cpython-38.pyc,sha256=bhDkb8XVy4d1epNstip9wKV1Fec299Bm_-Lw99usM8w,271 +bitblas/3rdparty/tvm/python/tvm/relay/op/dyn/__pycache__/_tensor.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/dyn/__pycache__/_tensor.cpython-310.pyc,sha256=oa8qfulJnOuFcS4rYDicZE64AljPduA7VpqzJ1Y0iMk,1050 +bitblas/3rdparty/tvm/python/tvm/relay/op/dyn/__pycache__/_tensor.cpython-38.pyc,sha256=3T0x8Omz2ZRKxE4EECN2lsGlgUvJ5ZqqI9TYBY6dkeA,1093 +bitblas/3rdparty/tvm/python/tvm/relay/op/dyn/__pycache__/_transform.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/dyn/__pycache__/_transform.cpython-310.pyc,sha256=xWVzn_j9hDGpyOUQZhKUmc9yFsvbm773Di8IVfwa-TU,6055 +bitblas/3rdparty/tvm/python/tvm/relay/op/dyn/__pycache__/_transform.cpython-38.pyc,sha256=lzBaSm8QRYtT9E8cepTxLgIJsTAqV6yRHbBXmcEGYBY,6091 +bitblas/3rdparty/tvm/python/tvm/relay/op/dyn/_algorithm.py,sha256=ODig7OrnkbBAIkK9GW_dacAU0xJN1fUnd2oLD0GVrFs,2321 +bitblas/3rdparty/tvm/python/tvm/relay/op/dyn/_make.py,sha256=D6vt4vs66bhrFagDLQZlwFoLhjbmHtYOMNfRQ0UoVmY,876 +bitblas/3rdparty/tvm/python/tvm/relay/op/dyn/_tensor.py,sha256=CrSnz_JguSJzoZhmybASsdWRmT9s4kvKtynG39B-QSQ,1932 +bitblas/3rdparty/tvm/python/tvm/relay/op/dyn/_transform.py,sha256=_c81s849Xgwj2rnXT0wKPL60NMnxtkVN_kHnwmmUnVk,9378 +bitblas/3rdparty/tvm/python/tvm/relay/op/dyn/image/__init__.py,sha256=YkisNXwmHGoYQzBn0uloMPPrYhzZWQ1QNEyh02V7lA4,930 +bitblas/3rdparty/tvm/python/tvm/relay/op/dyn/image/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/dyn/image/__pycache__/__init__.cpython-310.pyc,sha256=nsqiklNTV53WdtBRnGo2rNMFvriQjpX8jyQyCZfDkRI,269 +bitblas/3rdparty/tvm/python/tvm/relay/op/dyn/image/__pycache__/__init__.cpython-38.pyc,sha256=Uwqhc3zA1GzVceqxJyZGzONtMwIHOV2tpkk1qjX1pBs,256 +bitblas/3rdparty/tvm/python/tvm/relay/op/dyn/image/__pycache__/_image.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/dyn/image/__pycache__/_image.cpython-310.pyc,sha256=Hhz-gidDk1dNeE1Iflhm1Jhz70AG3SKThlfuZN7uFqQ,1972 +bitblas/3rdparty/tvm/python/tvm/relay/op/dyn/image/__pycache__/_image.cpython-38.pyc,sha256=aQ0WOATuzPivTVTZ2Gj6vzacWOdphHR-FcMsl5Dj7Mo,1961 +bitblas/3rdparty/tvm/python/tvm/relay/op/dyn/image/__pycache__/_make.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/dyn/image/__pycache__/_make.cpython-310.pyc,sha256=k7dsBGpAMG72Ijpe67ngNc2mh54HXSbtLMxm0kvpKR0,296 +bitblas/3rdparty/tvm/python/tvm/relay/op/dyn/image/__pycache__/_make.cpython-38.pyc,sha256=IQGFy2SOto9Yzm3gHSNiT5hPDiVNRY5VYhZ6JdNJv30,283 +bitblas/3rdparty/tvm/python/tvm/relay/op/dyn/image/_image.py,sha256=Y9nn5aRcORx6qjF5tg8718-yLTHGqyEfMNQX6fpBaRc,3154 +bitblas/3rdparty/tvm/python/tvm/relay/op/dyn/image/_make.py,sha256=lne114S1lXfDviXJPeT1bs7mJDghPYPRC_9b9-sXIwM,882 +bitblas/3rdparty/tvm/python/tvm/relay/op/dyn/nn/__init__.py,sha256=2ZcLu4fVPbYayF1UxRx3oX97xw5mQ9SUs3ePugnkqHk,921 +bitblas/3rdparty/tvm/python/tvm/relay/op/dyn/nn/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/dyn/nn/__pycache__/__init__.cpython-310.pyc,sha256=u_kTABPGhkr_EGEHDB_iTFz67_NtUeC0SCTv2nFka-o,257 +bitblas/3rdparty/tvm/python/tvm/relay/op/dyn/nn/__pycache__/__init__.cpython-38.pyc,sha256=C5hDFLttsibza9TZN0XSNBbUBw3-UnjV0kfSqg8hYHU,244 +bitblas/3rdparty/tvm/python/tvm/relay/op/dyn/nn/__pycache__/_make.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/dyn/nn/__pycache__/_make.cpython-310.pyc,sha256=FmGDC9TW_-IXo0Qr85Zd2OMEfWaHeo_tJFBMs0rmKz4,290 +bitblas/3rdparty/tvm/python/tvm/relay/op/dyn/nn/__pycache__/_make.cpython-38.pyc,sha256=IkpCCM_2E-ez6Ixm6Lyy0hSAayWO3ZJzLWYbyQ2fB1U,277 +bitblas/3rdparty/tvm/python/tvm/relay/op/dyn/nn/__pycache__/_nn.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/dyn/nn/__pycache__/_nn.cpython-310.pyc,sha256=c-RlFZOuuXdD6fRldOmKFxEQafGu5eXbSzKiON0dpP4,3321 +bitblas/3rdparty/tvm/python/tvm/relay/op/dyn/nn/__pycache__/_nn.cpython-38.pyc,sha256=iDQfUpbCgiIe2fXcXoS1uZ22MgMIRz-FX7o39wURgWc,3312 +bitblas/3rdparty/tvm/python/tvm/relay/op/dyn/nn/_make.py,sha256=ntTc_41z__y-L3FU9Sige-mTCR1OJbxH_9U6krkLbX0,879 +bitblas/3rdparty/tvm/python/tvm/relay/op/dyn/nn/_nn.py,sha256=kFJEtYnmngZLvMRuq0waKcX_RUYOoEnNYByk89_HuZM,4904 +bitblas/3rdparty/tvm/python/tvm/relay/op/image/__init__.py,sha256=pMeAeC_BjRd67fEu2s589w2j6Z4d6Hi3xedheEcdK5w,900 +bitblas/3rdparty/tvm/python/tvm/relay/op/image/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/image/__pycache__/__init__.cpython-310.pyc,sha256=5cd88GoBEAROnphTIDM5BAYfNQLREUDwGToPkMsdH90,270 +bitblas/3rdparty/tvm/python/tvm/relay/op/image/__pycache__/__init__.cpython-38.pyc,sha256=DFiZ_3wIKWcKvIh_LiKWwCOP--cClTwlDfBvKrjY4SE,257 +bitblas/3rdparty/tvm/python/tvm/relay/op/image/__pycache__/_image.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/image/__pycache__/_image.cpython-310.pyc,sha256=DKIofX8cuCCr2pPIWuV2IA5eLWya6Ib8N0VtLphgN7A,7817 +bitblas/3rdparty/tvm/python/tvm/relay/op/image/__pycache__/_image.cpython-38.pyc,sha256=OGcOpIbf0rjHUOOn3NN2f4R_0qVsPxfAeUjBqUEnox8,8181 +bitblas/3rdparty/tvm/python/tvm/relay/op/image/__pycache__/_make.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/image/__pycache__/_make.cpython-310.pyc,sha256=SxcTViyxSH_F4VHpZf7471BVuE9jbxao_CUKlcYlX3Y,288 +bitblas/3rdparty/tvm/python/tvm/relay/op/image/__pycache__/_make.cpython-38.pyc,sha256=mBYBegTc7eXaFrwPSQYRKs_6i8cANFh0VG8rOfxerhY,275 +bitblas/3rdparty/tvm/python/tvm/relay/op/image/__pycache__/image.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/image/__pycache__/image.cpython-310.pyc,sha256=E_OjSLkq94vLhHP-PTGonuLbK45cfkcN_OuJBbST0P4,14440 +bitblas/3rdparty/tvm/python/tvm/relay/op/image/__pycache__/image.cpython-38.pyc,sha256=v60D97kJwZURs_9FEUrvAak1rMCjOKLdNNheQGyfQJQ,14611 +bitblas/3rdparty/tvm/python/tvm/relay/op/image/_image.py,sha256=XC-F7OJwYAypUGAjYWSX8iIJNtG2qqjWaqdOHclfd0w,11581 +bitblas/3rdparty/tvm/python/tvm/relay/op/image/_make.py,sha256=XQNaQ5lOmhkMFqwwn9WknsqHiV_binVaO7iqu3yNaEo,878 +bitblas/3rdparty/tvm/python/tvm/relay/op/image/image.py,sha256=wjXkqtIUa8xah_JBchqFOeQw_s3kEqIx9twioX2G598,16683 +bitblas/3rdparty/tvm/python/tvm/relay/op/memory/__init__.py,sha256=YvbmPG8PlLdClPQiLtYgbBde3Ts6P-g5cSfx4B_fkAE,939 +bitblas/3rdparty/tvm/python/tvm/relay/op/memory/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/memory/__pycache__/__init__.cpython-310.pyc,sha256=ycoko6hwVBdVk3EAKCS8S-FpRh8auXI3ufoaREbU0AM,314 +bitblas/3rdparty/tvm/python/tvm/relay/op/memory/__pycache__/__init__.cpython-38.pyc,sha256=Kpu0Uid-eiA1S9xHg3zQgsyX1x-pYADr5ZjBWbFqaJc,301 +bitblas/3rdparty/tvm/python/tvm/relay/op/memory/__pycache__/_make.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/memory/__pycache__/_make.cpython-310.pyc,sha256=VGeecUAAQC7BvUXmvzNT1lrgZ1doNZ9pYcSH_JoKdhA,290 +bitblas/3rdparty/tvm/python/tvm/relay/op/memory/__pycache__/_make.cpython-38.pyc,sha256=p423QPyJMCnNzd76FcPAT3Kywe027UqciBT8lP7WkCY,277 +bitblas/3rdparty/tvm/python/tvm/relay/op/memory/__pycache__/memory.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/memory/__pycache__/memory.cpython-310.pyc,sha256=n9HmfPVxU3ML4NsHqUfp75g_O7FOBCpIg8kyyawQSqk,3059 +bitblas/3rdparty/tvm/python/tvm/relay/op/memory/__pycache__/memory.cpython-38.pyc,sha256=g3d_u5_uYDTtwkHuR9Lp71TKweC4rC8R8Q_jG2mNDvY,3058 +bitblas/3rdparty/tvm/python/tvm/relay/op/memory/_make.py,sha256=_NK_RL4y53YoEIgaOfy3WvjWekV9p6eHe1cBIYzOXa4,879 +bitblas/3rdparty/tvm/python/tvm/relay/op/memory/memory.py,sha256=dpsglYrm1InguJdPJ5HfBhDGXOszpLeEuFZdaFJ5DCo,3502 +bitblas/3rdparty/tvm/python/tvm/relay/op/nn/__init__.py,sha256=NS5XGo_k8Hf3yIke1dq6oJvPaHacc4p1ed0IP0iFU3c,942 +bitblas/3rdparty/tvm/python/tvm/relay/op/nn/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/nn/__pycache__/__init__.cpython-310.pyc,sha256=0fe8BUw5hvq60n8tFw61XjivYzCiYCSxIufGYVtnGlc,323 +bitblas/3rdparty/tvm/python/tvm/relay/op/nn/__pycache__/__init__.cpython-38.pyc,sha256=_okhMpXhtWw_qXjwENnqNNkJsLiWe0EAffTlKYpTeOo,310 +bitblas/3rdparty/tvm/python/tvm/relay/op/nn/__pycache__/_make.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/nn/__pycache__/_make.cpython-310.pyc,sha256=HvXhuen02Sfd6eTpImPlaodg3VxkJQCwdqEuWFVEKx4,282 +bitblas/3rdparty/tvm/python/tvm/relay/op/nn/__pycache__/_make.cpython-38.pyc,sha256=F05HKnyk61OXzdtVbwO1ryHTjILnAzaDbz8Cu2piVm0,269 +bitblas/3rdparty/tvm/python/tvm/relay/op/nn/__pycache__/_nn.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/nn/__pycache__/_nn.cpython-310.pyc,sha256=RnbkjKyb6qAgvY5_0PNtgB7tr0BuR9ajGeB4t_vEkvU,36310 +bitblas/3rdparty/tvm/python/tvm/relay/op/nn/__pycache__/_nn.cpython-38.pyc,sha256=vi3CGlKlqtgHtHYLHQWCHKKvVV36zlOco_x7UNYCwDI,37209 +bitblas/3rdparty/tvm/python/tvm/relay/op/nn/__pycache__/nn.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/nn/__pycache__/nn.cpython-310.pyc,sha256=wQyplDnldw6EPTT4gmZJgHZIOcAnw6m8XlrqBNve6xg,95571 +bitblas/3rdparty/tvm/python/tvm/relay/op/nn/__pycache__/nn.cpython-38.pyc,sha256=VqzKm1fBTdZseSf8Nh-iB8rFG60zXIvxwM_jdKMu_0w,96552 +bitblas/3rdparty/tvm/python/tvm/relay/op/nn/__pycache__/utils.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/nn/__pycache__/utils.cpython-310.pyc,sha256=04SwWpPzXe_X1YuVSn1PHJT8KzYECB4-VGX47r997Wc,2696 +bitblas/3rdparty/tvm/python/tvm/relay/op/nn/__pycache__/utils.cpython-38.pyc,sha256=VaYbmaptrVk3180RgBVE8n-F8MCnGT2KoDWrIXVQ1ks,2689 +bitblas/3rdparty/tvm/python/tvm/relay/op/nn/_make.py,sha256=VLvhu3YbzceGHeknIpdFiI6q9-gvCw7G-6Jjz_NAPf0,875 +bitblas/3rdparty/tvm/python/tvm/relay/op/nn/_nn.py,sha256=sQuZ9YHbv1Kf4Ox18x3aLSZAKE8FzlXfgbip3sN3Gng,48835 +bitblas/3rdparty/tvm/python/tvm/relay/op/nn/nn.py,sha256=MIwgar6ii0QIYYEN84qYMQbMt7FLWPWXtGbZpYZKM18,105660 +bitblas/3rdparty/tvm/python/tvm/relay/op/nn/utils.py,sha256=cN-gDIGWDIO7E1iQEthqFhjUM_FhnOr0qK23m3DJ8fA,4196 +bitblas/3rdparty/tvm/python/tvm/relay/op/op.py,sha256=HoTWyA827oVAya7LV3yVkZ_04euztOCsK0bKTQ_vDJI,15916 +bitblas/3rdparty/tvm/python/tvm/relay/op/op_attrs.py,sha256=0rUCpN3qQgoPLZrVghA3pTnsc96Rv9S1tv7yTNN9UY0,18897 +bitblas/3rdparty/tvm/python/tvm/relay/op/random/__init__.py,sha256=BcbDtyefFZqzLjIvyqbnm6JPfDPwBq_EPM2TL96r2uE,893 +bitblas/3rdparty/tvm/python/tvm/relay/op/random/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/random/__pycache__/__init__.cpython-310.pyc,sha256=5Wmn8s9fdRzXTn7dsEzYQT_ZzHSzEDwipkAwbI_3Ohg,264 +bitblas/3rdparty/tvm/python/tvm/relay/op/random/__pycache__/__init__.cpython-38.pyc,sha256=bk8TB0EJrscsZZTsmByoNf_r53zC7LRrIz7yde-Jg4I,251 +bitblas/3rdparty/tvm/python/tvm/relay/op/random/__pycache__/_kernel.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/random/__pycache__/_kernel.cpython-310.pyc,sha256=XtqoS16yje0PkR_KWA--_Onehf5cGvqv61LgOYWg9U0,765 +bitblas/3rdparty/tvm/python/tvm/relay/op/random/__pycache__/_kernel.cpython-38.pyc,sha256=MrpZ7WtxyQaQHJh4iVWcgtTe5aq7xAbsdHdDhYmlfCw,752 +bitblas/3rdparty/tvm/python/tvm/relay/op/random/__pycache__/_make.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/random/__pycache__/_make.cpython-310.pyc,sha256=TP-mR7Vvgo-PBWa-MONyzlMyeT3vNgm8NwyU4dr_y44,290 +bitblas/3rdparty/tvm/python/tvm/relay/op/random/__pycache__/_make.cpython-38.pyc,sha256=HUM5wlCSmvToCKS2ljppVCZoJklPc9u2HLsKUDM7VPE,277 +bitblas/3rdparty/tvm/python/tvm/relay/op/random/__pycache__/kernel.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/random/__pycache__/kernel.cpython-310.pyc,sha256=SYWgvTr8XXSbIrDyZEuPoD-R7RokDVMGCgYC5umFWXQ,8140 +bitblas/3rdparty/tvm/python/tvm/relay/op/random/__pycache__/kernel.cpython-38.pyc,sha256=DWioAY0ADSHkQxQ51zY_-sBltw64hZvwZmsVHbulaBg,8192 +bitblas/3rdparty/tvm/python/tvm/relay/op/random/_kernel.py,sha256=4K0vXn__wap-fT_P_0xGaS6-mCBpB9syy1H1cMlyH8g,1679 +bitblas/3rdparty/tvm/python/tvm/relay/op/random/_make.py,sha256=4DOGNcV7e3WHHEg6umnFXdlM1nhd11BouPU9Nvj1VHA,879 +bitblas/3rdparty/tvm/python/tvm/relay/op/random/kernel.py,sha256=nckLsKa6VHIN1aCalbjETvGFjeq-p2iBK9ybeVzwYAY,8610 +bitblas/3rdparty/tvm/python/tvm/relay/op/reduce.py,sha256=TL2dt82xjo_AXZjO9dekQ9fPyo94fTx3rkGnu6CN4NE,18241 +bitblas/3rdparty/tvm/python/tvm/relay/op/strategy/__init__.py,sha256=bFVDcL7xDRE6Ee4jEMo-4nDZ3MR_0y0sVuesIC5fUKY,1127 +bitblas/3rdparty/tvm/python/tvm/relay/op/strategy/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/strategy/__pycache__/__init__.cpython-310.pyc,sha256=HJuW0nP63rRaWcSlY4FkEhigYKNnX10IZpEnPjCu4fk,584 +bitblas/3rdparty/tvm/python/tvm/relay/op/strategy/__pycache__/__init__.cpython-38.pyc,sha256=HW740wILiCfDMU_xyKWdapRFuIxTlbIBGWpxgQWzlQk,571 +bitblas/3rdparty/tvm/python/tvm/relay/op/strategy/__pycache__/adreno.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/strategy/__pycache__/adreno.cpython-310.pyc,sha256=F61o6Ch6Z8-gC8wsqiSYLf-pmCyX1yBRbHFSXjyTSkM,7232 +bitblas/3rdparty/tvm/python/tvm/relay/op/strategy/__pycache__/adreno.cpython-38.pyc,sha256=KpZV0P2z3lN8Dcr2pby9B7HkfZgvemPSd5SMWJERb3M,7410 +bitblas/3rdparty/tvm/python/tvm/relay/op/strategy/__pycache__/arm_cpu.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/strategy/__pycache__/arm_cpu.cpython-310.pyc,sha256=QLsRcL9V2EpHe1tM-nAoNAzVK1BLxkhsOVoOYdqHn7M,17627 +bitblas/3rdparty/tvm/python/tvm/relay/op/strategy/__pycache__/arm_cpu.cpython-38.pyc,sha256=gxJuG8gMkCJIpYCWGD5WLSySHfe2seBtOuHUK4QAEes,17730 +bitblas/3rdparty/tvm/python/tvm/relay/op/strategy/__pycache__/bifrost.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/strategy/__pycache__/bifrost.cpython-310.pyc,sha256=ewg3lE4GZyyUnpYjnHngUPd8XcJDdGhoPu9Ep9Rr6oU,3326 +bitblas/3rdparty/tvm/python/tvm/relay/op/strategy/__pycache__/bifrost.cpython-38.pyc,sha256=5v73CRv72ym6Bj2R6e9QIKGtUAIyoVmx1CY8ok5vNYs,3356 +bitblas/3rdparty/tvm/python/tvm/relay/op/strategy/__pycache__/cuda.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/strategy/__pycache__/cuda.cpython-310.pyc,sha256=d197U_D6c4RtGtZJOc-iFgcmZXz4VUV9RSQo5oHtQbc,31903 +bitblas/3rdparty/tvm/python/tvm/relay/op/strategy/__pycache__/cuda.cpython-38.pyc,sha256=J1aZms_n5yJN2TyBCX4L04K0gg2vmBolwS_hPQFYEPQ,33834 +bitblas/3rdparty/tvm/python/tvm/relay/op/strategy/__pycache__/generic.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/strategy/__pycache__/generic.cpython-310.pyc,sha256=zCvYinimF3XCkDLvehZd_HYr9H_6ykBrNQXiUMBRHkU,52628 +bitblas/3rdparty/tvm/python/tvm/relay/op/strategy/__pycache__/generic.cpython-38.pyc,sha256=xoxQPJJIy5TRog2SKKMU7GsGbulQ1uWK6eOQMpaY6IE,56971 +bitblas/3rdparty/tvm/python/tvm/relay/op/strategy/__pycache__/hexagon.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/strategy/__pycache__/hexagon.cpython-310.pyc,sha256=stqc6M7atyBficuHUdbOGCZAWl7dKp0wEmYaSW8NknA,6047 +bitblas/3rdparty/tvm/python/tvm/relay/op/strategy/__pycache__/hexagon.cpython-38.pyc,sha256=l6rpGLntFwrZfzks2ex-3dCNpwEQB_E0ogIsTB7tknQ,6385 +bitblas/3rdparty/tvm/python/tvm/relay/op/strategy/__pycache__/hls.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/strategy/__pycache__/hls.cpython-310.pyc,sha256=G2esS-ERA0jTJH9RjxAI0oZl7G9QsBCAZcHZhAgsTM4,5253 +bitblas/3rdparty/tvm/python/tvm/relay/op/strategy/__pycache__/hls.cpython-38.pyc,sha256=s43ktamVs-Rq_YJaKWXOhg-XLXSXBWlQhavSWWzk7CQ,5481 +bitblas/3rdparty/tvm/python/tvm/relay/op/strategy/__pycache__/intel_graphics.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/strategy/__pycache__/intel_graphics.cpython-310.pyc,sha256=jBI11b4g9TakLVE2o4dhBMTtNYDdIqfpYcpu9J3Vexo,2017 +bitblas/3rdparty/tvm/python/tvm/relay/op/strategy/__pycache__/intel_graphics.cpython-38.pyc,sha256=Br1Wd37iNsPgAEvGNkSPLBAOpQjHfrdZJ8E8G_DU79c,2034 +bitblas/3rdparty/tvm/python/tvm/relay/op/strategy/__pycache__/mali.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/strategy/__pycache__/mali.cpython-310.pyc,sha256=jgbKOHIEKlvLaz07_vRG9qB6c_kNn_s6gLaGfcPb_k0,4799 +bitblas/3rdparty/tvm/python/tvm/relay/op/strategy/__pycache__/mali.cpython-38.pyc,sha256=sUZzpV9sO4qqfrJSaiZQQEUEE_DMiroYIwCTftqr5Js,4809 +bitblas/3rdparty/tvm/python/tvm/relay/op/strategy/__pycache__/rocm.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/strategy/__pycache__/rocm.cpython-310.pyc,sha256=tzUmZJDP32xH32zJy_62mAScIk30sfaTh1QoWnRvpbM,4840 +bitblas/3rdparty/tvm/python/tvm/relay/op/strategy/__pycache__/rocm.cpython-38.pyc,sha256=aksgUhE9DWmADxzIkihvQ6wgPsq2XrHidQsBX--nogg,5125 +bitblas/3rdparty/tvm/python/tvm/relay/op/strategy/__pycache__/x86.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/strategy/__pycache__/x86.cpython-310.pyc,sha256=XxPjebK799vlzCZQzr17nIP8eK13SrChvx5YvywmYw0,19952 +bitblas/3rdparty/tvm/python/tvm/relay/op/strategy/__pycache__/x86.cpython-38.pyc,sha256=rB-8-V5asyfMNgjtmks2icCdDgUGYwFJ6rWfEjcngSI,20069 +bitblas/3rdparty/tvm/python/tvm/relay/op/strategy/adreno.py,sha256=t5nBT9iQjzFYVswPTBoGe9_fnu-4wldzWQwWxX-FjFc,13352 +bitblas/3rdparty/tvm/python/tvm/relay/op/strategy/arm_cpu.py,sha256=umLWBo9rjoOgunGbk5D2nKa_hC2v02MwJl1F8vVBrG8,33189 +bitblas/3rdparty/tvm/python/tvm/relay/op/strategy/bifrost.py,sha256=Z8CnteD7YAvnRfg4dLp6ty8L3EyOm2egQIP8XnSFfro,5808 +bitblas/3rdparty/tvm/python/tvm/relay/op/strategy/cuda.py,sha256=JDe2iog5jOE5d9UYK_LvdmWi4Puv8p3-Ny3xNOH8mnY,52770 +bitblas/3rdparty/tvm/python/tvm/relay/op/strategy/generic.py,sha256=fHtTfTRxA_dV0JUPfrsr2IlEQpekUfy4GCVq1UujCmg,69990 +bitblas/3rdparty/tvm/python/tvm/relay/op/strategy/hexagon.py,sha256=UQCwOKJotc6DR4Batj6qg5z0rNkHLOwpJ7s83VRZ9eo,8212 +bitblas/3rdparty/tvm/python/tvm/relay/op/strategy/hls.py,sha256=umpHrnf8yzhMcSv-DxNLLhB-yDXOUgua6F9UZTHkhPg,7067 +bitblas/3rdparty/tvm/python/tvm/relay/op/strategy/intel_graphics.py,sha256=Yt5GK1TzdINoV2_byyfIBdSCK_NogTRXnxlFrF_AQ-U,3553 +bitblas/3rdparty/tvm/python/tvm/relay/op/strategy/mali.py,sha256=1b49cJyKLtHwHOpA2AhEwAD_d9C4KS3Ooqq3aKdPy9g,10506 +bitblas/3rdparty/tvm/python/tvm/relay/op/strategy/rocm.py,sha256=6G7OTvkwRalNxOc3LROU-fwCR3daBEzT-JdGbJ_nyRc,7363 +bitblas/3rdparty/tvm/python/tvm/relay/op/strategy/x86.py,sha256=tv0NLnW-oD98XxZAShfFOpXdZIJ5_ZKt-CD5yV0j2hA,34169 +bitblas/3rdparty/tvm/python/tvm/relay/op/tensor.py,sha256=XM7vV4JAx2BSmyJZM4-8N6b1LxkHGFyUwz-WM3o50WU,26589 +bitblas/3rdparty/tvm/python/tvm/relay/op/transform.py,sha256=QkN9l_8zyFlJAfhSsD6mDue4bNMelq7UHa-vQ_2jSA8,62501 +bitblas/3rdparty/tvm/python/tvm/relay/op/vision/__init__.py,sha256=PBUWxTtzV4SWNjqmVahLK8sF2yYqwV9wDM5d9ilkUtw,1004 +bitblas/3rdparty/tvm/python/tvm/relay/op/vision/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/vision/__pycache__/__init__.cpython-310.pyc,sha256=Em_40ZVb8t_pcDR3VhGjwrDiGhCK42HJnltRugKYHwA,379 +bitblas/3rdparty/tvm/python/tvm/relay/op/vision/__pycache__/__init__.cpython-38.pyc,sha256=eKR2dJtYmqVzWYzFZ6EeBuRfUTSgqAK1rmRDMURql_Y,366 +bitblas/3rdparty/tvm/python/tvm/relay/op/vision/__pycache__/_make.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/vision/__pycache__/_make.cpython-310.pyc,sha256=NFz7kVEOmh1KXhozgHGvGkXlKpi-ZET838yyp56u-pg,290 +bitblas/3rdparty/tvm/python/tvm/relay/op/vision/__pycache__/_make.cpython-38.pyc,sha256=uYpcQ1BqYWdWtSrFKuLPek_HS1ZWlGQxRXR4BF1Ns5Q,277 +bitblas/3rdparty/tvm/python/tvm/relay/op/vision/__pycache__/_rcnn.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/vision/__pycache__/_rcnn.cpython-310.pyc,sha256=GIWkgXykXKGgWtALJwClbUOl-0DcjZvR_2WPbnCcU_E,3122 +bitblas/3rdparty/tvm/python/tvm/relay/op/vision/__pycache__/_rcnn.cpython-38.pyc,sha256=lbVThiU3m5isAQrPF87jIhkGwjkPzcyEob-vpMZ5DqM,3315 +bitblas/3rdparty/tvm/python/tvm/relay/op/vision/__pycache__/_vision.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/vision/__pycache__/_vision.cpython-310.pyc,sha256=u7JSDSsjQNA_SyXxRmifJWcMHsP8supiIvxNE4ZiqpE,4293 +bitblas/3rdparty/tvm/python/tvm/relay/op/vision/__pycache__/_vision.cpython-38.pyc,sha256=HLqW-QcP3sWNKYAaZ-GTQlG3aIPsx1rP63FuzAsFkP4,4296 +bitblas/3rdparty/tvm/python/tvm/relay/op/vision/__pycache__/_yolo.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/vision/__pycache__/_yolo.cpython-310.pyc,sha256=JWXvRVvQzZOtIwCXkBh1ofxiVIwqvducEjuH46O10Kw,450 +bitblas/3rdparty/tvm/python/tvm/relay/op/vision/__pycache__/_yolo.cpython-38.pyc,sha256=-H1DJvdlj1tkwWVukl9_SwmgkoqJWFMJikdDnhzX3_0,437 +bitblas/3rdparty/tvm/python/tvm/relay/op/vision/__pycache__/multibox.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/vision/__pycache__/multibox.cpython-310.pyc,sha256=362VVvJLSPtEmYKF8PawuC8fpoklVGGCogctPUvaj-g,2264 +bitblas/3rdparty/tvm/python/tvm/relay/op/vision/__pycache__/multibox.cpython-38.pyc,sha256=Vm9kS4elO9iO1ecfKLJLbT6fHPeAVdTOfdOJA7q_XN0,2249 +bitblas/3rdparty/tvm/python/tvm/relay/op/vision/__pycache__/nms.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/vision/__pycache__/nms.cpython-310.pyc,sha256=aCmEihzdHsGG0ziAV7hRElpCGQQZ_s9HM0mEGSvjfNI,8542 +bitblas/3rdparty/tvm/python/tvm/relay/op/vision/__pycache__/nms.cpython-38.pyc,sha256=UTt3uKRas39LFjElXPIZ0iKJi84UJCCBSdvP79XGD7U,8505 +bitblas/3rdparty/tvm/python/tvm/relay/op/vision/__pycache__/rcnn.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/vision/__pycache__/rcnn.cpython-310.pyc,sha256=Erl5TVCbwBwO0qnYwzSgiyByNpcp1X-seUC90WUrOnQ,3870 +bitblas/3rdparty/tvm/python/tvm/relay/op/vision/__pycache__/rcnn.cpython-38.pyc,sha256=vXl4QQvP_avSk2gmT5NJTu1npLoS7JT35qFnoHq4tR0,3857 +bitblas/3rdparty/tvm/python/tvm/relay/op/vision/__pycache__/yolo.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/vision/__pycache__/yolo.cpython-310.pyc,sha256=aqOHPXpdp74VUluvFrf-h_y5Ii8y_O5fPAKxT7cWxlQ,1429 +bitblas/3rdparty/tvm/python/tvm/relay/op/vision/__pycache__/yolo.cpython-38.pyc,sha256=gsKlGUZrUoGRtVjtD1oQ7THhC9-l8a0ZZuCI8vWc0Z0,1416 +bitblas/3rdparty/tvm/python/tvm/relay/op/vision/_make.py,sha256=gspXaJoyKOCUeNjzSP_du_7n-2tKUx2HuXJ-UFhXa8w,879 +bitblas/3rdparty/tvm/python/tvm/relay/op/vision/_rcnn.py,sha256=2YlIYJ5cNLmKy1S6LJXjm77jsvtQ-FpoePyplF6MieE,4672 +bitblas/3rdparty/tvm/python/tvm/relay/op/vision/_vision.py,sha256=-xo3Ft1OSRGlWRQD0_TivpE35tCABNqv42vyh7zpIiQ,6323 +bitblas/3rdparty/tvm/python/tvm/relay/op/vision/_yolo.py,sha256=U_ToX2_QajD_Xxp-ZdwqOHESW21tY4Ow6x1C7AX2nyg,1131 +bitblas/3rdparty/tvm/python/tvm/relay/op/vision/multibox.py,sha256=PRtupHM4wLTZ4pCwVqBXq5E5JCrnhPuFR56J-G0zs6Y,2890 +bitblas/3rdparty/tvm/python/tvm/relay/op/vision/nms.py,sha256=TRMtyPmnN0hO5tgMoMF_36BWmqOQjx83q-ZwXuyCBls,10086 +bitblas/3rdparty/tvm/python/tvm/relay/op/vision/rcnn.py,sha256=GTLlokpgAylawdlqn1bTBbAfBDggYoVDxSkhJruk6YQ,4611 +bitblas/3rdparty/tvm/python/tvm/relay/op/vision/yolo.py,sha256=d0emDA68z-Es4JR1e3RskyZjovLH_6rUwH4WTHvunV0,1979 +bitblas/3rdparty/tvm/python/tvm/relay/op/vm/__init__.py,sha256=XsX7E2YMBoETJN7j7XCr5E7zbfrZ-Z5EovfNooG5Xr8,922 +bitblas/3rdparty/tvm/python/tvm/relay/op/vm/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/vm/__pycache__/__init__.cpython-310.pyc,sha256=QZglFP3QDQXAf-PoBKsVvYJdGlo7Sv9nZdl88VmBVyE,293 +bitblas/3rdparty/tvm/python/tvm/relay/op/vm/__pycache__/__init__.cpython-38.pyc,sha256=Qv2IiaJmLIDGjAC5WZFIYzhqKIEV_O3Oc2e--faiYDA,280 +bitblas/3rdparty/tvm/python/tvm/relay/op/vm/__pycache__/_ffi_api.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/vm/__pycache__/_ffi_api.cpython-310.pyc,sha256=lxE-3oPTXJD8Cqg_zH1upcaeCzmfEebBV7J6VyTV6qU,287 +bitblas/3rdparty/tvm/python/tvm/relay/op/vm/__pycache__/_ffi_api.cpython-38.pyc,sha256=OkXV47nK5LHjm0AD_ZUKGxh32u4gGSFhFxLnB3z77wM,274 +bitblas/3rdparty/tvm/python/tvm/relay/op/vm/__pycache__/vm.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/op/vm/__pycache__/vm.cpython-310.pyc,sha256=dUfKSSVkvgSrbue-T9SVH3-iQSi0BVkOy6zaz5W-qz4,2267 +bitblas/3rdparty/tvm/python/tvm/relay/op/vm/__pycache__/vm.cpython-38.pyc,sha256=_k3LrHqO4JSoNl9sXPlnyTYNnqg4W3K2Wkbj0-6bv3E,2268 +bitblas/3rdparty/tvm/python/tvm/relay/op/vm/_ffi_api.py,sha256=gH9LL4nxJPHou4NdpPv4hSf23TX2p0HOqoFTwKxEa4Q,877 +bitblas/3rdparty/tvm/python/tvm/relay/op/vm/vm.py,sha256=1hx3mmtbL43i0OtxQ4hjgjGuB0EsOVjlzTPu0g_U-y4,2825 +bitblas/3rdparty/tvm/python/tvm/relay/param_dict.py,sha256=NbZo1Wf36h6D62XlRITpH4sseApv5rMPEDQk9pM9Loo,2213 +bitblas/3rdparty/tvm/python/tvm/relay/parser.py,sha256=NcV7nNTGfWnmvMv90XEZShCldI42d2eVON5dfF-8PrE,1587 +bitblas/3rdparty/tvm/python/tvm/relay/prelude.py,sha256=PgtXIwLaxmBhdxZjUp4QE6PmheUNwljX0zXP2vfykXw,64853 +bitblas/3rdparty/tvm/python/tvm/relay/qnn/__init__.py,sha256=Hc0bY6lFkZXjCygpwNR1eYYHIASqsWhhWHI_svDyzv8,990 +bitblas/3rdparty/tvm/python/tvm/relay/qnn/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/qnn/__pycache__/__init__.cpython-310.pyc,sha256=OljT0RJz502Ww8tmA7JKtJWg8G809NxD1olN5TdKsd0,359 +bitblas/3rdparty/tvm/python/tvm/relay/qnn/__pycache__/__init__.cpython-38.pyc,sha256=ZJwrvO_b4ccIepysbTu44Lqvcd3a6TDJcsFcz72X9lo,346 +bitblas/3rdparty/tvm/python/tvm/relay/qnn/__pycache__/transform.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/qnn/__pycache__/transform.cpython-310.pyc,sha256=GASOcX3FtZbWxQayjoyqsDNhrr1UG9-jTrK4nk2-P4Y,4195 +bitblas/3rdparty/tvm/python/tvm/relay/qnn/__pycache__/transform.cpython-38.pyc,sha256=9o-qhKfq_4PZr3Xb5n0nobdZPMvNecAVuGXIIIRMIGo,4194 +bitblas/3rdparty/tvm/python/tvm/relay/qnn/op/__init__.py,sha256=1bbwig5r-zmm3RhZ1jZeYLjD192KS1WJn8WUV_uFEVM,1080 +bitblas/3rdparty/tvm/python/tvm/relay/qnn/op/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/qnn/op/__pycache__/__init__.cpython-310.pyc,sha256=s-GF_0iLn44EjYp-ynIYonidoOTwtRorBhRDL9YcKU8,488 +bitblas/3rdparty/tvm/python/tvm/relay/qnn/op/__pycache__/__init__.cpython-38.pyc,sha256=UlVqF-82hbmOH6EubfIC0tSmgzgwlmX38y6FR5-EwEM,475 +bitblas/3rdparty/tvm/python/tvm/relay/qnn/op/__pycache__/_make.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/qnn/op/__pycache__/_make.cpython-310.pyc,sha256=2faP66MBG8z1h-6K9pi-6vXlM65fLR1BS8Qb1Bb247w,284 +bitblas/3rdparty/tvm/python/tvm/relay/qnn/op/__pycache__/_make.cpython-38.pyc,sha256=NF0EFxexNMC363yhyqmSD2AKnVnWxX2-qhkG8Qc1byA,271 +bitblas/3rdparty/tvm/python/tvm/relay/qnn/op/__pycache__/_qnn.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/qnn/op/__pycache__/_qnn.cpython-310.pyc,sha256=HhPWBmDU8AYrx71fhEh7Hu4wTIAuCd8ObTVLivUl-u4,4240 +bitblas/3rdparty/tvm/python/tvm/relay/qnn/op/__pycache__/_qnn.cpython-38.pyc,sha256=7wEkexX1I-MNSjCE3YPlru9JfMlb2o4Z44y2jXnv5Og,4394 +bitblas/3rdparty/tvm/python/tvm/relay/qnn/op/__pycache__/_requantize.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/qnn/op/__pycache__/_requantize.cpython-310.pyc,sha256=_BbMMjasjsn7gzFIjLRzDNnkI5abemNgOZB83Jg3Cak,312 +bitblas/3rdparty/tvm/python/tvm/relay/qnn/op/__pycache__/_requantize.cpython-38.pyc,sha256=fj59IF0Ce5MUSZAu7YVrckZ2PUQ1yg5dT0eDlWJG5u4,299 +bitblas/3rdparty/tvm/python/tvm/relay/qnn/op/__pycache__/canonicalizations.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/qnn/op/__pycache__/canonicalizations.cpython-310.pyc,sha256=71Oo7JDPirE10Plu3i82CN0g0S61DtAxjDhxnjiX_Qc,4872 +bitblas/3rdparty/tvm/python/tvm/relay/qnn/op/__pycache__/canonicalizations.cpython-38.pyc,sha256=9UV01RbvWbgKiQTOz4KCmAe3xjLcmtqi4o4X0N6F7Hs,4809 +bitblas/3rdparty/tvm/python/tvm/relay/qnn/op/__pycache__/layout_conversions.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/qnn/op/__pycache__/layout_conversions.cpython-310.pyc,sha256=KfveZzquKDprZPXh6CSmhSfXFE8A52ttaEGj3HKdM3g,3991 +bitblas/3rdparty/tvm/python/tvm/relay/qnn/op/__pycache__/layout_conversions.cpython-38.pyc,sha256=WGsINGX6GsM9TBMWyLyBih_ZHJfvJGBXq9yk3fCyYp4,3993 +bitblas/3rdparty/tvm/python/tvm/relay/qnn/op/__pycache__/legalizations.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/qnn/op/__pycache__/legalizations.cpython-310.pyc,sha256=LcTSMoPztsUABNN1It602yjari5CDkNsMhwkH1XRvvo,16081 +bitblas/3rdparty/tvm/python/tvm/relay/qnn/op/__pycache__/legalizations.cpython-38.pyc,sha256=Z66swEnXE5yJ3p9fcDclQsGQoizciC3W11_xxssWCwk,16373 +bitblas/3rdparty/tvm/python/tvm/relay/qnn/op/__pycache__/op.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/qnn/op/__pycache__/op.cpython-310.pyc,sha256=bAjVDVzY8neTyj-cCmJE4Jk6sOLPr-7E3RINNCSWO2c,1384 +bitblas/3rdparty/tvm/python/tvm/relay/qnn/op/__pycache__/op.cpython-38.pyc,sha256=sagwYBWAgenpr0Ah2O8Ujkt0DB2aAIdamtKbFZV5Q7M,1399 +bitblas/3rdparty/tvm/python/tvm/relay/qnn/op/__pycache__/qnn.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/qnn/op/__pycache__/qnn.cpython-310.pyc,sha256=ooRdBbL3wAyyjfWIALNcKRaJj9xAmI7NY5KMNXe9uAQ,31826 +bitblas/3rdparty/tvm/python/tvm/relay/qnn/op/__pycache__/qnn.cpython-38.pyc,sha256=V6PABP9c9phrjNZVpN3vHImwFaAwfuAJvBDQmZqxt0w,32227 +bitblas/3rdparty/tvm/python/tvm/relay/qnn/op/_make.py,sha256=LMbZo6S9F7UatgDjPlk7AjkCBWVNLMupB72Co9_oBVU,876 +bitblas/3rdparty/tvm/python/tvm/relay/qnn/op/_qnn.py,sha256=lCq6dMowDUN7A1J6GX21HkYlwXTXvZRzNb8UKZOFucU,5833 +bitblas/3rdparty/tvm/python/tvm/relay/qnn/op/_requantize.py,sha256=xg8MdH5XryS7TPXTu5MbuZEkYt3e3ErJxlCFUVVdbGQ,932 +bitblas/3rdparty/tvm/python/tvm/relay/qnn/op/canonicalizations.py,sha256=cawZQs2hg1NbSapUVHrvfsVYczfcQMmED-uP1bEwnUE,6840 +bitblas/3rdparty/tvm/python/tvm/relay/qnn/op/layout_conversions.py,sha256=2uzA4fGnkCo209WQWaf8ktxG8xzAHnMCOmCcI3SpuqI,5883 +bitblas/3rdparty/tvm/python/tvm/relay/qnn/op/legalizations.py,sha256=sgfquwMojWz-JqEFCP6Baxx80DzX3QZIGFOkx2Br-1w,25590 +bitblas/3rdparty/tvm/python/tvm/relay/qnn/op/op.py,sha256=n7j8TJ_r5INmrSZHRmhbGWpFvv3XqKyMa4ufNxD8oV4,1987 +bitblas/3rdparty/tvm/python/tvm/relay/qnn/op/qnn.py,sha256=034C3cImH1hqBxg-8HaQl4XxdxTaskaYrBdhMwQWN28,35495 +bitblas/3rdparty/tvm/python/tvm/relay/qnn/strategy/__init__.py,sha256=bmyn9Ogp4-6jatGn_H7L8Unozb_QRovWDNwWjkJ6jNo,960 +bitblas/3rdparty/tvm/python/tvm/relay/qnn/strategy/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/qnn/strategy/__pycache__/__init__.cpython-310.pyc,sha256=j-CoZw6FPKDM7UjBBpsSIcNK8Vj2k6Uzwbw67he-h2Q,354 +bitblas/3rdparty/tvm/python/tvm/relay/qnn/strategy/__pycache__/__init__.cpython-38.pyc,sha256=gdLSeahET6VOtF3r_LybcJNqi4noQYBoQ-t1Hrp2Qlk,341 +bitblas/3rdparty/tvm/python/tvm/relay/qnn/strategy/__pycache__/arm_cpu.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/qnn/strategy/__pycache__/arm_cpu.cpython-310.pyc,sha256=PKGXyej6cplZkyrc-_E-S7NcpgpWmMGZQquAkG0OMQk,3930 +bitblas/3rdparty/tvm/python/tvm/relay/qnn/strategy/__pycache__/arm_cpu.cpython-38.pyc,sha256=qDVrhXeSQbzPVGI7OM873kaTm-LZyNZc8hB6-bg4GE0,4035 +bitblas/3rdparty/tvm/python/tvm/relay/qnn/strategy/__pycache__/generic.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/qnn/strategy/__pycache__/generic.cpython-310.pyc,sha256=7SefQpx4sGRvnpjrqHzQQH9ZceNymBN-qOBIsNcDUgg,7878 +bitblas/3rdparty/tvm/python/tvm/relay/qnn/strategy/__pycache__/generic.cpython-38.pyc,sha256=ZSvPW5zwugPlqlUdrC0W6gdkNa13L7BQ7w-dQnkJSbA,8134 +bitblas/3rdparty/tvm/python/tvm/relay/qnn/strategy/__pycache__/hexagon.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/qnn/strategy/__pycache__/hexagon.cpython-310.pyc,sha256=p75808olMnLHuGwFhQ_Ts1O_8MDhrZO5BbTKyJSg1MY,5676 +bitblas/3rdparty/tvm/python/tvm/relay/qnn/strategy/__pycache__/hexagon.cpython-38.pyc,sha256=btnexZoLadDvukOO4fMut3QV4_ud1x2JbPMimwGQpg0,6190 +bitblas/3rdparty/tvm/python/tvm/relay/qnn/strategy/arm_cpu.py,sha256=nQKzuA7-lQeSNMsKIE7dsgeQM8EP44mlgogFVWkCVgA,5451 +bitblas/3rdparty/tvm/python/tvm/relay/qnn/strategy/generic.py,sha256=1d40SlU9Iqbdp4BjeaH20oSvybDNcqCMPlsbY7VRfIc,10109 +bitblas/3rdparty/tvm/python/tvm/relay/qnn/strategy/hexagon.py,sha256=szE8K6ixQMM0U8ZdXH-R3KxEhdPq3KVdnV1WEtv6lI4,8378 +bitblas/3rdparty/tvm/python/tvm/relay/qnn/transform.py,sha256=GUFdk-hDHQEm5lso2UsKOvqdfrozaX1Rmu6AzZe1zd8,4792 +bitblas/3rdparty/tvm/python/tvm/relay/quantize/__init__.py,sha256=fm0CZaalSXtR2Y0RJ5HJS_QAtaTBcho8nsldGlQZooQ,1052 +bitblas/3rdparty/tvm/python/tvm/relay/quantize/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/quantize/__pycache__/__init__.cpython-310.pyc,sha256=d0eyibTgG-UKUHzOV2iPNkP-yoc4n0_sXPR8xOrYPwU,426 +bitblas/3rdparty/tvm/python/tvm/relay/quantize/__pycache__/__init__.cpython-38.pyc,sha256=9RZCaAbFoZSYB8KZrCGJFyjNAxzNJ4DRqtc8UTFnAwk,413 +bitblas/3rdparty/tvm/python/tvm/relay/quantize/__pycache__/_annotate.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/quantize/__pycache__/_annotate.cpython-310.pyc,sha256=ksKSkyhMPYy_HXnsiK0VF9kb-m4wsOTW1sdzjHWHoLc,10242 +bitblas/3rdparty/tvm/python/tvm/relay/quantize/__pycache__/_annotate.cpython-38.pyc,sha256=1tclSk5ZtevwkZWrPG8YNxnIxYSZl7Y8N-Nesh1H5jk,10610 +bitblas/3rdparty/tvm/python/tvm/relay/quantize/__pycache__/_calibrate.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/quantize/__pycache__/_calibrate.cpython-310.pyc,sha256=lNjeHh-C452CyGysrXAnmoOzmXxkzDMfaAk-tfu1Vmw,7040 +bitblas/3rdparty/tvm/python/tvm/relay/quantize/__pycache__/_calibrate.cpython-38.pyc,sha256=4cRs9S6iva34NlF6uCiVVqftCGY9spXepdCX6NUfik4,7151 +bitblas/3rdparty/tvm/python/tvm/relay/quantize/__pycache__/_partition.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/quantize/__pycache__/_partition.cpython-310.pyc,sha256=d8LrkyNwXgme-46mNeyhmZboU09OKGgH0C5YCf8KqRc,3476 +bitblas/3rdparty/tvm/python/tvm/relay/quantize/__pycache__/_partition.cpython-38.pyc,sha256=7tl6Rz0T6Tcq9egTPRxVnmYPBKKD0Yd849GuQUSs23U,3487 +bitblas/3rdparty/tvm/python/tvm/relay/quantize/__pycache__/_partition_conversions.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/quantize/__pycache__/_partition_conversions.cpython-310.pyc,sha256=aIRj_-W1YbRenwyWEexSWX5BlTolhdInNZR2SNgClj4,8926 +bitblas/3rdparty/tvm/python/tvm/relay/quantize/__pycache__/_partition_conversions.cpython-38.pyc,sha256=cLnpZY-WPZm8PijdfreydPR0oDdxjBUOoycTpUmr_Ys,8988 +bitblas/3rdparty/tvm/python/tvm/relay/quantize/__pycache__/_quantize.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/quantize/__pycache__/_quantize.cpython-310.pyc,sha256=WFc82mRzTpwAGZSX-EhD3pfQ9c17C62V-qGNa0NUsUw,304 +bitblas/3rdparty/tvm/python/tvm/relay/quantize/__pycache__/_quantize.cpython-38.pyc,sha256=TeagWijP1xv6FYI7cUc5jKYrY5Y2i85c8UO-COZwe2s,291 +bitblas/3rdparty/tvm/python/tvm/relay/quantize/__pycache__/kl_divergence.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/quantize/__pycache__/kl_divergence.cpython-310.pyc,sha256=kq7rqG-Z9OArlZRL-Em1EvXx_yYVCsM_YrCBugEjbTk,1471 +bitblas/3rdparty/tvm/python/tvm/relay/quantize/__pycache__/kl_divergence.cpython-38.pyc,sha256=VhXokOPNfglpHJE2-ZNyxYZJeOgvTQJRAWLfksoRb68,1480 +bitblas/3rdparty/tvm/python/tvm/relay/quantize/__pycache__/quantize.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/quantize/__pycache__/quantize.cpython-310.pyc,sha256=U5Jk68uvX3j4g-RpxzS6Ms86NCDFI9VnjBkeqOl7jUs,12381 +bitblas/3rdparty/tvm/python/tvm/relay/quantize/__pycache__/quantize.cpython-38.pyc,sha256=FJAfaQzcODHieHd1qVSOf4U5GRC1HSZDLMvL6tBme_Q,12303 +bitblas/3rdparty/tvm/python/tvm/relay/quantize/_annotate.py,sha256=1cbdsPgqHd3Gv6oYDgQqdyEzpUAMMbTDQcTD6qwXkxM,15961 +bitblas/3rdparty/tvm/python/tvm/relay/quantize/_calibrate.py,sha256=GKItch8NUlj7crtRYt2_9ieeh2eS8sxAiLNRDTiWfms,7850 +bitblas/3rdparty/tvm/python/tvm/relay/quantize/_partition.py,sha256=pIOTANe-GfO9koeP2bWiVltbAj-quIDVLycmcU0OK14,6579 +bitblas/3rdparty/tvm/python/tvm/relay/quantize/_partition_conversions.py,sha256=BpWkyd2wNoMsbfgpMZhpay0wbjKAZO9NGQQCc2AihfE,13363 +bitblas/3rdparty/tvm/python/tvm/relay/quantize/_quantize.py,sha256=Vvs53wBxNm178O5TWgrRf9ykzbtWCeyzbEMGO1CYLTg,924 +bitblas/3rdparty/tvm/python/tvm/relay/quantize/kl_divergence.py,sha256=n6YfZP7Vte7Sc-CwynY64tqhA-GcjQCqL5eHmunefp0,2129 +bitblas/3rdparty/tvm/python/tvm/relay/quantize/quantize.py,sha256=Fkk7vI49xDWR9WnY4T8tnVfPc6j1adxCA0MOhqciZOs,12297 +bitblas/3rdparty/tvm/python/tvm/relay/scope_builder.py,sha256=1mH_9vnApR-c0fIXSK4dicuoX9xgda9yrLLGaafmYD0,6235 +bitblas/3rdparty/tvm/python/tvm/relay/std/core.rly,sha256=gg9ntQZwNeO35ZSLpGDn3-IKsP8YMKIOD_lq9EK2sZE,851 +bitblas/3rdparty/tvm/python/tvm/relay/std/gradient.rly,sha256=y3U6fib9RsOCxxAkd3QlmyMKika9j106QtWO3rpuqWA,1681 +bitblas/3rdparty/tvm/python/tvm/relay/std/nat.rly,sha256=l2lug8AzFfh35_4TM45OKwGYr5YK2vZcoey_Yjr6bkE,2381 +bitblas/3rdparty/tvm/python/tvm/relay/std/prelude.rly,sha256=j51x2t1up0I7OaKkimEFyac-MmzrbFxPq1hBU4gPGQM,7585 +bitblas/3rdparty/tvm/python/tvm/relay/testing/__init__.py,sha256=9GpTSg76S_F5FHze4Oq5_T2hdj2jh5pYVKDDpula4FI,7367 +bitblas/3rdparty/tvm/python/tvm/relay/testing/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/testing/__pycache__/byoc.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/testing/__pycache__/darknet.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/testing/__pycache__/dcgan.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/testing/__pycache__/densenet.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/testing/__pycache__/dqn.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/testing/__pycache__/inception_v3.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/testing/__pycache__/init.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/testing/__pycache__/layers.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/testing/__pycache__/lstm.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/testing/__pycache__/mlp.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/testing/__pycache__/mobilenet.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/testing/__pycache__/nat.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/testing/__pycache__/py_converter.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/testing/__pycache__/resnet.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/testing/__pycache__/resnet_3d.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/testing/__pycache__/squeezenet.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/testing/__pycache__/synthetic.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/testing/__pycache__/temp_op_attr.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/testing/__pycache__/tf.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/testing/__pycache__/tflite.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/testing/__pycache__/vgg.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/testing/__pycache__/yolo_detection.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/testing/byoc.py,sha256=Vig0L1nM6-vZjSf8JKBTpsDGI9wk0A4ztdWJP6quyUc,2889 +bitblas/3rdparty/tvm/python/tvm/relay/testing/darknet.py,sha256=nLm1wH1jlJaXa3h6W_Qwwh3bLvXJ9drUHd6-fozNu78,12040 +bitblas/3rdparty/tvm/python/tvm/relay/testing/dcgan.py,sha256=pd5FEQBmzmwD3IhtfPWC8si5lVS-eq3fLb8q_jcl_2o,5048 +bitblas/3rdparty/tvm/python/tvm/relay/testing/densenet.py,sha256=GQ2Rd8RkXwqYjXyRgB3GN8Tv7VJuyq4QMv5yR4bqiwk,5127 +bitblas/3rdparty/tvm/python/tvm/relay/testing/dqn.py,sha256=neCIEH4oD0dwTCkMH2Zmv7mLDavOsDr5PHwsjSfaxTA,3497 +bitblas/3rdparty/tvm/python/tvm/relay/testing/inception_v3.py,sha256=cfIyT_qUPBfVg6U_xSOcD_iZqc6PpBSAaucenmdVbT4,12575 +bitblas/3rdparty/tvm/python/tvm/relay/testing/init.py,sha256=DoTtBdQr0TNPs6Kq56EjqPzohsQ6lUXZYY7R1aqfscs,5566 +bitblas/3rdparty/tvm/python/tvm/relay/testing/layers.py,sha256=ESBTTG0OkR5qqh-4u5e1hymnYbM5itrep-uNb20fAos,5202 +bitblas/3rdparty/tvm/python/tvm/relay/testing/lstm.py,sha256=GMyxgfrUENDPhAvAP1pgrn7R5N9iQ8qPAa-PX8LA2u0,6536 +bitblas/3rdparty/tvm/python/tvm/relay/testing/mlp.py,sha256=8OEg7uX3SByU5Bcvgstaz2JE7CF5pxkJXQCMKgF1pxQ,2784 +bitblas/3rdparty/tvm/python/tvm/relay/testing/mobilenet.py,sha256=Sc8cMxBgmEWoH6uZYfN95EcgL4sLMiUe6KkzxU--Z6Y,7442 +bitblas/3rdparty/tvm/python/tvm/relay/testing/nat.py,sha256=hHacBFRFfg0TcQsWPkpRee9vQPbKuZYQf--4xSzZSwM,2360 +bitblas/3rdparty/tvm/python/tvm/relay/testing/py_converter.py,sha256=hUJUyFW0MUb4wlo49PR-CWEZOgtzt9hI0b0UwaQhZic,28049 +bitblas/3rdparty/tvm/python/tvm/relay/testing/resnet.py,sha256=wqM3GcXlMt81d6ctZxK_-C_63iA9T_kuS4wi1jTXQZE,11058 +bitblas/3rdparty/tvm/python/tvm/relay/testing/resnet_3d.py,sha256=MxBXxe4DQ45IA09Jl9IkWcj4bz6teTvMwV2qs5Zbnkc,10913 +bitblas/3rdparty/tvm/python/tvm/relay/testing/squeezenet.py,sha256=MWFa92AiN7V6FEwXbb_BvFAUgzZjxS2q27AiXVd-K6c,5472 +bitblas/3rdparty/tvm/python/tvm/relay/testing/synthetic.py,sha256=4n4VEsdvL7N07R4i03_D3MDQB_V0200JtNC7LdM-k34,3672 +bitblas/3rdparty/tvm/python/tvm/relay/testing/temp_op_attr.py,sha256=zcDZe34dMtuUQYKF3Aly7p6nGfOTg-2ttUjVq36LRLk,2251 +bitblas/3rdparty/tvm/python/tvm/relay/testing/tf.py,sha256=a3xqFI2CpORGc73PIVY9-9F36jTnbUThMJ9mYARNLSw,15293 +bitblas/3rdparty/tvm/python/tvm/relay/testing/tflite.py,sha256=eq6hdHhQlxbo3DZikpAFF2o-6TbdcFRgLDpf4HQ-hXE,6889 +bitblas/3rdparty/tvm/python/tvm/relay/testing/vgg.py,sha256=9u-PmdCXQvgDgGds5rfGrFnIwRK-auC0mcG05MbJG3w,4754 +bitblas/3rdparty/tvm/python/tvm/relay/testing/yolo_detection.py,sha256=4vAGKPBAlckz3r7BqLaq3Ira13fcCfBjtIdhStnNBG0,12082 +bitblas/3rdparty/tvm/python/tvm/relay/transform/__init__.py,sha256=2zC3DuzcxaUMIRsodV6Iv9A7Utz0OzCQgPRFG-Ko2ck,1095 +bitblas/3rdparty/tvm/python/tvm/relay/transform/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/transform/__pycache__/__init__.cpython-310.pyc,sha256=bUfwiKFvGgiG2kV1RiXG77gk0raWKIMVP0ouJ4CTw-c,430 +bitblas/3rdparty/tvm/python/tvm/relay/transform/__pycache__/__init__.cpython-38.pyc,sha256=LWRsJyNum3Q9YrlwU1NXvivkzox1qJYNuzM0sgsiT_o,417 +bitblas/3rdparty/tvm/python/tvm/relay/transform/__pycache__/_ffi_api.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/transform/__pycache__/_ffi_api.cpython-310.pyc,sha256=HFZC9XdzK0IO2RRl0kDXCP9Fz8pGn8hc4HDUQO16YNI,313 +bitblas/3rdparty/tvm/python/tvm/relay/transform/__pycache__/_ffi_api.cpython-38.pyc,sha256=JU5VLBb3vyvKueEJcwuvYjHCN7PEv56O_k7jwoM1-pU,300 +bitblas/3rdparty/tvm/python/tvm/relay/transform/__pycache__/fake_quantization_to_integer.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/transform/__pycache__/fake_quantization_to_integer.cpython-310.pyc,sha256=3CCPO4IwZbH7to-ZRPKruHYERSuBuhzCj0x8wsTk-90,14579 +bitblas/3rdparty/tvm/python/tvm/relay/transform/__pycache__/fake_quantization_to_integer.cpython-38.pyc,sha256=sONvL1P_5UbhC6YPyhf9h5eHTBCkF8s_tdR6z3KQGD0,14858 +bitblas/3rdparty/tvm/python/tvm/relay/transform/__pycache__/flexible_shape.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/transform/__pycache__/flexible_shape.cpython-310.pyc,sha256=RkKBOvml1tN0iF2OuhsXR4uVOzzm1HDbRTmhoige9pc,11110 +bitblas/3rdparty/tvm/python/tvm/relay/transform/__pycache__/flexible_shape.cpython-38.pyc,sha256=bnlayUCKlSODExdfveHlOei8YS4yVQmRpcWImx5AKXg,11151 +bitblas/3rdparty/tvm/python/tvm/relay/transform/__pycache__/infer_layout_utils.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/transform/__pycache__/memory_plan.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/transform/__pycache__/memory_plan.cpython-310.pyc,sha256=CtTuxlAoTc9mUUzJ8o8XHbzmV61TbRVwt29n8adMEAQ,10878 +bitblas/3rdparty/tvm/python/tvm/relay/transform/__pycache__/memory_plan.cpython-38.pyc,sha256=V0RWjT_KyI3jYFPvJ7-Bs9XRAjku7VATX4ghef3VbVQ,10912 +bitblas/3rdparty/tvm/python/tvm/relay/transform/__pycache__/mixed_precision.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/transform/__pycache__/mixed_precision.cpython-310.pyc,sha256=gDmLmD9ggaRHIPrfaZb8N1YB97wHUN2r_jHT-RPdR2E,3205 +bitblas/3rdparty/tvm/python/tvm/relay/transform/__pycache__/mixed_precision.cpython-38.pyc,sha256=T7yqZcni1VxyRrqKqUW86xxLGBXiFCiMRYc8ojl8UAI,3553 +bitblas/3rdparty/tvm/python/tvm/relay/transform/__pycache__/recast.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/transform/__pycache__/recast.cpython-310.pyc,sha256=CsDD4XPWq2xps44Wh7JKS6E7tLIJ_HAWmIH-NOAHttA,4459 +bitblas/3rdparty/tvm/python/tvm/relay/transform/__pycache__/recast.cpython-38.pyc,sha256=4-qSToi2iw1Q-IDsDNNAVCZKwnrbRGj2-UCP8YMK_J8,4480 +bitblas/3rdparty/tvm/python/tvm/relay/transform/__pycache__/suffixes.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/transform/__pycache__/suffixes.cpython-310.pyc,sha256=7MWpjFbCBnTngjKjPdHuoCrieR1YFSd7V_42EWngbcM,3080 +bitblas/3rdparty/tvm/python/tvm/relay/transform/__pycache__/transform.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/relay/transform/__pycache__/transform.cpython-310.pyc,sha256=LwO4w5OTKoQxlIDYUtxPRob6_D-L6agiOU5R7xq4jVg,46949 +bitblas/3rdparty/tvm/python/tvm/relay/transform/__pycache__/transform.cpython-38.pyc,sha256=65FfWPS4rYraAIOQ-wii5FFnMl6bQakbxp8F5NSJccc,47413 +bitblas/3rdparty/tvm/python/tvm/relay/transform/_ffi_api.py,sha256=lr8a3Zza2CWHT_s-zSGt55tbHaZcSHb9A6zYIkmyG-0,899 +bitblas/3rdparty/tvm/python/tvm/relay/transform/fake_quantization_to_integer.py,sha256=c05u0ZXPi2PjnHUTzWeML0ZWomkDUWSYsQcSrsNFeZk,22075 +bitblas/3rdparty/tvm/python/tvm/relay/transform/flexible_shape.py,sha256=XQb6rEgxnJgmPZcFbfC5GPhVQPwGiTyVxSGseplrFf0,15463 +bitblas/3rdparty/tvm/python/tvm/relay/transform/infer_layout_utils.py,sha256=pplD2rMX4n0qKeiDLY3nTY4NNu8lXx3PQ2QMPTOlmfY,1374 +bitblas/3rdparty/tvm/python/tvm/relay/transform/memory_plan.py,sha256=EcsMMUjY4y-x429rU5GBHkpk6ws9KfU_AAaWT2rWV2M,12029 +bitblas/3rdparty/tvm/python/tvm/relay/transform/mixed_precision.py,sha256=-qwuYCC4TQY6wv1S837RiSyjoPE_dCf2svcsRe9LYOk,6766 +bitblas/3rdparty/tvm/python/tvm/relay/transform/recast.py,sha256=BhRIXu2Gq5PD4fx-CiKZLJboO28p934LbB2J_1w4-ec,6468 +bitblas/3rdparty/tvm/python/tvm/relay/transform/suffixes.py,sha256=zeoIHof_fZKiZohjIfufphvUr-sEUOM-X4gG4m0LpQw,3818 +bitblas/3rdparty/tvm/python/tvm/relay/transform/transform.py,sha256=KZmKSRWyPlFeBFQLSdLuYrULFLBMCHQl3s7Ds_QdOQE,45168 +bitblas/3rdparty/tvm/python/tvm/relay/ty.py,sha256=zu6GOrn3RbwD5EXo8mjlUP24jM7sl89L8fwAFoK5hsw,2020 +bitblas/3rdparty/tvm/python/tvm/relay/type_functor.py,sha256=sSIM_ZaFLcoFjt1pYo60_WisbacDR_256xiVdqjR6EQ,5878 +bitblas/3rdparty/tvm/python/tvm/rpc/__init__.py,sha256=6T8vn-q9MDGAy3mS8WxaaaeHRYCB58Bd3yw5mu1d01k,1388 +bitblas/3rdparty/tvm/python/tvm/rpc/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/rpc/__pycache__/__init__.cpython-310.pyc,sha256=IluWTvgR7lklkDZK3DJWmSv0up6jo4Ry3sXc12XWpSc,840 +bitblas/3rdparty/tvm/python/tvm/rpc/__pycache__/__init__.cpython-38.pyc,sha256=Lo9VUQTj9zcEiDwxBV2fdKH-IVHkUEDbIonx4Smo__M,827 +bitblas/3rdparty/tvm/python/tvm/rpc/__pycache__/_ffi_api.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/rpc/__pycache__/_ffi_api.cpython-310.pyc,sha256=4P9Ue9nB-3a2SDVkyMjeZI2QOFn5vP5mp_q27S00Zms,267 +bitblas/3rdparty/tvm/python/tvm/rpc/__pycache__/_ffi_api.cpython-38.pyc,sha256=YgIw3NwSrW7s9QCe05EwVhLylUcb52x5iddNDZUHhAo,254 +bitblas/3rdparty/tvm/python/tvm/rpc/__pycache__/base.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/rpc/__pycache__/base.cpython-310.pyc,sha256=bslhmrfHbIqykf1KlR9XtorFhgggIBsbQv8cBWBMQRs,4190 +bitblas/3rdparty/tvm/python/tvm/rpc/__pycache__/base.cpython-38.pyc,sha256=x8WCqLiSaAjj7ImI6A4bpfZdTWoo7VCwaH7Ikxjb4qo,4152 +bitblas/3rdparty/tvm/python/tvm/rpc/__pycache__/client.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/rpc/__pycache__/client.cpython-310.pyc,sha256=x-04o_mbGVgAe27hmu8yn8pT_QBiRW4VJOAMHG5NWYw,17024 +bitblas/3rdparty/tvm/python/tvm/rpc/__pycache__/client.cpython-38.pyc,sha256=QLWVreJAW4M7GaRt3VrsT9NXDyLpyNwzfzkyGOk2B7o,17284 +bitblas/3rdparty/tvm/python/tvm/rpc/__pycache__/minrpc.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/rpc/__pycache__/minrpc.cpython-310.pyc,sha256=izBXhQZ1qt0Gye2Xs7ydkkmfw48dPUuELO1dq1pzZTo,2109 +bitblas/3rdparty/tvm/python/tvm/rpc/__pycache__/minrpc.cpython-38.pyc,sha256=haz2oqJvnc9YTg_8ysncTowV1qMxf7VIvF2xEOcqgWM,2102 +bitblas/3rdparty/tvm/python/tvm/rpc/__pycache__/proxy.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/rpc/__pycache__/server.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/rpc/__pycache__/server.cpython-310.pyc,sha256=Mjp1Y2nDQq8SmJVHVZPouANyPbB-K8NDlL6jNpR-xIE,12701 +bitblas/3rdparty/tvm/python/tvm/rpc/__pycache__/server.cpython-38.pyc,sha256=owFHRVGB5xz5VKAUPySyk3hyxqkGteDE2cNcAJQjyUI,12656 +bitblas/3rdparty/tvm/python/tvm/rpc/__pycache__/server_ios_launcher.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/rpc/__pycache__/testing.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/rpc/__pycache__/testing.cpython-310.pyc,sha256=n1Sc2Vto1veb-aaWNPNPkncOMyYjjEXNFyOQOecnJoM,2145 +bitblas/3rdparty/tvm/python/tvm/rpc/__pycache__/testing.cpython-38.pyc,sha256=342nUg-5bMs0vGaLxtnDSl2w1yImNvLKc-9bTo2SAcI,2136 +bitblas/3rdparty/tvm/python/tvm/rpc/__pycache__/tornado_util.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/rpc/__pycache__/tracker.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/rpc/_ffi_api.py,sha256=3w5bEaPvZzJQZIR4ubsd5nwOIWM1UOhgTPYZ6iT2a5o,866 +bitblas/3rdparty/tvm/python/tvm/rpc/base.py,sha256=68rH68rTBMboNpVI82QN7bWpmd0mmizA46LISIxMoAU,4735 +bitblas/3rdparty/tvm/python/tvm/rpc/client.py,sha256=Z6tvm50_ZF87ZuNbc2I2yJREOyI9mM5Kelboh6DLAPk,17818 +bitblas/3rdparty/tvm/python/tvm/rpc/minrpc.py,sha256=SLrinmjx-5LDJ-ZmgjwfvoRDkzwCeB7GRcrZPUYXjQI,2888 +bitblas/3rdparty/tvm/python/tvm/rpc/proxy.py,sha256=eOduCT6b_cdzNap4TCR46tSCkn3CJZVaEdGYZKVwip4,24225 +bitblas/3rdparty/tvm/python/tvm/rpc/server.py,sha256=lspBZZKQ5m3h0UkITGEy8P8j5fV4i58VU9GUGj8kaks,18398 +bitblas/3rdparty/tvm/python/tvm/rpc/server_ios_launcher.py,sha256=GfpxiCNIFy58KIo3MNq6G_aE0f7ShiR7OsZF57pp8B4,16475 +bitblas/3rdparty/tvm/python/tvm/rpc/testing.py,sha256=Bw0qYkFUihGpdUyHxuHcc1njKenTeg_blRKotTODqH0,2066 +bitblas/3rdparty/tvm/python/tvm/rpc/tornado_util.py,sha256=w4vrzDDye4dXQhzfFco2Vdp6_zz6DrFMu29hGF4LeSM,4192 +bitblas/3rdparty/tvm/python/tvm/rpc/tracker.py,sha256=zdRKhSiVLGQtswiZbbg5eIUkYjO2SoEUEA_cjIhnz64,16533 +bitblas/3rdparty/tvm/python/tvm/runtime/__init__.py,sha256=eKbX0BGWyNivP6QiSgGaoq_TiyHJYebtYDs1Xot1W0c,1694 +bitblas/3rdparty/tvm/python/tvm/runtime/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/runtime/__pycache__/__init__.cpython-310.pyc,sha256=E9XV66exHPuivlKNxMyExY4rGR6ig0DXzzCJCWbm3L8,1367 +bitblas/3rdparty/tvm/python/tvm/runtime/__pycache__/__init__.cpython-38.pyc,sha256=yHCNxNxpmszafXqylF1s4GR4SpALRWjV8sHjwZmxqyo,1354 +bitblas/3rdparty/tvm/python/tvm/runtime/__pycache__/_ffi_api.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/runtime/__pycache__/_ffi_api.cpython-310.pyc,sha256=ljvOjRB_Lr3lFc9iMQ2npIBotZygTk25-CKyrj_5UBk,279 +bitblas/3rdparty/tvm/python/tvm/runtime/__pycache__/_ffi_api.cpython-38.pyc,sha256=0fNYxMhbUIZVVRW8tiZyyws1XcDuiN2x8ijhmV42owc,266 +bitblas/3rdparty/tvm/python/tvm/runtime/__pycache__/_ffi_node_api.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/runtime/__pycache__/_ffi_node_api.cpython-310.pyc,sha256=pZeVJoLt8U9GM74VeZgRIkm0YskQq6bdzQREgXYDDik,1177 +bitblas/3rdparty/tvm/python/tvm/runtime/__pycache__/_ffi_node_api.cpython-38.pyc,sha256=hYWdRV7c_dJaeo18OeuPoS-voT8f-FdZ-49MbMCy-DU,1212 +bitblas/3rdparty/tvm/python/tvm/runtime/__pycache__/container.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/runtime/__pycache__/container.cpython-310.pyc,sha256=xKvk5O-FRc3Tg0MXuiJRfLErU2nVO2s7gSgvH0RVEz8,5055 +bitblas/3rdparty/tvm/python/tvm/runtime/__pycache__/container.cpython-38.pyc,sha256=NBJxIp-6BeGY_YBK8cLs_a9W4aEgvdysc8s-ho7vjNw,5106 +bitblas/3rdparty/tvm/python/tvm/runtime/__pycache__/module.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/runtime/__pycache__/module.cpython-310.pyc,sha256=6J5X95DH71FVdlfDnojuGdcxljL3ErRtfxm96RtXnjg,23586 +bitblas/3rdparty/tvm/python/tvm/runtime/__pycache__/module.cpython-38.pyc,sha256=DqmV7e5BLcvNb1NzE8kDgmekakhXCLFl_bbPwNaCtFk,23660 +bitblas/3rdparty/tvm/python/tvm/runtime/__pycache__/name_transforms.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/runtime/__pycache__/name_transforms.cpython-310.pyc,sha256=cpXJecaYcTst2KXCvCSfu_nqLyOyTjXdROXt91aia8M,580 +bitblas/3rdparty/tvm/python/tvm/runtime/__pycache__/name_transforms.cpython-38.pyc,sha256=W2E0jypwEldi7AqJskMVu7_q_1bQ_m-9PvM7cTYV8xk,567 +bitblas/3rdparty/tvm/python/tvm/runtime/__pycache__/ndarray.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/runtime/__pycache__/ndarray.cpython-310.pyc,sha256=luffh0ClXryLZeYYY97F74_Xr-_Q3JADIycU5gqyCr4,16421 +bitblas/3rdparty/tvm/python/tvm/runtime/__pycache__/ndarray.cpython-38.pyc,sha256=dWWIPespYT1y0s029MN_HLTK1wNOhNpny2wu1Aqkh_c,16692 +bitblas/3rdparty/tvm/python/tvm/runtime/__pycache__/object.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/runtime/__pycache__/object.cpython-310.pyc,sha256=auhXZNxKdyyN7g-2Ibib80LpN6G0fNl2N3lXA0fRPOU,4097 +bitblas/3rdparty/tvm/python/tvm/runtime/__pycache__/object.cpython-38.pyc,sha256=dcC8wiROd0WZElT9l-uGe2l4hfjiTgnV8AF9NEEQfgs,4106 +bitblas/3rdparty/tvm/python/tvm/runtime/__pycache__/object_generic.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/runtime/__pycache__/object_generic.cpython-310.pyc,sha256=l47KcJYT8xVVL03ARG_DBM-oTebPgEht33YOZe7bGPk,4061 +bitblas/3rdparty/tvm/python/tvm/runtime/__pycache__/object_generic.cpython-38.pyc,sha256=JCQ8NeqiUdRCGuYTLg-K3AZFjAzKkG67t6-93O_bvu0,4048 +bitblas/3rdparty/tvm/python/tvm/runtime/__pycache__/object_path.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/runtime/__pycache__/object_path.cpython-310.pyc,sha256=7MWydkqXNYMnjtWeTPL_a9vFJDVBZU88cqOpriocfEM,4580 +bitblas/3rdparty/tvm/python/tvm/runtime/__pycache__/object_path.cpython-38.pyc,sha256=OBnzVSlOmsl5vCiY-f1UVsooDDclLFJ4nj9t6byhFps,4798 +bitblas/3rdparty/tvm/python/tvm/runtime/__pycache__/packed_func.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/runtime/__pycache__/packed_func.cpython-310.pyc,sha256=rgPPR9q4XEWOfSrPpbnVdg7lqf3QntbtRjEa7h5iN1o,1677 +bitblas/3rdparty/tvm/python/tvm/runtime/__pycache__/packed_func.cpython-38.pyc,sha256=7knUTj85DtvMrbLo7tOX7yhIafHofqmeNeBlgBPukRU,1656 +bitblas/3rdparty/tvm/python/tvm/runtime/__pycache__/params.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/runtime/__pycache__/params.cpython-310.pyc,sha256=UnpzXxK-N_xUR0cqa3eAbuMtJzk81y8nlLLgl9zE09I,2578 +bitblas/3rdparty/tvm/python/tvm/runtime/__pycache__/params.cpython-38.pyc,sha256=SmZiFNYdGcEhQq_tSv7wKLOYU0y7BNcOc_daGkbfCng,2565 +bitblas/3rdparty/tvm/python/tvm/runtime/__pycache__/profiler_vm.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/runtime/__pycache__/profiler_vm.cpython-310.pyc,sha256=AhB3O_hY_L2kUi9FrXJiM51ecBs1lDBeUxgtyfXMMRE,2767 +bitblas/3rdparty/tvm/python/tvm/runtime/__pycache__/relax_vm.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/runtime/__pycache__/relax_vm.cpython-310.pyc,sha256=rbRk4Nn8m4oYk_6_BDb-VhZkJsx0S_VhZhrrnUgVFlk,17676 +bitblas/3rdparty/tvm/python/tvm/runtime/__pycache__/relax_vm.cpython-38.pyc,sha256=-qJQ77m2Elm4gAn3gzk9-dFdDg1dfEwbL_gq1P8YjFQ,17662 +bitblas/3rdparty/tvm/python/tvm/runtime/__pycache__/script_printer.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/runtime/__pycache__/script_printer.cpython-310.pyc,sha256=DCk0EERJcyadRSxQuVqfVBje1BM4RrnHNwxFTMEDgY8,11711 +bitblas/3rdparty/tvm/python/tvm/runtime/__pycache__/script_printer.cpython-38.pyc,sha256=AK96DwVHxQkpcA6GItBrx6Hm_sUY-x2r8XV-QPG6L3k,10810 +bitblas/3rdparty/tvm/python/tvm/runtime/__pycache__/support.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/runtime/__pycache__/support.cpython-310.pyc,sha256=UOUmO3-JPdidTvq5it-oyLYo4YcMhAukaatplw6FW8w,1874 +bitblas/3rdparty/tvm/python/tvm/runtime/__pycache__/support.cpython-38.pyc,sha256=ia9wMA5CJ8v36U-GwBf21zDmvQ6pJmkTnAJoFv7QqtI,1859 +bitblas/3rdparty/tvm/python/tvm/runtime/__pycache__/vm.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/runtime/__pycache__/vm.cpython-310.pyc,sha256=xBXhXq_9bfHR4IaqjR4hfNCYrL3mM8CssraGvLQWKrw,24120 +bitblas/3rdparty/tvm/python/tvm/runtime/__pycache__/vm.cpython-38.pyc,sha256=sJOfbR7K3g5Pbk9kJfOJ1KwnEM1k1WUCRlPN4Hb7r1E,24234 +bitblas/3rdparty/tvm/python/tvm/runtime/_ffi_api.py,sha256=aQBejdsJKYIHbu3TxNoe1i4sR1SKAXSlZy4wT2P4maw,1012 +bitblas/3rdparty/tvm/python/tvm/runtime/_ffi_node_api.py,sha256=TYaoLwI6P0wptA52_P5BMTYQk5wloKVad9mxe_1ZKxo,1748 +bitblas/3rdparty/tvm/python/tvm/runtime/container.py,sha256=zT6Rl5GzMl68njNGZAaAkbsG8ZuNSAwos4Vxzenl9BA,5018 +bitblas/3rdparty/tvm/python/tvm/runtime/disco/__init__.py,sha256=gcPKMBgQj7TVWn2LmQaZWSBzUWEqNv7PDcW3p00dbss,939 +bitblas/3rdparty/tvm/python/tvm/runtime/disco/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/runtime/disco/__pycache__/__init__.cpython-310.pyc,sha256=nKEaIxZpevuEqj9YCWxBzIiPA3YPTeYE5itaNeHaq08,357 +bitblas/3rdparty/tvm/python/tvm/runtime/disco/__pycache__/__init__.cpython-38.pyc,sha256=EPAM9qLC4wvNr-R0NVJ0fbC4W_eH2236nsH1ylkp07o,344 +bitblas/3rdparty/tvm/python/tvm/runtime/disco/__pycache__/_ffi_api.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/runtime/disco/__pycache__/_ffi_api.cpython-310.pyc,sha256=YHGNiN1nE_HV5dewG6LtvMQg5xdMK1E6t_yL1Hq1y4I,276 +bitblas/3rdparty/tvm/python/tvm/runtime/disco/__pycache__/_ffi_api.cpython-38.pyc,sha256=LcM-8kADGNqwEgImezcoScQ3YcoyPX-LJRtPeUx0IHw,263 +bitblas/3rdparty/tvm/python/tvm/runtime/disco/__pycache__/process_pool.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/runtime/disco/__pycache__/process_pool.cpython-310.pyc,sha256=aRhhZwgrnsL6YqvQc6-fgu3HrhvK1tKs2REbQDf79HE,4496 +bitblas/3rdparty/tvm/python/tvm/runtime/disco/__pycache__/process_pool.cpython-38.pyc,sha256=-FftQUXJ_joWGiBKD0foOpE2KdjPiJjgjj0ZUn8H0lg,4459 +bitblas/3rdparty/tvm/python/tvm/runtime/disco/__pycache__/session.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/runtime/disco/__pycache__/session.cpython-310.pyc,sha256=ZEBpQN3gl89j3P5X_XrCmUYRK799HoAgxOiYB4bdU7M,15200 +bitblas/3rdparty/tvm/python/tvm/runtime/disco/__pycache__/session.cpython-38.pyc,sha256=Gt8l8U3e0lltlfX3H4h0NbbcKgcJXoYdDCy3H5qYq-E,15262 +bitblas/3rdparty/tvm/python/tvm/runtime/disco/_ffi_api.py,sha256=lrYyTE1UZhFKYd4Rwec6IYCA1oV24ID4ZE0wKlm5hHg,877 +bitblas/3rdparty/tvm/python/tvm/runtime/disco/process_pool.py,sha256=zAmSOKUZzmIL7OBZIIzopygRecRVgW3V9B_nArJJWpk,5695 +bitblas/3rdparty/tvm/python/tvm/runtime/disco/session.py,sha256=TavTcRHyawDYWhgRNigMZy6IPpaUgYcXKNl-1CPyPdI,15419 +bitblas/3rdparty/tvm/python/tvm/runtime/executor/__init__.py,sha256=EdTXinQMAsSB-40UwHfmVHsF6vvQiYoTM2ZhhdHjZ5o,1134 +bitblas/3rdparty/tvm/python/tvm/runtime/executor/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/runtime/executor/__pycache__/__init__.cpython-310.pyc,sha256=_KGnppj9n0x0l2DOdw3CE85NkfLuiPgOJ_xFJlORvq4,541 +bitblas/3rdparty/tvm/python/tvm/runtime/executor/__pycache__/__init__.cpython-38.pyc,sha256=47voezHjN_Kx2JXi2IhEH2-8Jy02IKDz6l0qT7oA078,528 +bitblas/3rdparty/tvm/python/tvm/runtime/executor/__pycache__/aot_executor.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/runtime/executor/__pycache__/aot_executor.cpython-310.pyc,sha256=pIK5Gmt8wnt_CTZAooTxLOqmVCpaQByKsihJxzPx6hA,5468 +bitblas/3rdparty/tvm/python/tvm/runtime/executor/__pycache__/aot_executor.cpython-38.pyc,sha256=Z5kqe_dS7B5x23SZkuR00DvzbyNJTIh52RbBLBJMmb8,5453 +bitblas/3rdparty/tvm/python/tvm/runtime/executor/aot_executor.py,sha256=eIKiqadWWL7DE2xnvTg_hgcSetIRlPakI-4_XcQNVyo,6108 +bitblas/3rdparty/tvm/python/tvm/runtime/module.py,sha256=f1On4L7TYqxwHEVcpRQzryHcwrVdP4y0vU9MwvWi3Gg,26158 +bitblas/3rdparty/tvm/python/tvm/runtime/name_transforms.py,sha256=zFNB3oNFY4tNPQEa3uADiQMBRw0xFRxLWig9hmHcrrs,1119 +bitblas/3rdparty/tvm/python/tvm/runtime/ndarray.py,sha256=QAMIvXDnfHLrJQjhVv4LMJzDENCrd4giiTYYoAVkWqo,18168 +bitblas/3rdparty/tvm/python/tvm/runtime/object.py,sha256=_8iFKqxrd2tJhFY72GtZIiwJ46G4X4NSFiYn7WSG6ho,4249 +bitblas/3rdparty/tvm/python/tvm/runtime/object_generic.py,sha256=yWWIOsKSB2b88tS6MuJEJmvSZfuwg2ACeRA7BScmSB8,5146 +bitblas/3rdparty/tvm/python/tvm/runtime/object_path.py,sha256=-FxXZ1OlGENG2rVOHisKyObw-etxWMVs_UEs3BH-Odg,4038 +bitblas/3rdparty/tvm/python/tvm/runtime/packed_func.py,sha256=A0hBFweW7vDo_y9sSsiCgwPPkeIH5YwSe8Ye6_8whMM,2442 +bitblas/3rdparty/tvm/python/tvm/runtime/params.py,sha256=IPsessBEjUi7S1nDIFP2FuzEtQpbKoovGSiNVlbkwzI,3041 +bitblas/3rdparty/tvm/python/tvm/runtime/profiler_vm.py,sha256=zdNoFpxMx7N43Gqq1BTCGCbTdzp3YSogjGiqZ11QHVQ,3521 +bitblas/3rdparty/tvm/python/tvm/runtime/profiling/__init__.py,sha256=m43fDYP7ooKv5F-IKsIhfW54I_DCfVtZRwWm0R1bZZc,9085 +bitblas/3rdparty/tvm/python/tvm/runtime/profiling/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/runtime/profiling/__pycache__/__init__.cpython-310.pyc,sha256=wbrPwYObH1hCogikXgCam88eebuCbRmOd_fi6qrajEY,9411 +bitblas/3rdparty/tvm/python/tvm/runtime/profiling/__pycache__/__init__.cpython-38.pyc,sha256=L10zFTwS8T7Fw9ecHwe7JEbbM_94YsEaKa3VU7AKzAQ,9624 +bitblas/3rdparty/tvm/python/tvm/runtime/profiling/__pycache__/_ffi_api.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/runtime/profiling/__pycache__/_ffi_api.cpython-310.pyc,sha256=wEbCaQi4tLXQm2Yd4G-Dh0rp8UJzw_1XL0PFBFId1rE,288 +bitblas/3rdparty/tvm/python/tvm/runtime/profiling/__pycache__/_ffi_api.cpython-38.pyc,sha256=Gyw7djYSBh-_8dopuX4EvVkhwjw_wcng9VfFYc7IhO4,275 +bitblas/3rdparty/tvm/python/tvm/runtime/profiling/_ffi_api.py,sha256=FVWor3vIcr8VFjQosc1m_5wxQbWPJHHFKkhhuJBRaxk,877 +bitblas/3rdparty/tvm/python/tvm/runtime/relax_vm.py,sha256=vRABxjiNCO2DaT1lh_ZqFL6Lio1AaQR96e31nqwR67k,19405 +bitblas/3rdparty/tvm/python/tvm/runtime/script_printer.py,sha256=BD8v3T46Z6iWKgpAiC5s0zRfMksLHLRDp9F9OyvfxhA,15789 +bitblas/3rdparty/tvm/python/tvm/runtime/support.py,sha256=GXQedHPIoFve9YB-0FpSDZUxgL4cvxpbr3tH40xgmxs,2415 +bitblas/3rdparty/tvm/python/tvm/runtime/vm.py,sha256=ysiB4HzXmfW7Dy2ekJ3Go6F_nogvNpZ0sRLwMZhNUow,26630 +bitblas/3rdparty/tvm/python/tvm/script/__init__.py,sha256=cTKFAJmpxXlV-sn8VOrOEvrW7GdLFJ7sgrh2PzCZlnQ,904 +bitblas/3rdparty/tvm/python/tvm/script/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/script/__pycache__/__init__.cpython-310.pyc,sha256=_CCXrw02vRRcqXONxhOodOYjuw8s5N08LVBixbE3zAs,308 +bitblas/3rdparty/tvm/python/tvm/script/__pycache__/__init__.cpython-38.pyc,sha256=Z3nl7ZR-jSTb_XGYPYGa5barG0VwgTEi3vimmUq3zIQ,295 +bitblas/3rdparty/tvm/python/tvm/script/__pycache__/_ffi_api.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/script/__pycache__/highlight.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/script/__pycache__/relax.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/script/__pycache__/tir.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/script/__pycache__/tir.cpython-310.pyc,sha256=HSP12f-oefLsGZyS_RA69f7pXg283N8ZngyBmtdictk,244 +bitblas/3rdparty/tvm/python/tvm/script/__pycache__/tir.cpython-38.pyc,sha256=tY8NYuwfHXaFbm6HGUGwFY2suIMxI0TzoHDeIWw6S6s,231 +bitblas/3rdparty/tvm/python/tvm/script/_ffi_api.py,sha256=9sA9DszvRFx6OMUsSNrkAq3SWD0Vo8sKWiI8r2y-85o,811 +bitblas/3rdparty/tvm/python/tvm/script/highlight.py,sha256=cXQdOQ8Jr6cAMyq9ZOQ8NCSxukGBeN0qx5x8AdJjS0w,9918 +bitblas/3rdparty/tvm/python/tvm/script/ir_builder/__init__.py,sha256=aDbgk0vLuOURcNOAjXGS9kywXkBWG4xigJ1-fK8qZt0,874 +bitblas/3rdparty/tvm/python/tvm/script/ir_builder/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/script/ir_builder/__pycache__/__init__.cpython-310.pyc,sha256=5ipEw7cYzaxy8__FzvnBjndjAX7chsBEyaxOIbkJoBE,280 +bitblas/3rdparty/tvm/python/tvm/script/ir_builder/__pycache__/__init__.cpython-38.pyc,sha256=0xpthWjwo16VvcG0nMJoSn_sgHOZYYtWPYK3FxAgves,267 +bitblas/3rdparty/tvm/python/tvm/script/ir_builder/__pycache__/_ffi_api.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/script/ir_builder/__pycache__/_ffi_api.cpython-310.pyc,sha256=1lUmfdLC0aiYEfGVl78Li71-9lXpuEylTeq3WUElu-o,309 +bitblas/3rdparty/tvm/python/tvm/script/ir_builder/__pycache__/_ffi_api.cpython-38.pyc,sha256=S22F4p1MFcvPv5sYsYBO-AhDW8VOGywkkyPR28yYXZg,296 +bitblas/3rdparty/tvm/python/tvm/script/ir_builder/__pycache__/base.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/script/ir_builder/__pycache__/base.cpython-310.pyc,sha256=NhGItGkFyMov5ALxwYdQvJCA2uuMIQW3vKh9fcHbwjU,6420 +bitblas/3rdparty/tvm/python/tvm/script/ir_builder/__pycache__/base.cpython-38.pyc,sha256=BNfl-ObhYc9p4l_444xuz-DDZViAXbToz4OoWQYrfLw,6436 +bitblas/3rdparty/tvm/python/tvm/script/ir_builder/_ffi_api.py,sha256=IQGx0nLIzyCeN6bFKONrxNNZi7bKrlqvko0N6Z0cObw,929 +bitblas/3rdparty/tvm/python/tvm/script/ir_builder/base.py,sha256=CMTQ1Ddl9EQ6rbOe_tIQhj4y78PtmTfwo9BKeUxnRHw,6743 +bitblas/3rdparty/tvm/python/tvm/script/ir_builder/ir/__init__.py,sha256=dkmEIEHEjn-Z08t0OVz333ZZRxCXVhwqvdm8vFMvLIc,1028 +bitblas/3rdparty/tvm/python/tvm/script/ir_builder/ir/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/script/ir_builder/ir/__pycache__/__init__.cpython-310.pyc,sha256=PCvRYtNbc51LQ8OqhMkus8HGierkPg3LD3PjdDEaY2c,473 +bitblas/3rdparty/tvm/python/tvm/script/ir_builder/ir/__pycache__/__init__.cpython-38.pyc,sha256=B_UgxORLXNyVv_5C_nQQcjXFgQKy8UyJSZQqOpjfFEw,460 +bitblas/3rdparty/tvm/python/tvm/script/ir_builder/ir/__pycache__/_ffi_api.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/script/ir_builder/ir/__pycache__/_ffi_api.cpython-310.pyc,sha256=pEFmDegHZFZcJJeez8Ko6kibaBCXSCvkMahoCo0QczI,289 +bitblas/3rdparty/tvm/python/tvm/script/ir_builder/ir/__pycache__/_ffi_api.cpython-38.pyc,sha256=_04JGlrWt9y55XtFNdocqJOLe797TXVv3QWahM0ZaZ8,276 +bitblas/3rdparty/tvm/python/tvm/script/ir_builder/ir/__pycache__/frame.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/script/ir_builder/ir/__pycache__/frame.cpython-310.pyc,sha256=p7zuDP2Gz2V21IJOAJW3FWUnAy7TMZ4nGWSHzbKnwjQ,547 +bitblas/3rdparty/tvm/python/tvm/script/ir_builder/ir/__pycache__/frame.cpython-38.pyc,sha256=uqAUbhx74ETK7U2JVMe7wkZjGrBspoPuiC56OxUrz8k,532 +bitblas/3rdparty/tvm/python/tvm/script/ir_builder/ir/__pycache__/ir.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/script/ir_builder/ir/__pycache__/ir.cpython-310.pyc,sha256=JeA2B6HqwgJyUTqfnGqZjq7NAwiDAOQB2UGAkCJj_aQ,3856 +bitblas/3rdparty/tvm/python/tvm/script/ir_builder/ir/__pycache__/ir.cpython-38.pyc,sha256=6ZsbKzQwRldq1lxSEXaZbU7nFlApk3rezaaj_dIpR0A,3890 +bitblas/3rdparty/tvm/python/tvm/script/ir_builder/ir/_ffi_api.py,sha256=RjhNofNNyJLUGK91asEzdyZsviq4BYwQIufmvPXXTu0,906 +bitblas/3rdparty/tvm/python/tvm/script/ir_builder/ir/frame.py,sha256=BAy5Gdj0-pQLuLQENh7amFIyGEqoLQ8Uhwx00B259iw,1023 +bitblas/3rdparty/tvm/python/tvm/script/ir_builder/ir/ir.py,sha256=QfGZ9Mgfp6mgryC-SUgEXroNZ-KXVOCBjsemg_4twFg,4653 +bitblas/3rdparty/tvm/python/tvm/script/ir_builder/relax/__init__.py,sha256=KqnDAadcdJ9Kgkn-ChvVOe3OJjkExOLUg5_WOxVDLBs,931 +bitblas/3rdparty/tvm/python/tvm/script/ir_builder/relax/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/script/ir_builder/relax/__pycache__/_ffi_api.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/script/ir_builder/relax/__pycache__/frame.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/script/ir_builder/relax/__pycache__/ir.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/script/ir_builder/relax/_ffi_api.py,sha256=R1QdQndUx9hexamq_hpMD1C0crvsgjqYqtJVOn1VgsE,941 +bitblas/3rdparty/tvm/python/tvm/script/ir_builder/relax/distributed/__init__.py,sha256=f8lDnRSPWpqalImAJYbByj_wHOyf2-JXEoVOHXxlTYU,942 +bitblas/3rdparty/tvm/python/tvm/script/ir_builder/relax/distributed/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/script/ir_builder/relax/distributed/__pycache__/_ffi_api.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/script/ir_builder/relax/distributed/__pycache__/ir.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/script/ir_builder/relax/distributed/_ffi_api.py,sha256=KJoQybuMO21BfOv7xaf68-CnVKIgchpRfPDu8LflMtU,971 +bitblas/3rdparty/tvm/python/tvm/script/ir_builder/relax/distributed/ir.py,sha256=bgSzQwGey2Vgm38MARr0sjx2glGun3gHkC_XRcyHIgM,5560 +bitblas/3rdparty/tvm/python/tvm/script/ir_builder/relax/frame.py,sha256=3u-1eRQ44cgNHf-XFRc0Z-rhEY71ZMyQuTyp_-LgQ9s,1747 +bitblas/3rdparty/tvm/python/tvm/script/ir_builder/relax/ir.py,sha256=-6xjJAc6w5T2Blx7_yEZecGObhcaaIW45NZRBIjVk0k,18746 +bitblas/3rdparty/tvm/python/tvm/script/ir_builder/tir/__init__.py,sha256=VVbdqjq7xdpKxWkunxzo1axsB2jWHlqffML6YZ91Luo,998 +bitblas/3rdparty/tvm/python/tvm/script/ir_builder/tir/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/script/ir_builder/tir/__pycache__/__init__.cpython-310.pyc,sha256=F3PSul6x0o0x_JY8N4FAALrZ6Zb3Hz42S7L4E95oO-8,317 +bitblas/3rdparty/tvm/python/tvm/script/ir_builder/tir/__pycache__/__init__.cpython-38.pyc,sha256=UCWcpt_Hqyw36iA_w4qY2-HvVvgojPYt_AZNjVYAh-I,304 +bitblas/3rdparty/tvm/python/tvm/script/ir_builder/tir/__pycache__/_ffi_api.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/script/ir_builder/tir/__pycache__/_ffi_api.cpython-310.pyc,sha256=k5zdZG29pGxtocwYOESX8Wn8iduTZu1nBW0GqDxefsU,291 +bitblas/3rdparty/tvm/python/tvm/script/ir_builder/tir/__pycache__/_ffi_api.cpython-38.pyc,sha256=ll1oZbKtWPYwju5SnurszcCJTg4N2HLr4XrkpmTf-yw,278 +bitblas/3rdparty/tvm/python/tvm/script/ir_builder/tir/__pycache__/frame.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/script/ir_builder/tir/__pycache__/frame.cpython-310.pyc,sha256=9CUWn3zkJDN4-71xVXSXXeVftOfPGNDPa9YkB4gF8J0,4174 +bitblas/3rdparty/tvm/python/tvm/script/ir_builder/tir/__pycache__/frame.cpython-38.pyc,sha256=ZO7Xg9yWKleDGnvZEOz8ULZGgAmjX3IfqlWHAvMbR-E,4501 +bitblas/3rdparty/tvm/python/tvm/script/ir_builder/tir/__pycache__/ir.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/script/ir_builder/tir/__pycache__/ir.cpython-310.pyc,sha256=GaHjlF45NU3KhzviYrcDDt6IzKirn4uYJZgwjey-CJ4,46187 +bitblas/3rdparty/tvm/python/tvm/script/ir_builder/tir/__pycache__/ir.cpython-38.pyc,sha256=kSyc3gyNH98LXLnwiT8wg9iQdQxtZiP1AzT2DBDWSMo,48492 +bitblas/3rdparty/tvm/python/tvm/script/ir_builder/tir/_ffi_api.py,sha256=zZ5-7hd4icWbH8DBaNHchWrkLpjnywR6S6h3CurYUgo,907 +bitblas/3rdparty/tvm/python/tvm/script/ir_builder/tir/frame.py,sha256=JSmFb8nYdUL4EUNkhAhODStnLY_2IGIlKvpQuKcjwTg,3153 +bitblas/3rdparty/tvm/python/tvm/script/ir_builder/tir/ir.py,sha256=qyntfCMyqRgwO5ZbX7YqlMVqkC6cDOKKvSfbC-VmdtY,58722 +bitblas/3rdparty/tvm/python/tvm/script/parser/__init__.py,sha256=sNXBqtaL8Er1EW08V9qz0DE61bSu_ZkEpctk1D0cJi0,877 +bitblas/3rdparty/tvm/python/tvm/script/parser/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/script/parser/__pycache__/__init__.cpython-310.pyc,sha256=Wx1F3xb5CK0gcoz__MD1fR9w3gDlXyDfUUtpVvEyRqc,297 +bitblas/3rdparty/tvm/python/tvm/script/parser/__pycache__/__init__.cpython-38.pyc,sha256=HRDs6E6PUjAefTp1r4ePDrV6e1w_zdO3mbIUnKm5pKE,284 +bitblas/3rdparty/tvm/python/tvm/script/parser/__pycache__/_core.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/script/parser/__pycache__/_core.cpython-310.pyc,sha256=o3IOa_nnxbv2b0k6TpseCKQIf4ol-isdY4QQ8_TiPpk,440 +bitblas/3rdparty/tvm/python/tvm/script/parser/__pycache__/_core.cpython-38.pyc,sha256=-3-7OLp7J5QsZVNc685wfSUH4q4NRVXCYz2lHD3BkpE,427 +bitblas/3rdparty/tvm/python/tvm/script/parser/_core.py,sha256=8ms98830B0uE3aVEeSwiY-mc2JCGKkeu6iAPBo3aiYY,1006 +bitblas/3rdparty/tvm/python/tvm/script/parser/core/__init__.py,sha256=ZlVxXKwxeloRQs8zPhu2sGQhq2PEGNwJtzAi-1pD97U,897 +bitblas/3rdparty/tvm/python/tvm/script/parser/core/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/script/parser/core/__pycache__/__init__.cpython-310.pyc,sha256=flTQemy4qhA_yic24UluR8vHKgrS3UU7lG2_8BSXZm4,367 +bitblas/3rdparty/tvm/python/tvm/script/parser/core/__pycache__/__init__.cpython-38.pyc,sha256=v-ImqGXwP_23UaN7_tYGzf1jt-zURDcaB7Rpioh23TY,354 +bitblas/3rdparty/tvm/python/tvm/script/parser/core/__pycache__/diagnostics.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/script/parser/core/__pycache__/diagnostics.cpython-310.pyc,sha256=SYHzH4z0QrJdpHFRE4zzsO8rk20PLGqw3i5YalVnon0,6307 +bitblas/3rdparty/tvm/python/tvm/script/parser/core/__pycache__/diagnostics.cpython-38.pyc,sha256=zguWpOf3CvY6jTH5FdBSg0eAfi9-i16zn4OzRYdFlLU,6304 +bitblas/3rdparty/tvm/python/tvm/script/parser/core/__pycache__/dispatch.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/script/parser/core/__pycache__/dispatch.cpython-310.pyc,sha256=Kggg6xKbvFA6MXngC3jTS4TXb9wa8xMwnXzO9UTzmlo,4422 +bitblas/3rdparty/tvm/python/tvm/script/parser/core/__pycache__/dispatch.cpython-38.pyc,sha256=ay463a9fWNO2Jh78ot_fEn00IeQnNXabUuscz_Lmx4o,4410 +bitblas/3rdparty/tvm/python/tvm/script/parser/core/__pycache__/doc.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/script/parser/core/__pycache__/doc.cpython-310.pyc,sha256=wgtfH_7uInf8NEM7nXASRvRhF7iBvkdxF80CvGG-PZ0,13102 +bitblas/3rdparty/tvm/python/tvm/script/parser/core/__pycache__/doc.cpython-38.pyc,sha256=fj2NdePSM0FYRI-EGEgaSErKkKovhDiT3HdoNcURVzs,13293 +bitblas/3rdparty/tvm/python/tvm/script/parser/core/__pycache__/doc_core.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/script/parser/core/__pycache__/doc_core.cpython-310.pyc,sha256=VERxnm__-0UIXfM9sfAnhr6xIKFhf65paPs3f7qxe6w,26996 +bitblas/3rdparty/tvm/python/tvm/script/parser/core/__pycache__/doc_core.cpython-38.pyc,sha256=AOVHGXsVkUfa_wHJaEoOuggoACHzJpoUTgtRcQQLJV4,36126 +bitblas/3rdparty/tvm/python/tvm/script/parser/core/__pycache__/entry.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/script/parser/core/__pycache__/entry.cpython-310.pyc,sha256=_Y_Ca-WiEI7e7H2iP11BhVIWljMFQw0vNyiZ1_kEnFk,2896 +bitblas/3rdparty/tvm/python/tvm/script/parser/core/__pycache__/entry.cpython-38.pyc,sha256=iDlFYBi86NrSMTVEaJPzaMsolQ212xQom0Azd9l1Njs,2851 +bitblas/3rdparty/tvm/python/tvm/script/parser/core/__pycache__/error.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/script/parser/core/__pycache__/error.cpython-310.pyc,sha256=4llFIH_UE2F6m2X1P89Hf1wi06Y_7qY8txVR5gFdUos,691 +bitblas/3rdparty/tvm/python/tvm/script/parser/core/__pycache__/error.cpython-38.pyc,sha256=DYkdviEdlF1Gy6sXFxcad8jEubBOuc9aa_9gaFw5W98,676 +bitblas/3rdparty/tvm/python/tvm/script/parser/core/__pycache__/evaluator.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/script/parser/core/__pycache__/evaluator.cpython-310.pyc,sha256=SnFwrq8yntP82VZDtZXKjsmloDpuSjlbA961JuMYt_0,16739 +bitblas/3rdparty/tvm/python/tvm/script/parser/core/__pycache__/evaluator.cpython-38.pyc,sha256=vH3CvA3CBrqWmuxrI33ycdNDd-pPqGnJMO2bgMYXcg8,16778 +bitblas/3rdparty/tvm/python/tvm/script/parser/core/__pycache__/parser.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/script/parser/core/__pycache__/parser.cpython-310.pyc,sha256=pEVXs8HVMHGHNZ5VOLrPAp_Id9L0jkX6hnPK2VskLS0,24540 +bitblas/3rdparty/tvm/python/tvm/script/parser/core/__pycache__/parser.cpython-38.pyc,sha256=_-mfT4KY0FgRqCoRRVj3xemtftVcM1DmplSqCdZmceM,24688 +bitblas/3rdparty/tvm/python/tvm/script/parser/core/__pycache__/utils.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/script/parser/core/__pycache__/utils.cpython-310.pyc,sha256=QvteDDvcqsg6c6rRwJemrgvVvl4FZCrNpkVs36OjGWc,2699 +bitblas/3rdparty/tvm/python/tvm/script/parser/core/__pycache__/utils.cpython-38.pyc,sha256=TqOLH3qMnxGn4cAzTsIDp3tc7UGi27oiBTX0H8m5DOI,2668 +bitblas/3rdparty/tvm/python/tvm/script/parser/core/diagnostics.py,sha256=Qaz2w3-CaqiSssalbH4VoVBbeslLA7b-4muksnYDTWc,8363 +bitblas/3rdparty/tvm/python/tvm/script/parser/core/dispatch.py,sha256=q9iw_OyDF0Pp9wh6IFCy7k-_ofSQKOzszU1Ubp3jm2w,4719 +bitblas/3rdparty/tvm/python/tvm/script/parser/core/doc.py,sha256=wBABGFEO1OXe8Zoou87dbR-41K1moHqhTlZVOd2t4Mk,14708 +bitblas/3rdparty/tvm/python/tvm/script/parser/core/doc_core.py,sha256=RHgfLrNAq2n6Y06JhrVlBEaYf4iJMlFKp9tXvHnqpgU,35222 +bitblas/3rdparty/tvm/python/tvm/script/parser/core/entry.py,sha256=p0Kj6wIM7Ke5ROoWcgMmNX5WV0OBz5qVtI6bb5oyFDk,4085 +bitblas/3rdparty/tvm/python/tvm/script/parser/core/error.py,sha256=38xNdk4ho-Wn6b2YgLPjoXuAKOm3cfYrOnE4hjMy20w,1016 +bitblas/3rdparty/tvm/python/tvm/script/parser/core/evaluator.py,sha256=ub5dWGHhuySbqwtLmh3WZWhd_mWlCH8izqG3AC5WuOk,17991 +bitblas/3rdparty/tvm/python/tvm/script/parser/core/parser.py,sha256=KHpvJsYhK_QXAEWwIWglkc4HVDPCF81CgzgrksdbbMI,25173 +bitblas/3rdparty/tvm/python/tvm/script/parser/core/utils.py,sha256=Rqg2S3lUCfXjgjIwomfeB0hYXkC0R4ApxP1pSv0tt3E,3702 +bitblas/3rdparty/tvm/python/tvm/script/parser/ir/__init__.py,sha256=Jzyan5mbxHcDYtn-v7KtUuKAdd_kVDlyGmSLYBBhJ1Q,1121 +bitblas/3rdparty/tvm/python/tvm/script/parser/ir/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/script/parser/ir/__pycache__/__init__.cpython-310.pyc,sha256=AfXzhV538qP9TRXqdoSaqQvtrJa-90BfiPsQkyTFMlI,472 +bitblas/3rdparty/tvm/python/tvm/script/parser/ir/__pycache__/__init__.cpython-38.pyc,sha256=kID0EocqUt7YfYVhJNsoZqLM9--bbwW93Wks00aVKbQ,481 +bitblas/3rdparty/tvm/python/tvm/script/parser/ir/__pycache__/entry.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/script/parser/ir/__pycache__/entry.cpython-310.pyc,sha256=IVAQGbXXp5tefFilxVXpmuXWj8cTxSnDdF0O14esH7A,1325 +bitblas/3rdparty/tvm/python/tvm/script/parser/ir/__pycache__/entry.cpython-38.pyc,sha256=FrkJXPOt-BNUhmJjycbapwtV-CHYc6qIkSlLyP0UFEY,1314 +bitblas/3rdparty/tvm/python/tvm/script/parser/ir/__pycache__/parser.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/script/parser/ir/__pycache__/parser.cpython-310.pyc,sha256=llbiY8XwCKiMVV0wvtyiyMyuoBL3cXjEOuV5tSi9Ipc,3527 +bitblas/3rdparty/tvm/python/tvm/script/parser/ir/__pycache__/parser.cpython-38.pyc,sha256=0g4wnwawp6h0QJmt474l0CH9gHA-IQs-FKRmDBVnku0,3382 +bitblas/3rdparty/tvm/python/tvm/script/parser/ir/entry.py,sha256=IRdv8kbelyNOk1XseQznfn6cYZOFhGbypyi5d6rnDs8,2254 +bitblas/3rdparty/tvm/python/tvm/script/parser/ir/parser.py,sha256=52V_YVPh8_cmvXLUDEHm5XofIjTHOIvJuIunbKX5wVE,4403 +bitblas/3rdparty/tvm/python/tvm/script/parser/relax/__init__.py,sha256=__940Ep5dBNM4bgGzDdLCP5spT_drC5doUYf_gqe5pM,1603 +bitblas/3rdparty/tvm/python/tvm/script/parser/relax/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/script/parser/relax/__pycache__/dist.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/script/parser/relax/__pycache__/entry.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/script/parser/relax/__pycache__/parser.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/script/parser/relax/dist.py,sha256=BmPE8Vfv_aeIQldG8aZ0O7GHs14cd5F90kOMTvZZetE,3731 +bitblas/3rdparty/tvm/python/tvm/script/parser/relax/entry.py,sha256=8dfLORq2e2yeVj-E9v2ZqCZ-UGkDPB4XCByY6zCIdLs,16993 +bitblas/3rdparty/tvm/python/tvm/script/parser/relax/parser.py,sha256=VzIffjGOWxR_Vi_7sT4BfhnZ4kl4uZilZEAp1M6BJxY,15294 +bitblas/3rdparty/tvm/python/tvm/script/parser/tir/__init__.py,sha256=O-5MgLSEDfYoSz1jMq-GbALrqKaLLjH3GarRcRgb1Zk,1375 +bitblas/3rdparty/tvm/python/tvm/script/parser/tir/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/script/parser/tir/__pycache__/__init__.cpython-310.pyc,sha256=iwVwvCG6T8nZx1WNAjWECKsdcORBrw0HT8haF3xk1f0,581 +bitblas/3rdparty/tvm/python/tvm/script/parser/tir/__pycache__/__init__.cpython-38.pyc,sha256=eSHwbTp_cL-opaCoY0trhFRqhIqB4RDkRgBnTz1YWrI,572 +bitblas/3rdparty/tvm/python/tvm/script/parser/tir/__pycache__/entry.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/script/parser/tir/__pycache__/entry.cpython-310.pyc,sha256=UkE1cFz-aWHWc4H05NzBBtthuldjZO5_Db3sUKVNYOg,5834 +bitblas/3rdparty/tvm/python/tvm/script/parser/tir/__pycache__/entry.cpython-38.pyc,sha256=q-4xWFToQt_Cfry3D9b9xQw7WqfNueh3Vw_HGM3CPJA,5809 +bitblas/3rdparty/tvm/python/tvm/script/parser/tir/__pycache__/operation.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/script/parser/tir/__pycache__/operation.cpython-310.pyc,sha256=xlqF1IF55qb03vY89zWSEs9_3LwxYbkYpdzPZZTOYd8,3745 +bitblas/3rdparty/tvm/python/tvm/script/parser/tir/__pycache__/operation.cpython-38.pyc,sha256=q6nlHvFuHDaHlP1rcT-h9j_GQY-IBMnNh0S1in_ALBQ,3862 +bitblas/3rdparty/tvm/python/tvm/script/parser/tir/__pycache__/parser.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/script/parser/tir/__pycache__/parser.cpython-310.pyc,sha256=omwWlVeVR5u6rLe3UcHfT3qsTwfGa00PFWu_xpnk34E,14053 +bitblas/3rdparty/tvm/python/tvm/script/parser/tir/__pycache__/parser.cpython-38.pyc,sha256=EiJYz2ASeslMGbyFmTvFR-nkACrxsrZaCwdcQ3uo2vw,13519 +bitblas/3rdparty/tvm/python/tvm/script/parser/tir/entry.py,sha256=4ALzsLclHW2JD5Cqc1NbTbJaAImt2Ys8NJXfhrEYf4M,7104 +bitblas/3rdparty/tvm/python/tvm/script/parser/tir/operation.py,sha256=_YFJVjVogb1zANSJ3ggFif1RsfwtjtCyccjTip4HWZ0,5588 +bitblas/3rdparty/tvm/python/tvm/script/parser/tir/parser.py,sha256=lErFLYRTor0bnjJwWSzF8wL8qBzwOzohP2zdthnmSqU,18368 +bitblas/3rdparty/tvm/python/tvm/script/printer/__init__.py,sha256=gz1bo4bItAfJZwfB0IU_rv2tK2hKvkd5oiw1K0_eTow,921 +bitblas/3rdparty/tvm/python/tvm/script/printer/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/script/printer/__pycache__/_ffi_api.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/script/printer/__pycache__/doc.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/script/printer/__pycache__/doc_printer.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/script/printer/_ffi_api.py,sha256=_4A1jcBG0i7OptSnJkobwlwGLFjM5ay2a59HI9Z3bDQ,923 +bitblas/3rdparty/tvm/python/tvm/script/printer/doc.py,sha256=EfnvfVcsSV3hwFe3MVKwRHupZ6Jk7Xem4XStD-Hvqq8,16534 +bitblas/3rdparty/tvm/python/tvm/script/printer/doc_printer.py,sha256=py5ol5r1A7Tc4kd5JcX4V7afuZqBvt7KPBRZP4H-6ao,2086 +bitblas/3rdparty/tvm/python/tvm/script/relax.py,sha256=cJ6orGOfcWv9MEVfT1gABJxNq6b8hzss5T8m0-eoQq8,943 +bitblas/3rdparty/tvm/python/tvm/script/tir.py,sha256=DMUxOyIV-jvYrhwtkNJyxu95H-aBtbxD-1QKUYTMKHg,939 +bitblas/3rdparty/tvm/python/tvm/support.py,sha256=0Rh_b6fCnrwK3g-PbdRXQT1tCm1O99CWUunewQjrxew,3022 +bitblas/3rdparty/tvm/python/tvm/target/__init__.py,sha256=tNlRhEyBMHBYQ6xV4_xZrApbett-ifP91fN8iNRczKw,2652 +bitblas/3rdparty/tvm/python/tvm/target/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/target/__pycache__/__init__.cpython-310.pyc,sha256=Q_OD9mDmwgDMIYYsHxLShLCoxyjHiwwSDoe09jfdiYM,2169 +bitblas/3rdparty/tvm/python/tvm/target/__pycache__/__init__.cpython-38.pyc,sha256=RGRW7aAaiqELJfb-uFvBSjhrbWuUvupVnmYnbZvTUao,2156 +bitblas/3rdparty/tvm/python/tvm/target/__pycache__/_ffi_api.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/target/__pycache__/_ffi_api.cpython-310.pyc,sha256=sQ8ocAg8P_4S1prhnDKFkIc2ogkdMbp1NIHvLzNzlgA,276 +bitblas/3rdparty/tvm/python/tvm/target/__pycache__/_ffi_api.cpython-38.pyc,sha256=FtLOIehbFUNlZ5u89ahhjhQMXhIzSuI_q31IuY5kAec,263 +bitblas/3rdparty/tvm/python/tvm/target/__pycache__/codegen.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/target/__pycache__/codegen.cpython-310.pyc,sha256=G9cd2iMUvsLesPvsBnpMYSFD8i6Cvx_1ExJUxA_3ksU,4979 +bitblas/3rdparty/tvm/python/tvm/target/__pycache__/codegen.cpython-38.pyc,sha256=kwqO3OYTdbLJQbnmn34XlYP58pQs6E0D9ysDjVDlfr0,5168 +bitblas/3rdparty/tvm/python/tvm/target/__pycache__/compilation_config.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/target/__pycache__/compilation_config.cpython-310.pyc,sha256=NZb-zisQKu_35IR9dKASsIl-rd7SV0d5M5q2Hit2fSg,734 +bitblas/3rdparty/tvm/python/tvm/target/__pycache__/compilation_config.cpython-38.pyc,sha256=zQbzsma-WUPkGqBmATH9iG-oietr_xdE06BNQk-AfU8,721 +bitblas/3rdparty/tvm/python/tvm/target/__pycache__/datatype.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/target/__pycache__/datatype.cpython-310.pyc,sha256=G9IyrXIcqvLXdm2n1RTC7Q-j3YBTPV4wLgZGTJ7cUpw,11370 +bitblas/3rdparty/tvm/python/tvm/target/__pycache__/datatype.cpython-38.pyc,sha256=owNjrkXuRhYZlr0YX-_--I9oXjbbvE3DZl6XeALutzU,11414 +bitblas/3rdparty/tvm/python/tvm/target/__pycache__/detect_target.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/target/__pycache__/generic_func.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/target/__pycache__/generic_func.cpython-310.pyc,sha256=RgdQhpIPbobH34TEq28EUqfquvhMODbh4fZfrP9DgQw,8638 +bitblas/3rdparty/tvm/python/tvm/target/__pycache__/generic_func.cpython-38.pyc,sha256=ouf68-vH2hlUMElWK9NB3MmJPVHJWoRDmBBlq_SDk3Y,8616 +bitblas/3rdparty/tvm/python/tvm/target/__pycache__/intrin.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/target/__pycache__/tag.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/target/__pycache__/tag.cpython-310.pyc,sha256=Ct56mToeDgmkwqhGU53cAcYu-Cb41pB8ohLeQv9zGTY,1873 +bitblas/3rdparty/tvm/python/tvm/target/__pycache__/tag.cpython-38.pyc,sha256=1zTd9Xk6_IN4h_0JbIFNbbgR4bj9bCPx1ihK1OOxVgg,1863 +bitblas/3rdparty/tvm/python/tvm/target/__pycache__/target.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/target/__pycache__/target.cpython-310.pyc,sha256=z8tQGG9e6FKEuGiBDPDGoXkO2wHTeZWgjFXYzNh7Vls,28210 +bitblas/3rdparty/tvm/python/tvm/target/__pycache__/target.cpython-38.pyc,sha256=quPOiTZnxd-aB-g196IphvpIH3WSsNDXSr4LbgpfaxU,28504 +bitblas/3rdparty/tvm/python/tvm/target/__pycache__/virtual_device.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/target/__pycache__/virtual_device.cpython-310.pyc,sha256=l3Ziho6w4FTSIZ7RCWGbqzff2NeE_BiYKawEMBIiLus,1147 +bitblas/3rdparty/tvm/python/tvm/target/__pycache__/virtual_device.cpython-38.pyc,sha256=LIKdxfC6OOPQwNkUIMDIYRAfWLshFZWQ2RdJfGNgpso,1136 +bitblas/3rdparty/tvm/python/tvm/target/__pycache__/x86.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/target/__pycache__/x86.cpython-310.pyc,sha256=6oLcrEiNC5Q1-gnWAW5Dugv5C7A3_Aiv5e8NBIYdt2c,748 +bitblas/3rdparty/tvm/python/tvm/target/__pycache__/x86.cpython-38.pyc,sha256=lLJ_f09oDhZb278-fMFVGlCMN-ftIqqnnzG5dhUB8jY,731 +bitblas/3rdparty/tvm/python/tvm/target/_ffi_api.py,sha256=p15KInVkLBDoinG_LVsWa3so8EXQBf9qUCCWugPMv4E,872 +bitblas/3rdparty/tvm/python/tvm/target/codegen.py,sha256=qU8jmY6ZjbimdxrEeZCwhf2ClfpEAFryhzv_2SQv5Bo,5612 +bitblas/3rdparty/tvm/python/tvm/target/compilation_config.py,sha256=x43KaDbMzIhWLN2iOXTJs69oPbhHVVH-hv2JMXVFj6o,1281 +bitblas/3rdparty/tvm/python/tvm/target/datatype.py,sha256=tN0buQL-WTJn_gxEopBY81q396N6YzpNZdjlysHw9Hk,12348 +bitblas/3rdparty/tvm/python/tvm/target/detect_target.py,sha256=SGiCZSTNp-zbQA2fh64wkrAXQG6zoS2YAlBn7KQ_3Jk,4771 +bitblas/3rdparty/tvm/python/tvm/target/generic_func.py,sha256=yLJALCaaLdQGSWl-kV1FFwT1EY5Z3ydjWip78dYyBVo,8938 +bitblas/3rdparty/tvm/python/tvm/target/intrin.py,sha256=JErRtvy8ZeWNUxlbp4TMNwTEcWiwnduF5dBUK6A2sig,2551 +bitblas/3rdparty/tvm/python/tvm/target/tag.py,sha256=t0VLTaonPi-FNqmG93NraYw0_eo9o9fwrtqKvNBm42Y,2661 +bitblas/3rdparty/tvm/python/tvm/target/target.py,sha256=WPdc6bcufzsdILVMpXOF1N71mTFqTJ9-k8e104KycO0,32889 +bitblas/3rdparty/tvm/python/tvm/target/virtual_device.py,sha256=wSMHA45sjLTDUiXJkb2qfCLbJ8gCMGR_FZHWojs5FTE,1542 +bitblas/3rdparty/tvm/python/tvm/target/x86.py,sha256=oCbKzmP_Avs96vyAXT1Gy0aKMExdoYcCZeczGhpBNP8,1349 +bitblas/3rdparty/tvm/python/tvm/te/__init__.py,sha256=dLRdQ4OiTyoBi7s-F54tQ0k41udI2rNyZPlPUDf9MVg,2075 +bitblas/3rdparty/tvm/python/tvm/te/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/te/__pycache__/__init__.cpython-310.pyc,sha256=IhBZYq5xwv-D1rH5D1EO0D1bA9fCDFu0ocF-MVNrz9U,1965 +bitblas/3rdparty/tvm/python/tvm/te/__pycache__/__init__.cpython-38.pyc,sha256=-WwYjfKF50mW1ylc4YkT-h0Laqb3TntAPDv25x-MneM,1952 +bitblas/3rdparty/tvm/python/tvm/te/__pycache__/_ffi_api.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/te/__pycache__/_ffi_api.cpython-310.pyc,sha256=XeDdmdbayu_ULRdx-5renbWDOwpFdPhJFCSEUHvi6FE,264 +bitblas/3rdparty/tvm/python/tvm/te/__pycache__/_ffi_api.cpython-38.pyc,sha256=z39NKp5PWjUDXOSTVGug7jpc35_hlMY7z08_PoAWsHs,251 +bitblas/3rdparty/tvm/python/tvm/te/__pycache__/autodiff.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/te/__pycache__/autodiff.cpython-310.pyc,sha256=fLOrIXfJ9LTbrjcmWNSCT6qi0reeX6Z3lY6fw8KrDDw,1718 +bitblas/3rdparty/tvm/python/tvm/te/__pycache__/autodiff.cpython-38.pyc,sha256=QSjaHw2I4urkqY4pL1GcxkVTAU_rJpwf4ZEQ8vwFnfM,1705 +bitblas/3rdparty/tvm/python/tvm/te/__pycache__/operation.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/te/__pycache__/operation.cpython-310.pyc,sha256=Luxa2e79Fzc6iaPleRY0UiJm90VsyEThBW9OzZtHXoo,17675 +bitblas/3rdparty/tvm/python/tvm/te/__pycache__/operation.cpython-38.pyc,sha256=h9HuiHFoUFchCqYKjtNcUIk62q5EH01mlgWd6GEPgFs,17829 +bitblas/3rdparty/tvm/python/tvm/te/__pycache__/schedule.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/te/__pycache__/schedule.cpython-310.pyc,sha256=bgzz-zzeAImmTW-cJGc6TA1NAXh7hinUXpCF7_1w34Q,22258 +bitblas/3rdparty/tvm/python/tvm/te/__pycache__/schedule.cpython-38.pyc,sha256=fL-qXuaDWvgGskR1igsY3gfs-xdG8vNmiLMomN_9pV0,22457 +bitblas/3rdparty/tvm/python/tvm/te/__pycache__/tag.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/te/__pycache__/tag.cpython-310.pyc,sha256=G_NsK1l3iXm5YcFvuDHQKvVtx79FaKdkS2TgJcKarQs,2709 +bitblas/3rdparty/tvm/python/tvm/te/__pycache__/tag.cpython-38.pyc,sha256=tFEY3BBiSE6gZlC9Q5-tO2f2sLKiBwEYWlkRLXQmWYc,2692 +bitblas/3rdparty/tvm/python/tvm/te/__pycache__/tensor.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/te/__pycache__/tensor.cpython-310.pyc,sha256=DLAjQfJZ2JraX7PB4qgK4WMKyTtskrBqmRBXdeVaSHU,6714 +bitblas/3rdparty/tvm/python/tvm/te/__pycache__/tensor.cpython-38.pyc,sha256=oYS-Ox3EDlM0mspHZHXXbCBMmOUQ-Xblq8t5T6jL_q8,6909 +bitblas/3rdparty/tvm/python/tvm/te/__pycache__/tensor_intrin.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/te/__pycache__/tensor_intrin.cpython-310.pyc,sha256=Uy__adI1QBdxuTa94GwfFVh6FOFWSVNBGOJ-_Z-qnFk,4602 +bitblas/3rdparty/tvm/python/tvm/te/__pycache__/tensor_intrin.cpython-38.pyc,sha256=eszhRjAxfAPF3Sk_5VozayxBorvsSZ4KEQiB3hZF-U8,4617 +bitblas/3rdparty/tvm/python/tvm/te/_ffi_api.py,sha256=cyeapm7_9SkcyBaE4ODt73YcfcK_xkgc7qh7cPU_RmE,864 +bitblas/3rdparty/tvm/python/tvm/te/autodiff.py,sha256=hyxcxIvmHJWt-EzMC3-riQyCXFTVnmNzuDdGqmnScL8,2305 +bitblas/3rdparty/tvm/python/tvm/te/hybrid/__init__.py,sha256=eUu4E5nQKg6jX-SFw6pUOfS3qoSp5pTLMkn59uUgEek,3330 +bitblas/3rdparty/tvm/python/tvm/te/hybrid/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/te/hybrid/__pycache__/__init__.cpython-310.pyc,sha256=2JDvt66V2-YPfEm0aQRcuLLI8MHXrUGajiQzJw9aBdU,2578 +bitblas/3rdparty/tvm/python/tvm/te/hybrid/__pycache__/__init__.cpython-38.pyc,sha256=N5usdcp5thX5eKtFeNgBh7p4E69oeBkQd8nzh9ktON0,2561 +bitblas/3rdparty/tvm/python/tvm/te/hybrid/__pycache__/calls.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/te/hybrid/__pycache__/calls.cpython-310.pyc,sha256=BqO0sTFKgZVcKsDQmITFfyQ8IOjM99cc-ScEIfYqMK8,5234 +bitblas/3rdparty/tvm/python/tvm/te/hybrid/__pycache__/calls.cpython-38.pyc,sha256=em5TmwGQ1yvAGpY_PpRxo2lTM4KkcXkCDMJI8fN2YIc,5276 +bitblas/3rdparty/tvm/python/tvm/te/hybrid/__pycache__/module.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/te/hybrid/__pycache__/module.cpython-310.pyc,sha256=ns7ldJVdgLePMqYh94RP8B-sTq7tQ2Uy0H623Owab24,3621 +bitblas/3rdparty/tvm/python/tvm/te/hybrid/__pycache__/module.cpython-38.pyc,sha256=M8Vra3e4rDBiXd1SbJaFZwY5FCAEVLWHu5kccLgsVgQ,3546 +bitblas/3rdparty/tvm/python/tvm/te/hybrid/__pycache__/parser.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/te/hybrid/__pycache__/parser.cpython-310.pyc,sha256=4eXZwVaVWjVf6Qirn3Sr1-6yE3e7fAZ-B_Q8giFTQSk,20868 +bitblas/3rdparty/tvm/python/tvm/te/hybrid/__pycache__/parser.cpython-38.pyc,sha256=VZTHcoTRpkGbHssuaquhA5CnvNR0BhWMwzPTK3pl4PQ,20937 +bitblas/3rdparty/tvm/python/tvm/te/hybrid/__pycache__/preprocessor.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/te/hybrid/__pycache__/preprocessor.cpython-310.pyc,sha256=iIe8w0nt_dmbPYJzsYs17dDcgy6OnE_67OdacPrMGpI,3670 +bitblas/3rdparty/tvm/python/tvm/te/hybrid/__pycache__/preprocessor.cpython-38.pyc,sha256=YjrFFSuIA6QkXlAfKFvt52Xtvp04m9JzQsTA_N-iEuA,3665 +bitblas/3rdparty/tvm/python/tvm/te/hybrid/__pycache__/runtime.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/te/hybrid/__pycache__/runtime.cpython-310.pyc,sha256=a3kP278lAS5q97XrMQMd5S-BcLJk1tanJpctNAp9YIs,4200 +bitblas/3rdparty/tvm/python/tvm/te/hybrid/__pycache__/runtime.cpython-38.pyc,sha256=XZJNgcTYL8P4ZqbUh3Ts39Y-m-vpPHS2g_kelpD2_xM,4102 +bitblas/3rdparty/tvm/python/tvm/te/hybrid/__pycache__/utils.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/te/hybrid/__pycache__/utils.cpython-310.pyc,sha256=HmUjO4x9Is0EHQxYLU831yk8VmstKQx6QfFs4JcgrEE,3257 +bitblas/3rdparty/tvm/python/tvm/te/hybrid/__pycache__/utils.cpython-38.pyc,sha256=a0ztdCLMLxBi1c_YjiEXRh3SEYezgVNGMqoSqmk-t0U,3228 +bitblas/3rdparty/tvm/python/tvm/te/hybrid/calls.py,sha256=zsFaN5JMUsdeYSoLDCH8MFuhPgw-hFKiAV-a1TSO5es,6635 +bitblas/3rdparty/tvm/python/tvm/te/hybrid/module.py,sha256=PzbFlFZ1gBrCfqtZmgx7pDYj_XhblT5N4CKSdCIPgnQ,3857 +bitblas/3rdparty/tvm/python/tvm/te/hybrid/parser.py,sha256=ytIdtzU3-aE0sw7yyHWoFnNBgGqfC00A8GvcoTsjhfc,24126 +bitblas/3rdparty/tvm/python/tvm/te/hybrid/preprocessor.py,sha256=CPTAHebkkGAzDCtu2aYCNRwwmPbIvNrwcbaqm-juY_o,4746 +bitblas/3rdparty/tvm/python/tvm/te/hybrid/runtime.py,sha256=RSwThKNrQcwXADrGfexiIkP2Lf3-lWKsd_YLtIlT5yk,4235 +bitblas/3rdparty/tvm/python/tvm/te/hybrid/utils.py,sha256=icdyqS5o8Zf7eFl6utCKskpw3IF6ftzHUmhYmvx18yQ,3906 +bitblas/3rdparty/tvm/python/tvm/te/operation.py,sha256=PX926QTHBBY9h6-LwZawJyxSyeYuibGdnfziXVPpc50,19915 +bitblas/3rdparty/tvm/python/tvm/te/schedule.py,sha256=s-sCX52bJdzHtqUEY7QFr6H_qnPb53BYJcA6fvLExo0,21401 +bitblas/3rdparty/tvm/python/tvm/te/tag.py,sha256=B7NkhW8g1sLIt09ljHvEtFL4gqLjTmmuZmWWx7ln0mI,2857 +bitblas/3rdparty/tvm/python/tvm/te/tensor.py,sha256=vJlEU01NkGSlgLiJpMsOTaxVAP-hk_Ff0wWWmZZYT7g,5958 +bitblas/3rdparty/tvm/python/tvm/te/tensor_intrin.py,sha256=0oVyLs-B1tibEDmhvlss6TBSMgILVps6sGMaRzLTJhc,5302 +bitblas/3rdparty/tvm/python/tvm/testing/__init__.py,sha256=WqMwiyGjm-FGIGr4KJcOGjwAc6I31LBd5lD-Ff71-Rk,1429 +bitblas/3rdparty/tvm/python/tvm/testing/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/testing/__pycache__/__init__.cpython-310.pyc,sha256=IgnhQGqeF1CdzVSO9F1Ywmt2q-F-E5hGgwN7mia-FWI,892 +bitblas/3rdparty/tvm/python/tvm/testing/__pycache__/_ffi_api.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/testing/__pycache__/_ffi_api.cpython-310.pyc,sha256=ptLy2KaOAtKbKHtYMXjg96r40PCnVVifwFDvR5K5kmw,279 +bitblas/3rdparty/tvm/python/tvm/testing/__pycache__/aot.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/testing/__pycache__/auto_scheduler.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/testing/__pycache__/auto_scheduler.cpython-310.pyc,sha256=7CFY5zZ3e_V3RPVmq-LlGXFoxcY--MoSMj7zpGQqWzU,9004 +bitblas/3rdparty/tvm/python/tvm/testing/__pycache__/autotvm.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/testing/__pycache__/autotvm.cpython-310.pyc,sha256=EvQTHd2Kf7nmPPGu7kKiiGZCvG3P-8aThNt5JZT6BO0,3498 +bitblas/3rdparty/tvm/python/tvm/testing/__pycache__/plugin.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/testing/__pycache__/popen_pool.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/testing/__pycache__/popen_pool.cpython-310.pyc,sha256=QT21CV3Yyc3Va3FM-3CvYSk667_CIu_yjZglBNMf5m4,1992 +bitblas/3rdparty/tvm/python/tvm/testing/__pycache__/runner.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/testing/__pycache__/runner.cpython-310.pyc,sha256=2MNw939IpUKQiaP8fpr1_YzXYhWKDgvMnAeAya27_s0,6764 +bitblas/3rdparty/tvm/python/tvm/testing/__pycache__/tir.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/testing/__pycache__/usmp.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/testing/__pycache__/utils.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/testing/__pycache__/utils.cpython-310.pyc,sha256=tPn4d53ng9bUyaTxmlxXl_8Gvi-aBEdfNr_zz-QwvqM,63521 +bitblas/3rdparty/tvm/python/tvm/testing/_ffi_api.py,sha256=WX22JMTecwol_kb2xRD6NhefeNoyhQfhVyn4o6YKa9s,874 +bitblas/3rdparty/tvm/python/tvm/testing/aot.py,sha256=O64UfNL_lP0TkkhnS-eBm-SHQWXhKNIctEHtzlDRZh4,39693 +bitblas/3rdparty/tvm/python/tvm/testing/auto_scheduler.py,sha256=3qFIXA8mjIM83rUcGprauZ364Rr__ilTxG2b9IsnVDg,9066 +bitblas/3rdparty/tvm/python/tvm/testing/autotvm.py,sha256=xx4Fhjz-XD5Y-bK174n1uyXIKgqMT3LomWwcGPwXMQE,3762 +bitblas/3rdparty/tvm/python/tvm/testing/plugin.py,sha256=WVP7_A5PzA57ESJIuqoG6LXeB5dqpMm35YRITYfhIzU,13989 +bitblas/3rdparty/tvm/python/tvm/testing/popen_pool.py,sha256=kS_pIZRCTudNnAzOoXwu_gFNUsl1Z7P9Ej_Yl66BZ3A,2170 +bitblas/3rdparty/tvm/python/tvm/testing/runner.py,sha256=Tcd_Wcv_BnkR78k31chrZVGOJlEwrl-8abMT3tqcj7M,8859 +bitblas/3rdparty/tvm/python/tvm/testing/tir.py,sha256=sd1UXgZZpBdbjbwdwgfY-0JLnEUxyvo5XgpkBHn6Mws,7909 +bitblas/3rdparty/tvm/python/tvm/testing/usmp.py,sha256=8DiGhvmQcaIBN38KcjSjFjySeUaJG8qFGc-TJ8WrP3U,1531 +bitblas/3rdparty/tvm/python/tvm/testing/utils.py,sha256=QJToSqIhIBe-_WJ4whCvI2rP3A9p12lkLuQcLR3rLqs,71687 +bitblas/3rdparty/tvm/python/tvm/tir/__init__.py,sha256=XuGpm0oqCtO6DMAk1lTmpk-VjiKssnIs4utzeoPNZZg,4268 +bitblas/3rdparty/tvm/python/tvm/tir/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/tir/__pycache__/__init__.cpython-310.pyc,sha256=bFi-mMrlaUxK6EdBlSFaJqRF5n79hjKvQhPukotH9Ww,5339 +bitblas/3rdparty/tvm/python/tvm/tir/__pycache__/__init__.cpython-38.pyc,sha256=6PU9kc__IY6Pz1MpHjZhK8XKeUkHXrr7J4hRm4Vempo,5326 +bitblas/3rdparty/tvm/python/tvm/tir/__pycache__/_ffi_api.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/tir/__pycache__/_ffi_api.cpython-310.pyc,sha256=YzH1WU1y4TA6U4RyhVGuSq0QM4KSqdKSW5aZO1yJDsg,267 +bitblas/3rdparty/tvm/python/tvm/tir/__pycache__/_ffi_api.cpython-38.pyc,sha256=RFD5a7F1EAHQiBomsXwH74deXb9WCjTlUi0-xMW0_zQ,254 +bitblas/3rdparty/tvm/python/tvm/tir/__pycache__/block_dependence_info.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/tir/__pycache__/block_dependence_info.cpython-310.pyc,sha256=vYutkK4psdtcTZ_AkM3cgVC7jahhSXBnrRFGfaVq3Bw,2830 +bitblas/3rdparty/tvm/python/tvm/tir/__pycache__/block_dependence_info.cpython-38.pyc,sha256=Y3xIsgw3u5-xadPuWUiUBGnMJFlWh9sfFwuoCeR-Ch8,2841 +bitblas/3rdparty/tvm/python/tvm/tir/__pycache__/block_scope.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/tir/__pycache__/block_scope.cpython-310.pyc,sha256=wIFFMutV317_A05bTloA972qkUQqidU_oWEo5UJTSnQ,5130 +bitblas/3rdparty/tvm/python/tvm/tir/__pycache__/block_scope.cpython-38.pyc,sha256=2FX2oAPi1T0qBC3KIfPfWNC5P56lfjsroLSDS_5bC18,5141 +bitblas/3rdparty/tvm/python/tvm/tir/__pycache__/buffer.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/tir/__pycache__/buffer.cpython-310.pyc,sha256=qWM4tW4MiVNzN2Y7S_LaHnoj-N4gWxeqziCWhvfbuBk,11438 +bitblas/3rdparty/tvm/python/tvm/tir/__pycache__/buffer.cpython-38.pyc,sha256=mDEtNtmcMlCSjlGHJtztAJr3xmXW_fe6N4qDfdcWeUI,11443 +bitblas/3rdparty/tvm/python/tvm/tir/__pycache__/data_layout.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/tir/__pycache__/data_layout.cpython-310.pyc,sha256=tRzaPaxWBVUb3IGvaOLn77XRwWYett1yXbLz1WFPMEk,6444 +bitblas/3rdparty/tvm/python/tvm/tir/__pycache__/data_layout.cpython-38.pyc,sha256=skj_4OTrcdo_XNIopN5v7UbHa6XLORJ4OBHvbOTvzVM,6502 +bitblas/3rdparty/tvm/python/tvm/tir/__pycache__/expr.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/tir/__pycache__/expr.cpython-310.pyc,sha256=gUpdykNpItGFSXCxfD2yooTYLbZP195a0F3J6L4rhyo,36188 +bitblas/3rdparty/tvm/python/tvm/tir/__pycache__/expr.cpython-38.pyc,sha256=ORkDtcb4XC_kAa0CycRwfMNbHKlsNJTs6zh70nZLWdg,38061 +bitblas/3rdparty/tvm/python/tvm/tir/__pycache__/function.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/tir/__pycache__/function.cpython-310.pyc,sha256=Y9piRoZyT7cOB3hh3qpiqiZUytWvVXZf6zSVQyyCt-A,17189 +bitblas/3rdparty/tvm/python/tvm/tir/__pycache__/function.cpython-38.pyc,sha256=O4VRD556EOlDPrcIL4lgbbwoTfu3Gl9xxZeZJvHjUNI,17269 +bitblas/3rdparty/tvm/python/tvm/tir/__pycache__/generic.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/tir/__pycache__/generic.cpython-310.pyc,sha256=fptgn9A0VYtiU5PBFGwu43m26GOOteN7BjbnCyVBYxo,2989 +bitblas/3rdparty/tvm/python/tvm/tir/__pycache__/generic.cpython-38.pyc,sha256=Ms9rsycjS4Yg534vAy35sBbmYO6FaVgT0M6ffirv4qw,3055 +bitblas/3rdparty/tvm/python/tvm/tir/__pycache__/ir_builder.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/tir/__pycache__/ir_builder.cpython-310.pyc,sha256=o8P9zvpQ0o1fAIA_u499VYhFnc5l0GbLx8wogQLSkDI,15699 +bitblas/3rdparty/tvm/python/tvm/tir/__pycache__/ir_builder.cpython-38.pyc,sha256=Igs-HsTfNPmv6-vGAZer7QgulxYIOFw71XPSIoeRjC4,15747 +bitblas/3rdparty/tvm/python/tvm/tir/__pycache__/op.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/tir/__pycache__/op.cpython-310.pyc,sha256=BmmnHrv9lEHrvOWiiiOsw15uCONWri_2oR2QegVkimU,73010 +bitblas/3rdparty/tvm/python/tvm/tir/__pycache__/op.cpython-38.pyc,sha256=wEJMV5nUnrbT9EoloIayj8q6NYveP9ztsaO8KCvmrEU,75667 +bitblas/3rdparty/tvm/python/tvm/tir/__pycache__/stmt.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/tir/__pycache__/stmt.cpython-310.pyc,sha256=eTs3I7OPFFCUppQ7K9jGTLsE5neKlCV_d2wq_5SHg_8,20989 +bitblas/3rdparty/tvm/python/tvm/tir/__pycache__/stmt.cpython-38.pyc,sha256=Kqi-2nBIWamFCPLijfForACNZV-FxgeVyk6VbVKnjiI,21661 +bitblas/3rdparty/tvm/python/tvm/tir/__pycache__/stmt_functor.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/tir/__pycache__/stmt_functor.cpython-310.pyc,sha256=9M8EpPxkEMnUFGY4gX2v45-Y8N-qSswLdz4YMoleQok,2778 +bitblas/3rdparty/tvm/python/tvm/tir/__pycache__/stmt_functor.cpython-38.pyc,sha256=8bC9oKA_zeUnL9ZSRw6ikJjtc5GrWB7MjDwVuaO0DLk,2791 +bitblas/3rdparty/tvm/python/tvm/tir/_ffi_api.py,sha256=KZB_tz_B5O8mb99VHc3_5m1eIFtEbtXR-l1d-CbwWZ0,866 +bitblas/3rdparty/tvm/python/tvm/tir/analysis/__init__.py,sha256=2e63Lqvzsd9gf_kk0ReqqoW09bDQHisRkTLISJqCVTE,901 +bitblas/3rdparty/tvm/python/tvm/tir/analysis/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/tir/analysis/__pycache__/__init__.cpython-310.pyc,sha256=POBnqP1dSRBUlsPKWuC6u6Pi3KGfbWd_1CtGSaTOpdQ,244 +bitblas/3rdparty/tvm/python/tvm/tir/analysis/__pycache__/__init__.cpython-38.pyc,sha256=KwzXkzUZjRE9BPzYKpk7S_GKZ_cgCTfl4hPr8-03ZZc,231 +bitblas/3rdparty/tvm/python/tvm/tir/analysis/__pycache__/_ffi_api.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/tir/analysis/__pycache__/_ffi_api.cpython-310.pyc,sha256=gsbccfvK0pUlxX_Ejba0fiNbhxS04l4LpLnIwSMEjhw,294 +bitblas/3rdparty/tvm/python/tvm/tir/analysis/__pycache__/_ffi_api.cpython-38.pyc,sha256=0s8-0OYlEsrXwRMA5lMQntG3Wsez3jwj1vE-wGdZCXo,281 +bitblas/3rdparty/tvm/python/tvm/tir/analysis/__pycache__/analysis.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/tir/analysis/__pycache__/analysis.cpython-310.pyc,sha256=ZZWwZqTRK87I1k4paNfi7S3jrkb-JN07ZkhoV9Tw-J0,12837 +bitblas/3rdparty/tvm/python/tvm/tir/analysis/__pycache__/analysis.cpython-38.pyc,sha256=83w4-aM-0BHkOs-NkJI6zu9XNI_-6AwqBRy41cBq51c,13019 +bitblas/3rdparty/tvm/python/tvm/tir/analysis/_ffi_api.py,sha256=RgGvnR_K3ad2QqhF7h-m0Ni2Waxs-AqadGrYn875e70,884 +bitblas/3rdparty/tvm/python/tvm/tir/analysis/analysis.py,sha256=DwMZiyav4ZomTNjF14FNs0VBbvAO1Lzz9x8SpY4aKLs,13693 +bitblas/3rdparty/tvm/python/tvm/tir/block_dependence_info.py,sha256=o2rWfouwpLajEPiI77bN9PmZ6gYy9uehrOCe3sjwId8,3215 +bitblas/3rdparty/tvm/python/tvm/tir/block_scope.py,sha256=gw66a0EDGjZkZVsFDKPZ0JcciwgBix-cu_pFALMYBuw,5125 +bitblas/3rdparty/tvm/python/tvm/tir/buffer.py,sha256=-IL8FokCliVGBQTun2xzoYQm4X6BRVQcd1QXSyOviG0,13322 +bitblas/3rdparty/tvm/python/tvm/tir/data_layout.py,sha256=c2NcQsOASVYhgNZLSeYD6NSwQ_LdAjYBLIFKFSUe34U,6463 +bitblas/3rdparty/tvm/python/tvm/tir/expr.py,sha256=BD2uihYDSoij47pdJvnm0Fo1u8sQSD7mEmxuszBG0i0,34027 +bitblas/3rdparty/tvm/python/tvm/tir/function.py,sha256=VdOBH5y87J496ZxqxSyWmDU9NOuc3zXb1DOo9hyYfgw,19327 +bitblas/3rdparty/tvm/python/tvm/tir/generic.py,sha256=UY_P-22FTnNKVJrv2U59WE0e9L8dWV15fSEL3hlXfjw,3576 +bitblas/3rdparty/tvm/python/tvm/tir/ir_builder.py,sha256=qH9mjjxEaS5aBe7Gs3mHZYDjHhOPNEP6V-L5aZiyQHM,15154 +bitblas/3rdparty/tvm/python/tvm/tir/op.py,sha256=gOon42mxQlyDMS_TD3U0zyrfSpIC3a7EsumSRyIITts,78555 +bitblas/3rdparty/tvm/python/tvm/tir/schedule/__init__.py,sha256=Qr8Gi3cM1C7-igaw9nsadW8gDV1CxHqrrk8b1FGdbJw,1183 +bitblas/3rdparty/tvm/python/tvm/tir/schedule/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/tir/schedule/__pycache__/__init__.cpython-310.pyc,sha256=Cig58I1nDTApWIzSuv-esPCgS26VXAFxD0lpTPLw-r0,693 +bitblas/3rdparty/tvm/python/tvm/tir/schedule/__pycache__/__init__.cpython-38.pyc,sha256=VL8yrfo_ijJ-ZEmuuK2iQsLKLHO22gPY8Ta0LY4WftU,680 +bitblas/3rdparty/tvm/python/tvm/tir/schedule/__pycache__/_ffi_api.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/tir/schedule/__pycache__/_ffi_api.cpython-310.pyc,sha256=fW50IX_tIsmX9gzf-Y4mJvUbP5ARberbaFE4j1NEMKU,294 +bitblas/3rdparty/tvm/python/tvm/tir/schedule/__pycache__/_ffi_api.cpython-38.pyc,sha256=wacB4qPs-REmGRkueB_2jTD4LInrBBJPwXAJ5asNghs,281 +bitblas/3rdparty/tvm/python/tvm/tir/schedule/__pycache__/_type_checker.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/tir/schedule/__pycache__/_type_checker.cpython-310.pyc,sha256=tFptCq5yoxPy2X4jC11NlxXcYt0OK94WcvF5fvIuelQ,10332 +bitblas/3rdparty/tvm/python/tvm/tir/schedule/__pycache__/_type_checker.cpython-38.pyc,sha256=MGyuqHS3ZOvRuSuGx5VEAOL1Ql53mzsOyFSmuEHp6DQ,10368 +bitblas/3rdparty/tvm/python/tvm/tir/schedule/__pycache__/analysis.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/tir/schedule/__pycache__/analysis.cpython-310.pyc,sha256=CnIPXZr21sJJAHeYlHu0IScebUXdyLSfYGDzZywhzTc,4746 +bitblas/3rdparty/tvm/python/tvm/tir/schedule/__pycache__/analysis.cpython-38.pyc,sha256=PrTVJi7JLghaHbsxiMhh-p9B2885C8E3dcWhvaFBYtE,4779 +bitblas/3rdparty/tvm/python/tvm/tir/schedule/__pycache__/instruction.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/tir/schedule/__pycache__/instruction.cpython-310.pyc,sha256=F5lU_O4DksFDsabtSWTyL0X0i4u-wSsJZ2V7SnCtjBg,5364 +bitblas/3rdparty/tvm/python/tvm/tir/schedule/__pycache__/instruction.cpython-38.pyc,sha256=eBErU-5keLLqgKBSjzjgM84LBVciAp4pCmZfLUtBVlM,5363 +bitblas/3rdparty/tvm/python/tvm/tir/schedule/__pycache__/schedule.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/tir/schedule/__pycache__/schedule.cpython-310.pyc,sha256=8G9WWc6A9B8dP0O7ybpK17X13bf4cQ0z17-ZWaTWzmY,137433 +bitblas/3rdparty/tvm/python/tvm/tir/schedule/__pycache__/schedule.cpython-38.pyc,sha256=6rpLfzwSbW98RoBA3fRbQewAKC_zvreBdUP9RqbIbT0,138557 +bitblas/3rdparty/tvm/python/tvm/tir/schedule/__pycache__/state.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/tir/schedule/__pycache__/state.cpython-310.pyc,sha256=1fEzJx5-BPlJWdFVmS_foGwGArtJPAAshUCYwAGEZT8,8025 +bitblas/3rdparty/tvm/python/tvm/tir/schedule/__pycache__/state.cpython-38.pyc,sha256=RijiA-MrZkhgYteGw7fXbnVakmojze9c5bSgUEVjQgI,8053 +bitblas/3rdparty/tvm/python/tvm/tir/schedule/__pycache__/testing.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/tir/schedule/__pycache__/trace.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/tir/schedule/__pycache__/trace.cpython-310.pyc,sha256=61LcAuNJP243fWIF8vSiYZFC8a8Yz8gMw1PItWdQMMw,9019 +bitblas/3rdparty/tvm/python/tvm/tir/schedule/__pycache__/trace.cpython-38.pyc,sha256=hYfOfMB-N3zhDcdnt_CILBwUOLvfkDvlQoeeSfUssl4,9082 +bitblas/3rdparty/tvm/python/tvm/tir/schedule/__pycache__/transform.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/tir/schedule/__pycache__/transform.cpython-310.pyc,sha256=5zV5ilLuaLxqzMWLNaZV0TUpCGr86BKFK4kRsUs_ICE,1321 +bitblas/3rdparty/tvm/python/tvm/tir/schedule/__pycache__/transform.cpython-38.pyc,sha256=XI11Mtad8OyrHJBklAx0jeUf81DL9qPa4lG_QnBOOck,1292 +bitblas/3rdparty/tvm/python/tvm/tir/schedule/_ffi_api.py,sha256=I8cQrPvrkSdI1_5lJ2rRW101c4oV-kWOxHPWJRy6a1I,919 +bitblas/3rdparty/tvm/python/tvm/tir/schedule/_type_checker.py,sha256=-QyhGxBc-cd0MBkeQUNvYr1yVFW037NolTKl1LEGgVE,12491 +bitblas/3rdparty/tvm/python/tvm/tir/schedule/analysis.py,sha256=DSiDZSYVVy-RKX1nwqQ5ESam0G0MFTUL4V5tu0yzvmQ,5029 +bitblas/3rdparty/tvm/python/tvm/tir/schedule/instruction.py,sha256=NA91bk73ZNYxNyZyE-M3R2uC-xm2M57ODkqQjciHcOA,5838 +bitblas/3rdparty/tvm/python/tvm/tir/schedule/schedule.py,sha256=9eiQtDPbY5H7Q4u_V3SQEKqXJowlAMBap6oNq2di_mc,148290 +bitblas/3rdparty/tvm/python/tvm/tir/schedule/state.py,sha256=2DXUFbFpc94Y0-svOEb5AastLhmX7C56SvzmbEWJWt4,8773 +bitblas/3rdparty/tvm/python/tvm/tir/schedule/testing.py,sha256=LGcyd3yQ2VCY3JapxPPIAviDalyBbtAGDEQCj6GGNzc,4049 +bitblas/3rdparty/tvm/python/tvm/tir/schedule/trace.py,sha256=aPwOXSiye_T61hEEXfYHCvbl2e4wrjL866MpoRV0tyw,9680 +bitblas/3rdparty/tvm/python/tvm/tir/schedule/transform.py,sha256=8bFzg5BoSsMZFCIxkw9WLtg31kWZme_bT5GEw8rGwXs,1828 +bitblas/3rdparty/tvm/python/tvm/tir/stmt.py,sha256=ktYMvhpyJjQNd0N7-y3eR66dUtiAWZjl7V5oaP-k_YA,21054 +bitblas/3rdparty/tvm/python/tvm/tir/stmt_functor.py,sha256=petyown-e5gEfPg6ADPKwIvFZGMdYITXiDCxQNk6lEw,3239 +bitblas/3rdparty/tvm/python/tvm/tir/tensor_intrin/__init__.py,sha256=zPUhYN-qOclErALnPWb9uRybwBTTGzLJFYC4i52MzGY,901 +bitblas/3rdparty/tvm/python/tvm/tir/tensor_intrin/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/tir/tensor_intrin/__pycache__/__init__.cpython-310.pyc,sha256=uqUU9o_B8WxR0bTNOVPhr9nUVF-zd8hsGllCuM_SpLo,311 +bitblas/3rdparty/tvm/python/tvm/tir/tensor_intrin/__pycache__/arm_cpu.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/tir/tensor_intrin/__pycache__/arm_cpu.cpython-310.pyc,sha256=5hBvNiNNytLJPgPGDa8W7dcV7FFRyQwYLHN6dHU62OQ,4372 +bitblas/3rdparty/tvm/python/tvm/tir/tensor_intrin/__pycache__/cuda.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/tir/tensor_intrin/__pycache__/cuda.cpython-310.pyc,sha256=betXm5W7goix99lb-3sUKpPHSRvJXhp4RplT4252xQo,50081 +bitblas/3rdparty/tvm/python/tvm/tir/tensor_intrin/__pycache__/dot_product_common.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/tir/tensor_intrin/__pycache__/dot_product_common.cpython-310.pyc,sha256=_5yxyGK4qxcJ8vQ3IB_VtvHOu_tLQYLGNfgDSFwLVbE,2085 +bitblas/3rdparty/tvm/python/tvm/tir/tensor_intrin/__pycache__/hexagon.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/tir/tensor_intrin/__pycache__/hexagon.cpython-310.pyc,sha256=81Bnz9UXDid0oEMhBg27eMFmgaec7Ml9IoFSeCkru0w,6773 +bitblas/3rdparty/tvm/python/tvm/tir/tensor_intrin/__pycache__/hip.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/tir/tensor_intrin/__pycache__/rocm.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/tir/tensor_intrin/__pycache__/rocm.cpython-310.pyc,sha256=1p2a14x8PbE0sdzueRNpXcK4y4ZUS68a_eZj7pCM9QE,12594 +bitblas/3rdparty/tvm/python/tvm/tir/tensor_intrin/__pycache__/x86.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/tir/tensor_intrin/__pycache__/x86.cpython-310.pyc,sha256=s56gunwHES4HOCK-Ib_nX77DRcfDw4j7WqsVyNdaCJQ,2670 +bitblas/3rdparty/tvm/python/tvm/tir/tensor_intrin/arm_cpu.py,sha256=ut8Z2d6VTQCxkghaVGqGNouf21f5sk_SLoY4ME2BzAY,6389 +bitblas/3rdparty/tvm/python/tvm/tir/tensor_intrin/cuda.py,sha256=Apdc_CokKmQLRsOy65vH0nGEoonYlsf7kvaebW825ls,77262 +bitblas/3rdparty/tvm/python/tvm/tir/tensor_intrin/dot_product_common.py,sha256=YCiOUmMlxX4azr2P16aZdkjhy08lG8ZfcpHM9xaNCo4,2956 +bitblas/3rdparty/tvm/python/tvm/tir/tensor_intrin/hexagon.py,sha256=jreTFmiE_bSqUIoJjX-Rjmgi-I1JRnvlQWPzBFHZ2UM,9555 +bitblas/3rdparty/tvm/python/tvm/tir/tensor_intrin/hip.py,sha256=4-jzVMdiKgsawpiDMQU-Qe3CZEx2Cvuc6wnaUGTcZBA,15700 +bitblas/3rdparty/tvm/python/tvm/tir/tensor_intrin/rocm.py,sha256=olVam_oPvQhbEG-dMm60Tjr8JIH27GeOe4SVJ7ij7Y4,17169 +bitblas/3rdparty/tvm/python/tvm/tir/tensor_intrin/x86.py,sha256=a1ywdH0o4jhCv9g0bPhD5Cv9PJI3NNvuYoe8kA6U7RA,3826 +bitblas/3rdparty/tvm/python/tvm/tir/transform/__init__.py,sha256=YtQt6oDEXTL0UuNekSfZiyhgUYNMzMEV_IXd7dBj6nI,958 +bitblas/3rdparty/tvm/python/tvm/tir/transform/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/tir/transform/__pycache__/__init__.cpython-310.pyc,sha256=hniH-qGI2tcvi61aRaSmXQiDy0ILgUq0wl7q28i5tng,321 +bitblas/3rdparty/tvm/python/tvm/tir/transform/__pycache__/__init__.cpython-38.pyc,sha256=WzKsEkBbn5tuCU0kIQOscXsdzfn29AUKgVqszYwTpDE,308 +bitblas/3rdparty/tvm/python/tvm/tir/transform/__pycache__/_ffi_api.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/tir/transform/__pycache__/_ffi_api.cpython-310.pyc,sha256=yJYScwNgI6zhJlU4kf_4lkoQ0SiFwZWt9BF6rtA8s7I,297 +bitblas/3rdparty/tvm/python/tvm/tir/transform/__pycache__/_ffi_api.cpython-38.pyc,sha256=4RxzQ6SYIOeDL7_PkzuUkq__wVzvJlHv0ANVnqx2oJw,284 +bitblas/3rdparty/tvm/python/tvm/tir/transform/__pycache__/function_pass.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/tir/transform/__pycache__/function_pass.cpython-310.pyc,sha256=WWzsBDUtvyLBxgw_djsAwVI9AfG3uT9dEm1LALYduTQ,5393 +bitblas/3rdparty/tvm/python/tvm/tir/transform/__pycache__/function_pass.cpython-38.pyc,sha256=J9_Hu5FWUNBxmYWtlWcT4hlLN-CCMA30r-WBPkZM5w4,5356 +bitblas/3rdparty/tvm/python/tvm/tir/transform/__pycache__/transform.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/tir/transform/__pycache__/transform.cpython-310.pyc,sha256=5zs_3OP_SCyCY3XtQ6ES2XHI4D2uQtXUiEmEKx9IJPE,31492 +bitblas/3rdparty/tvm/python/tvm/tir/transform/__pycache__/transform.cpython-38.pyc,sha256=KhpceEOZG4tFrSECedBNPV9BV5jPme1XyXllWuKOL5c,32198 +bitblas/3rdparty/tvm/python/tvm/tir/transform/_ffi_api.py,sha256=UdI_C4cWUtiraM4TptCj2fOjYZQylm5t2MhwZFjyLFM,886 +bitblas/3rdparty/tvm/python/tvm/tir/transform/function_pass.py,sha256=HoWdnDAkjju5hyczR79hobVAPDJjiMHV6AUwvvgtRsY,5842 +bitblas/3rdparty/tvm/python/tvm/tir/transform/transform.py,sha256=lEFjixANTxS0bsjUStur2qLBQM0upO9rVDngoeqN14Q,31133 +bitblas/3rdparty/tvm/python/tvm/tir/usmp/__init__.py,sha256=gPYV1_Ut9OnAYdOx8BqECvYTLguuW8OUnEAJuNyYS5w,964 +bitblas/3rdparty/tvm/python/tvm/tir/usmp/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/tir/usmp/__pycache__/__init__.cpython-310.pyc,sha256=SikCFRA3ma-gq1Z1bxRXWJsKSvnKwN7xiVTxlNl-zd4,327 +bitblas/3rdparty/tvm/python/tvm/tir/usmp/__pycache__/__init__.cpython-38.pyc,sha256=kZKaFbL07jzlfpTeJyzjIg44Dl2SaMQiDd296CTrKvA,314 +bitblas/3rdparty/tvm/python/tvm/tir/usmp/__pycache__/_ffi_api.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/tir/usmp/__pycache__/_ffi_api.cpython-310.pyc,sha256=1JkK-ZPDIAQuQqgMxrYQ649dFKGbBal2mdECYhIizFg,282 +bitblas/3rdparty/tvm/python/tvm/tir/usmp/__pycache__/_ffi_api.cpython-38.pyc,sha256=h25KZV5vuy_9UJ-54Ckn-CfSLfuM8auz8UebVUPEJmE,269 +bitblas/3rdparty/tvm/python/tvm/tir/usmp/__pycache__/utils.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/tir/usmp/__pycache__/utils.cpython-310.pyc,sha256=8SSZE4NOPVXnlX25mfmstpDlyzfVNRV8ssKMtxGuZ40,2881 +bitblas/3rdparty/tvm/python/tvm/tir/usmp/__pycache__/utils.cpython-38.pyc,sha256=QTMoWrPmlqY4JWWkmk_af5h6mm91h5OgfmZObcl1-Do,2854 +bitblas/3rdparty/tvm/python/tvm/tir/usmp/_ffi_api.py,sha256=jCjMdolDwdE67Zp3_3hujFlqJEMuMGAaE7C4ILizOT8,876 +bitblas/3rdparty/tvm/python/tvm/tir/usmp/analysis/__init__.py,sha256=jYAAoynVyRGb-rikIq0blepFdsl_KohX9yTmxJY5zqY,929 +bitblas/3rdparty/tvm/python/tvm/tir/usmp/analysis/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/tir/usmp/analysis/__pycache__/__init__.cpython-310.pyc,sha256=ZuEURgtzOwP5E96ulatQ5TwZr_s3vb8V030NcMd6Ciw,283 +bitblas/3rdparty/tvm/python/tvm/tir/usmp/analysis/__pycache__/__init__.cpython-38.pyc,sha256=2ZMHfkq6eSY88MPZmZgYjJblH32m1M1VpYBAotnVBSY,270 +bitblas/3rdparty/tvm/python/tvm/tir/usmp/analysis/__pycache__/_ffi_api.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/tir/usmp/analysis/__pycache__/_ffi_api.cpython-310.pyc,sha256=9BN_nH9QW0LrG6aHhfwSKbCK2_3sHygCBwXU45ZtnfE,309 +bitblas/3rdparty/tvm/python/tvm/tir/usmp/analysis/__pycache__/_ffi_api.cpython-38.pyc,sha256=8qrHtGibHkSR0zNOf5Brl8TQ7-6BCnNvqU04bkRCUWA,296 +bitblas/3rdparty/tvm/python/tvm/tir/usmp/analysis/__pycache__/analysis.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/tir/usmp/analysis/__pycache__/analysis.cpython-310.pyc,sha256=baijkVYYITgrR_CiEd1ZiyJE4vpzBvhQWIrzFjzdNW8,856 +bitblas/3rdparty/tvm/python/tvm/tir/usmp/analysis/__pycache__/analysis.cpython-38.pyc,sha256=p_jdcObgC__Bitbr8ln6Wzww9gLbMHhHMujlKPhBpzc,836 +bitblas/3rdparty/tvm/python/tvm/tir/usmp/analysis/_ffi_api.py,sha256=NWj-S6TWkpEhNSr1vyafOQFak5LCfoiEkwH38xO3QFs,894 +bitblas/3rdparty/tvm/python/tvm/tir/usmp/analysis/analysis.py,sha256=k2hZh2Cuhj4pCfav-JNQ0or5f0_R6FWVb9gOdEUR9Rw,1420 +bitblas/3rdparty/tvm/python/tvm/tir/usmp/transform/__init__.py,sha256=lgL7dvQimaPqNAfg8pRgnYnoBEdbiHc1iirsjMccxg8,946 +bitblas/3rdparty/tvm/python/tvm/tir/usmp/transform/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/tir/usmp/transform/__pycache__/__init__.cpython-310.pyc,sha256=wDlQrJv3iTt6QSxcdGDM9-Z9W3eA8sM8O_TStgZZ-I0,301 +bitblas/3rdparty/tvm/python/tvm/tir/usmp/transform/__pycache__/__init__.cpython-38.pyc,sha256=SiDRrpnyRfL3aiG7ENgKrMT7055Nw1WBBxDdHEv-yCg,288 +bitblas/3rdparty/tvm/python/tvm/tir/usmp/transform/__pycache__/_ffi_api.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/tir/usmp/transform/__pycache__/_ffi_api.cpython-310.pyc,sha256=HbxqIbvz4jM4BRbivJV8Dj7SmJekncycWr5Qz_C6Lag,311 +bitblas/3rdparty/tvm/python/tvm/tir/usmp/transform/__pycache__/_ffi_api.cpython-38.pyc,sha256=VtGWMIVvM20seZiRCM67kp4v2GYFo-XHBmVFFQT4hWI,298 +bitblas/3rdparty/tvm/python/tvm/tir/usmp/transform/__pycache__/transform.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/tir/usmp/transform/__pycache__/transform.cpython-310.pyc,sha256=008FGFTmkbmCM0Z4nsw0x7nd3TPwab_VuojaWRbeS5o,1229 +bitblas/3rdparty/tvm/python/tvm/tir/usmp/transform/__pycache__/transform.cpython-38.pyc,sha256=GgjXs3vBH-SeCcvv11xAnYMoiiDKxTzW9uKh0C99xps,1208 +bitblas/3rdparty/tvm/python/tvm/tir/usmp/transform/_ffi_api.py,sha256=AisdFRcKIDOYz0ofa7qpNP8moeLtMNM44T0wQVV4lUE,895 +bitblas/3rdparty/tvm/python/tvm/tir/usmp/transform/transform.py,sha256=RfFhfeLgIQ4Ku9i-qDIhpqMoc6aMsUlSVJxb0nOf59A,1769 +bitblas/3rdparty/tvm/python/tvm/tir/usmp/utils.py,sha256=zk2k2EqZgkA68x7yKVSFNXon6ji8Mvw-AN2f9KSpUIM,3317 +bitblas/3rdparty/tvm/python/tvm/tl/__init__.py,sha256=xObOhQFSYOhfn_4gkXlTyne33m72s2Glk6tJEWBzXds,904 +bitblas/3rdparty/tvm/python/tvm/tl/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/tl/__pycache__/__init__.cpython-310.pyc,sha256=u2t7TCb1OIvJLXuho7dtl0g-WcqEX1OrOeNIr949emo,331 +bitblas/3rdparty/tvm/python/tvm/tl/__pycache__/_ffi_api.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/tl/__pycache__/_ffi_api.cpython-310.pyc,sha256=1jLSr0dm8Q4YA703Ni0D1TaUxNK1D9fYjnvwg1UuO7E,264 +bitblas/3rdparty/tvm/python/tvm/tl/__pycache__/autotuner.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/tl/__pycache__/autotuner.cpython-310.pyc,sha256=GBxZNFW2qyrue2K1FGqRsBSpaSXo8GDJ1usljqPw4PY,5326 +bitblas/3rdparty/tvm/python/tvm/tl/__pycache__/engine.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/tl/__pycache__/engine.cpython-310.pyc,sha256=O9syy6GIcfB7wtP4zCYi58NMr2ixqjhmsTGbgWPh4nQ,7010 +bitblas/3rdparty/tvm/python/tvm/tl/__pycache__/language.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/tl/__pycache__/language.cpython-310.pyc,sha256=37GPMTg_vp_2-yJ8TDZrc9nU6OJyrY2meNybpu_hIOg,11131 +bitblas/3rdparty/tvm/python/tvm/tl/__pycache__/layout.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/tl/__pycache__/layout.cpython-310.pyc,sha256=jq1OXcy5VZSj0C0TpF7fCeoucCziKn_cCubD1GFAzJI,3468 +bitblas/3rdparty/tvm/python/tvm/tl/__pycache__/transform.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/tl/__pycache__/transform.cpython-310.pyc,sha256=9PvchWDmSzuh2OjTte5EJBwv8V8gt28y-rflug8--r0,2979 +bitblas/3rdparty/tvm/python/tvm/tl/__pycache__/utils.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/tl/__pycache__/utils.cpython-310.pyc,sha256=Q-DUNE1SIWmp29WIXaLa9KDqVo-0dKTsV7W9W4jxia8,10558 +bitblas/3rdparty/tvm/python/tvm/tl/_ffi_api.py,sha256=0GPbsXb6agfuQiIfcMpT9jJuU4SetpVGtzDk3E7yvXA,864 +bitblas/3rdparty/tvm/python/tvm/tl/autotuner.py,sha256=6M38q4QzexuYmY6xdxBQG17-QfSc53aab9ldA0r9FIc,6626 +bitblas/3rdparty/tvm/python/tvm/tl/engine.py,sha256=OcybKtCZUV9z7wl5xxQTlrb_F2gECW4SgBo2nmdkBeo,10593 +bitblas/3rdparty/tvm/python/tvm/tl/language.py,sha256=oRbjcR1XONGJ5TZVoRJhX4UlLKg0dTemcKgkpLYOb6Y,11048 +bitblas/3rdparty/tvm/python/tvm/tl/layout.py,sha256=gUBMzLeWD5pJ-MCc-1tGDRpbX2dtDXZEahD_XuTkPcw,3461 +bitblas/3rdparty/tvm/python/tvm/tl/transform.py,sha256=LtKHmMdRbrvpyZzUMWjGs73Qh302-74k-mYcAfyVFD0,3677 +bitblas/3rdparty/tvm/python/tvm/tl/utils.py,sha256=OLsktqkYYTv265moQuFPiIxc2slwXHXbGSRThVRGyc0,13722 +bitblas/3rdparty/tvm/python/tvm/topi/__init__.py,sha256=Y8NFUB5R74_AYqdVyC93BJL2-5WBOTzSHEbwPSv6eBY,2264 +bitblas/3rdparty/tvm/python/tvm/topi/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/__pycache__/__init__.cpython-310.pyc,sha256=9iMNhUpjpUM6VhMfiYaYKwTel3aJ_kbuJX4mZtt1Fuo,1430 +bitblas/3rdparty/tvm/python/tvm/topi/__pycache__/__init__.cpython-38.pyc,sha256=QMrjzPSPrDxAaubXyTaFvPKJrfQi_OlIyHfc_JsQ_j0,1417 +bitblas/3rdparty/tvm/python/tvm/topi/__pycache__/argwhere.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/__pycache__/argwhere.cpython-310.pyc,sha256=Fx5fh0qdxexkr4XnmzObyDHfFG1aMX-eclk5-3_AwSY,4097 +bitblas/3rdparty/tvm/python/tvm/topi/__pycache__/argwhere.cpython-38.pyc,sha256=h5IHPqfuhTzDrdk8M_q6WbzkjowbRyjM-Q9_n1KLmS0,4059 +bitblas/3rdparty/tvm/python/tvm/topi/__pycache__/broadcast.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/__pycache__/broadcast.cpython-310.pyc,sha256=rALGxosSCqltOYjVzU5pktkuVfmGaUlgbwFhOBGnMls,11728 +bitblas/3rdparty/tvm/python/tvm/topi/__pycache__/broadcast.cpython-38.pyc,sha256=BJX0M8onmhZM6_euyMCicp9ZNpVhMuZSvJ9ZcPVJEWc,12061 +bitblas/3rdparty/tvm/python/tvm/topi/__pycache__/einsum.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/__pycache__/einsum.cpython-310.pyc,sha256=XVSUy_dMUizOyXQZV8Unm2yoP9dYNQ-_PzN3_SjdiwI,1137 +bitblas/3rdparty/tvm/python/tvm/topi/__pycache__/einsum.cpython-38.pyc,sha256=nvSybmyABbp97O5N-E6WqtelRrKUToiIpiwcgNL1tzk,1124 +bitblas/3rdparty/tvm/python/tvm/topi/__pycache__/generic_op_impl.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/__pycache__/generic_op_impl.cpython-310.pyc,sha256=wfolm1b__pj6QQod3ojNbj3SzBdOljiqOliclYBBdqw,3022 +bitblas/3rdparty/tvm/python/tvm/topi/__pycache__/generic_op_impl.cpython-38.pyc,sha256=9M6Vg-EeIrviEjeou8k-tqD87gyhuEgDLJoxQH8ogls,3003 +bitblas/3rdparty/tvm/python/tvm/topi/__pycache__/math.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/__pycache__/math.cpython-310.pyc,sha256=QvjF8zA7RiiR5knPwUQj6kpeP7H89YYgfd5Zcyxe4s4,20628 +bitblas/3rdparty/tvm/python/tvm/topi/__pycache__/math.cpython-38.pyc,sha256=lMsJI0pNz2sw32NU9ibtPFUHYRDeFZwyGb5k-iR7kFc,21753 +bitblas/3rdparty/tvm/python/tvm/topi/__pycache__/reduction.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/__pycache__/reduction.cpython-310.pyc,sha256=BxSoFXOVNSVDx-J4qjoJiFacmLkR3qa7y9uKcVfSj1s,8609 +bitblas/3rdparty/tvm/python/tvm/topi/__pycache__/reduction.cpython-38.pyc,sha256=8D3ODOUN8l1pCsKDDIMIPJMS5OxnsSFZzXRqh7pDvZk,8731 +bitblas/3rdparty/tvm/python/tvm/topi/__pycache__/scan.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/__pycache__/scan.cpython-310.pyc,sha256=CS8TFgf8L2jP4l9TeDhSVkogZRTgRxg7v7tIWeSYDOs,6768 +bitblas/3rdparty/tvm/python/tvm/topi/__pycache__/scan.cpython-38.pyc,sha256=_Ap_7ZpZHQgRiVFYZ-u0j_vlSfcOY4KQiY_ZUuWC8W4,6672 +bitblas/3rdparty/tvm/python/tvm/topi/__pycache__/scatter.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/__pycache__/scatter.cpython-310.pyc,sha256=omNHuvLXrUkDK7IT9fyWPpeNr3bv1cEShGeIXDnt8Q8,4018 +bitblas/3rdparty/tvm/python/tvm/topi/__pycache__/scatter.cpython-38.pyc,sha256=zGkJ_kmmXIiC8hoB22ppZvAnsg5Dz1y6Ra7P2wgJU2o,3913 +bitblas/3rdparty/tvm/python/tvm/topi/__pycache__/scatter_elements.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/__pycache__/scatter_elements.cpython-310.pyc,sha256=iQaPDUkWIjIj6MyXZwgkrlq5Rg8vsR04mpc7CFKaYps,5002 +bitblas/3rdparty/tvm/python/tvm/topi/__pycache__/scatter_elements.cpython-38.pyc,sha256=Bz5uep1tNJ5xecJkNAPhTA455NpYYAX3Oj1TTrg3QU4,4931 +bitblas/3rdparty/tvm/python/tvm/topi/__pycache__/searchsorted.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/__pycache__/searchsorted.cpython-310.pyc,sha256=SizVBXyabOTazKnb7Q5gOXNJunIBJwmlgOCBil_eGms,3903 +bitblas/3rdparty/tvm/python/tvm/topi/__pycache__/searchsorted.cpython-38.pyc,sha256=RxI_6yfvwIs16z2u3EW5a-_OiRX0lS8cPkIMGeFQRrA,3753 +bitblas/3rdparty/tvm/python/tvm/topi/__pycache__/signal.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/__pycache__/signal.cpython-310.pyc,sha256=7bzXCl5S2vE5WZKhO7K3pHDsVqzfC9gUBnJMtn9DxPA,5496 +bitblas/3rdparty/tvm/python/tvm/topi/__pycache__/signal.cpython-38.pyc,sha256=ZQhm-X97TpPuZloxTHIPkLSnWcUCrCBKEQkSFdZwzUc,5261 +bitblas/3rdparty/tvm/python/tvm/topi/__pycache__/sort.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/__pycache__/sort.cpython-310.pyc,sha256=h674brXTEvuk--wokoTCwcIHkeu2CFAQ8ePLUd5ovFs,5248 +bitblas/3rdparty/tvm/python/tvm/topi/__pycache__/sort.cpython-38.pyc,sha256=YlENQaAkiwwdBFRYwRWqcEJQwncwgRBxlEY5BVUdBRI,5291 +bitblas/3rdparty/tvm/python/tvm/topi/__pycache__/sparse_fill_empty_rows.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/__pycache__/sparse_fill_empty_rows.cpython-310.pyc,sha256=7oVXkQ_7yuRN0trXya4Dp_C2DY2tERL8WGpjBUvnUJc,1560 +bitblas/3rdparty/tvm/python/tvm/topi/__pycache__/sparse_fill_empty_rows.cpython-38.pyc,sha256=kI-Y32ScSt1Vkd-HkHXKuM2i_8FipF2Y2xf397KsDgc,1561 +bitblas/3rdparty/tvm/python/tvm/topi/__pycache__/sparse_reshape.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/__pycache__/sparse_reshape.cpython-310.pyc,sha256=qa1S79Dc64Fmub3ICXyPApEzJrUQ8x2x1_GytHvJBvU,4552 +bitblas/3rdparty/tvm/python/tvm/topi/__pycache__/sparse_reshape.cpython-38.pyc,sha256=7RuWlq4JjL6ny4Pam6bwq2fgxHBqLNq-gB4Kj5pUs54,4069 +bitblas/3rdparty/tvm/python/tvm/topi/__pycache__/tag.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/__pycache__/tag.cpython-310.pyc,sha256=ynaKxS8uQfGoRrGTrBCTZBGcgeGtIFZy7K4td5PXge4,2202 +bitblas/3rdparty/tvm/python/tvm/topi/__pycache__/tag.cpython-38.pyc,sha256=wBmQKEJyB1dC_Grlzw0GEP28Sb0fG2xA-zj3nr3W-5Y,2189 +bitblas/3rdparty/tvm/python/tvm/topi/__pycache__/tensor.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/__pycache__/tensor.cpython-310.pyc,sha256=0HZVojJUtm6SZMgLll1gU-sjEG_RA4YDP9DDti44btM,1420 +bitblas/3rdparty/tvm/python/tvm/topi/__pycache__/tensor.cpython-38.pyc,sha256=Va9MPsz6iGxNaKkLNg6HflfFwP4FXXLg8v2ZxmCVMJU,1407 +bitblas/3rdparty/tvm/python/tvm/topi/__pycache__/transform.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/__pycache__/transform.cpython-310.pyc,sha256=wuDL1Wek6VK1xg0tQaNnpyC0ds5y0DJG-n1HrBAyf1o,29031 +bitblas/3rdparty/tvm/python/tvm/topi/__pycache__/transform.cpython-38.pyc,sha256=NlAu1fTrCumV2FU0H4R6vPyGwqti9F48-J-d53jf8rQ,29339 +bitblas/3rdparty/tvm/python/tvm/topi/__pycache__/unique.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/__pycache__/unique.cpython-310.pyc,sha256=xPu9_u14LaP0K366o7lIg59rDDAVVK2OWNAiJRtafOs,9987 +bitblas/3rdparty/tvm/python/tvm/topi/__pycache__/unique.cpython-38.pyc,sha256=6A3a_iOttnzu2NTzdZPOOl1GH5u8byA9fPuiINWHxIs,9488 +bitblas/3rdparty/tvm/python/tvm/topi/__pycache__/utils.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/__pycache__/utils.cpython-310.pyc,sha256=sTj_jkJh-NTbPYrN_zMHPJS68D2jE18MkvSpb59uq4w,13321 +bitblas/3rdparty/tvm/python/tvm/topi/__pycache__/utils.cpython-38.pyc,sha256=Y3_CTBgsR27uJfJzjZ0cgelvDmLAJDcU_Pe1YAjq8uE,13396 +bitblas/3rdparty/tvm/python/tvm/topi/adreno/__init__.py,sha256=McVqQ5ziazIoZtF31tyrEuax9OjpQ3FGsFvzbn4N4_o,1300 +bitblas/3rdparty/tvm/python/tvm/topi/adreno/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/adreno/__pycache__/__init__.cpython-310.pyc,sha256=UJt1S-BUyW9VthFH0GeyGDNEHtafhpjl3f0-KgQiaLQ,607 +bitblas/3rdparty/tvm/python/tvm/topi/adreno/__pycache__/__init__.cpython-38.pyc,sha256=m3QFljJSqx1p36pYLQO_Z8cdJkBtetKUywCx5EQCLIY,594 +bitblas/3rdparty/tvm/python/tvm/topi/adreno/__pycache__/conv2d_alter_op.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/adreno/__pycache__/conv2d_alter_op.cpython-310.pyc,sha256=BLUmvj7uOSYPTgAVLIjEsW7vE3ACRicDjcfU6RxAI3U,6506 +bitblas/3rdparty/tvm/python/tvm/topi/adreno/__pycache__/conv2d_alter_op.cpython-38.pyc,sha256=fZ5SG60M2CFpnknlc_pEzbZQY2ckCOTxbgYyos9W1l0,6527 +bitblas/3rdparty/tvm/python/tvm/topi/adreno/__pycache__/conv2d_nchw.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/adreno/__pycache__/conv2d_nchw.cpython-310.pyc,sha256=mVPVVfV9itfG95HYJAVAqCm2jsRVITdzoMyuNLJ4se4,9389 +bitblas/3rdparty/tvm/python/tvm/topi/adreno/__pycache__/conv2d_nchw.cpython-38.pyc,sha256=3I2i0ErgUwh4PWnI4zoF7QKzKroBg2TZdkzlV-s690Y,9449 +bitblas/3rdparty/tvm/python/tvm/topi/adreno/__pycache__/conv2d_nchw_winograd.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/adreno/__pycache__/conv2d_nchw_winograd.cpython-310.pyc,sha256=P6agqz4h4HR8VGhlrnKZZJUfBD7n0Xl2hzo9IW9KM9E,2492 +bitblas/3rdparty/tvm/python/tvm/topi/adreno/__pycache__/conv2d_nchw_winograd.cpython-38.pyc,sha256=-ObbMRifA3gmkbs4pKyLn0yLMt-yCv4gtc2tiVj-hcs,2547 +bitblas/3rdparty/tvm/python/tvm/topi/adreno/__pycache__/conv2d_nhwc.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/adreno/__pycache__/conv2d_nhwc.cpython-310.pyc,sha256=9mpCXC-ERPaUHSuyy85iGx_MC1HT6GSrDpN2Xpe9Omw,9374 +bitblas/3rdparty/tvm/python/tvm/topi/adreno/__pycache__/conv2d_nhwc.cpython-38.pyc,sha256=H25d8HqgAHqR-ZYdFaYWWZ-uIEyBoFrzYe08tdmB4Ic,9434 +bitblas/3rdparty/tvm/python/tvm/topi/adreno/__pycache__/conv2d_nhwc_winograd.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/adreno/__pycache__/conv2d_nhwc_winograd.cpython-310.pyc,sha256=x1NZZILTYMAeonu-f05Y1CPwwjH9gG2XqEZV58pAdTw,2492 +bitblas/3rdparty/tvm/python/tvm/topi/adreno/__pycache__/conv2d_nhwc_winograd.cpython-38.pyc,sha256=uOfLyDVOi4MFyXC42SQod9QKc_ljPnbgeHDTP2s3jD4,2547 +bitblas/3rdparty/tvm/python/tvm/topi/adreno/__pycache__/conv2d_transpose_alter_op.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/adreno/__pycache__/conv2d_transpose_alter_op.cpython-310.pyc,sha256=Fp8ZKtS5mESTT0mJbn5YCMCVJf2v2782PU4v50lLpoE,2821 +bitblas/3rdparty/tvm/python/tvm/topi/adreno/__pycache__/conv2d_transpose_alter_op.cpython-38.pyc,sha256=AilqNw0ymlYyUO23ZSFZyH03U7QBmo6qwSiOdknWQ58,2842 +bitblas/3rdparty/tvm/python/tvm/topi/adreno/__pycache__/conv2d_transpose_nchw.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/adreno/__pycache__/conv2d_transpose_nchw.cpython-310.pyc,sha256=DssRpCpMzeZM_ujOW-JGzkDa84AJk4DRrWts0nyt3to,10306 +bitblas/3rdparty/tvm/python/tvm/topi/adreno/__pycache__/conv2d_transpose_nchw.cpython-38.pyc,sha256=FYsRHDNidURhEp-o6Fvj9PsXGcmOSHUq8wryuEb5mbs,10351 +bitblas/3rdparty/tvm/python/tvm/topi/adreno/__pycache__/conv2d_winograd_common.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/adreno/__pycache__/conv2d_winograd_common.cpython-310.pyc,sha256=BfBxKniZVMNt6bJDAibnsoX3bdEd5E4u20AHFbeHVD8,11858 +bitblas/3rdparty/tvm/python/tvm/topi/adreno/__pycache__/conv2d_winograd_common.cpython-38.pyc,sha256=Tl8AL_5VF6cIE1UfvPaMxMACApJQN2S5cy7GE9gNVT4,11921 +bitblas/3rdparty/tvm/python/tvm/topi/adreno/__pycache__/depthwise_conv2d_nchw.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/adreno/__pycache__/depthwise_conv2d_nchw.cpython-310.pyc,sha256=vAmS2bHcRUSpjVALzCe07TtWSld14Ns2sBVe9B0nTsQ,8212 +bitblas/3rdparty/tvm/python/tvm/topi/adreno/__pycache__/depthwise_conv2d_nchw.cpython-38.pyc,sha256=IoxdzzMgTKqUqZxPhCSco7NUQPuuJyEzWQtRM2PPozM,8262 +bitblas/3rdparty/tvm/python/tvm/topi/adreno/__pycache__/depthwise_conv2d_nhwc.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/adreno/__pycache__/depthwise_conv2d_nhwc.cpython-310.pyc,sha256=n9vx-M3HEwO-q4gh7dPz2fOHpY4P19w7Q6Jqkzf7yLA,8261 +bitblas/3rdparty/tvm/python/tvm/topi/adreno/__pycache__/depthwise_conv2d_nhwc.cpython-38.pyc,sha256=oAOQHyox2GACoPmNUmHpJcnPCkAPxNicdcnrv6Whufk,8311 +bitblas/3rdparty/tvm/python/tvm/topi/adreno/__pycache__/injective.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/adreno/__pycache__/injective.cpython-310.pyc,sha256=56EqejIzxMPxNwVKb6XXs9ATVdJuObDvFWNbDC2MSoc,1550 +bitblas/3rdparty/tvm/python/tvm/topi/adreno/__pycache__/injective.cpython-38.pyc,sha256=okjoBCoYyoMg3x-8RJkPqLmpPOFsleUDn6WbI5zc4ys,1537 +bitblas/3rdparty/tvm/python/tvm/topi/adreno/__pycache__/pooling.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/adreno/__pycache__/pooling.cpython-310.pyc,sha256=-HpBGLfRa-gxxwBLa4Ltpoj2lYwIvNhV_8ZMyGv4o4I,4729 +bitblas/3rdparty/tvm/python/tvm/topi/adreno/__pycache__/pooling.cpython-38.pyc,sha256=ghY3UoPUlSJHO4kQHoJOPfKMmnz1-0wCtYopAB-wqAU,4734 +bitblas/3rdparty/tvm/python/tvm/topi/adreno/__pycache__/reduction.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/adreno/__pycache__/reduction.cpython-310.pyc,sha256=N53De1ljUvKxhB5RNYwVdheHlgGOpAOR9Sm_3SpegrM,2639 +bitblas/3rdparty/tvm/python/tvm/topi/adreno/__pycache__/reduction.cpython-38.pyc,sha256=6U0JINrohnVaYtu2GTfxDSe9rdZHlQySbVP8PjRZT9s,2656 +bitblas/3rdparty/tvm/python/tvm/topi/adreno/__pycache__/utils.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/adreno/__pycache__/utils.cpython-310.pyc,sha256=m65rg2m6PxD-t6leKsoO-I4Z0wNCDcQQEQVNuPF41jk,15295 +bitblas/3rdparty/tvm/python/tvm/topi/adreno/__pycache__/utils.cpython-38.pyc,sha256=BHnN3JgK2rHTpttpY4-fsQo2hyNG_11soCnI_xHgC80,15439 +bitblas/3rdparty/tvm/python/tvm/topi/adreno/conv2d_alter_op.py,sha256=asbPMEKsNbX0nAZbQmelkWYSIVZtoIuayEvEn8D58T0,17860 +bitblas/3rdparty/tvm/python/tvm/topi/adreno/conv2d_nchw.py,sha256=APZWZ8HtOP5PMmGtzf2-YvA79eaFj0S-ypguaZqz110,14174 +bitblas/3rdparty/tvm/python/tvm/topi/adreno/conv2d_nchw_winograd.py,sha256=1K0eYuFmkyg9-7LsPQ6UwfLyiS41Y8iEZFBmovGT6eQ,3361 +bitblas/3rdparty/tvm/python/tvm/topi/adreno/conv2d_nhwc.py,sha256=46GH9XF8_lwiKB7kHdyS2Hd7PkoGp0-bou8ZiDevw8M,14150 +bitblas/3rdparty/tvm/python/tvm/topi/adreno/conv2d_nhwc_winograd.py,sha256=lQrSh69zLsLIW3Pb6rIKdhog3LP2TmtsuI3mbflKZQo,3361 +bitblas/3rdparty/tvm/python/tvm/topi/adreno/conv2d_transpose_alter_op.py,sha256=VrIcc-nQxp-6e9cvgmty-35FRqQCx8w7p1xwbacGbEo,5038 +bitblas/3rdparty/tvm/python/tvm/topi/adreno/conv2d_transpose_nchw.py,sha256=YoK7v6T7lGNFcfak3jyapRZIDElPtiU5RH2X5-pSQLk,15734 +bitblas/3rdparty/tvm/python/tvm/topi/adreno/conv2d_winograd_common.py,sha256=3-mL5e3fZrw5zPta24v4Wx_OBqydtGwQOs-CMJG3tYE,18204 +bitblas/3rdparty/tvm/python/tvm/topi/adreno/depthwise_conv2d_nchw.py,sha256=4SgGWrLMe-ynotzAdDjtS3L7ZjWP0RM-2hwFH6c10Ic,12100 +bitblas/3rdparty/tvm/python/tvm/topi/adreno/depthwise_conv2d_nhwc.py,sha256=FkwGXDwq60DJiSM454eHhiGMy-VeAA5COH9RrGZ14wc,11995 +bitblas/3rdparty/tvm/python/tvm/topi/adreno/injective.py,sha256=Qigv8mBtISXE6fXjq9gWu5EutBRkv3spZqeEQZL4Alk,1973 +bitblas/3rdparty/tvm/python/tvm/topi/adreno/pooling.py,sha256=uw3FUC4vrrx5gJMkoLskfQT-lPejL-3bOc3ZhdK5p54,7044 +bitblas/3rdparty/tvm/python/tvm/topi/adreno/reduction.py,sha256=bE-dPr7xO3J5x2LTTNGxJipN3Pwiv3BNbBsY2Am0dQk,5285 +bitblas/3rdparty/tvm/python/tvm/topi/adreno/utils.py,sha256=QWVzdIksZM6KvObI_27tENSgVeT2js_5-51i4Z6KP8E,22220 +bitblas/3rdparty/tvm/python/tvm/topi/argwhere.py,sha256=_NrqcEZ33vORbTuvwgs7ROFo2qiVXGPkFqFjZtUOZuY,5848 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/__init__.py,sha256=2a-96keDAy1MjW1J0o4Jw5R2ej5Ou0dAaBJA96g5WZc,1245 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/__pycache__/__init__.cpython-310.pyc,sha256=77rJ6spubML6tBj-izCYQJeSmilis9R3ReJpsXk08LE,584 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/__pycache__/__init__.cpython-38.pyc,sha256=xv_6JEf-5w5R0shYPiv_EXeGJYvk04Bxtsf0p-hYA0g,571 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/__pycache__/arm_utils.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/__pycache__/arm_utils.cpython-310.pyc,sha256=ZC9t0U7oxseBy4SzA7GCVcZe1cNDViD8Hi_obU6i1P0,4690 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/__pycache__/arm_utils.cpython-38.pyc,sha256=ksmxg4-QnqNoQGiCcpUY11Xzy2wybKpIZF0QKJ3lsfw,4613 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/__pycache__/bitserial_conv2d.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/__pycache__/bitserial_conv2d.cpython-310.pyc,sha256=dLJx4PwdqjYoQ4vM-ZTTe2GzJ1iQREolPDH6M3Ac72I,12311 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/__pycache__/bitserial_conv2d.cpython-38.pyc,sha256=V_l_NTKGwOQ-GLJ1_O5BeLIWqTogT85DQG1bXKr1rj0,12410 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/__pycache__/bitserial_dense.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/__pycache__/bitserial_dense.cpython-310.pyc,sha256=jUv3Nb3pp2r6-GnhbEqOvUcjWQjZXQTnuDO4S8AJ3uk,5479 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/__pycache__/bitserial_dense.cpython-38.pyc,sha256=BNI6zygw8BrpAeMnMk_nYQ0G6yv_P4OZjB5g3ojk3rw,5465 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/__pycache__/conv1d.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/__pycache__/conv1d.cpython-310.pyc,sha256=kkbMPTlm2NHIcBAnswz6e2FE-sjG-AI-gistKkAg2iU,859 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/__pycache__/conv1d.cpython-38.pyc,sha256=PZ6LlN7-p4gjnTn4bsIuNQgrMN9ZAvZpacRn1J_3CKc,846 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/__pycache__/conv2d.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/__pycache__/conv2d.cpython-310.pyc,sha256=Dvq34YfewxfuMnejMXt3qpNdoHSdIJZb6tvuHD5gxXc,17448 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/__pycache__/conv2d.cpython-38.pyc,sha256=go_quN2oEUcsEthU7v4XetFA9njSaFQgMgDBZmputWI,17954 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/__pycache__/conv2d_alter_op.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/__pycache__/conv2d_alter_op.cpython-310.pyc,sha256=YAgz7zfy4RPMEn28kmMuWyz7EeYJ1hsO7Kpipd8DUUY,9650 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/__pycache__/conv2d_alter_op.cpython-38.pyc,sha256=7IxV3T7Pg3oS5iaagFNCNyseQ2_6WtIOyBhPoMYGnFg,9679 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/__pycache__/conv2d_gemm.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/__pycache__/conv2d_gemm.cpython-310.pyc,sha256=9Qz7S02-DPbHQV0RvRmgElPiO9QCwA3vjP1djWSeXt4,10402 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/__pycache__/conv2d_gemm.cpython-38.pyc,sha256=YfkUs2e2h9Dpd3c3H3oiiQwvyHVykGij_DSaUqT92Xk,10470 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/__pycache__/conv2d_int8.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/__pycache__/conv2d_int8.cpython-310.pyc,sha256=Os8FpqRDwFzaiMysjJzc41aPfT0TdFmD9MgGyyfIF88,7639 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/__pycache__/conv2d_int8.cpython-38.pyc,sha256=SkdCKSR7_pTbTtwII4ujaV5ptQ_SzZCVum-KIgg0iUc,7846 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/__pycache__/conv2d_spatial_pack.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/__pycache__/conv2d_spatial_pack.cpython-310.pyc,sha256=llTpoi1cQa8aFjrlMmJgPd0u6l9_rqgYwr3wgLrzPQQ,11261 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/__pycache__/conv2d_spatial_pack.cpython-38.pyc,sha256=COkBNT7vobt0d0FyIZUps1gOo7Ft4_nDXy_M5RRJNvQ,11270 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/__pycache__/conv2d_transpose.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/__pycache__/conv2d_transpose.cpython-310.pyc,sha256=Hm3f2-HnzTTUYlbk7fb81e1kz8lpce7Lnh7AZGUXFWg,5727 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/__pycache__/conv2d_transpose.cpython-38.pyc,sha256=9KvM-MY6XVzX0XfM0WjLf9ArCOWXcuutOo_yunrvLns,5736 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/__pycache__/dense.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/__pycache__/dense.cpython-310.pyc,sha256=pdfX5tNVm5e_KRDkCLc5GLhEu0JpaFxrBImwxf3r8U0,798 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/__pycache__/dense.cpython-38.pyc,sha256=LiRlKFAmDDfVTfvNRnKxvJGBpLE2cQ1sJ3uPh6LqCOM,785 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/__pycache__/depthwise_conv2d.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/__pycache__/depthwise_conv2d.cpython-310.pyc,sha256=9zbm8Zw4kqnV-_VTqLxHA5YQYLM2dHjB_o3bFVmnuao,17255 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/__pycache__/depthwise_conv2d.cpython-38.pyc,sha256=10i4Tet0qJiO9Zkc_-JbcIDq7py2sfTj0TOYZII8YZw,17313 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/__pycache__/group_conv2d.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/__pycache__/group_conv2d.cpython-310.pyc,sha256=ImFTxWKKyaOENqZnfwyhM_HyAenamSraTHdnZETQ_2w,7891 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/__pycache__/group_conv2d.cpython-38.pyc,sha256=Ve6Ao1U-LEOMWLotwVphdPZ0oNu68qbiefah27C1cIQ,7912 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/__pycache__/injective.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/__pycache__/injective.cpython-310.pyc,sha256=o-IT3LjC0q2AtfNQSC7Fo5oKRij0GOSVRgUDQ8wOVuo,2960 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/__pycache__/injective.cpython-38.pyc,sha256=L1ZsQ_5Xk1Ov2D_MKOhNzInx86Z01otovL8l_tOxg88,2957 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/__pycache__/pooling.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/__pycache__/pooling.cpython-310.pyc,sha256=2Bx14fVynoMVQRi-BpeZ59r2LApmxVm5sinrpfMCqnY,441 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/__pycache__/pooling.cpython-38.pyc,sha256=fkTNqblL1QEBCcxM2vAHusDwg7MNJgBXRU2pT1InijI,428 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/__pycache__/pstate_attributes.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/__pycache__/qnn.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/__pycache__/qnn.cpython-310.pyc,sha256=PM5HBAfT_yY3UqXiV2KcRgsgVy8LnQkFbN3KhV9YB4I,16747 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/__pycache__/qnn.cpython-38.pyc,sha256=7MhynNzmvde4PqRwhwC7z2uvxRBmBpsxj8HT8lS4Yj8,16699 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/__pycache__/qnn_alter_op.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/__pycache__/qnn_alter_op.cpython-310.pyc,sha256=qscNYH2iGIe4ickL4kv-GwFF_-63MbqZ0wC_r-Fu834,6723 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/__pycache__/qnn_alter_op.cpython-38.pyc,sha256=3fZ9A2LfN65t3REwxnaptfTCM5ftIvTvohdSpxiAN74,6710 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/__pycache__/qnn_legalize.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/__pycache__/qnn_legalize.cpython-310.pyc,sha256=VHELoediEpnNmiPY_VxBimv6HeI8JS8xUCSAkFiKdPU,11110 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/__pycache__/qnn_legalize.cpython-38.pyc,sha256=BFqyLtpodFO3IE_sieLyFPtjZAWZkXnvJD-u3G2fbKc,11087 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/__pycache__/tensor_intrin.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/__pycache__/tensor_intrin.cpython-310.pyc,sha256=AtbbtCVHLmIP_QZojCsVzXVbyuI64hzUvqiR2jcnMPM,28638 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/__pycache__/tensor_intrin.cpython-38.pyc,sha256=JEMt62L1IeV8uDTOl6ce3HIPJMmHnUBNEyQULKbq6s0,29130 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/arm_utils.py,sha256=3Mid8lwdyAs98nmu3446LVCEbveUQG7odh_CiXFadkw,8129 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/bitserial_conv2d.py,sha256=DKhH9KBORmRy5K9uQFFn6NNm2m3pSN1IeDWYOS_ZEss,17600 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/bitserial_dense.py,sha256=7IZWPD4vZGwdvOi3J9XAv0DIeBbRXDeBiQaNNAp8LB0,7252 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/conv1d.py,sha256=IGjI6Gq3uWMPMDIoEYSdSkHPxcbZwCCKNNRFqdPTQQM,1521 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/conv2d.py,sha256=tPJ7pnkTQ3OQozMSvOUlk7-nu1mTXI_eXBruT6jCCF8,22137 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/conv2d_alter_op.py,sha256=vqu6n4U9WzlzCgMQ_kRxvi58NJuc27-bTcs37LYs41g,20420 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/conv2d_gemm.py,sha256=6fCuCyYX3rGjFm6fP4VLfKKxjFva0amDmUy_B7qTdLA,20064 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/conv2d_int8.py,sha256=x1zKY4G3TLvGfvZ04SuY2JtYeFM5imnNUYjU8PHhqWo,11773 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/conv2d_spatial_pack.py,sha256=ubF-nB1QULaeoGNgZOVlBKIdiq48dH4YY9F5GSuObzE,17788 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/conv2d_transpose.py,sha256=jMij6tZ0d8pVQbdRPSbamy2rl7EBplMWeQRJcrlOdsk,7416 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/dense.py,sha256=RYrCEZ9RHVweRkn43f9Owi2VhwFwWEsUfZYxM8TTXjg,1434 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/depthwise_conv2d.py,sha256=EEd58pQwB2oW_wn4ImDBqLluoYFx6SqcH3F9UyJAfck,25219 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/group_conv2d.py,sha256=CvWxZGuRyHvZE7vMd328DWXvXjrGVpbTbwSqvSgyB1I,12062 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/injective.py,sha256=nV86p39TB6-uxKcjvRPYFSwaQzWKc5BqiKmgEi21VPs,3412 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/mprofile/__init__.py,sha256=g8IDy4HuPXXjwfIvmn3insuKwPfrKXfhnkdWkxqqGok,844 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/mprofile/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/mprofile/__pycache__/__init__.cpython-310.pyc,sha256=lPMidr1joPylcQPZoBUWzCeqsD9QPoMMbi68nCIw4cs,239 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/mprofile/__pycache__/__init__.cpython-38.pyc,sha256=jIVOYW1ZVlwDqnaKoiMgo1xG5KkFwp9mLhKwOvQo2R0,226 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/mprofile/dsp/__init__.py,sha256=9hdXHABrVpkbpjZgUft39kOFL2xSGeG4GEua0Hmelus,785 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/mprofile/dsp/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/mprofile/dsp/__pycache__/__init__.cpython-310.pyc,sha256=qXed0a1lUuWF0mMYzouEUFoafD6u2b8uEGw1VTMkLr8,179 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/mprofile/dsp/__pycache__/__init__.cpython-38.pyc,sha256=fjaALUkaSXPIdzWLgi-72JbvqgcuMWgtY89_Agpskgo,166 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/mprofile/dsp/__pycache__/conv1d.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/mprofile/dsp/__pycache__/conv1d.cpython-310.pyc,sha256=PY7ZD0yUD6MWxznaDKijBTfMnKvyjwha-mrrHmkd0ec,4466 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/mprofile/dsp/__pycache__/conv1d.cpython-38.pyc,sha256=0MVzt8j4B0bGQJg62a4QGrGMmLNnYunUdYb3q8wgBdI,4467 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/mprofile/dsp/__pycache__/conv2d.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/mprofile/dsp/__pycache__/conv2d.cpython-310.pyc,sha256=1mCjbJdz5l8Hz78O99vXzmAS7rjTISeUc_OS6usvFjI,4836 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/mprofile/dsp/__pycache__/conv2d.cpython-38.pyc,sha256=sFTIGwgXcURVaRsr0OCBOTBCWeG6ds3-b1LgZKGtl4M,4844 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/mprofile/dsp/__pycache__/dense.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/mprofile/dsp/__pycache__/dense.cpython-310.pyc,sha256=9e1moQrLdFDqlGlHle23RCJG60j3nEq3zcr9U-dbC5g,2500 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/mprofile/dsp/__pycache__/dense.cpython-38.pyc,sha256=cM9uczXKqGO4XwZprt47Y4DxI-EaWVueY0rKOwDjM24,2485 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/mprofile/dsp/__pycache__/depthwise_conv2d.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/mprofile/dsp/__pycache__/depthwise_conv2d.cpython-310.pyc,sha256=pz-rV2AzycY17xQngMckZh63o2kADovKMReK-yXaOeM,3795 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/mprofile/dsp/__pycache__/depthwise_conv2d.cpython-38.pyc,sha256=HENTXAIftALdX4s9CpVDTbYro6Y8srXfSO2Gj0uc7PE,3836 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/mprofile/dsp/__pycache__/pool.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/mprofile/dsp/__pycache__/pool.cpython-310.pyc,sha256=McbWTyIWXRda5u1_8mtHYVqgo-EhvbTGG_P0RX275Ws,3448 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/mprofile/dsp/__pycache__/pool.cpython-38.pyc,sha256=4ZvuziDNGvUiDnnB4PylqH3VoDte21ARoVzGjTMFR8Y,3409 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/mprofile/dsp/conv1d.py,sha256=W0LiHfSppHu6NlSrA1NekKK-mAwfsd7TWs_6XfjIy3E,6247 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/mprofile/dsp/conv2d.py,sha256=RXemjo_PhN3Sk914rR-rXVPTFLGpByKY7qbr_9NDjOY,6988 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/mprofile/dsp/dense.py,sha256=rmD1z_RFecwc1y4PJNiQnqBWk4j3dSLA--o5r5yndos,2886 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/mprofile/dsp/depthwise_conv2d.py,sha256=xgwGWtK6-Iz2_clGg92gow70PQCDHA5vqLE86S8AUZ8,6439 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/mprofile/dsp/micro_kernel/__init__.py,sha256=9hdXHABrVpkbpjZgUft39kOFL2xSGeG4GEua0Hmelus,785 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/mprofile/dsp/micro_kernel/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/mprofile/dsp/micro_kernel/__pycache__/__init__.cpython-310.pyc,sha256=ON9br1GJFej0IPG4XowUSU5DwQ1V_J-O1Y9zlmU0xKg,192 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/mprofile/dsp/micro_kernel/__pycache__/__init__.cpython-38.pyc,sha256=XbeIKc5gIL1Jt4N-Zuy6taYLfUvEJwHZ5ZPyOfc8HQQ,179 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/mprofile/dsp/micro_kernel/__pycache__/avg_pool.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/mprofile/dsp/micro_kernel/__pycache__/avg_pool.cpython-310.pyc,sha256=e2O34bd-KOYEbhpqD0mRDjqDIyfhHEbncPka0l0rXOQ,3966 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/mprofile/dsp/micro_kernel/__pycache__/avg_pool.cpython-38.pyc,sha256=bn559TQVf3sdxqJBwT_Xsmr8vgZujcPeurZ3_ekpbaM,3969 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/mprofile/dsp/micro_kernel/__pycache__/common.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/mprofile/dsp/micro_kernel/__pycache__/common.cpython-310.pyc,sha256=q6jHXMvFaVkOvH1NW2QYc96CYhyVjmEm1A1UXc5egLE,1700 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/mprofile/dsp/micro_kernel/__pycache__/common.cpython-38.pyc,sha256=3tsZLU145Nm1IvLGFPc74FF6Dtos21hSKKsnB0hVvXU,1703 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/mprofile/dsp/micro_kernel/__pycache__/gemm.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/mprofile/dsp/micro_kernel/__pycache__/gemm.cpython-310.pyc,sha256=g0SntM8UO_2k4egIfudlx-67d05jHsFzY_Cwsh2ShxY,15726 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/mprofile/dsp/micro_kernel/__pycache__/gemm.cpython-38.pyc,sha256=FkrxciIyxci8RevG7o0KaipFRgyxtpN-cdE8TzTntmU,14455 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/mprofile/dsp/micro_kernel/__pycache__/max_pool.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/mprofile/dsp/micro_kernel/__pycache__/max_pool.cpython-310.pyc,sha256=FVKeWPN9jv7SmfSfXWyD4nX8K6LtPU6tN2Ud_MYl7nk,4374 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/mprofile/dsp/micro_kernel/__pycache__/max_pool.cpython-38.pyc,sha256=atXLlZVEm_lS8sZxhnv1fhplCuRc5gjjIJghEH1HeJI,4381 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/mprofile/dsp/micro_kernel/__pycache__/multi_channel_convolve.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/mprofile/dsp/micro_kernel/__pycache__/multi_channel_convolve.cpython-310.pyc,sha256=-5knaPhfs-YT896awwcmczGCIz74quAuONRMhJbxPXM,6975 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/mprofile/dsp/micro_kernel/__pycache__/multi_channel_convolve.cpython-38.pyc,sha256=3ED8NiUJzMbkMV6gtX7c49iaAA5TngArOM8_aU6ezdQ,6975 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/mprofile/dsp/micro_kernel/__pycache__/tensordot.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/mprofile/dsp/micro_kernel/__pycache__/tensordot.cpython-310.pyc,sha256=Y7-9jhw6YKC6vuQ4Z06yWShgUx6CCVkFZYeC4AqIpws,15426 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/mprofile/dsp/micro_kernel/__pycache__/tensordot.cpython-38.pyc,sha256=nfz1wTbZ-r_xGi9LIdXPdfXb7Se70AUsgVuCzHrWDpk,15344 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/mprofile/dsp/micro_kernel/avg_pool.py,sha256=oREqOEWHd3saL2TBZ8SJK5bOSUnQwHvpJtwdwmEgm4E,3815 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/mprofile/dsp/micro_kernel/common.py,sha256=UjipH7Z0cPiUr3FUXliL7be8hs_oeVQ6-r0SHeKVJYM,2309 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/mprofile/dsp/micro_kernel/gemm.py,sha256=N3ryY57n1h07bjdWf4-hoe0aUxn3s7C-2sB8N8FDXhE,18592 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/mprofile/dsp/micro_kernel/max_pool.py,sha256=dtiy_7fc7inVLD8GxzV3_lKVIfWdzXdZf1W0mTm2wUM,4389 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/mprofile/dsp/micro_kernel/multi_channel_convolve.py,sha256=YgJsoenZ8awPEfplr5qJ-OFwSZnwt55SEBAlwmi0wiE,8416 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/mprofile/dsp/micro_kernel/tensordot.py,sha256=ZkgN7wBre73EcnWKDW0a3ucf9cs3J8XfBbbvv6Yj0xs,17936 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/mprofile/dsp/pool.py,sha256=BKPIwbM-zUDlkmng-DxeNjRKrBBhxetDBtIlZOu9V_Q,4171 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/pooling.py,sha256=_CQVsovv38LTYaCf5M2WlGBAzRRRljZkr991SybN1Lk,1053 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/pstate_attributes.py,sha256=ASp2xxwsmoaiY4E0q4SyvV_nsjo1pIyqAV6o9QYACH8,3079 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/qnn.py,sha256=X_j9xTgnODsLNwbi1OKgPjfDo8DCxIJ8ABsSduDuBiE,23460 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/qnn_alter_op.py,sha256=BeDdwzrcxqyQuN19BOT2IrCf6N2nia3aRdliVDCLiJc,10775 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/qnn_legalize.py,sha256=TtkxdLUnPcCdFCDoV1Y9__qHy3Vu8K0M8cEq2Hq7kQs,15959 +bitblas/3rdparty/tvm/python/tvm/topi/arm_cpu/tensor_intrin.py,sha256=PCRMg74DVzd1NXwe2HAToiCek8erQrneVorSRVDWq_0,40937 +bitblas/3rdparty/tvm/python/tvm/topi/bifrost/__init__.py,sha256=KN6GrelxhEmvAxkgv9RqkBhVWFJOI_fgGCLP3vHDvQs,1037 +bitblas/3rdparty/tvm/python/tvm/topi/bifrost/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/bifrost/__pycache__/__init__.cpython-310.pyc,sha256=roLyRARU0U7RUW9dZfMRGh9F0sjI_HOy4jbUuU9AuEA,376 +bitblas/3rdparty/tvm/python/tvm/topi/bifrost/__pycache__/__init__.cpython-38.pyc,sha256=In8WfNh6Vlxy4NhIjGfZ8c8etKgzjrtjedm9rTNyRY8,363 +bitblas/3rdparty/tvm/python/tvm/topi/bifrost/__pycache__/conv2d.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/bifrost/__pycache__/conv2d.cpython-310.pyc,sha256=7qlw8INztoELsBZGyIIrfxUC0k9YC0fUtKamHUQBRDg,14029 +bitblas/3rdparty/tvm/python/tvm/topi/bifrost/__pycache__/conv2d.cpython-38.pyc,sha256=I3ieshKfHYL6h5uRQX8Wns-zpl0NQF_Uj0GTI0xAnQw,14259 +bitblas/3rdparty/tvm/python/tvm/topi/bifrost/__pycache__/dense.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/bifrost/__pycache__/dense.cpython-310.pyc,sha256=EcwXjd3mrSnHVuqSFdteGkIp45vukdjfDc4-q7mtGto,3005 +bitblas/3rdparty/tvm/python/tvm/topi/bifrost/__pycache__/dense.cpython-38.pyc,sha256=_t2tIe1f0o8z_EGiI3mw75fWHT54Zkv28G_STuuNzs0,2989 +bitblas/3rdparty/tvm/python/tvm/topi/bifrost/__pycache__/depthwise_conv2d.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/bifrost/__pycache__/depthwise_conv2d.cpython-310.pyc,sha256=ccFXpwvE5INRI1qDekERR9jYOEiGgh09ojw9wioF8ns,3349 +bitblas/3rdparty/tvm/python/tvm/topi/bifrost/__pycache__/depthwise_conv2d.cpython-38.pyc,sha256=RcgsAh6cyvXE08BIFOO0tqC7WPV_63_7Sel_TVSE2Lk,3244 +bitblas/3rdparty/tvm/python/tvm/topi/bifrost/__pycache__/gemm.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/bifrost/__pycache__/gemm.cpython-310.pyc,sha256=9DkKEDmd3f943V0HpDYwPf6SMK6SZrg5u_8dG1Ik-ao,8705 +bitblas/3rdparty/tvm/python/tvm/topi/bifrost/__pycache__/gemm.cpython-38.pyc,sha256=nlahymkegvXGMEWTi7aCEf6Wkpg0bNpOQ3XvK0_ToUI,8808 +bitblas/3rdparty/tvm/python/tvm/topi/bifrost/__pycache__/transforms.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/bifrost/__pycache__/transforms.cpython-310.pyc,sha256=M13aKNHJ79-3Zj9EMuGxIBupj4vVOrAKt6SF8WqiG8c,3703 +bitblas/3rdparty/tvm/python/tvm/topi/bifrost/__pycache__/transforms.cpython-38.pyc,sha256=pw33Y30yhShWDLOD1ItAP40w-gynjx-fxKinobkC70w,3713 +bitblas/3rdparty/tvm/python/tvm/topi/bifrost/conv2d.py,sha256=6w7rf9sAqPfC8Rhi4xWLS0fVtFhUnyHsyQ_J4FYl1d8,18009 +bitblas/3rdparty/tvm/python/tvm/topi/bifrost/dense.py,sha256=21aOjMpJwLoVF3kuiYvDcOrT4zDrsXFgmOACU-Xb450,4031 +bitblas/3rdparty/tvm/python/tvm/topi/bifrost/depthwise_conv2d.py,sha256=1vsUnUlIMlXAyOBWAlzTeMOcy_lRMazASdEdD0A7rDk,4550 +bitblas/3rdparty/tvm/python/tvm/topi/bifrost/gemm.py,sha256=YE-Hc7C0j-yQ0TfmHzdmN7AusYTNtoEFw6oZTPhHvdk,11006 +bitblas/3rdparty/tvm/python/tvm/topi/bifrost/transforms.py,sha256=TPxTz4PlZfM3xV0Ye9Po55IkpI-deu_3Nb4JEfX6HXw,4877 +bitblas/3rdparty/tvm/python/tvm/topi/broadcast.py,sha256=LW6-BSYkcU4G9P1b8OPHlrWaaJdGm0b1y41G3nVKQP4,11673 +bitblas/3rdparty/tvm/python/tvm/topi/cpp/__init__.py,sha256=TwQ99wUiwttV4IfnEKvUFi7wlfoXehGBSDHA7pZ8SNs,1018 +bitblas/3rdparty/tvm/python/tvm/topi/cpp/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/cpp/__pycache__/__init__.cpython-310.pyc,sha256=9VK-YZOMKCQkKoVPO5CX8VKWzzPMBxS13vAM7lP0KUE,428 +bitblas/3rdparty/tvm/python/tvm/topi/cpp/__pycache__/__init__.cpython-38.pyc,sha256=a8PE8UUdKy2xVcjgQec2M1DJGT1PU-r3PPTL8jyY500,415 +bitblas/3rdparty/tvm/python/tvm/topi/cpp/__pycache__/cuda.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/cpp/__pycache__/cuda.cpython-310.pyc,sha256=O4r4ppYlrfHOQVQsRh6VnvwfhzYgdB_16r7AMLNGiYk,298 +bitblas/3rdparty/tvm/python/tvm/topi/cpp/__pycache__/cuda.cpython-38.pyc,sha256=s_WtzFEV7S0V_rCLxjpeKIxqgY67ceDDPBjDwJ1pznw,285 +bitblas/3rdparty/tvm/python/tvm/topi/cpp/__pycache__/generic.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/cpp/__pycache__/generic.cpython-310.pyc,sha256=FoOo3dY_Gu_e5cLCBUV_7ZZk4zBP7zUfVDQYlaZ5w9s,310 +bitblas/3rdparty/tvm/python/tvm/topi/cpp/__pycache__/generic.cpython-38.pyc,sha256=_YigBKJkVQfneqppy1UpcAWjKJ0KZvpiCZTlURUbZuo,297 +bitblas/3rdparty/tvm/python/tvm/topi/cpp/__pycache__/impl.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/cpp/__pycache__/impl.cpython-310.pyc,sha256=LtDgU3yI-sryCxxAjeQuGQioCC-7vg2oBDqx3RnPhyw,292 +bitblas/3rdparty/tvm/python/tvm/topi/cpp/__pycache__/impl.cpython-38.pyc,sha256=s_5t4QBKVuakM--lq4nnjjltzkNNw3Rw5T9G7Jf7Us8,279 +bitblas/3rdparty/tvm/python/tvm/topi/cpp/__pycache__/nn.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/cpp/__pycache__/nn.cpython-310.pyc,sha256=pCCNYcHcWdIEsCCh-5qx92A6dTVCTZ-xNr43vfBuNCE,290 +bitblas/3rdparty/tvm/python/tvm/topi/cpp/__pycache__/nn.cpython-38.pyc,sha256=wipE3pSfNkFYcWI8kUdzrpguFTWNFxh-j_zII2Ekmys,277 +bitblas/3rdparty/tvm/python/tvm/topi/cpp/__pycache__/rocm.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/cpp/__pycache__/rocm.cpython-310.pyc,sha256=4TTtAXILrw01-csL8Chlx7IIJM9eEVrEZcu5udBoHW8,298 +bitblas/3rdparty/tvm/python/tvm/topi/cpp/__pycache__/rocm.cpython-38.pyc,sha256=RAYeCAEUnoC0CUoSrv2erjb2hmr7AuS0-0zls_ndyHM,285 +bitblas/3rdparty/tvm/python/tvm/topi/cpp/__pycache__/utils.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/cpp/__pycache__/utils.cpython-310.pyc,sha256=-Mn3ejXVnv_qSZtV6JOUdwSpxHd7-4JyZkuAXlUfWrc,296 +bitblas/3rdparty/tvm/python/tvm/topi/cpp/__pycache__/utils.cpython-38.pyc,sha256=3D_AWtt_EOTViqZom84HxQES5pORbvl--82aQRWL3nE,283 +bitblas/3rdparty/tvm/python/tvm/topi/cpp/__pycache__/x86.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/cpp/__pycache__/x86.cpython-310.pyc,sha256=n5kbRSFV4-QtZFSp1sSm9BV0SDO77pmuOb1_7usEOvU,294 +bitblas/3rdparty/tvm/python/tvm/topi/cpp/__pycache__/x86.cpython-38.pyc,sha256=3myFCRx835T5OlIB9fXvpTXY8knJazx70Rjr_I0uPbk,281 +bitblas/3rdparty/tvm/python/tvm/topi/cpp/cuda.py,sha256=nJd-amH7cV_ep4XukMK4Wpz0lBnKAYTn9b8lnaDaur0,897 +bitblas/3rdparty/tvm/python/tvm/topi/cpp/generic.py,sha256=E9cdpMWpzR07zSH7Q1twFCNQOiCBeJcr-nfeIhbdlvI,906 +bitblas/3rdparty/tvm/python/tvm/topi/cpp/impl.py,sha256=tMW2yuINrufs81pQXH-p13yoZsq_gvQFvP_93iEvBOU,891 +bitblas/3rdparty/tvm/python/tvm/topi/cpp/nn.py,sha256=AXiBQSKMIVt34ArRWsuzu0sRgLa_ka0WWoqlLNTMsQk,891 +bitblas/3rdparty/tvm/python/tvm/topi/cpp/rocm.py,sha256=PnPd8E9E7PcniUHHiVlAx5C58dSzsXl-c-MrldPf-XM,897 +bitblas/3rdparty/tvm/python/tvm/topi/cpp/utils.py,sha256=ORZNdFvCCSJJ2CmWzwNdcinsrDSREZ8d5JeQN5G6Ojk,894 +bitblas/3rdparty/tvm/python/tvm/topi/cpp/vision/__init__.py,sha256=XbXJcQFVG9vsmHO3IjR2KxDwwTYJ4ZUJzB_jGgMB0AU,924 +bitblas/3rdparty/tvm/python/tvm/topi/cpp/vision/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/cpp/vision/__pycache__/__init__.cpython-310.pyc,sha256=PjEmRVPEHsvqpIWWmn8NLVYxRUIlnv1HqNba0eHLb5E,349 +bitblas/3rdparty/tvm/python/tvm/topi/cpp/vision/__pycache__/__init__.cpython-38.pyc,sha256=SDjY9JSbWcLG-oD7QY3kxFzTrDybA4jYEI6MOOKZOiA,336 +bitblas/3rdparty/tvm/python/tvm/topi/cpp/vision/__pycache__/yolo.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/cpp/vision/__pycache__/yolo.cpython-310.pyc,sha256=o_sqROngPghOhf7EaY40zzmB0lM-4DoK-FKa7argP2w,319 +bitblas/3rdparty/tvm/python/tvm/topi/cpp/vision/__pycache__/yolo.cpython-38.pyc,sha256=w8xBjGca0TuswaxaLmHVlebAO5SWsNjnMsCBM4oF2yQ,306 +bitblas/3rdparty/tvm/python/tvm/topi/cpp/vision/yolo.py,sha256=VfDO7TKayCmUq9EKU_K4T751uFGH4N8kpjyEUpSOblc,911 +bitblas/3rdparty/tvm/python/tvm/topi/cpp/x86.py,sha256=nCHva85PFHqjAE1m8BFaqMuUV5ZaTT9mq3cgcUNAXLw,894 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__init__.py,sha256=5UxuvpPCyvMMpyv4IEiPHDNZaNpivoAqkXTon1uOUm8,2274 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/__init__.cpython-310.pyc,sha256=5R9-x_xHLb2atSFaVbPdr-HdapqqAmOT45TWmT7EQcs,1563 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/__init__.cpython-38.pyc,sha256=AOXoQnSzrvQextcd1cd7ilHjHXBhtPw92lwQua0VynU,1550 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/argwhere.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/argwhere.cpython-310.pyc,sha256=kxrvPwq5cTBKoyu5kORUBXDXCyzFwUTN-YOuRDWKfQ8,8171 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/argwhere.cpython-38.pyc,sha256=Cd9DBgTHhJyV6sTUS-0b3I96ayLIkPSWL_IBHYZrclE,8140 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/batch_matmul.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/batch_matmul.cpython-310.pyc,sha256=k1G5LPqTKu1cfJX858-Cr1msKpqzFaYkA1vmyMutMaw,11887 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/batch_matmul.cpython-38.pyc,sha256=dE-GcJ_OFwPc8rPTWHb7NtnSdPQknLzUxaDrdUQrxKU,11979 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/batch_matmul_tensorcore.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/batch_matmul_tensorcore.cpython-310.pyc,sha256=3inYyAs-UUEp7HXwHwjGUvRGbLJVLmRTTiSJoWySLhQ,8242 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/batch_matmul_tensorcore.cpython-38.pyc,sha256=rSCVfes0PWbtvWLrAqRsnWdk5gFAd9Vn8l9FVzVCQTQ,8268 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/conv1d.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/conv1d.cpython-310.pyc,sha256=7SBtBe0-Hagmiyv-6rOT8jrn1RgviRpZeimaao0Nk14,6791 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/conv1d.cpython-38.pyc,sha256=e5MiKrl7F_6kfHNGB1abEdn3fzm9dJGC8uLDWG2BmvA,7129 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/conv1d_transpose_ncw.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/conv1d_transpose_ncw.cpython-310.pyc,sha256=bvUKdqHEMX_ncWbSdxE4cH3wKI-EnJIzzB9q23KElis,5443 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/conv1d_transpose_ncw.cpython-38.pyc,sha256=0Kf5otMQE1UUQHS6oDimY2ScPewdYj0BN9nGJcKzB7M,5440 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/conv2d.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/conv2d.cpython-310.pyc,sha256=sgP3xd_kwopGPWGsak3hcwV-KIQ8PD-kSIbDZRdTRZM,3668 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/conv2d.cpython-38.pyc,sha256=BN8L_-8NhhS3Ktih-3w_ZFUsrsIeVAEHKtvoZkdYFrs,3681 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/conv2d_alter_op.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/conv2d_alter_op.cpython-310.pyc,sha256=U795to5aOiIdQhZbGOGMDLyJPdLYG0IAS6gg-AILmn8,9745 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/conv2d_alter_op.cpython-38.pyc,sha256=zz3BoOXKE7BtYO3KA2EBDRnFuBIIlESKIX0fDK2a6QU,9947 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/conv2d_direct.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/conv2d_direct.cpython-310.pyc,sha256=qN78mO5a46bx05rTApymVt1f2K2ZH9yDa66hKMHUIeg,2877 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/conv2d_direct.cpython-38.pyc,sha256=UBlb_av__vUqdSBHHzvMSDvqqt2A8ia2XWW5hsUcCEE,2863 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/conv2d_hwcn.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/conv2d_hwcn.cpython-310.pyc,sha256=J1ObssDIo-PdYYU1RVnenxh6er1BmK0JZcekQwX188E,4380 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/conv2d_hwcn.cpython-38.pyc,sha256=VWohL12fxNIgxIA_wisvkrivd_yGv4MkMXessz_NzXo,4357 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/conv2d_hwnc_tensorcore.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/conv2d_hwnc_tensorcore.cpython-310.pyc,sha256=paTxFG1SliZ8JEg8dhMRoEPdgrKdmBeJIXhfzrpWSlE,9917 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/conv2d_hwnc_tensorcore.cpython-38.pyc,sha256=Yix4AK_xvnbEVIo6Cme0ut_RmSqmIhKp45pDfdnLdO0,9902 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/conv2d_int8.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/conv2d_int8.cpython-310.pyc,sha256=Yd2tzF49fUuEVCdV7evB0aIDz0M5fhofQxj-qvU6YP4,8865 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/conv2d_int8.cpython-38.pyc,sha256=wtuvPYBiwp0UK-B104Dnq3tf8O64eU7N9HJgYxRaosU,8872 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/conv2d_nhwc_tensorcore.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/conv2d_nhwc_tensorcore.cpython-310.pyc,sha256=_vbqW3aY-L9pQnAkcMu0M7D4JkEVfL3Ome4Bp_BxNLU,8873 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/conv2d_nhwc_tensorcore.cpython-38.pyc,sha256=7h4nY7CkArUfW3wGdYVN2eQGOTMqCYSrF8dGWI1N2m0,8911 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/conv2d_nhwc_winograd.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/conv2d_nhwc_winograd.cpython-310.pyc,sha256=lJd7QtnnH_Fsd2UdxGEPWpe27ebMr_6qZBZTXAeSFBQ,17859 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/conv2d_nhwc_winograd.cpython-38.pyc,sha256=Bbx3I2MF88Xiw74PmBSiRQUPD8Kik0nDW-j2WhRd1qk,18374 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/conv2d_transpose.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/conv2d_transpose.cpython-310.pyc,sha256=d7ToUIk984bVGtuCJUV27nSmeEeh7YjlOsY0MfCnnMk,7953 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/conv2d_transpose.cpython-38.pyc,sha256=-x96kuCQ3MwH2np7SXsxOoifYrD2c3pmklqTgv5YIV0,7905 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/conv2d_winograd.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/conv2d_winograd.cpython-310.pyc,sha256=EEvo2BjkwViS91SMJPvcRShqja1RcNOCMRdpvqALOmc,9825 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/conv2d_winograd.cpython-38.pyc,sha256=k17zEp23TY0zCZlboD4C7jNZp0q-X4yjOAXrz_ySCT0,10074 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/conv3d.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/conv3d.cpython-310.pyc,sha256=ztS7HXxpeSwnAuZHhQotaiSddPtP_pKVpDGE8_wLXFk,6836 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/conv3d.cpython-38.pyc,sha256=X-X-1cn-k0kTqiX_WszhAY_jH50POmF_mCBSIGNZea4,7022 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/conv3d_alter_op.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/conv3d_alter_op.cpython-310.pyc,sha256=MphI6UWGOWx5mlil5C4xnS75zA8XxW0pc4MIX-z5VWo,2462 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/conv3d_alter_op.cpython-38.pyc,sha256=95RA50ggNYTHzwlt6VcnlTMgSkJUKvU9Nmi8-GgY7K8,2487 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/conv3d_direct.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/conv3d_direct.cpython-310.pyc,sha256=PYB-h_vEPhZxfml_3OcuN1QI6_xLo7OEjRXBs_KYMFg,3264 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/conv3d_direct.cpython-38.pyc,sha256=cD-EChn1V2eLT2VNSFmxfQR3RYpUu1Y27EGlW3dVO6s,3258 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/conv3d_ndhwc_tensorcore.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/conv3d_ndhwc_tensorcore.cpython-310.pyc,sha256=3vY5urmL7O-udrK7IQcJs0F7gaRKxKdjvFQxOn4DYUA,9329 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/conv3d_ndhwc_tensorcore.cpython-38.pyc,sha256=JNOQ3UBK-yTsyw3XzzQP4TS3m8uVVZ5ICa2Khw24KZ0,9376 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/conv3d_transpose_ncdhw.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/conv3d_transpose_ncdhw.cpython-310.pyc,sha256=0nIKeSLmSNEKSFVG6Wgy0gcxV1cHYG-jBXOZ5gCc7ec,4541 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/conv3d_transpose_ncdhw.cpython-38.pyc,sha256=Ss5YUB0SS0u6YbXtmHqYNJ2PIj-k8auNmvJ5knWO9d4,4554 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/conv3d_winograd.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/conv3d_winograd.cpython-310.pyc,sha256=Rhu9rzdeTUucG2hhTnAqoFP4j3WPq_GHOdn07Qi2S2Q,16478 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/conv3d_winograd.cpython-38.pyc,sha256=MRPOpbXXz90uXAucN-0VKrMWMM1Kf0KTtALO4BE1egA,16767 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/correlation.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/correlation.cpython-310.pyc,sha256=7e9d2c6IYSOYsPHqV7zJQpHMGNJ2vycPiJgFJbA-2VA,4713 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/correlation.cpython-38.pyc,sha256=Hnfmx13DXKSAuWUfYIMTUUGvPhtcxvl_GNoSe63SLCQ,4705 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/deformable_conv2d.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/deformable_conv2d.cpython-310.pyc,sha256=AtaeTjoX1Th-iTEdSb_S8RYSZJ0qIohLbHNd66F8kqg,4117 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/deformable_conv2d.cpython-38.pyc,sha256=4p8uuV0w3FUQTNUNQQ0V93RbQgtamcbiUhfjHyzVJTw,4117 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/dense.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/dense.cpython-310.pyc,sha256=9AcsKK5UJIOHyphsOMoCdgYKosxaL0_VlyywMHDEywU,5960 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/dense.cpython-38.pyc,sha256=WGOmnTfIvWzOfvFnBdwA528HapN8hcf7mCAS0hxvDz0,5993 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/dense_tensorcore.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/dense_tensorcore.cpython-310.pyc,sha256=bv_8WzCmcad4xtKHtJbpZbSdNOsiEtpzgNkDV9tH0zE,7537 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/dense_tensorcore.cpython-38.pyc,sha256=EzWW-XWt3DpAm0gu6H7STQ4IV1H0CA0OyvCPoX6Wp08,7582 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/depthwise_conv2d.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/depthwise_conv2d.cpython-310.pyc,sha256=oAcsqSSr-BWHXcEMaSQ5-hBC7R6Xw_1AUyTAwyWRRfs,9163 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/depthwise_conv2d.cpython-38.pyc,sha256=OrdJfrddqwmEOsFY0dNsY50jrGuAOruV4pW53-rHN2Y,9309 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/group_conv2d_nchw.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/group_conv2d_nchw.cpython-310.pyc,sha256=EHaHOoVPjntafJRF3CMUFbXQueiBLugTmeEfJQ0Hg4Y,12907 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/group_conv2d_nchw.cpython-38.pyc,sha256=-eHyWWtm9dPBiiTensBeJHOMmFHJvSHHiT4ryLY5c7g,13107 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/injective.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/injective.cpython-310.pyc,sha256=tqdIp2MdvfixwCqiqmSWn8pppRRAhfZN8YGVgy740L0,3011 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/injective.cpython-38.pyc,sha256=rTW9BocTJxPMEmRIgMT-4lfk46ofgnhr763To1YeOxk,3002 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/nms.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/nms.cpython-310.pyc,sha256=9MDUl0q-41mcLE3dEShBHiX8jiRckTEAoXC8nJbgRFo,28887 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/nms.cpython-38.pyc,sha256=vYooJFMKZmprsu8-O1LbquQXmt0bKij2i1e_jT-gR9s,27462 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/nn.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/nn.cpython-310.pyc,sha256=VCtdmMg2cR-svxYPrH5Fh4N9lklBX_gckTgCMNt58g0,1607 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/nn.cpython-38.pyc,sha256=yEECkrhyOXg3E7zOUkTwGuL6s6ONOPwLyAkzryPUjok,1590 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/pooling.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/pooling.cpython-310.pyc,sha256=JCpOfDIDm3oRDVLLGTUIiioToHMs651NKWQ6sX9x0fg,5681 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/pooling.cpython-38.pyc,sha256=n6f_pevOKuj0GTYSwxiW8WFx27wnyB-tUSuoxujd6ko,5700 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/reduction.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/reduction.cpython-310.pyc,sha256=rPeAyYSbvk1ZOAWub4hwhqlc-SILXxLd1KE8CRgsP9k,5381 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/reduction.cpython-38.pyc,sha256=g84BsjKrobj5r8ZQ9_AhYg_I483k1SN2kUlRG_81_Yw,5389 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/scan.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/scan.cpython-310.pyc,sha256=jv17REs2lgSEDB5iN-znqZTotMeDP2VAYpGpdx225vc,21295 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/scan.cpython-38.pyc,sha256=9SUhQH5VZRT3MtfASk412pxrLB19P6goTWNFUtS8F54,20784 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/scatter.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/scatter.cpython-310.pyc,sha256=rw6Zh-1n8oNFjeCtjsZ4fgf4WRh7nHFPoB3DQzIRlS4,7874 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/scatter.cpython-38.pyc,sha256=t_RrH8onGVTZ-oiyVGMjwBcNAoorJ4teU374Kzw5Vcg,7484 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/scatter_elements.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/scatter_elements.cpython-310.pyc,sha256=5y3oIEpTP57Z_wGPXpaKMRYZCCzw8VIMhT0pdR5JpwM,7999 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/scatter_elements.cpython-38.pyc,sha256=pX8OOFvvPfUl1lJMOQqppilJHM4ZqCa_IvBMgcfdask,7710 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/searchsorted.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/searchsorted.cpython-310.pyc,sha256=xKpsCg_r7qzFK03BDmY1mboV2z-ygn2pWkORm_ck7kg,2883 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/searchsorted.cpython-38.pyc,sha256=8p2kQm0_7QnrTorZJLW1D-yoaqXNi6ihaa6IznkoeVw,2840 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/signal.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/signal.cpython-310.pyc,sha256=j9nM2KT4NKZ0sivlis1ElSDBdeo3HdXX6Kn-QAwV6WM,6110 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/signal.cpython-38.pyc,sha256=daXhchznhFy27gPC25Qwq4JnE0dDhRQ1-rp6aWG5wJs,5841 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/softmax.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/softmax.cpython-310.pyc,sha256=LJXhKSYDhnV_5T8mM82rfevXuU41Nb7Bfp7WYc9chhI,4685 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/softmax.cpython-38.pyc,sha256=V_xnvXNH5CWbg6dRG9HpR2-SEQMoYxr0LHNSwZJD1p0,4699 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/sort.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/sort.cpython-310.pyc,sha256=-d3Imt1jalQBFBykpum0wsNZjuukxaYFGSpmG68pI4o,27834 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/sort.cpython-38.pyc,sha256=4oRWfLpsZBQ2vOpMmOLb35XccEK375FD9h1bOT6ZMBM,27279 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/sparse.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/sparse.cpython-310.pyc,sha256=gS2-J2LqmDudmYKBGOHepag5_4cV8LEoq4V__UdMsRE,11112 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/sparse.cpython-38.pyc,sha256=_EY6dhsdAbz1BxL2n3fD0Hlx_E5BQONteQ8w0kWqJVI,10713 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/sparse_reshape.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/sparse_reshape.cpython-310.pyc,sha256=qUVsZFLdzMoRwpqT7E78YTXZdQm2v02Y9XYKSlNaP8A,5169 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/sparse_reshape.cpython-38.pyc,sha256=AjYuT2lIJRMwdcKn_YOvMnvQxWVYEEsEygs5XwOPHLo,4630 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/tensor_intrin.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/tensor_intrin.cpython-310.pyc,sha256=_YwAm9LE-FKrK6-tli4VWh-i5VMPWb_el39g0a9hGXw,7515 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/tensor_intrin.cpython-38.pyc,sha256=7TvMCgne6AE1pIZNK6oYdOvQ-GyUR4F9OzbFszmZHvM,7840 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/tensorcore_alter_op.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/tensorcore_alter_op.cpython-310.pyc,sha256=wAmTYQBNyl4LP-o3N8IeMqtPypkX1mPTcvcqwf5_uFk,5280 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/tensorcore_alter_op.cpython-38.pyc,sha256=aO9FhlMXL563bOoFryLYL0lCxffSenkMqCcpnvSyU8k,5404 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/transform.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/transform.cpython-310.pyc,sha256=4ocrG3NPZ3GqWCseIl3YCTtK47RZJR6OiUF6Tr_rdnE,3960 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/transform.cpython-38.pyc,sha256=K2eLsR3-xjCYwbaMpwksWjyzU2i3TCyNDVPndso3Eec,3916 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/unique.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/unique.cpython-310.pyc,sha256=VAGk_e5QOyTAcDsO0lKOjcLJKMV2AasY8vW8a3HR07w,12528 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/unique.cpython-38.pyc,sha256=mvlSwdihB_R93AFLgWkurCoMRdCtvcCsQDs4DKEHAAg,11814 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/vision.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/vision.cpython-310.pyc,sha256=ZvhfNw0stCgppYOAa42dHVJpFdTGVooGytvDbP3h_nI,4491 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/__pycache__/vision.cpython-38.pyc,sha256=hQJONTt0-3hpWOcmYTm4bH6lNE7_cA_HMMXA0CkjT_g,4538 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/argwhere.py,sha256=lNak_qLZRGHVAXn_YmHta4BLFHtOCxGX3_u_VZ_Th94,8918 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/batch_matmul.py,sha256=EVCFMVbU3QIfYv0Ryeb2OwwVpkh9SSnODqFexqbHsJA,15091 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/batch_matmul_tensorcore.py,sha256=34RYwqoFVTqlii6Htbs2WmWErX8gzbnEewxwxmI6zf4,12197 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/conv1d.py,sha256=dakJEIMzbzaPSyn0iRYoyJIXgDEavjsRlUkuDuLnq40,10813 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/conv1d_transpose_ncw.py,sha256=7lICKR60KOvgh3BEODoB8OUMEe1GR1p23kXmdF_SswU,7537 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/conv2d.py,sha256=MPmLDTzq6JNHuHayC_oTu3QyuUAKOT-BPlK45eZLAvI,5169 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/conv2d_alter_op.py,sha256=DgeE-7xG-yut-osBiVm__ifzZzfg_vIjqkFbTtMz6dM,21672 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/conv2d_direct.py,sha256=21DqNjZ-cjs7TKHfSGCdeOtIC24kge9pcO2h01iSeC0,4632 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/conv2d_hwcn.py,sha256=vwraW4cCzqXanRnqaXm4pnhMJ0h-3PaWKj4u1nKQgCg,6036 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/conv2d_hwnc_tensorcore.py,sha256=nWBiA2jMYCnZJWj9w3E7ruTCzfNYoGPQO7ugCn17VJI,14745 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/conv2d_int8.py,sha256=EJ7bQqx8OCHw6loQNRla8QtQzguDzjMZLyBKe91SJCg,13169 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/conv2d_nhwc_tensorcore.py,sha256=LZfmo9L97q-yxgVRhEOddNslo-Z3w3FEdvI5tw9rZog,12782 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/conv2d_nhwc_winograd.py,sha256=bezRuv5-YLe16dJThDuC6xuDX2knXJE4GlnIjodRJkQ,26587 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/conv2d_transpose.py,sha256=bRCItu_X6se6oTvjIUJlKFsrPScDaPTfTqP90NG7t6Y,12269 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/conv2d_winograd.py,sha256=aHeO1utby138um6CWePFaH2VLpmdZlDazuiglyIcapU,13569 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/conv3d.py,sha256=vv9K8i6v-8HBp-nNRs0KgGvTqjyMJB5LxdNFBPONlZ0,8538 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/conv3d_alter_op.py,sha256=unKWKaxZJwht9G45gPa5IYMEmV-1aTNIHiUMlw_Ey_A,3910 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/conv3d_direct.py,sha256=qBWKfNhxpqvww7n5TWuiD6IgtPowDUS7u9M44cJjolQ,5229 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/conv3d_ndhwc_tensorcore.py,sha256=yTQz7ho0qIyK3bq2fzYWWCJJNe1gQJgUWdOMZ0ceBro,13475 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/conv3d_transpose_ncdhw.py,sha256=536_DuqBUDzjU9FYY_QU5YqhCJYw41WfsKJTnaiJDnk,6131 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/conv3d_winograd.py,sha256=JrXHiMe5QGibFw1N3pyjBooIfbDuz_EoXDAQJGCj3aA,24547 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/correlation.py,sha256=-GWzSX3SOzG2AnHPp0TmuAic-TGsGS-9c3tGinwZhOU,6237 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/deformable_conv2d.py,sha256=pfuuyVkjeoQ_bla-v-TzBcUR-mvgl0hr8OL5WQvFndU,5572 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/dense.py,sha256=HaMfD5i_3Cv3G5bJs6q6oQBjh9vg3pw0fbyAQilIcXc,7192 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/dense_tensorcore.py,sha256=loyXMmoQmObYGQw3LyiVv1nz-Ii17Hs3FBvHJ1Iurvc,10714 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/depthwise_conv2d.py,sha256=JTo2i-gareInoBhfXyAHJ-LyX24ZTcJaRsfNGgUGzqc,12050 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/group_conv2d_nchw.py,sha256=KSU8ipZ4EZlbRKmVq02dZboDSAHwZc1DEtclMGHnviE,20528 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/injective.py,sha256=nEEnzpeeZVbyqkVIiVBjagnFf3yd-pR4o0lFjZ066BY,4841 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/nms.py,sha256=-fKoJu01Zk2nOdN3D_CUBiyFzvsqPYalV1Nk0GNkmi0,40363 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/nn.py,sha256=IZ6doXgIoiwNLtTSKZ23DoTx_aadT_9zrsKDKD5oqUo,1965 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/pooling.py,sha256=0vsbDnaTYRshtvhTLQ7lvP2pmFEQJlN2ZaCdM66vok4,6895 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/rcnn/__init__.py,sha256=gHTIxlMyNRMQmlKrSC4czpDGIx0XjK-w_WxW_zeYSfc,895 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/rcnn/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/cuda/rcnn/__pycache__/__init__.cpython-310.pyc,sha256=4GHIFXMZ0bMLLQIGh6Oi6jjMtcj6jiw7sWWugTnkM64,253 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/rcnn/__pycache__/__init__.cpython-38.pyc,sha256=bAiOcqbK5GCjeKGUy5V0DD4YgMblxn9RVJMnxJNpci4,240 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/rcnn/__pycache__/proposal.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/cuda/rcnn/__pycache__/proposal.cpython-310.pyc,sha256=YavCw-ELz3LwuOooksxRw5O257kCsU-6kWujKEjnVRY,12069 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/rcnn/__pycache__/proposal.cpython-38.pyc,sha256=ma5zZcqmrVIn4lzy6lJgnx24TswpUCSZ7c-FEe17iNU,11584 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/rcnn/proposal.py,sha256=NwmbCF11HCcGanCHxwYtjCzAQAIj_gGrXFgOSKGc250,15163 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/reduction.py,sha256=qB_rUuNbxKq0mogOIt5TcCHkLvTZ4_Z5CiNvErknTEM,7891 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/scan.py,sha256=ig2ZT9r8pfThv8fYEPU50XoyU8aby1ikVOS8j9HcRKQ,27761 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/scatter.py,sha256=U5ml0El1yRIxvktW4AQLJhR7QVpbUk6w5dCJnrnSwJ0,13032 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/scatter_elements.py,sha256=AbAIdJGCbkaJppMgUllc3WwRYJRbji401TUNSG2o6tM,10364 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/searchsorted.py,sha256=FQftFbJ17u9qEDoJY1puF904FcoA3V6EfL8Brq-Fj7U,3846 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/signal.py,sha256=kjn9EE2ZaxzFO-IjJHBEWmJeon1_RPVVY_qjIFgEu4o,8348 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/softmax.py,sha256=hudNV_GkcIjwd5tSChFfyNdZxzwdzOdO2gonQe8Rig4,6940 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/sort.py,sha256=gF9QT9Lvmnyf3caHn_Ek6JWPNU7IjIbTCfOXKoHHHt0,41019 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/sparse.py,sha256=3a3CylwU-Wk-7OE5gWVvtohfQp0fC-PpsaFbCRt6004,17177 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/sparse_reshape.py,sha256=i7_DD8MSiiTBS64JHMolhmb52Pl-9-zS8N7p1Ff8Snw,8725 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/ssd/__init__.py,sha256=xwPGFUARnRF61AC2_lsP0KTeriCo1R-wtYqXn0Mn3DM,923 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/ssd/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/cuda/ssd/__pycache__/__init__.cpython-310.pyc,sha256=MlWsr--4ihQXo69kQl8fSrJr0a5owbZNmeYPPTZ_s-k,294 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/ssd/__pycache__/__init__.cpython-38.pyc,sha256=gvINmwIr-YvNLFNSGWPhFn5txNYCbxJpyslaZRkVdck,281 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/ssd/__pycache__/multibox.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/cuda/ssd/__pycache__/multibox.cpython-310.pyc,sha256=5-kB03pXLwHISn4Na1Pnhnjb8Pyzpi56KAgEw-e52B4,12707 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/ssd/__pycache__/multibox.cpython-38.pyc,sha256=9OsPdydS8kYIYgdhs4EkgUIVCbl0EIBIKmSuSe6yiB8,12257 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/ssd/multibox.py,sha256=UzPO-c4dcJKsdis6GVPCLZ-G4oScdwFlgkkAO-pN6gg,18207 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/tensor_intrin.py,sha256=exVEawrVs7mznF2gDtBBiRtTaVOxjSFqIWZjgkE0s0M,10581 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/tensorcore_alter_op.py,sha256=PlIxjkA_5DWPK6xBypVLyCa-tSQ9rtHfz969R_flTEM,8084 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/transform.py,sha256=qXaX4t7Ft39gY3a5szgoBxBZf7ubemiSGhurjJgZ2Co,4600 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/unique.py,sha256=mn9Nwxiux4jj-0uUF1rZOjr6L1s4e1ckbEJt5g9idxk,17024 +bitblas/3rdparty/tvm/python/tvm/topi/cuda/vision.py,sha256=kzAW0V9eI0TilkS_9sVQG079UEP3wrYWavf4JGQVRfA,4603 +bitblas/3rdparty/tvm/python/tvm/topi/einsum.py,sha256=rZqQ_O6Mzbo_fqNq-9MADoxfEO7EqQFu99tLUCw6dgM,1776 +bitblas/3rdparty/tvm/python/tvm/topi/generic/__init__.py,sha256=5tDOypZtbRJcDnGBxtHLhBKYb4cT8XGt21jjvulQlbo,1440 +bitblas/3rdparty/tvm/python/tvm/topi/generic/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/generic/__pycache__/__init__.cpython-310.pyc,sha256=crNuj86xac1y8-xDaEIx-p4VO_uCwXiT8FHtJbX0NOA,785 +bitblas/3rdparty/tvm/python/tvm/topi/generic/__pycache__/__init__.cpython-38.pyc,sha256=5xRqcU9X8HDog-xtPl3BEDdeFx8fkBsevpWUHeBFtCg,772 +bitblas/3rdparty/tvm/python/tvm/topi/generic/__pycache__/conv2d.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/generic/__pycache__/conv2d.cpython-310.pyc,sha256=ngkiQdydIG8FX6rAIu7mG2nUi3wRDCPOIxqMQSIrRKk,13079 +bitblas/3rdparty/tvm/python/tvm/topi/generic/__pycache__/conv2d.cpython-38.pyc,sha256=x7FYHsHoiaaL6V--cQl8hmCoY-caEYBQlDoXmXoFnVI,13109 +bitblas/3rdparty/tvm/python/tvm/topi/generic/__pycache__/default.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/generic/__pycache__/default.cpython-310.pyc,sha256=wHK7UX9cnsxLIoIPwW6UIiJ-WAUveA0IcoPtVxXslAU,947 +bitblas/3rdparty/tvm/python/tvm/topi/generic/__pycache__/default.cpython-38.pyc,sha256=uyh8b7br9oHqTwlEP2AJoNiRH5YWUtxKHqq7zs5FXMQ,936 +bitblas/3rdparty/tvm/python/tvm/topi/generic/__pycache__/extern.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/generic/__pycache__/extern.cpython-310.pyc,sha256=ugN3p4BSHZDPq0gs2c1Zja-FimXnz5VM6vl4QsU8BlA,785 +bitblas/3rdparty/tvm/python/tvm/topi/generic/__pycache__/extern.cpython-38.pyc,sha256=u96SLwdjynChqR4x7ubguhmQuz6wZ8xbhK8MKmOQBgU,772 +bitblas/3rdparty/tvm/python/tvm/topi/generic/__pycache__/image.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/generic/__pycache__/image.cpython-310.pyc,sha256=xllXCFvNzpkt57SZIWPIkL9UA5mBzskXg9VCiFPyKZo,795 +bitblas/3rdparty/tvm/python/tvm/topi/generic/__pycache__/image.cpython-38.pyc,sha256=Fhlg5jMYxdbg6Jbx3s2olWiLFDGGFeFwEheWpsVQVHg,794 +bitblas/3rdparty/tvm/python/tvm/topi/generic/__pycache__/injective.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/generic/__pycache__/injective.cpython-310.pyc,sha256=RgEK4uaHgcpFN6K5EXKXTMmJiacvl_6pNeXn10CkLXw,1721 +bitblas/3rdparty/tvm/python/tvm/topi/generic/__pycache__/injective.cpython-38.pyc,sha256=nC9Uk0M5q6dYBhCPufNnexWOf2fZUk5zhH07zvonhes,1710 +bitblas/3rdparty/tvm/python/tvm/topi/generic/__pycache__/math.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/generic/__pycache__/math.cpython-310.pyc,sha256=gNV_hFlo9xX9WaHrBVJd6if7Fxwv8UxdXOtmygjabKk,617 +bitblas/3rdparty/tvm/python/tvm/topi/generic/__pycache__/math.cpython-38.pyc,sha256=Fwhr6_S58eyhE3DzZw-M1hb5LFwJNSJsyUhgUWFocAs,604 +bitblas/3rdparty/tvm/python/tvm/topi/generic/__pycache__/nn.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/generic/__pycache__/nn.cpython-310.pyc,sha256=l7IwVjbAoHh-yrKTK3lnqoQPF6KihCOwglQc0peV5BI,23112 +bitblas/3rdparty/tvm/python/tvm/topi/generic/__pycache__/nn.cpython-38.pyc,sha256=I8GgPA_hv9yC6yL7E6JUYwciBYbyZoKkytF9_m7icGU,23743 +bitblas/3rdparty/tvm/python/tvm/topi/generic/__pycache__/search.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/generic/__pycache__/search.cpython-310.pyc,sha256=oqImXVyYxfYiysH2mzqlWVUn0G6a7TtazedwsCYDoDc,1143 +bitblas/3rdparty/tvm/python/tvm/topi/generic/__pycache__/search.cpython-38.pyc,sha256=6MQMBDwT2JX4bcvuXKKOXhfLzrNmIqMM_A_V6obthIM,1152 +bitblas/3rdparty/tvm/python/tvm/topi/generic/__pycache__/sort.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/generic/__pycache__/sort.cpython-310.pyc,sha256=XYejZx0-Nq1NwSvIQZ8bEJcxWOPFZyVwjf85qmPtZ5M,1414 +bitblas/3rdparty/tvm/python/tvm/topi/generic/__pycache__/sort.cpython-38.pyc,sha256=VulfEtz811Q9_gQIBB1ssOQWculom3vZfJmX_6XZWmg,1425 +bitblas/3rdparty/tvm/python/tvm/topi/generic/__pycache__/vision.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/generic/__pycache__/vision.cpython-310.pyc,sha256=JLqzY-kgFDCU-ZYujXXSgGkU_JmH45nek2DMToUPUJs,4046 +bitblas/3rdparty/tvm/python/tvm/topi/generic/__pycache__/vision.cpython-38.pyc,sha256=tbS8zMmYS7XCUFCnrTQjBOlTOIWIYds0QcfzlK-Lbo0,4115 +bitblas/3rdparty/tvm/python/tvm/topi/generic/conv2d.py,sha256=ye7JieGcLPIUirYmd0IUKJmt1vQsGkVOml7LAwF9VyI,21998 +bitblas/3rdparty/tvm/python/tvm/topi/generic/default.py,sha256=n_qoqx_zyDbZ5lBwNvKkfSlbcODxvLwMbiAY54ylvik,1411 +bitblas/3rdparty/tvm/python/tvm/topi/generic/extern.py,sha256=DuQ0FENLGfyOHs6rNFFhy4noDlxId2ExmIt62-0sEoY,1351 +bitblas/3rdparty/tvm/python/tvm/topi/generic/image.py,sha256=iBFGZByiKj0YbS9atgO5YCSfC8A2TQhXlQ-icaKqUbA,1606 +bitblas/3rdparty/tvm/python/tvm/topi/generic/injective.py,sha256=i2mt-fkQNg2EJf4oMremlwW05RVsBs03vpje8btEbwE,2128 +bitblas/3rdparty/tvm/python/tvm/topi/generic/math.py,sha256=03wUFCXH9aq9tBbRfbDGxob7DCDyrLWYlHYe8swTqVo,1181 +bitblas/3rdparty/tvm/python/tvm/topi/generic/nn.py,sha256=IwASyjSnnXOtHJeZUKr-PH-MzXCx9TegZ2JjISwko04,22232 +bitblas/3rdparty/tvm/python/tvm/topi/generic/search.py,sha256=j0c162lhOKIC7V_OtYTY9TB-OMFoEzt3r2MtBuk2ISo,1673 +bitblas/3rdparty/tvm/python/tvm/topi/generic/sort.py,sha256=SSwJyaf6dTdAQKn7um5v2NRzA6nn0n3edRxjHH6nQoE,1958 +bitblas/3rdparty/tvm/python/tvm/topi/generic/vision.py,sha256=lmtwMKIUVEO-MVHFJmi2vPaIsXg-4AoA0KE04SdzNK0,4372 +bitblas/3rdparty/tvm/python/tvm/topi/generic_op_impl.py,sha256=7D9MLHBMAB_hBYwhSRild3UN0RyelTN_t3OGM1Uu3bY,3915 +bitblas/3rdparty/tvm/python/tvm/topi/gpu/__init__.py,sha256=l9DsWuFNE3M9pd7N1uNgL7nMOeH0pk7-59ehrXPP0yY,928 +bitblas/3rdparty/tvm/python/tvm/topi/gpu/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/gpu/__pycache__/__init__.cpython-310.pyc,sha256=nUuX10t67FvX-t5P59hhsU2wF7zInHPL5WGNfKsErqU,258 +bitblas/3rdparty/tvm/python/tvm/topi/gpu/__pycache__/__init__.cpython-38.pyc,sha256=fuoYKcKg8fdaypKatWIv0h26pCmsm9HHG7hb2gDDwJA,245 +bitblas/3rdparty/tvm/python/tvm/topi/gpu/__pycache__/conv2d.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/gpu/__pycache__/conv2d.cpython-310.pyc,sha256=Lk_e-ysOUbasdpFCB91KhBUQqfbQuZy3isMe8fcS9Uw,1356 +bitblas/3rdparty/tvm/python/tvm/topi/gpu/__pycache__/conv2d.cpython-38.pyc,sha256=W2DPI4AYW7OBLkL14s8QtUa7JypH0WFFKdQJY0a7ifM,1339 +bitblas/3rdparty/tvm/python/tvm/topi/gpu/__pycache__/conv2d_nhwc.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/gpu/__pycache__/conv2d_nhwc.cpython-310.pyc,sha256=XXykerc3ekVv4PbZANpxBAHE-ujlD48NzQU-S7oDz_k,3374 +bitblas/3rdparty/tvm/python/tvm/topi/gpu/__pycache__/conv2d_nhwc.cpython-38.pyc,sha256=9SDh26KC7-0sG4OZshbsQVXBwyFmdPi5S7u51VpttAo,3328 +bitblas/3rdparty/tvm/python/tvm/topi/gpu/__pycache__/dense.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/gpu/__pycache__/dense.cpython-310.pyc,sha256=dslloGEX_mKY9p0G_kdWol4a4oodBB1x0LnqCoe83Gk,6621 +bitblas/3rdparty/tvm/python/tvm/topi/gpu/__pycache__/dense.cpython-38.pyc,sha256=YDv388AWO_UCBpZbjP7OEB0HJmA1sGwTuuAz-kwM7-4,6956 +bitblas/3rdparty/tvm/python/tvm/topi/gpu/conv2d.py,sha256=d6VGYkT9Ssw78-1M_e52A5JmkI5w0mJP301wNGNVQ2s,1695 +bitblas/3rdparty/tvm/python/tvm/topi/gpu/conv2d_nhwc.py,sha256=sbTzhBciiLXMKF_a6c0HfPpWdx81uez3Sehq22Xpjmw,5436 +bitblas/3rdparty/tvm/python/tvm/topi/gpu/dense.py,sha256=U1X0ePlSar_-6_QH3U-APDQwaxnVGzYkN3mjIy1BoFE,8670 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/__init__.py,sha256=jAjn8bi7r5PRf9IUGccfPrisUDugpE1dBMgaGd_qT6s,1146 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/__pycache__/__init__.cpython-310.pyc,sha256=LEldvkaHYGb-6M2XkB_1nCdR4gSKdDHsnJFhMuiY5C0,457 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/__pycache__/__init__.cpython-38.pyc,sha256=eOYIVxxH2PytjL184EcDCcPu4xXzuvZu3oL-NQipSTY,444 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/__pycache__/batch_matmul.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/__pycache__/batch_matmul.cpython-310.pyc,sha256=tmNMIZ3DnCz04q4f25D9xLH4ymWldDiYB4Xn9Gyl7o8,959 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/__pycache__/batch_matmul.cpython-38.pyc,sha256=Zp529oll5y7uZ0SpEh7NuVNJ8DRcMZji570n95fbYA4,948 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/__pycache__/compute_poolarea.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/__pycache__/compute_poolarea.cpython-310.pyc,sha256=UG_W94W1axeYnHAJFRpVk4elK0b6St95on1AKZGjpws,6814 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/__pycache__/compute_poolarea.cpython-38.pyc,sha256=ops16npL6IL7LhI47KVbAjKROZujc3cryrQhld9Lunk,6809 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/__pycache__/conv2d.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/__pycache__/conv2d.cpython-310.pyc,sha256=dPJ2iw__uY_0M5z7wLM4oqMrO8l-oQA6jJ9fG2Kp_-U,3837 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/__pycache__/conv2d.cpython-38.pyc,sha256=AgWUpjTFOmcL2RDLYoSaaA0t5UCv2gXmxCMsrl--3TI,3866 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/__pycache__/conv2d_alter_op.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/__pycache__/conv2d_alter_op.cpython-310.pyc,sha256=5i3eTXE8kKUVqg6hsCWFzDvBXI_0dDCmo2xnc-m3t-4,2786 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/__pycache__/conv2d_alter_op.cpython-38.pyc,sha256=d37Mky8Z8mMnHHwDxvWqJsP1gYIZs2n0Criv2bzbAQM,2825 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/__pycache__/dense.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/__pycache__/dense.cpython-310.pyc,sha256=TEIOgm8MBiShpZ6xJfmuk3ZYq9rwx8NcsrdrX2Joo0c,3312 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/__pycache__/dense.cpython-38.pyc,sha256=kIu61JzhnIXTKfoSgdwJah9m2KUuZAMSL4uasmcSQpc,3325 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/__pycache__/dense_alter_op.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/__pycache__/dense_alter_op.cpython-310.pyc,sha256=ir_oxLDgRQtZ_4OcZyqoJ3HVqM8Y8iCEIIr3UV7M7rk,3617 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/__pycache__/dense_alter_op.cpython-38.pyc,sha256=g7k3AOGkerwaNM2P1oZa_7CFnWZ79T-BeMWU72_tyzk,3612 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/__pycache__/injective.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/__pycache__/injective.cpython-310.pyc,sha256=HXzmkCl3X-hEk604S2JHTrBloalAAMcd4yLD45G2FLc,1494 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/__pycache__/injective.cpython-38.pyc,sha256=PP43s5l8gGlf2RhbGc2LkY4plIok1e8gaRl5w5Pkbj4,1503 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/__pycache__/pad.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/__pycache__/pad.cpython-310.pyc,sha256=yCipT5M0QC65RH_2O_dKK4qyjCLXEYjlhaphPFpN71Y,1183 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/__pycache__/pad.cpython-38.pyc,sha256=XDkHapjkh85BYPnLu38Bzhi9s6Rd3RAvUdOv0R0orEY,1172 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/__pycache__/pooling.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/__pycache__/pooling.cpython-310.pyc,sha256=tXOOlCjTOW-u1A3DsoOjDpyuOCK_tsx5LKVTyaYsgvE,1103 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/__pycache__/pooling.cpython-38.pyc,sha256=qK81sYp_Rd7RM0HNsO50XFUa3lPHP37is3YIZY0n_C8,1092 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/__pycache__/reduce.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/__pycache__/reduce.cpython-310.pyc,sha256=oOQRLuj8xQro7ZbSbDZruyuaTMSlz61b4xJvsefDId4,932 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/__pycache__/reduce.cpython-38.pyc,sha256=_6yyPSej8fEu9hBTN1bMaRu8rYuPPE4ljUvAGmgoSgk,921 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/__pycache__/resize2d.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/__pycache__/resize2d.cpython-310.pyc,sha256=ED-oTMIu3xkN4dK0DIoRedkTKIiz5JmJbGNtHrDFVhc,1946 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/__pycache__/resize2d.cpython-38.pyc,sha256=Vv9O6kFFbqbSKJ92uroG6nM6ZOXt6yp015dIZdIiCwk,1911 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/__pycache__/tensor_intrin.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/__pycache__/tensor_intrin.cpython-310.pyc,sha256=ZwPpq4xE2SUqZg_0AabJOELST2YnEJvbLbLZYLH5u8g,7806 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/__pycache__/tensor_intrin.cpython-38.pyc,sha256=CvB2Kbca5axauz__z5daJKMI7k5qj2-uQVoVK46MYh8,7845 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/__pycache__/utils.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/__pycache__/utils.cpython-310.pyc,sha256=9V0u4ocuyiVoGsCru_7EQNGXDsB5E7Wl58bUfdiFuUY,14877 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/__pycache__/utils.cpython-38.pyc,sha256=U4_6lS1QUY_vLKeFP5Ny0q9spt31_v5dNUM1qZLdsi4,15375 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/batch_matmul.py,sha256=K_i59a37r37MyHa-5y9TNCDfMBAtqwO2bCwmIjpnCeM,1362 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/compute_poolarea.py,sha256=NHt5z_HBbqkK9zQMpARItc90YxI6z4imD2xNVdjxSEs,7553 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/conv2d.py,sha256=2bMpp-OVYYcqtdA8ijR_CT2iXiEGAZlij_J9dWZu2Mg,4408 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/conv2d_alter_op.py,sha256=e5bKvxz7D-Bn_Ay_I8j_4olhVhk7_iCq1X86g9tHs2k,3961 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/dense.py,sha256=vXYcMxRBQJGcnRelhvkSj9HNFzdbGafnGTulNW7Wp5o,3434 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/dense_alter_op.py,sha256=HyImSk55U6vbaeoOrFG4MGjsazjCYjmDbuj1MdHTAXM,4910 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/injective.py,sha256=ijAiPVIJHtCWEwqSSWY5Qf-1Mj9s4gKeFubTBnTddi8,1799 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/pad.py,sha256=j4jrU-I0Pm7Up9QLKll_o7DEEE-LXIA8j2PlnYj65dQ,1723 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/pooling.py,sha256=yq8ftrfDr0xn3xu4Wzq5kE-i0KBCgCLUkFGPK3PiPuk,1488 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/qnn/__init__.py,sha256=WGKFr5V4PxYKOCYaXEc8BoPJW0HQDBK2Be2nlShyd1s,1286 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/qnn/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/qnn/__pycache__/__init__.cpython-310.pyc,sha256=x41rEoPkjzLuw3kEyPMRbPBKODozSAU377F0XcPvB4k,709 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/qnn/__pycache__/__init__.cpython-38.pyc,sha256=ZxCoIhIRkGMGR2O6H30LfX1GQAKyUONq7TPH-R3UZsY,696 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/qnn/__pycache__/adaptive_avg_pool1d.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/qnn/__pycache__/adaptive_avg_pool1d.cpython-310.pyc,sha256=Y5KBDrc8HcnC1nDWWkDBiRx99xHhgJ7x73ztnnr7mDM,3634 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/qnn/__pycache__/adaptive_avg_pool1d.cpython-38.pyc,sha256=OP7zg-JbKhRQKVVxI_Lx1Zaw6zN0g8vWwMvQBTPAjf0,3609 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/qnn/__pycache__/avg_pool2d.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/qnn/__pycache__/avg_pool2d.cpython-310.pyc,sha256=hmxRX1HN_L8m0FoHwVMnmkkc-AUUNuiNRcQUpAKt9Zo,8261 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/qnn/__pycache__/avg_pool2d.cpython-38.pyc,sha256=65hP8FGJOAI8aWOHGtByX-Ki6pvCgUuMoSrnOlxM834,8308 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/qnn/__pycache__/conv2d_alter_op.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/qnn/__pycache__/conv2d_alter_op.cpython-310.pyc,sha256=lkssW5jDjQGyw-JNWrgmYCJHzGHVehI3p-cDKiT4eA8,1069 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/qnn/__pycache__/conv2d_alter_op.cpython-38.pyc,sha256=QNwiRWTkc57KPfvNz4S9sqTC1e-vqZbW13thMzw9em0,1060 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/qnn/__pycache__/dense_alter_op.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/qnn/__pycache__/dense_alter_op.cpython-310.pyc,sha256=qI0YRjpXlB7vnxJfGGgiDbxFPCXtQlmG5oR294NM1ak,745 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/qnn/__pycache__/dense_alter_op.cpython-38.pyc,sha256=ajOyUb1nesu3WlPA-Kwoh_e2M21MUCWbdy72Ckjgieo,728 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/qnn/__pycache__/dequantize.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/qnn/__pycache__/dequantize.cpython-310.pyc,sha256=BHX5GMIJkVGO8UFbE29Xa09d7pkoOAJrCo2pNd-zxkI,2287 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/qnn/__pycache__/dequantize.cpython-38.pyc,sha256=bo1fQQnhDFQTNrcRCoq426c13aYB0TlrCyGhmsTPX5g,2277 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/qnn/__pycache__/global_avg_pool2d.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/qnn/__pycache__/global_avg_pool2d.cpython-310.pyc,sha256=M9oCRzVSkexMrrweSbRsX0KB5mEau3_pTxIQZxWPfFU,2405 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/qnn/__pycache__/global_avg_pool2d.cpython-38.pyc,sha256=nO-kxrG4j2EXlZkpCRySUDPMytdsnpkAk4U0OXeqoho,2372 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/qnn/__pycache__/nn.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/qnn/__pycache__/nn.cpython-310.pyc,sha256=RFSnrn6teR-QD_x2BziywLg-3uxq_t5_B644HTSlAf4,24572 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/qnn/__pycache__/nn.cpython-38.pyc,sha256=yfRjL0InroiGZdXywiaTztQFktPqYoRLiQquLV7ZrYU,24873 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/qnn/__pycache__/qadd_qsub_qmul.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/qnn/__pycache__/qadd_qsub_qmul.cpython-310.pyc,sha256=bnkQ6Zfb6RS1eeeIlDA4WO1xmPvilR0B2Y08VQOCz1M,5039 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/qnn/__pycache__/qadd_qsub_qmul.cpython-38.pyc,sha256=1U3yzaoX3c7WJwqigORjHrmBTEhHCZKx-vfeT8MuLbU,5098 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/qnn/__pycache__/qdense.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/qnn/__pycache__/qdense.cpython-310.pyc,sha256=Id6C0SFDoxvCVEywi36YttO7hNbZxqiDOZtmckVB-b0,3972 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/qnn/__pycache__/qdense.cpython-38.pyc,sha256=OdCUVjUaqfHbYQOxP9pgp5UuVGGlg8KJYzPELL27rhg,3961 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/qnn/__pycache__/qdepthwise_conv2d_slice.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/qnn/__pycache__/qdepthwise_conv2d_slice.cpython-310.pyc,sha256=W6F6b_7DGnfwJGZnFCwqaXAKznuw7lW9JnQP1cNYXo0,5034 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/qnn/__pycache__/qdepthwise_conv2d_slice.cpython-38.pyc,sha256=vTKJZ7ThCj_5PKA5fIlvstrbj9L2e3qhwr7Lv1HGHJU,4999 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/qnn/__pycache__/quantize.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/qnn/__pycache__/quantize.cpython-310.pyc,sha256=A4i-4wKYzjDeFia-YdCw2xpwI0zL5IP4AXYLEPOAnag,1910 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/qnn/__pycache__/quantize.cpython-38.pyc,sha256=ZSao-6wycgnFjDn_bNf9YXxByD4hK5FplF-4gAZYG4M,1869 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/qnn/adaptive_avg_pool1d.py,sha256=RiAXNSJLkJ2kNPyjZvYU0G8HdOGpQXjiESL199Uz79E,4364 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/qnn/avg_pool2d.py,sha256=LsbUHWX0LRdDLSS7v3bvBDP80AE9nE1bhSBI2yIAPGw,13400 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/qnn/conv2d_alter_op.py,sha256=u9oD_xDxh3HCbNVoZDkZY5etkKIZ-9H5SCpdjbhDYBA,1921 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/qnn/dense_alter_op.py,sha256=kvG2Newnji1V17QbbPiOzo_Z8i_nsPqyW0_iIZKcqKQ,1332 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/qnn/dequantize.py,sha256=O9iYFI-h38m0CgffLkDy3o_3_vpNUoIFRIoCoG8trSY,3207 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/qnn/global_avg_pool2d.py,sha256=bN6_k-fG9lzg8c-dMBdmRcsOtxJwhK60iw_2sz-5Afo,3136 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/qnn/nn.py,sha256=v8aZfQ3f0BkDc-ndbZ-HW7S3KoefBk0ZjJSE2xqKhWg,31389 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/qnn/qadd_qsub_qmul.py,sha256=GV8Slg42REjXngE2f1y6rtP3S6IJ4vIRTuzrcd06BHo,8713 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/qnn/qdense.py,sha256=2W7Cq6hvAwgOyTyGJPOSQ0vK6_PyHsF9EDVaafk0koo,5202 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/qnn/qdepthwise_conv2d_slice.py,sha256=384cwCrFEhNEEdKbs1MvgpOajR6_DflB7yQ3YNhVVJM,7240 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/qnn/quantize.py,sha256=U6Y2jA9LkAYWe4gz9rzAPQ8Jv4t5Lj5NAR4XlOYAmnI,2777 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/reduce.py,sha256=PlOofQNsGz16mdb2H_8gAifqivHM_A2t1zQKLe8ybaA,1347 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/resize2d.py,sha256=DYrsa8OOV_qEvsyhNJrmmyL9z3L4t3D-mamYuIUy_FQ,3642 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/slice_ops/__init__.py,sha256=tCwVDC-tvtMduMoVo3GV3vTol4N1hjWjsX8v8aMCBwE,1649 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/slice_ops/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/slice_ops/__pycache__/add_subtract_multiply.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/slice_ops/__pycache__/argmax.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/slice_ops/__pycache__/avg_pool2d.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/slice_ops/__pycache__/batch_flatten.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/slice_ops/__pycache__/cast.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/slice_ops/__pycache__/clip.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/slice_ops/__pycache__/conv2d.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/slice_ops/__pycache__/dense.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/slice_ops/__pycache__/depth_to_space.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/slice_ops/__pycache__/dwconv2d.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/slice_ops/__pycache__/global_avg_pool2d.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/slice_ops/__pycache__/max_pool2d.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/slice_ops/__pycache__/relu.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/slice_ops/__pycache__/reshape.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/slice_ops/__pycache__/softmax_slice.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/slice_ops/__pycache__/tanh.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/slice_ops/add_subtract_multiply.py,sha256=E8okz9WgXPlJ7YsYSjBikobf8GQptty3OesfFi1hPlY,2910 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/slice_ops/argmax.py,sha256=JyYRbeHNrj0_gFqweSbseFeDqmpR4T-N6Iu-e5GeGbs,2263 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/slice_ops/avg_pool2d.py,sha256=c7md-szZkBQRv6zpCUPIRDwaHoF5OTI2GnUPjmAacYU,7872 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/slice_ops/batch_flatten.py,sha256=1HRP5SMIBgSAv30y-21jk-GngQQCexB-twRfw1rjqTY,2869 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/slice_ops/cast.py,sha256=niVZ_REEFHGHWVZmy20F3lT8ztC1FJMFS9Up0TnZwl4,6273 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/slice_ops/clip.py,sha256=xN9rRuf7vYzQqV4-XSLPPuubPKUz4Vbl785qEft41bk,1933 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/slice_ops/conv2d.py,sha256=q7mys03jukHF384iqB7fXFYs9yimZCwnkRKcUC6e5lk,9197 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/slice_ops/dense.py,sha256=GKZyWW3BKUzXdrITW0r_bIfACXFKVMWIglRvdc4LnGk,4122 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/slice_ops/depth_to_space.py,sha256=InkrU44hFHkBrx5WrOEiLkn4DEx6cLNgUcU_aGqxYYw,1777 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/slice_ops/dwconv2d.py,sha256=binxqiK8FZlihWu9wDT3J8NK1IdzWTwjG5GG69z6p20,6336 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/slice_ops/global_avg_pool2d.py,sha256=f0COlit43yEJ4kT38fJMANHxK6WU_q52w8R4OX3CZi4,1851 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/slice_ops/max_pool2d.py,sha256=nHUYm59aq6IjJePSuGVjhZJ5aNnoe-NsQHkFUxvOh-8,8183 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/slice_ops/relu.py,sha256=HUrpDljPPnEztBzbAFL7wI8pwzKaEePrqobcSLoAW_4,2329 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/slice_ops/reshape.py,sha256=ubLRB5rQgI6otLXW8RcasDcqomSmpW-mGnzxlsI3RTw,4005 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/slice_ops/softmax_slice.py,sha256=6mDzbyDWjEK13Ui_e86fWAM2O_0CC4GP8J3DPJGN0P0,2628 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/slice_ops/tanh.py,sha256=4GjQCKcixSfHwKA-wl73OHFjZF6ur3Yn5gowlvdLyR4,2228 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/tensor_intrin.py,sha256=cl_7AkatjR5xD9XSYB-roAHyfOUehMKW0SGh37KTYlE,12176 +bitblas/3rdparty/tvm/python/tvm/topi/hexagon/utils.py,sha256=5Bjs1o9e4e-4wTs2GBwhIeANjuZ31hPuxCZ8LmFjge8,16525 +bitblas/3rdparty/tvm/python/tvm/topi/hls/__init__.py,sha256=-JjO0ax1NZHFAWpqrVKnCNjm5YIxO5ttgjHxeEnprWs,1032 +bitblas/3rdparty/tvm/python/tvm/topi/hls/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/hls/__pycache__/__init__.cpython-310.pyc,sha256=IID-DfEabvV0VFewvW_P7hYXutVd0ynmDwnjuG1ACwg,407 +bitblas/3rdparty/tvm/python/tvm/topi/hls/__pycache__/__init__.cpython-38.pyc,sha256=8a-uVOjbEENfNH8mUMwCKXLREBIZuIU2UiHj565qS9o,394 +bitblas/3rdparty/tvm/python/tvm/topi/hls/__pycache__/injective.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/hls/__pycache__/injective.cpython-310.pyc,sha256=-JmAObgInPhuSxvrgJ5zUm-fW83exnJtrtkJv_0Lsx0,1621 +bitblas/3rdparty/tvm/python/tvm/topi/hls/__pycache__/injective.cpython-38.pyc,sha256=xm58evI_lCe_XI6g7JxbRmtFxu1PF50G9iL9RGWigNU,1610 +bitblas/3rdparty/tvm/python/tvm/topi/hls/__pycache__/nn.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/hls/__pycache__/nn.cpython-310.pyc,sha256=jln80QPab47Tbz9gQ2VZh8WN-7NseU_YJUJV9XThYOM,9879 +bitblas/3rdparty/tvm/python/tvm/topi/hls/__pycache__/nn.cpython-38.pyc,sha256=WFfBhov1acY1UALatNEX57mhZJCE4XPG1-HaPktIxSU,10552 +bitblas/3rdparty/tvm/python/tvm/topi/hls/injective.py,sha256=KAmfn7f-89QL08tnP3luT1aAEhRzBnhdKpOoqpfX1a8,2055 +bitblas/3rdparty/tvm/python/tvm/topi/hls/nn.py,sha256=ktFuldHjqyhNBIphrPwMRboW1Vxit0Dj0OEQ9oT83a0,11909 +bitblas/3rdparty/tvm/python/tvm/topi/image/__init__.py,sha256=byXNzuvGBpos96cr22MFpImu-wW6vAqpcTi8rGzIyeE,973 +bitblas/3rdparty/tvm/python/tvm/topi/image/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/image/__pycache__/__init__.cpython-310.pyc,sha256=pcsG5iN9aMHr7pVstKpS1-v9-OOHRtuxbDD9_Gh_VBQ,333 +bitblas/3rdparty/tvm/python/tvm/topi/image/__pycache__/__init__.cpython-38.pyc,sha256=n4icb1W6Nus4cFyfP_QIHfxtJaqGEwZueBFNfLcTIDY,320 +bitblas/3rdparty/tvm/python/tvm/topi/image/__pycache__/dilation2d.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/image/__pycache__/dilation2d.cpython-310.pyc,sha256=aLO02ylCS5hVPvv5lIY2H8Ygq8muPz3Hf67RLRh-hwk,4178 +bitblas/3rdparty/tvm/python/tvm/topi/image/__pycache__/dilation2d.cpython-38.pyc,sha256=ooVrcJ8SnZESH5mr0ahKpHYerkXLAU5D7uEzLV8btNw,4190 +bitblas/3rdparty/tvm/python/tvm/topi/image/__pycache__/grid_sample.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/image/__pycache__/grid_sample.cpython-310.pyc,sha256=nfntWqXjeTUf8pZYRhzAA-NlYltFcQmOEedHRyh6Q1g,17466 +bitblas/3rdparty/tvm/python/tvm/topi/image/__pycache__/grid_sample.cpython-38.pyc,sha256=fQLTDTD0RdTJb7U8BHMWI7JLfD8xcqUnF6k8rYdyJJU,17716 +bitblas/3rdparty/tvm/python/tvm/topi/image/__pycache__/resize.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/image/__pycache__/resize.cpython-310.pyc,sha256=7foPlxzNaKnZAXmvLcURoW3q83J1wc4euDMxR8EZEEM,31591 +bitblas/3rdparty/tvm/python/tvm/topi/image/__pycache__/resize.cpython-38.pyc,sha256=Fsg6zK7xfDfsJdoXt8jiv8m0vhyHZK7X6PVj_4fsDbs,32074 +bitblas/3rdparty/tvm/python/tvm/topi/image/dilation2d.py,sha256=e_d-9pyzQg3YcUS8uZH0dBRh7YgNOst1Odvb9PO1Krg,6187 +bitblas/3rdparty/tvm/python/tvm/topi/image/grid_sample.py,sha256=w2SXIcc5-dKqjn8oNFx0Kjm0jY0xK2D7xQGkIKxeUwA,20738 +bitblas/3rdparty/tvm/python/tvm/topi/image/resize.py,sha256=m7M0h8AhQjd2NURJj9QGWTav3jIJGdJBKt7MQnl9bdY,42595 +bitblas/3rdparty/tvm/python/tvm/topi/intel_graphics/__init__.py,sha256=VOYB33wKvNZ6_3lT_7X8qwhdRhI9ZjJxs6iwbkeUZxM,1028 +bitblas/3rdparty/tvm/python/tvm/topi/intel_graphics/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/intel_graphics/__pycache__/__init__.cpython-310.pyc,sha256=AkoQfxKowW3Cqp0bbvtNdcbcNGeApUjr4h9cPUayoZU,392 +bitblas/3rdparty/tvm/python/tvm/topi/intel_graphics/__pycache__/__init__.cpython-38.pyc,sha256=OVFZYZB6rKU674YAi2McB3otoVo6dfojS9Ks0kl-wkE,379 +bitblas/3rdparty/tvm/python/tvm/topi/intel_graphics/__pycache__/conv2d.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/intel_graphics/__pycache__/conv2d.cpython-310.pyc,sha256=eubMl6LgpfdLlafODT_14I9LyWgbk3FAyAE64BdfdVs,16129 +bitblas/3rdparty/tvm/python/tvm/topi/intel_graphics/__pycache__/conv2d.cpython-38.pyc,sha256=_VgjchH7yJl0dhGvIEaM12Ek4QRR6FKSFDBGr56CP_M,16264 +bitblas/3rdparty/tvm/python/tvm/topi/intel_graphics/__pycache__/conv2d_alter_op.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/intel_graphics/__pycache__/conv2d_alter_op.cpython-310.pyc,sha256=GVBTG8CGTfJp6B9PK_NmObRSrowf_pGcQHey_4f4Ciw,2930 +bitblas/3rdparty/tvm/python/tvm/topi/intel_graphics/__pycache__/conv2d_alter_op.cpython-38.pyc,sha256=B9QBa1WidnQxXeJtIgp-b3T4l26XZOT5NsM9sW0hsKc,2955 +bitblas/3rdparty/tvm/python/tvm/topi/intel_graphics/__pycache__/depthwise_conv2d.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/intel_graphics/__pycache__/depthwise_conv2d.cpython-310.pyc,sha256=VuOK93Zv_myzwz3M7HwtnSJC8VQJI3e8Mtg7OCpqVN0,4613 +bitblas/3rdparty/tvm/python/tvm/topi/intel_graphics/__pycache__/depthwise_conv2d.cpython-38.pyc,sha256=eK7I3dwEbRYSgo8CS7O8knYqM0wLkQfgnmx5clwgyNo,4601 +bitblas/3rdparty/tvm/python/tvm/topi/intel_graphics/conv2d.py,sha256=eUBPlTtnZqw4ilu7u91hbglM-SJMIX7j5FZKwSXSSvs,22334 +bitblas/3rdparty/tvm/python/tvm/topi/intel_graphics/conv2d_alter_op.py,sha256=mio88D8LmfpaNOR355eO-FhWQRJIXmkxSmAmVLUWYaY,4884 +bitblas/3rdparty/tvm/python/tvm/topi/intel_graphics/depthwise_conv2d.py,sha256=y7tHdfc0NwjBljvZSkg_WRHJxwmGVmKTvSV_ELHk6Bo,6819 +bitblas/3rdparty/tvm/python/tvm/topi/mali/__init__.py,sha256=4LeoaYWxjmQx9ob8KFEB7wIOccItGA9QfIxtvpRM0jM,1017 +bitblas/3rdparty/tvm/python/tvm/topi/mali/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/mali/__pycache__/__init__.cpython-310.pyc,sha256=nqg5IuzY_45itUJJjrKh_5NBwjTJNhbg-EeaRVqPL1c,357 +bitblas/3rdparty/tvm/python/tvm/topi/mali/__pycache__/__init__.cpython-38.pyc,sha256=UObTGDAZCwZMlrIssEhczqd5qCovml4orrxB48xWbho,344 +bitblas/3rdparty/tvm/python/tvm/topi/mali/__pycache__/conv2d.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/mali/__pycache__/conv2d.cpython-310.pyc,sha256=4G1F8Ggwbc1HyqELHE9x7CfLENe_tK4E2QgZu7HM6ac,16871 +bitblas/3rdparty/tvm/python/tvm/topi/mali/__pycache__/conv2d.cpython-38.pyc,sha256=aM6tFBoW6yBBN1-gmuFi_6PCu0jSsR4t-1CTQoDVV00,17121 +bitblas/3rdparty/tvm/python/tvm/topi/mali/__pycache__/dense.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/mali/__pycache__/dense.cpython-310.pyc,sha256=M1vVqxf2ht20CxCthoE3hNXPNu8KKc2whoKF9DVFIhI,2988 +bitblas/3rdparty/tvm/python/tvm/topi/mali/__pycache__/dense.cpython-38.pyc,sha256=n271p8KbMlo5p2XJHGZxYE6icZklQwNmBX7eKoft3zw,2972 +bitblas/3rdparty/tvm/python/tvm/topi/mali/__pycache__/depthwise_conv2d.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/mali/__pycache__/depthwise_conv2d.cpython-310.pyc,sha256=7GBHUnhgBo5hNm-zXWbRhC76ETxlKEDkfLejMUFd3Qk,4950 +bitblas/3rdparty/tvm/python/tvm/topi/mali/__pycache__/depthwise_conv2d.cpython-38.pyc,sha256=R-Mp6CCxcHlgAdzt2qAntaloUaq7jpK4laWukN685QE,5152 +bitblas/3rdparty/tvm/python/tvm/topi/mali/conv2d.py,sha256=bzWvAVrYjynxbRwjB9YnkChjz_jHKz6zZClOyh1I4Zs,23060 +bitblas/3rdparty/tvm/python/tvm/topi/mali/dense.py,sha256=xmeJFeYZQwEbccecjfxSiz_SiWU79EI4wVCUf6uj7-M,4074 +bitblas/3rdparty/tvm/python/tvm/topi/mali/depthwise_conv2d.py,sha256=-bcz_XEmM3N6IKkHwJeEI_cBPQ83QO20hUhhttSKlRU,7489 +bitblas/3rdparty/tvm/python/tvm/topi/math.py,sha256=XqjcCxY9wUhoeFoN27sx31Nbk01jUsouKoWY4xSlrF0,17888 +bitblas/3rdparty/tvm/python/tvm/topi/nn/__init__.py,sha256=GJxomU72Dp_MDXeeQVqCKqqeXMKR7Dl1o8ADTq0GgBg,1904 +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/__init__.cpython-310.pyc,sha256=h1Qnr-5krV62UxF00QyKG3sDYKU_FGL55uxwdMgouZE,1132 +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/__init__.cpython-38.pyc,sha256=p-UKFCVzx3CbbJkCHCuWeqC3VzYBMXhjYEIexRSf8Og,1119 +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/batch_matmul.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/batch_matmul.cpython-310.pyc,sha256=CMWccGtd-UFqmnx4O6sduiaWrJwq7f3aqjmCf_wo2Lc,4448 +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/batch_matmul.cpython-38.pyc,sha256=-Ds0k3FTNREveYMS-1nA-ZSMqdWXXW8lA9IXy_E7bYY,4484 +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/batch_norm.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/batch_norm.cpython-310.pyc,sha256=qaNPI8KLZgBhuJkhJZL97Fq4PmfcTyjf1qOHcP_CPic,3490 +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/batch_norm.cpython-38.pyc,sha256=v3WRol_HA5fEc0gSIeVVNbJRbAEuOkMqwpaetNkjfus,3445 +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/batch_to_space_nd.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/batch_to_space_nd.cpython-310.pyc,sha256=MTPScfen22mRmO-QlBxIEi2bIqxluNkalqKhs4ynMa8,1240 +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/batch_to_space_nd.cpython-38.pyc,sha256=XPgeLx_11jKc7PvKOIqfdkVw61XA0XEEMkIpAqJeQbA,1227 +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/bitserial_conv2d.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/bitserial_conv2d.cpython-310.pyc,sha256=mMC9vXa-AZi8r4ItNlsh81JeqYnhG8LgSO6cJk6likI,6327 +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/bitserial_conv2d.cpython-38.pyc,sha256=vMWMPjR3ggB4hCnahm5C8jxvSX09R0qYaEZaTaVXAL0,6358 +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/bitserial_dense.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/bitserial_dense.cpython-310.pyc,sha256=5oK13P5yyr4g6ZLwnLpicmk_TOjCEdOrUpIcFiipMWQ,1956 +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/bitserial_dense.cpython-38.pyc,sha256=Zg0xV5-vl8LpQBqr-S-fEr_xdZv6cfqKIdqlmirK188,1945 +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/bitserial_util.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/bitserial_util.cpython-310.pyc,sha256=Ong6OrGEm95l7xDY4ZMdI4NCIbYeKsKc3gruZ1xQHIY,2176 +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/bitserial_util.cpython-38.pyc,sha256=NcnN4IgrqlmeRuEG2vyW-ye4V76ARw1wcdZ2INmK85o,2160 +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/bnn.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/bnn.cpython-310.pyc,sha256=nQGaPk7kVikurNHLavuURqa-kfjIpZfcwcdNXcKdC98,3361 +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/bnn.cpython-38.pyc,sha256=RTYr3-mGD23p9DYkbtRsgCt1x11vclOTdlQ0wbefsGE,3383 +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/conv1d.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/conv1d.cpython-310.pyc,sha256=_oBsYp5T1mRYJIdAm7UVPCVDkipcDmDkjmm8Obu3BwA,3752 +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/conv1d.cpython-38.pyc,sha256=hVH6PEoyt-rcYQ_tT4GJ08kgvMnVh_qDwqoMqGNLuH4,3850 +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/conv1d_transpose.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/conv1d_transpose.cpython-310.pyc,sha256=zN15iq15o4VzmX7We4uyV_ZeQ_1ferqIQA_-Xr8uSxo,5242 +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/conv1d_transpose.cpython-38.pyc,sha256=bW1BvGbe09Mh7Oi88tliy85C-ZOwAdhHBV3TEOsYAnE,5270 +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/conv2d.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/conv2d.cpython-310.pyc,sha256=57MAmkKs25_-W0HNOJhYXqsq_1kQqpkgFcV4hWzZLV4,39433 +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/conv2d.cpython-38.pyc,sha256=7ScJIVBEnB0jS3syFH6j-gjbj3O68yZoFFXbTj3MJLI,39786 +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/conv2d_transpose.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/conv2d_transpose.cpython-310.pyc,sha256=fudjQ9gujF0Kd4TxndP2L4kh4chyPKT1z6-dOT4hxro,8797 +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/conv2d_transpose.cpython-38.pyc,sha256=n97Vn3khdBwwqUX5r4um0UzVUC1yf9rgdgXR5GhoRZc,8940 +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/conv3d.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/conv3d.cpython-310.pyc,sha256=mV6i8KzuW6LsSwZY7hxs4c7xUNmYtz-L-BU9nPZ9BBY,4793 +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/conv3d.cpython-38.pyc,sha256=YOeEASnCu6C1GoQx-rP84A55UmEEIvk-mcvacrVVnbc,4787 +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/conv3d_transpose.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/conv3d_transpose.cpython-310.pyc,sha256=h1E5fDnLohIX5F1Y5xa3-8A2AITZ3JhkJchWK2ZLR5A,6706 +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/conv3d_transpose.cpython-38.pyc,sha256=ncY3Rvbd490Cle74EqdD9s0CcyYB8BS9raoNrog8Jkk,6744 +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/correlation.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/correlation.cpython-310.pyc,sha256=krMf-jBGm1bPJV8BgBcRaTW7nAeMY0q101-9tCFn4LA,3322 +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/correlation.cpython-38.pyc,sha256=xTtvNnQbaUUJ8qAreXH6X93XvzEqYqB13Tz688SdbrY,3325 +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/deformable_conv2d.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/deformable_conv2d.cpython-310.pyc,sha256=RRDIpezUnSW4RFtaj3cuHJfgSoJgZ5tClzr1GH0ohlI,6031 +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/deformable_conv2d.cpython-38.pyc,sha256=r1aj4oTM8CaxvhpwaLxqKPOI3qd8ejguMsGTRUJAHp0,6108 +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/dense.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/dense.cpython-310.pyc,sha256=97_MKnmuwy47XoyhY6PhQYzU_xu_YlUF0Gbob9riKmc,8302 +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/dense.cpython-38.pyc,sha256=nMLahRrmg8kcwZTM3ZVszxbMU6qijBc4PANjyiTqQgI,8331 +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/depth_to_space.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/depth_to_space.cpython-310.pyc,sha256=0IgtYKptMWjM4IsLD6M01ieGQiyVdD8NgaR03vbmXdY,2413 +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/depth_to_space.cpython-38.pyc,sha256=KaxalDI2nnBoZ4c5URdEu3uMvYqQpOaba_eR1NEXzPM,2396 +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/depthwise_conv2d.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/depthwise_conv2d.cpython-310.pyc,sha256=oNbuvE66srh143VodRgP6x3ExMsgtllmSeB2d67TThU,11151 +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/depthwise_conv2d.cpython-38.pyc,sha256=r8-icgKEubOmLPMphGLw_GoBUaBZGivLNUMVMLnh9EI,11223 +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/dilate.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/dilate.cpython-310.pyc,sha256=B-kdGpUrA2sLiB66ICh2qe383lOQqLwkibE080dujsE,1985 +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/dilate.cpython-38.pyc,sha256=dgp7CkabGeFEpQOIlsq6Aoh6RM2wkLd1Aq5ruDFSoC8,1974 +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/elemwise.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/elemwise.cpython-310.pyc,sha256=5ct5VAgBA3n4Cv4TubKRBNqGoAlSygJ_jbKrB5CUbMA,2611 +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/elemwise.cpython-38.pyc,sha256=ZrtRmNDyTfn5-1jz76lpp6ttxTZRCiWjWzchDgRwTq4,2612 +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/fifo_buffer.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/fifo_buffer.cpython-310.pyc,sha256=BqHCzDcfpogrCF_EPkVRGrRM-yfsi8-Wqi07ZugHvqY,4206 +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/fifo_buffer.cpython-38.pyc,sha256=MVs8m56S3AZJQU6oQyTK-pEZHcP9nixxUGoSq-s_1jA,4285 +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/flatten.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/flatten.cpython-310.pyc,sha256=k4Iy18TAAAxFsgoK357ZhuPkx-aJmRT-M6sOYDHeUSM,1348 +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/flatten.cpython-38.pyc,sha256=nFM2bybzkqc1TaOWszTPoQW-WpCK0bJhA5uqZsyafWQ,1331 +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/group_norm.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/group_norm.cpython-310.pyc,sha256=3vk26B0RblJmEyS7H4lHSgyuUIZUkVu1HE6cBNyCMrc,1301 +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/group_norm.cpython-38.pyc,sha256=Bh3ZDPWl2jkRlAezcSmanZYyA76RWLNv0g3kwvpPWR0,1288 +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/instance_norm.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/instance_norm.cpython-310.pyc,sha256=zLQXxQ6-VN4wxFFWxeNgYcGiKhsOM93M0y3TCSPueew,1123 +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/instance_norm.cpython-38.pyc,sha256=pckubgHf5-q7X94eT-b2DB2rls2-Fj9m6Bc6XzhDaZ0,1110 +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/layer_norm.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/layer_norm.cpython-310.pyc,sha256=0cIlAMuqpO7nzq-HZKka9EgizRV2_GDTg7TWgOde93E,1207 +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/layer_norm.cpython-38.pyc,sha256=k8hxxAk0RArb_dL4n52BeNYPQpk4ybVd0xv5HaFfXrU,1194 +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/local_response_norm.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/local_response_norm.cpython-310.pyc,sha256=j-LfXyQoxqDVbjpDsrbwFOC7W__DV6PRSQ7PdQ3aRqA,1369 +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/local_response_norm.cpython-38.pyc,sha256=_qTMbEiabXLTqARiI1RSSAe_iVEmgmmOVeYxa6bjeJA,1356 +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/loss.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/loss.cpython-310.pyc,sha256=jCwy29IYZKyASIBqryw0U3VRaWP4iOnY_LHihPg1rk8,1482 +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/loss.cpython-38.pyc,sha256=rt34gZ_PhloFkjTXNppZXA_gB6DWjBNlDzVstTNESyQ,1469 +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/lstm.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/lstm.cpython-310.pyc,sha256=hKuoQ_0TV9T8shYOGMjC9BGiT9XtGzqtVlb-nWP81PQ,6781 +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/lstm.cpython-38.pyc,sha256=RRuNOvizZs7MSnyddcMM4umJwQrqf3a83D-YYlWYhiU,6938 +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/mapping.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/mapping.cpython-310.pyc,sha256=mh6gnITAYZ3_VHr9Chjvx5LpPo6756QSedzviaXuTLQ,2674 +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/mapping.cpython-38.pyc,sha256=wtQMTNmzkRtiIZgiCDGz73swEw8chnA_QkqcMI9ea3M,2731 +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/pad.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/pad.cpython-310.pyc,sha256=svAsvpY_ntpUzRjktISvE7AOP-SHlmWPZkuy8SBhzbI,4282 +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/pad.cpython-38.pyc,sha256=mH7O3RDSL0RWGIprFuB88u8eNztSCX47suXClObdknM,4285 +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/pooling.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/pooling.cpython-310.pyc,sha256=zM3YdLWPmkDM2cJgxqMmxLju-xUYHe-kMQm8nyGnENc,11193 +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/pooling.cpython-38.pyc,sha256=NL__BdXHAdAcNGzAFrA5v2mZT3p4VzmWQey04gZ3GVU,11263 +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/qnn.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/qnn.cpython-310.pyc,sha256=2_BthbhlDXCksM7jk4h6a94LyVh1BhCdNftCN57AZDw,9391 +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/qnn.cpython-38.pyc,sha256=kF1MTZixKNZlUm00O0PspAnSDJT7rT4kCgIK93sQYsw,9576 +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/rms_norm.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/rms_norm.cpython-310.pyc,sha256=o-3ogJYJlbRcMruupeji2E6tIKygeBvrIOthDYYcZLs,981 +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/rms_norm.cpython-38.pyc,sha256=1VhjPaV1t-G3_4QjqoomWfloCUxedfOx6s6XcDQGQT0,968 +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/softmax.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/softmax.cpython-310.pyc,sha256=3MFIp1GbLpuKL7DOSw1BxbJxrN6Om4Pa5u-U-361GhY,6119 +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/softmax.cpython-38.pyc,sha256=92Pqh81T9MBR1ywLC0wr-h9uzVrsxXmDfBQcPdaTLSA,6382 +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/space_to_batch_nd.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/space_to_batch_nd.cpython-310.pyc,sha256=5EroySKlg_auIWLkUULJ8RGbHIBNO-QUOATZTiJ394c,1334 +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/space_to_batch_nd.cpython-38.pyc,sha256=XaV2HPKeC723I-hw_QkisDX98RvtfYdYoD6C9O0Cy6A,1321 +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/space_to_depth.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/space_to_depth.cpython-310.pyc,sha256=vD7e3jeYO8hKk67aLnq03H-GZkFba1tMHC0S0YS5xcg,2126 +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/space_to_depth.cpython-38.pyc,sha256=05GPBsFPD3oBpV4Z8hu3KcD-K7CWbfeFmuuzx33T2OQ,2109 +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/sparse.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/sparse.cpython-310.pyc,sha256=lnTwEbfN8_7T6kajF-nsZ94B0lHv5U7gy7xYtctT3DU,19035 +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/sparse.cpython-38.pyc,sha256=kvWmJrzKRYfJvDEeaRV5bDsXB9pAn4TzorkKBMQmRN8,19132 +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/upsampling.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/upsampling.cpython-310.pyc,sha256=2GA-BxdmsIe_1sOXFwPlIPoNJrsl9NSWQpF9TsQOisc,4664 +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/upsampling.cpython-38.pyc,sha256=zqm3PFjw0Xx92HpkZHHV1BR_3MiDTCciqVeMR2e4j4M,4651 +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/utils.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/utils.cpython-310.pyc,sha256=rRGY-k7sgXOOAoSzjaKx_KOoXPC82oT6G9js8ryeaXI,6875 +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/utils.cpython-38.pyc,sha256=Mk1u7faTqruCfclF4B1cZgbDf8E_MagkDN6C1hq6j5o,6894 +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/winograd_util.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/winograd_util.cpython-310.pyc,sha256=cgHjrDW3s9FccNuTkGos2A-gg21OAPHIGMk8hn2mSZI,5563 +bitblas/3rdparty/tvm/python/tvm/topi/nn/__pycache__/winograd_util.cpython-38.pyc,sha256=gsig6oSZmdFeAlCz2fQWEwm7LgJCrJJt5s_qtkDpmz8,5241 +bitblas/3rdparty/tvm/python/tvm/topi/nn/batch_matmul.py,sha256=Gj2QnoHdkti7ze7Sgq3oV5WPb3rv1Vhm73FEPvCdlCc,6250 +bitblas/3rdparty/tvm/python/tvm/topi/nn/batch_norm.py,sha256=AcjKyVHDlO3ferKFrqMS4hjDWv_jv_MulDZxLHtmj8k,4747 +bitblas/3rdparty/tvm/python/tvm/topi/nn/batch_to_space_nd.py,sha256=7ZpN_vcyrr4HeIk6f7mcqOFB04GI4ZKtivDv2AzBSbk,1836 +bitblas/3rdparty/tvm/python/tvm/topi/nn/bitserial_conv2d.py,sha256=XteWDo2JkTYa6eehjtekQ2uVl8_CVZ1wxDQw4ZKMi2k,9643 +bitblas/3rdparty/tvm/python/tvm/topi/nn/bitserial_dense.py,sha256=CSAoEtuBXkAFlidbTpK6pzmwXiZHlklGXYAprZuMsEc,2830 +bitblas/3rdparty/tvm/python/tvm/topi/nn/bitserial_util.py,sha256=BVyEe-MAeLZ4CanPNgN3JZ7Aa2_xVvx9-HpIy8-EWhM,3465 +bitblas/3rdparty/tvm/python/tvm/topi/nn/bnn.py,sha256=ft9dXBtNM_3ymrSPP6WZM8AJfE7qGshyMkwJxruIj10,3325 +bitblas/3rdparty/tvm/python/tvm/topi/nn/conv1d.py,sha256=w6oOyMz5iy7Fb9_NX44XXJwBlPaE68qj-wOdVMNgvsc,4603 +bitblas/3rdparty/tvm/python/tvm/topi/nn/conv1d_transpose.py,sha256=-lbGQFttKDSLUXHygtaIIrWFJXDXJFDN2LuP6jfAaTU,6960 +bitblas/3rdparty/tvm/python/tvm/topi/nn/conv2d.py,sha256=rGl9ACZ1nptR-ZKP4kupQs4XuOz9d5T_nZokzjdPcdc,50407 +bitblas/3rdparty/tvm/python/tvm/topi/nn/conv2d_transpose.py,sha256=6DCj2Vc-XWEjGxxOwI0_7wFi8gQSk5b9dZiG2GnydYQ,11441 +bitblas/3rdparty/tvm/python/tvm/topi/nn/conv3d.py,sha256=eIsfDPhKI2ImLf0oMyQX3zCEP8QwW-RvzatvcXJ0uLk,5672 +bitblas/3rdparty/tvm/python/tvm/topi/nn/conv3d_transpose.py,sha256=lNVrExZKU95yR3A9bygBeEisBubZXHDgrF3kowWkdKw,9581 +bitblas/3rdparty/tvm/python/tvm/topi/nn/correlation.py,sha256=8lEwicaC4U7dnCr3p2YVbWsZmqmN8tvFSWWSdF7_V_s,4544 +bitblas/3rdparty/tvm/python/tvm/topi/nn/deformable_conv2d.py,sha256=9-nK3Y0uwaasu1TLO9FVMA0ip6SAHdstWfl9mF1kpb8,8238 +bitblas/3rdparty/tvm/python/tvm/topi/nn/dense.py,sha256=jMXkE0Pw4gHg_Uqvrne8SJ-IprTQhqd-hrjU8Notu5c,10554 +bitblas/3rdparty/tvm/python/tvm/topi/nn/depth_to_space.py,sha256=3-lgYQUCi4fa0L4R0KeFobUo4RyzA06ZMTJeidy0f5I,3249 +bitblas/3rdparty/tvm/python/tvm/topi/nn/depthwise_conv2d.py,sha256=JzgyyXYBiiJjV5QCHNusTyJxXOZL28g-MGWO59srig0,15625 +bitblas/3rdparty/tvm/python/tvm/topi/nn/dilate.py,sha256=qJgRD1vSUjBGrBWuazJQBngnaJImU9tWVk2hhpL-A8k,2524 +bitblas/3rdparty/tvm/python/tvm/topi/nn/elemwise.py,sha256=LSt9yQImaZVI1B0zOWmg1Fe6y2Nm76DTBa2Fy-gSQoc,2807 +bitblas/3rdparty/tvm/python/tvm/topi/nn/fifo_buffer.py,sha256=xG4fWGWpNY8iHZWOktRT2G6_kAHYHj8BPrewlQbNE2Q,6780 +bitblas/3rdparty/tvm/python/tvm/topi/nn/flatten.py,sha256=Mv6qLPVnmeQ1ekXrjCYv8D25jvwixlgRYpWf5SJLP1Y,1704 +bitblas/3rdparty/tvm/python/tvm/topi/nn/group_norm.py,sha256=Uw3i14ihzgCye77ocubNubR7HWvCwwuRf4BMBs7WkCU,1872 +bitblas/3rdparty/tvm/python/tvm/topi/nn/instance_norm.py,sha256=tjTYts_82Fr3hHdwtOX66ew67um3cBsn_R0z43ZLpEk,1672 +bitblas/3rdparty/tvm/python/tvm/topi/nn/layer_norm.py,sha256=R9WYREW08CqGs22ICxdQ0hnW9xgv8dO-g2MFMcfADzU,1756 +bitblas/3rdparty/tvm/python/tvm/topi/nn/local_response_norm.py,sha256=0CVbPSqvLqiKX--gs_k13zhhaEmUrchh34DWXAWYQ6w,1904 +bitblas/3rdparty/tvm/python/tvm/topi/nn/loss.py,sha256=Gtgs-Qd9sBR0-xkz4nRpw1jMyfByM19nVSIqIXYA8r4,2100 +bitblas/3rdparty/tvm/python/tvm/topi/nn/lstm.py,sha256=PIqfol8ms_gkIOkaPJlDzj9RjlvzyD0wK754b2P54eo,8244 +bitblas/3rdparty/tvm/python/tvm/topi/nn/mapping.py,sha256=Tm0qyELFPYVZly0BTGPZP6mGh8OJ3oYbTts5QL6zthI,2987 +bitblas/3rdparty/tvm/python/tvm/topi/nn/pad.py,sha256=BH5fxlJ2Xu5djF7vNjJBxyOJWqT4uayPoK51RNv5Pkk,5423 +bitblas/3rdparty/tvm/python/tvm/topi/nn/pooling.py,sha256=zx9S9mv_Hr_b5L-bP3jTzb3N4O9j16_U2qzuf0udmvw,12665 +bitblas/3rdparty/tvm/python/tvm/topi/nn/qnn.py,sha256=GCnLD2tW0t1UCqpHF9DhfTBgNv-6TalTApG2gktMJA4,10747 +bitblas/3rdparty/tvm/python/tvm/topi/nn/rms_norm.py,sha256=jiVV-_FbNvtRRIjiA5W3pPxyBy47FIMXprzdOUYJ32Q,1527 +bitblas/3rdparty/tvm/python/tvm/topi/nn/softmax.py,sha256=mbxSNGoOK7fRB3iNPA8JYacUgJlUAomWr-OeBJm8mpA,5682 +bitblas/3rdparty/tvm/python/tvm/topi/nn/space_to_batch_nd.py,sha256=7lbpAIBZi1YOkPQOQGyvNWvltnULUN6i-n0d7DMBiXM,1916 +bitblas/3rdparty/tvm/python/tvm/topi/nn/space_to_depth.py,sha256=hwJU6vZ9pe6kVhJY3o996cojh7Vm-PaJrPlroL3nf_4,2964 +bitblas/3rdparty/tvm/python/tvm/topi/nn/sparse.py,sha256=HpUnMmn6zINp8l_Dm8qEe1AwvIua6MFsaqm_1-Ppp60,27503 +bitblas/3rdparty/tvm/python/tvm/topi/nn/upsampling.py,sha256=DQIxQsq7mDW18zAEc0FZ5MLKtiPSQnJvmCnmkqLapeY,7378 +bitblas/3rdparty/tvm/python/tvm/topi/nn/utils.py,sha256=_krE45zeXVcnZJImjS06WV-MRzvAtayBApZNIQrGqcU,8120 +bitblas/3rdparty/tvm/python/tvm/topi/nn/winograd_util.py,sha256=fg9gnidNJFm00629YGcXd1mdEd65qGWbxwWLzjEfras,6243 +bitblas/3rdparty/tvm/python/tvm/topi/random/__init__.py,sha256=ZiHnKUQGulxKdOQNlGaxfcc4Il6MiE0gBZwJ27jP7yQ,934 +bitblas/3rdparty/tvm/python/tvm/topi/random/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/random/__pycache__/__init__.cpython-310.pyc,sha256=oMJy36vJbFMm7h4jOgLvAyJL6MdYbXuA8QHcsktpNTM,305 +bitblas/3rdparty/tvm/python/tvm/topi/random/__pycache__/__init__.cpython-38.pyc,sha256=eVZlCtyi6Mh1JHYQcElOGeSUapgnaaAvv7B1Nc3TqoA,292 +bitblas/3rdparty/tvm/python/tvm/topi/random/__pycache__/kernel.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/random/__pycache__/kernel.cpython-310.pyc,sha256=ODxUmU53J7sUDD1wpJRmPMF-ZwHL20bIyBFN_LI-RDU,17714 +bitblas/3rdparty/tvm/python/tvm/topi/random/__pycache__/kernel.cpython-38.pyc,sha256=u-pzrr5qCWfLF6TerrrDDYTsL9o67-lO9twAR2Wj1Ro,17169 +bitblas/3rdparty/tvm/python/tvm/topi/random/kernel.py,sha256=UwQRS_7scj3nAs2ehU69XIzEZxljA2abNclEjWi5Swg,27010 +bitblas/3rdparty/tvm/python/tvm/topi/reduction.py,sha256=DGfahDAsol0Pbg0PQ546iSuSXjMdcTDRpR6PcMPKR-E,9360 +bitblas/3rdparty/tvm/python/tvm/topi/rocm/__init__.py,sha256=9N5BjQIupxhg4v6jA9LM-SfFZo4hWee2RPDUZNLTgqo,1005 +bitblas/3rdparty/tvm/python/tvm/topi/rocm/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/rocm/__pycache__/__init__.cpython-310.pyc,sha256=AtVpkpuFk8x5Af-E2bVRk3eCUhF7WHBJOoIKj57vDMo,345 +bitblas/3rdparty/tvm/python/tvm/topi/rocm/__pycache__/__init__.cpython-38.pyc,sha256=hZk4AAnh7mlIC_G60jeAEtd5wSpQ3GpI7o7Twr4iWwg,332 +bitblas/3rdparty/tvm/python/tvm/topi/rocm/__pycache__/batch_matmul.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/rocm/__pycache__/batch_matmul.cpython-310.pyc,sha256=NxzofVjj95i67vL7SHjA6OxnXE5vzwFyxLJp74awSBY,1574 +bitblas/3rdparty/tvm/python/tvm/topi/rocm/__pycache__/batch_matmul.cpython-38.pyc,sha256=5VO123if0J1-headfZinOlG7ScNFrlt4DmHc68ZP1vw,1581 +bitblas/3rdparty/tvm/python/tvm/topi/rocm/__pycache__/conv2d.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/rocm/__pycache__/conv2d.cpython-310.pyc,sha256=BjALxoXNDf3ymxBfD8IJkLT9XEFECg2xo6x_m3aF0jo,2556 +bitblas/3rdparty/tvm/python/tvm/topi/rocm/__pycache__/conv2d.cpython-38.pyc,sha256=2SSPkUxezr-0jkYwpC9Mvn6fm005Xf60QjBlx6GuGcI,2577 +bitblas/3rdparty/tvm/python/tvm/topi/rocm/__pycache__/dense.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/rocm/__pycache__/dense.cpython-310.pyc,sha256=ZySITt4FUVqfqs-bgBPPGsmnlWsSPc6bIxHkOhRaunQ,1689 +bitblas/3rdparty/tvm/python/tvm/topi/rocm/__pycache__/dense.cpython-38.pyc,sha256=uyJxuEs0IGFd2oun0TOszFcwFjQn8nvW7bzBF4BP84s,1694 +bitblas/3rdparty/tvm/python/tvm/topi/rocm/batch_matmul.py,sha256=86jmxKox8Td9jd5OqJNFBaH4saDYyaqXWyfvxqiI7xk,2218 +bitblas/3rdparty/tvm/python/tvm/topi/rocm/conv2d.py,sha256=WFjuW855Roto-I-FIYQcW6ZMS3v29b6r50uad79IRqM,3300 +bitblas/3rdparty/tvm/python/tvm/topi/rocm/dense.py,sha256=u417RF6jfpxI7rLet0FztIZDM2x-ZBLYwgXpQ2vcG8Q,2229 +bitblas/3rdparty/tvm/python/tvm/topi/scan.py,sha256=gjkSGvsB0uRXOdKkaudtkcWE747SSIfaMguN6p5G3wc,8064 +bitblas/3rdparty/tvm/python/tvm/topi/scatter.py,sha256=CO_FqnZDERjDlSj_gY0b1GDsLujvJeiRYE5ihK8AR9M,6167 +bitblas/3rdparty/tvm/python/tvm/topi/scatter_elements.py,sha256=OOM41aSyhmv0kiwX5rpGrhj_fqTMLp0o5iVicyqo4-Y,6242 +bitblas/3rdparty/tvm/python/tvm/topi/searchsorted.py,sha256=ATAxkjf2MJyXLMSHTxn0aG-VTwWgMWs04zmsFs5aq68,4777 +bitblas/3rdparty/tvm/python/tvm/topi/signal.py,sha256=t1uKX1YJ3g0ZyUhHJkYOg1VLvGatxQqN8ScN72LUXeQ,7390 +bitblas/3rdparty/tvm/python/tvm/topi/sort.py,sha256=XMXExAPxMTNV1xETqliI9aPa4ohUgQ5_cwQbdBYTHSQ,6597 +bitblas/3rdparty/tvm/python/tvm/topi/sparse/__init__.py,sha256=nQOs66cSo9lY1CZDfsaFC73XnMc2HpiDpT98MqKL-gU,966 +bitblas/3rdparty/tvm/python/tvm/topi/sparse/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/sparse/__pycache__/__init__.cpython-310.pyc,sha256=vgLbUMQxZ21quDe1UpqEfXlXNTCFvAFj7MfolukxbOI,343 +bitblas/3rdparty/tvm/python/tvm/topi/sparse/__pycache__/__init__.cpython-38.pyc,sha256=QufR_YlAIuwUN0ibIW01oI-gHC6pBXfkw1suZvaRMeQ,330 +bitblas/3rdparty/tvm/python/tvm/topi/sparse/__pycache__/csrmm.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/sparse/__pycache__/csrmm.cpython-310.pyc,sha256=msc4BVpggYoKife-P-A57lvqn47Y1kntXfq9Q5jb8AA,3636 +bitblas/3rdparty/tvm/python/tvm/topi/sparse/__pycache__/csrmm.cpython-38.pyc,sha256=x7wBr-dwrh54FT5oHjs6POe7Rtn_tFoLygmzPzUbWow,3547 +bitblas/3rdparty/tvm/python/tvm/topi/sparse/__pycache__/csrmv.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/sparse/__pycache__/csrmv.cpython-310.pyc,sha256=LjJtuoOnzhb37IZL2itHOE4Rv00K15U4F432g8Jy3ck,3400 +bitblas/3rdparty/tvm/python/tvm/topi/sparse/__pycache__/csrmv.cpython-38.pyc,sha256=DwjuiwSfPIkumh4JaAFlFdUnmoO6eV8tzl6OIu0Sz4A,3351 +bitblas/3rdparty/tvm/python/tvm/topi/sparse/__pycache__/dense.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/sparse/__pycache__/dense.cpython-310.pyc,sha256=JmXzi4ovVXmuL914o9R3qcHT7Phmjg4lgKdZm51s5F8,5936 +bitblas/3rdparty/tvm/python/tvm/topi/sparse/__pycache__/dense.cpython-38.pyc,sha256=xtHz6Yf0yybLeqt8EjFRmFfkQeaNOhbUYCXoa_DeCK0,5811 +bitblas/3rdparty/tvm/python/tvm/topi/sparse/__pycache__/utils.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/sparse/csrmm.py,sha256=rRp4PLfqPxV1bzmyeHsjO76p5-uuhL8PiY1VQQAjtoo,4310 +bitblas/3rdparty/tvm/python/tvm/topi/sparse/csrmv.py,sha256=zHAM7xw0xfPOH97z_4cAHTJQzzlNfdEerlSI9ZHOEbI,3990 +bitblas/3rdparty/tvm/python/tvm/topi/sparse/dense.py,sha256=MxYo615eV9ym0UUlBQfKno_QWKEyFe2uPFQ3jYSrYic,7312 +bitblas/3rdparty/tvm/python/tvm/topi/sparse/utils.py,sha256=FFZq-JJnOhvlUp5OxLJgyfSJ68v5o4CXZRHF_lDHF7k,13690 +bitblas/3rdparty/tvm/python/tvm/topi/sparse_fill_empty_rows.py,sha256=tNyILqvHYdPLQDcRPgXpDlveoGAUZ7P-cxnnwfmhtUI,4485 +bitblas/3rdparty/tvm/python/tvm/topi/sparse_reshape.py,sha256=wX5Y3M6blZvJ_Ox2jsdvlP7djDtn93Tij97BnuwaN-U,7340 +bitblas/3rdparty/tvm/python/tvm/topi/tag.py,sha256=uv3x4Zd5FCxajfZLC3TzRJOh_fOHEht2lm_rMQV6LiM,2823 +bitblas/3rdparty/tvm/python/tvm/topi/tensor.py,sha256=-AUxw1L3zkaguemiG13pf0Skq3viBqRcm1fYtxfgZd0,1956 +bitblas/3rdparty/tvm/python/tvm/topi/testing/__init__.py,sha256=dCPUTmix--NSprkyu6NXHKl-v073WmK-2AyorWEV1bA,3773 +bitblas/3rdparty/tvm/python/tvm/topi/testing/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/testing/__pycache__/adaptive_pool_python.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/testing/__pycache__/batch_matmul.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/testing/__pycache__/batch_norm.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/testing/__pycache__/batch_to_space_nd.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/testing/__pycache__/common.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/testing/__pycache__/conv1d_ncw_python.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/testing/__pycache__/conv1d_transpose_ncw_python.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/testing/__pycache__/conv2d_backcward_weight_python.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/testing/__pycache__/conv2d_hwcn_python.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/testing/__pycache__/conv2d_nchw_python.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/testing/__pycache__/conv2d_nhwc_python.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/testing/__pycache__/conv2d_transpose_python.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/testing/__pycache__/conv3d_ncdhw_python.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/testing/__pycache__/conv3d_ndhwc_python.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/testing/__pycache__/conv3d_transpose_ncdhw_python.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/testing/__pycache__/correlation_nchw_python.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/testing/__pycache__/crop_and_resize_python.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/testing/__pycache__/deformable_conv2d_python.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/testing/__pycache__/dense.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/testing/__pycache__/depth_to_space.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/testing/__pycache__/depthwise_conv2d_python.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/testing/__pycache__/dilate_python.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/testing/__pycache__/gather_nd_python.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/testing/__pycache__/gather_python.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/testing/__pycache__/grid_sample_python.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/testing/__pycache__/group_norm_python.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/testing/__pycache__/instance_norm_python.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/testing/__pycache__/l2_normalize_python.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/testing/__pycache__/layer_norm_python.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/testing/__pycache__/lrn_python.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/testing/__pycache__/lstm_python.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/testing/__pycache__/matrix_set_diag.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/testing/__pycache__/nll_loss.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/testing/__pycache__/one_hot.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/testing/__pycache__/pool_grad_python.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/testing/__pycache__/poolnd_python.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/testing/__pycache__/reorg_python.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/testing/__pycache__/resize_python.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/testing/__pycache__/rms_norm_python.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/testing/__pycache__/roi_align_python.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/testing/__pycache__/roi_pool_python.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/testing/__pycache__/searchsorted.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/testing/__pycache__/sequence_mask_python.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/testing/__pycache__/slice_axis_python.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/testing/__pycache__/softmax_python.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/testing/__pycache__/space_to_batch_nd.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/testing/__pycache__/space_to_depth.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/testing/__pycache__/strided_slice_python.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/testing/adaptive_pool_python.py,sha256=T9QvAbir3_F7RJcuxI1m-f0tpMk_XlrtFicnK7bcx1Y,4515 +bitblas/3rdparty/tvm/python/tvm/topi/testing/batch_matmul.py,sha256=W-V1T0Ed94lJFxm4E9XmPoaWuiaRvqlS4PQFByOYokQ,1838 +bitblas/3rdparty/tvm/python/tvm/topi/testing/batch_norm.py,sha256=HHAUR86F5WaoK7oSZgNRBGSHB6iN2XeGeyBV3_uinwM,3367 +bitblas/3rdparty/tvm/python/tvm/topi/testing/batch_to_space_nd.py,sha256=px-m4bWDSa9oBROBaBUu-XarVWAbvz2BqecZMgba6-Q,3439 +bitblas/3rdparty/tvm/python/tvm/topi/testing/common.py,sha256=QjJlCeFc2_kQvPnjZlJf05_mlijJls4kUciJXymsQjM,5422 +bitblas/3rdparty/tvm/python/tvm/topi/testing/conv1d_ncw_python.py,sha256=H-P9kKUoOyBfBvPia1odIIzWP2XDrkfuSy6pUNZZZJY,3532 +bitblas/3rdparty/tvm/python/tvm/topi/testing/conv1d_transpose_ncw_python.py,sha256=oGKNyuqsfz8VqAcMRMQkzWI2XNzqD8O5eFfIFAASruk,3314 +bitblas/3rdparty/tvm/python/tvm/topi/testing/conv2d_backcward_weight_python.py,sha256=3WGugd1TtWzLNWJLs6YLRMoFjEDk-Xz3-g1Nx3C_6yE,4974 +bitblas/3rdparty/tvm/python/tvm/topi/testing/conv2d_hwcn_python.py,sha256=heaQyAZSsf772R4U4rVwPl2jyUjIaqiG7ayObnuucqI,3068 +bitblas/3rdparty/tvm/python/tvm/topi/testing/conv2d_nchw_python.py,sha256=scTNmS5EEuW5McWC2HhAkcoAN_RlTyvlzBSodj6id6M,5383 +bitblas/3rdparty/tvm/python/tvm/topi/testing/conv2d_nhwc_python.py,sha256=iP4-s7n2ARA2B-UXR_a_5V2CcUo30d1OlDjaiQkOHIw,4109 +bitblas/3rdparty/tvm/python/tvm/topi/testing/conv2d_transpose_python.py,sha256=V61nErI99s6EqsoAcbZ8qZUtTUR5FgsDE4eyObaumSw,6092 +bitblas/3rdparty/tvm/python/tvm/topi/testing/conv3d_ncdhw_python.py,sha256=4v6yfAACvib3YsmAfN6PgdyxXBSjNhvvBm8KtbizBKU,3711 +bitblas/3rdparty/tvm/python/tvm/topi/testing/conv3d_ndhwc_python.py,sha256=H4pmgEyqNIcuYrqhTbY4BturifgwPd7_fnR2jpvGRQo,4597 +bitblas/3rdparty/tvm/python/tvm/topi/testing/conv3d_transpose_ncdhw_python.py,sha256=uQ3ywnoOwXoOhRwhFrlu4Jvx8r5At6lR6ZDEIPQe4XA,4916 +bitblas/3rdparty/tvm/python/tvm/topi/testing/correlation_nchw_python.py,sha256=wYuGYofmQ5aujQGHQXtbgXXIg4klx6bw_mMrZEQARdg,4133 +bitblas/3rdparty/tvm/python/tvm/topi/testing/crop_and_resize_python.py,sha256=EZKccSXyj9P_UMoFUaCkARHjOxV3StXEb-A-FU0gepc,5697 +bitblas/3rdparty/tvm/python/tvm/topi/testing/deformable_conv2d_python.py,sha256=bmjQxJxdJTF9TSdtojASgCIKh6TjeOvCmKa8BT2aRgE,6373 +bitblas/3rdparty/tvm/python/tvm/topi/testing/dense.py,sha256=oBmLCp23bgbPQWK1YtuiK8Nc66TPY-c40bkv7k-ruqA,1590 +bitblas/3rdparty/tvm/python/tvm/topi/testing/depth_to_space.py,sha256=7Sz3uNvXLw6VfFLfDdctfD1ousGkbbU7YgFT_7ru7ws,2069 +bitblas/3rdparty/tvm/python/tvm/topi/testing/depthwise_conv2d_python.py,sha256=PLxdX1tk74v19D9H3Veze7qA2G-aKx3ACpkj4xXRc-E,5556 +bitblas/3rdparty/tvm/python/tvm/topi/testing/dilate_python.py,sha256=ygIvmTQtmc_IN-ODy2grm_fuD4fBJn_9Fbxr7KRkIrI,2102 +bitblas/3rdparty/tvm/python/tvm/topi/testing/gather_nd_python.py,sha256=Vi1J1p4z_ZwN__TdxfaiaoupPvCOjPOHADi40lJx0rY,1801 +bitblas/3rdparty/tvm/python/tvm/topi/testing/gather_python.py,sha256=l-k6SleYwzST4pM4z707Gcop3OrS5dSszcwNf-2znks,1487 +bitblas/3rdparty/tvm/python/tvm/topi/testing/grid_sample_python.py,sha256=fIspdk5zBYo8ECXyLWN-whdBbB_z2AFzgecRQFH32PI,15371 +bitblas/3rdparty/tvm/python/tvm/topi/testing/group_norm_python.py,sha256=KBKySm2z4d809jVYKAo4ymVBgEQoqxz284GJ2ymFzgM,2823 +bitblas/3rdparty/tvm/python/tvm/topi/testing/instance_norm_python.py,sha256=5bNAhUGovZ0Fn1SJBOwqNvlOJ0RFSPm-rA90hnlRR9s,1871 +bitblas/3rdparty/tvm/python/tvm/topi/testing/l2_normalize_python.py,sha256=2-uD7FXaT0dMelRLGR7czBNAa3jIkSgBN10-G1td0dA,1620 +bitblas/3rdparty/tvm/python/tvm/topi/testing/layer_norm_python.py,sha256=zRihUPa_-Ba7zstbkjztVzpUuYXzr-uxU2eIoEFVFKI,1961 +bitblas/3rdparty/tvm/python/tvm/topi/testing/lrn_python.py,sha256=-hkEKL7kmfvVJRj_hM-bfB9oUSuFTAOQSuWHrMgx3lw,2543 +bitblas/3rdparty/tvm/python/tvm/topi/testing/lstm_python.py,sha256=4pQoGm02eDY-Ln1N2OMkSFD6htrPoJeSCPAdGcyGCEI,4276 +bitblas/3rdparty/tvm/python/tvm/topi/testing/matrix_set_diag.py,sha256=N197Uj2knT0j27RZetbdQKz0d3UyNIb-Fqdk01mJuG4,2837 +bitblas/3rdparty/tvm/python/tvm/topi/testing/nll_loss.py,sha256=PozmPn4EAIhChVX4bKD4uXYxtUP5mMLovgKUolWrpHg,2492 +bitblas/3rdparty/tvm/python/tvm/topi/testing/one_hot.py,sha256=fFyIkEc6hsE7M4xksKrF-9vQXVhhLmrowPy0JjmvTRA,2510 +bitblas/3rdparty/tvm/python/tvm/topi/testing/pool_grad_python.py,sha256=6c8N25-rKcPPFCHWSbrJoU3gfiw3ZVeYales-7U5D2s,3226 +bitblas/3rdparty/tvm/python/tvm/topi/testing/poolnd_python.py,sha256=VTBk8BVqLdA2ydefXqwtks5WTEaAxckmTra49nn5H4E,7140 +bitblas/3rdparty/tvm/python/tvm/topi/testing/reorg_python.py,sha256=uGT-UP8kXjt_2ONEg-12bk1hYjdu9eFLu66qSps59zM,2293 +bitblas/3rdparty/tvm/python/tvm/topi/testing/resize_python.py,sha256=Vmo8JgnOyjrm374l9gjbnKquqgieA-D7M2ELYzAmeKY,9851 +bitblas/3rdparty/tvm/python/tvm/topi/testing/rms_norm_python.py,sha256=Wf0RqTxcf8qagPzDooWWlCGbp_lIbcGWZVAQfQduJqw,1901 +bitblas/3rdparty/tvm/python/tvm/topi/testing/roi_align_python.py,sha256=l10yNkRoAYlREFhecEawxkLtyOMQqDEMXmIiIFYOI1s,5625 +bitblas/3rdparty/tvm/python/tvm/topi/testing/roi_pool_python.py,sha256=SbvAskd23B-UU2EzguyWMhTE8WVgwwgk8xUJWhiDVyQ,2700 +bitblas/3rdparty/tvm/python/tvm/topi/testing/searchsorted.py,sha256=gkNqh7yJ3PXR4xy0WTPs7lwZCg3MxO5zCNG5gp7ZYjg,1576 +bitblas/3rdparty/tvm/python/tvm/topi/testing/sequence_mask_python.py,sha256=d46u7icJ3Du1fH6ae8pks4hp2LmRVd4WlcREVLEqKMc,1883 +bitblas/3rdparty/tvm/python/tvm/topi/testing/slice_axis_python.py,sha256=2QyBiCwl3BVt0O8t1TyxVdXLJjPd9mVatkp5TNLW4cc,1533 +bitblas/3rdparty/tvm/python/tvm/topi/testing/softmax_python.py,sha256=yw6458pP7AGwyWZUz4kybvu6c-NPfMATw9fWMZO5Xoo,1766 +bitblas/3rdparty/tvm/python/tvm/topi/testing/space_to_batch_nd.py,sha256=klyy1rYsRkwTfoomMYpWK53KwflXHkoAD1O42MmmzYg,3453 +bitblas/3rdparty/tvm/python/tvm/topi/testing/space_to_depth.py,sha256=h8MaFtMw5cbfRcgrnU4UNb2PGxYbPNj-CEJlbnjIGTo,1857 +bitblas/3rdparty/tvm/python/tvm/topi/testing/strided_slice_python.py,sha256=2rpgx4kXmOnHYAINnbr3CxrRDL_gR_cSPEEvjssLDWA,3650 +bitblas/3rdparty/tvm/python/tvm/topi/transform.py,sha256=SzvzL-JvL3-ia6pHycOs8CTcsQQRLvlbIgt_zmh3Yr8,29629 +bitblas/3rdparty/tvm/python/tvm/topi/unique.py,sha256=WfXJH5nyr4esJX-mUVLOEzTH6EvuhNB1q2_1ndwLJn8,12245 +bitblas/3rdparty/tvm/python/tvm/topi/utils.py,sha256=YcxuhG5K9cutRV7NzyBkL32L0MERy0tNBQBaDHhWQww,13369 +bitblas/3rdparty/tvm/python/tvm/topi/vision/__init__.py,sha256=5l2EiNc04R5sxv8FQJUloPCsKZFHcyyk-KvEGkRj2TY,977 +bitblas/3rdparty/tvm/python/tvm/topi/vision/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/vision/__pycache__/__init__.cpython-310.pyc,sha256=ChPg_4IDctmUUau29_MsgY6FEca5Ir7PMnYw1_K-q80,348 +bitblas/3rdparty/tvm/python/tvm/topi/vision/__pycache__/__init__.cpython-38.pyc,sha256=1-NwaGlDUc_8L0GM-3JPxeol27RU8zh8K1FnSVBmfEA,335 +bitblas/3rdparty/tvm/python/tvm/topi/vision/__pycache__/nms.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/vision/__pycache__/nms.cpython-310.pyc,sha256=pQ1c5hznUpVyX9mz-9T-OE6sjDvsBz5PiHjpe6qzat0,27683 +bitblas/3rdparty/tvm/python/tvm/topi/vision/__pycache__/nms.cpython-38.pyc,sha256=oT_AjqIWIwbvh8mDFNIyC-2hmh8FGKVpVMaUwl_Gr8Q,27218 +bitblas/3rdparty/tvm/python/tvm/topi/vision/__pycache__/nms_util.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/vision/__pycache__/nms_util.cpython-310.pyc,sha256=qGq3Lu2OIq-xCZZhfDqVWT7IWyXgC196BTSHOrwaD-Y,9024 +bitblas/3rdparty/tvm/python/tvm/topi/vision/__pycache__/nms_util.cpython-38.pyc,sha256=w_mLBTV2bi_54V_JADYLXql7-RokTWMUwijB3QMq-W0,8879 +bitblas/3rdparty/tvm/python/tvm/topi/vision/__pycache__/reorg.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/vision/__pycache__/reorg.cpython-310.pyc,sha256=8w2UXKLFmU43haw1njT8Vb0V0_1_o8QBp5POp2NXcbA,805 +bitblas/3rdparty/tvm/python/tvm/topi/vision/__pycache__/reorg.cpython-38.pyc,sha256=sc0vbavuSyzCnQXKfqVGYl0Fs-qQ-2Li1Dm_OnV4z5w,792 +bitblas/3rdparty/tvm/python/tvm/topi/vision/nms.py,sha256=I4sgZbxHLOrdie8Mp7mHTI1-L_9q67YdGJ5FtF0RVxM,43588 +bitblas/3rdparty/tvm/python/tvm/topi/vision/nms_util.py,sha256=RjPvBrt5-LJZuxBZ1fu3-mbPXeX0LyUS2ELUFe0CyFY,11318 +bitblas/3rdparty/tvm/python/tvm/topi/vision/rcnn/__init__.py,sha256=wQ86PosxuK-RhF_9nRhL2F7c6Nz6OZk7zbGZnqZ1c8I,937 +bitblas/3rdparty/tvm/python/tvm/topi/vision/rcnn/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/vision/rcnn/__pycache__/__init__.cpython-310.pyc,sha256=v3u3AvZbbvn6-85StVrqiiVZMK1Drg7CloEWn-MS42E,290 +bitblas/3rdparty/tvm/python/tvm/topi/vision/rcnn/__pycache__/__init__.cpython-38.pyc,sha256=St6ycc8LqV6IT6P0ajSS9Kz_w-PLy4UJanMQEg7MRt8,277 +bitblas/3rdparty/tvm/python/tvm/topi/vision/rcnn/__pycache__/proposal.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/vision/rcnn/__pycache__/proposal.cpython-310.pyc,sha256=lr3aJ5yY1yHq7NNwFlGW3Nl_1SwDw0wGWeCz_nph_qg,12549 +bitblas/3rdparty/tvm/python/tvm/topi/vision/rcnn/__pycache__/proposal.cpython-38.pyc,sha256=4rmExbdprbawe64OO0JVNGEeHwsg-z-J3UWVN6VWiyk,11908 +bitblas/3rdparty/tvm/python/tvm/topi/vision/rcnn/__pycache__/roi_align.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/vision/rcnn/__pycache__/roi_align.cpython-310.pyc,sha256=g7_Td2jJYFpLV3vkiVMa75xukGCmb359vBRIv3AFpo4,5322 +bitblas/3rdparty/tvm/python/tvm/topi/vision/rcnn/__pycache__/roi_align.cpython-38.pyc,sha256=mSn2MuHDqPWldl-niRcCQEmzMHrVW1OAt3R-KTq26BY,5408 +bitblas/3rdparty/tvm/python/tvm/topi/vision/rcnn/__pycache__/roi_pool.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/vision/rcnn/__pycache__/roi_pool.cpython-310.pyc,sha256=jaBH93_QFeb0piiFe_hbfOiZQ5uzzjsa9RVsBx8qeQk,2859 +bitblas/3rdparty/tvm/python/tvm/topi/vision/rcnn/__pycache__/roi_pool.cpython-38.pyc,sha256=xw0Bro5oVoqrRS35ivWz7tmBg2WObMeCOCCWo8XerMM,2846 +bitblas/3rdparty/tvm/python/tvm/topi/vision/rcnn/proposal.py,sha256=PZk3c0LelJT1TWnJg0roPkBkNvqqsDdZw6CAsIVhnc4,15572 +bitblas/3rdparty/tvm/python/tvm/topi/vision/rcnn/roi_align.py,sha256=wMMUgz5_IsVEa47yEjyafgyZkM0iFbqE3ZISJjD5aMY,7429 +bitblas/3rdparty/tvm/python/tvm/topi/vision/rcnn/roi_pool.py,sha256=2NtrBdMVXpUQ-UP72CBHv62vFaT-CvznLw1-nQjZbqs,4084 +bitblas/3rdparty/tvm/python/tvm/topi/vision/reorg.py,sha256=iInu7lTdu9vWZlOmRnyWvNP6F7lvE_etss3RVBUbU3A,1335 +bitblas/3rdparty/tvm/python/tvm/topi/vision/ssd/__init__.py,sha256=xwPGFUARnRF61AC2_lsP0KTeriCo1R-wtYqXn0Mn3DM,923 +bitblas/3rdparty/tvm/python/tvm/topi/vision/ssd/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/vision/ssd/__pycache__/__init__.cpython-310.pyc,sha256=gdPpMDf7a9_vs43ilIioXKIp6jeCZhDqOvumU1KMOWE,296 +bitblas/3rdparty/tvm/python/tvm/topi/vision/ssd/__pycache__/__init__.cpython-38.pyc,sha256=TIPVwjoXGG1qOgFhsRHbG2uB64gqSYnGkQa4VDhDXtI,283 +bitblas/3rdparty/tvm/python/tvm/topi/vision/ssd/__pycache__/multibox.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/vision/ssd/__pycache__/multibox.cpython-310.pyc,sha256=uFw7k3hyj0ek2-xqxOsmNCnx07pnUASOLzQB1GGFGy8,8019 +bitblas/3rdparty/tvm/python/tvm/topi/vision/ssd/__pycache__/multibox.cpython-38.pyc,sha256=dMXUTa5-yc7qvw9ttILNvZvmMmq5CjTjLaVMArWX2Oo,7998 +bitblas/3rdparty/tvm/python/tvm/topi/vision/ssd/multibox.py,sha256=ndA5RhY3lnRFZQyXepV-FXy2DB5J7dfMbCNSfI5DrQ8,10830 +bitblas/3rdparty/tvm/python/tvm/topi/x86/__init__.py,sha256=wkHp-MbfNQB4ebpKtndSlFQP-PKbjsEeUf50LExoo20,1659 +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/__init__.cpython-310.pyc,sha256=c4-GLyPdfi0uD3SeE3XWdMVu7_nYeX9NmFMR8awBD3A,979 +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/__init__.cpython-38.pyc,sha256=ceSE7z7vjpLLtrfhf2bJFpO7nuE05uQDCtcfhW-EdKM,966 +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/batch_matmul.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/batch_matmul.cpython-310.pyc,sha256=P08v5aPbpFxA2O1u3eVFWnQ0PYHmEdrObGfhCPBNqJI,9361 +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/batch_matmul.cpython-38.pyc,sha256=viGRFPIkAN2oLS0Ac2M0bY1863JIjwvj1TKHUBgOI8s,9508 +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/binarize_pack.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/binarize_pack.cpython-310.pyc,sha256=YIASpg69oSDE7v2oudckXX7l7VJpYmNyGQYCLwFIhRM,1403 +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/binarize_pack.cpython-38.pyc,sha256=U4ZOSOg68OkMs0mskLHmWUBr4yIiyZy76fLIvR_QGt4,1394 +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/binary_dense.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/binary_dense.cpython-310.pyc,sha256=9Q_DXWQHs5Xkh2n75ENKCC54hQckAgdrmkVIf-5DHlg,1963 +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/binary_dense.cpython-38.pyc,sha256=mlWXu_qvzP2GYTMYy5Svs3T5eUxuk7ETdWQ0t9shRko,1948 +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/bitserial_conv2d.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/bitserial_conv2d.cpython-310.pyc,sha256=W1o4nDQqCDzGwa-0WtSsyb2ZmviStZ4g-qy_5XDT0vs,12229 +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/bitserial_conv2d.cpython-38.pyc,sha256=CCn973RiZrB40wEyVKAA-rbapDmOPKi3tgcFGo85Kk4,12381 +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/bitserial_dense.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/bitserial_dense.cpython-310.pyc,sha256=ZS89PBQQqLeoFj4Obk7e9BXF-6toh37-4faV8w0oazE,5162 +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/bitserial_dense.cpython-38.pyc,sha256=ZNQsg7M9gRdTU9wr6Ybleg1rtlolHvITCI_N00QNai4,5171 +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/concat.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/concat.cpython-310.pyc,sha256=eh2zlign_n_3rStEAeBRsUuchIDySwOxyKuQr8b8RIY,3480 +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/concat.cpython-38.pyc,sha256=Nu5b3SjFGVGsf2w2k9VYzohRpksriy9b7nP6xlkWBuU,3408 +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/conv1d.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/conv1d.cpython-310.pyc,sha256=q0NT24OPiko0hr8EFA4_2xmwP3xr4Cc9xA2dGKgOD6A,2438 +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/conv1d.cpython-38.pyc,sha256=OpBdTxGTjHw1jUu9YUv89x932XhywVfGo2nx_iBg8us,3073 +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/conv2d.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/conv2d.cpython-310.pyc,sha256=vDv6JS9J4bw9L5kmiZ1HsBYkX6d1nh5dRWxIP3IQ8m8,8259 +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/conv2d.cpython-38.pyc,sha256=_HfhFflZVfUNkluOaYQbcvZC5ohIvRCynZY4woS-wUQ,8308 +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/conv2d_alter_op.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/conv2d_alter_op.cpython-310.pyc,sha256=SQLAgyPB19IrlDJXRD16dkgy1cm-joxAfZgKWaiGcjc,4974 +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/conv2d_alter_op.cpython-38.pyc,sha256=J5Af8lEeIdEYhr7fxpbz3LLmm7C-yiTsR3i1fdalTVw,5005 +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/conv2d_avx_1x1.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/conv2d_avx_1x1.cpython-310.pyc,sha256=Rj9dY1HBTfmI9fZpcnGzVb42xuGR1Xs9QbGxf1FvmUI,6239 +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/conv2d_avx_1x1.cpython-38.pyc,sha256=iATS3wV-fWQTrg8I19_nyQotYsfjn7OTtQUe_37f8UM,6694 +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/conv2d_avx_common.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/conv2d_avx_common.cpython-310.pyc,sha256=X-5czGfoh8v8F9ypgmJZ92eJPpuO_jw3X6RtWSjE_fo,3983 +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/conv2d_avx_common.cpython-38.pyc,sha256=hV27sRDes-Lnu9L6f3ibzXUb1GTEUioRAJiZAogr6SI,3976 +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/conv2d_int8.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/conv2d_int8.cpython-310.pyc,sha256=pP36Qb4cwVsSIGbHpKPB14WZ0SeGtoSn6lMdtwDG4n0,7272 +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/conv2d_int8.cpython-38.pyc,sha256=5OLBkGVOaa8UxzcqnUNvoa4ApVgNwfVSBQb7JA4aFTA,7351 +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/conv2d_transpose.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/conv2d_transpose.cpython-310.pyc,sha256=_0ydVt25Pl_rGFIo9k6Fmxu1UEXzRnZwYbb86DJxeCY,1485 +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/conv2d_transpose.cpython-38.pyc,sha256=HjdK9lR_xeTKLh5dCcl0u_H0SurygN6K72o84i0Ing8,1470 +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/conv3d.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/conv3d.cpython-310.pyc,sha256=e1HHz3odfud_VU2TlLRQWl6HG8mRotrPGbda2twJwwQ,15880 +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/conv3d.cpython-38.pyc,sha256=wcIIpEpsvJq0KtLsu5vGia1VcC-QjXXzwKWOemjHOo8,16390 +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/conv3d_transpose.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/conv3d_transpose.cpython-310.pyc,sha256=g1_Gus29KxtHMgtNQ8FdPWO35FvB1BXiS-jpQc56Y_0,1411 +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/conv3d_transpose.cpython-38.pyc,sha256=kmCZ541YTXwsVTByNxDYY8hEy14-eSC0fzqcKgr72qw,1402 +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/dense.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/dense.cpython-310.pyc,sha256=YqD9VjcsZyR6l_MTW1wOlraVRKUX8DM3duWPfDRdTk0,18795 +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/dense.cpython-38.pyc,sha256=qRGnn6zk7_hQrKYcii3ZB-jbsXcJ4iQ4hJ8GV6zHbbg,19076 +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/dense_alter_op.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/dense_alter_op.cpython-310.pyc,sha256=zHoc9MMBIZWaxux9TVaeU82uqlI-wXhZs0ux8kZ-_tE,3630 +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/dense_alter_op.cpython-38.pyc,sha256=7Mlb7KHB2MZDnx4guf6w3Uxe5ekNuhSA9B9IH101xdQ,3636 +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/depthwise_conv2d.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/depthwise_conv2d.cpython-310.pyc,sha256=lrvLJPl94wS7VusvBj9-lt1CWMKorzJ2J9GsyiBR3vI,8370 +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/depthwise_conv2d.cpython-38.pyc,sha256=3qFusDPTuh05MfPvzIzFAi_qYwti0HJ8F0GdQdedRbw,8371 +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/group_conv2d.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/group_conv2d.cpython-310.pyc,sha256=ylDapEWo8OOkT37f65F6Oct7wcYCnyAFtNzfI-EXsHo,7932 +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/group_conv2d.cpython-38.pyc,sha256=Nqt1X79POfxc6lifSDgGw0CgnWTG5yF95w_qLvlZaVY,7953 +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/injective.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/injective.cpython-310.pyc,sha256=98Fko7Uc1xXqNg04yps2O7a8YL94g37n8YCK4ZXFMiA,4550 +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/injective.cpython-38.pyc,sha256=nizbt3S1O-iEAfTeBpezMXT_oK0RFLiPd8JgEHnoYW8,4559 +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/math_alter_op.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/math_alter_op.cpython-310.pyc,sha256=YVGhJ9LmYitESYWwSpOrUnfMMArx4N3ePGP0sTLaxZ0,1045 +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/math_alter_op.cpython-38.pyc,sha256=ldJsdai4W1DgbL6fk0dHfCwCmNcG4tQTFDNfDFPtgLk,1032 +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/nn.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/nn.cpython-310.pyc,sha256=2yyLgfcCfDi9i5krDEFlLHTmXn_3VhdJ8KgurPkQBjw,3422 +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/nn.cpython-38.pyc,sha256=Csn9M5MYBIFnUVdE5ssfnSI6BHP9W6GbNO-IQptxq2M,3449 +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/pooling.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/pooling.cpython-310.pyc,sha256=4WK-A-DSIEkGWoUShD16z3B4K3VvPJ8ZlZnWBNjH2q8,4180 +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/pooling.cpython-38.pyc,sha256=620XLVAGRVc8TWxvEDxM9eNY6bUjudbm_t3z5DcFbgA,4169 +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/reduction.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/reduction.cpython-310.pyc,sha256=SFTkO3vNKDwn11u4ZH-gLLMAndhqU_uZZOjg_LNqeu4,2914 +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/reduction.cpython-38.pyc,sha256=CTbT8uqvunIkL_L5TXMubkHyrQ3PlrgGRiT0-P_8JYA,2865 +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/roi_align.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/roi_align.cpython-310.pyc,sha256=ar8fmgJGADcz2XH_3mmrwA0HLMi9-leGET-WUTAPPkk,5685 +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/roi_align.cpython-38.pyc,sha256=ibn9AQ_DUvNE9MbnderbhDusqbIPqhsT9gZCiRmFLi0,5700 +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/sparse.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/sparse.cpython-310.pyc,sha256=PwrJQgPntaEqe0tGdWDhOQcSotXzHIH9YtgfrXrlYQI,8043 +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/sparse.cpython-38.pyc,sha256=dYbCyjUttwTf1LCcQJfVvCuiya9RR_t-29ZNM6-BnJs,8263 +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/tensor_intrin.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/tensor_intrin.cpython-310.pyc,sha256=qYj0QL0ZztFlaQX1Btq0BxgQ8RQhUPQNbOS3WsBVHR8,14963 +bitblas/3rdparty/tvm/python/tvm/topi/x86/__pycache__/tensor_intrin.cpython-38.pyc,sha256=P2bVFtcwWjg5opUM2laswMcFNdnmWhXTH1e2g1peRNI,15132 +bitblas/3rdparty/tvm/python/tvm/topi/x86/batch_matmul.py,sha256=UOr3qYIsL4rxhtDpAOhkGUniutevo-AnO7Sv2YKMIvo,11505 +bitblas/3rdparty/tvm/python/tvm/topi/x86/binarize_pack.py,sha256=qsyUC-9ie4SC7bJDYqnyfXmJoKA31ULaJnz1lQo4NOU,1669 +bitblas/3rdparty/tvm/python/tvm/topi/x86/binary_dense.py,sha256=uKsALf_QDcpn70kWpf2bIpz3vxmct1-V2EMphAvIFWA,2528 +bitblas/3rdparty/tvm/python/tvm/topi/x86/bitserial_conv2d.py,sha256=1PQQv_D4QR7w_BC2I2RGisZnZiDD_7OMm5UtW_-GxYs,18896 +bitblas/3rdparty/tvm/python/tvm/topi/x86/bitserial_dense.py,sha256=_IL5VgHWQUH3Y0VliRFDcp75_gKizTQXBvmfAg081hI,6750 +bitblas/3rdparty/tvm/python/tvm/topi/x86/concat.py,sha256=9O9kV-Cmnl6eQGQ9g0cG_A859sabD4mLYcg6bX7Gafc,3799 +bitblas/3rdparty/tvm/python/tvm/topi/x86/conv1d.py,sha256=RPkFv2aSLqZmVPFkp6mgszZ3ZT3IbZ2XboZVAYpGWlA,5054 +bitblas/3rdparty/tvm/python/tvm/topi/x86/conv2d.py,sha256=EmJtr4OCvyDv830XJ19UT4j1Cd1AouBYChX3GnUPx_0,11899 +bitblas/3rdparty/tvm/python/tvm/topi/x86/conv2d_alter_op.py,sha256=oVHRXU4lVsjHBqWqqMCOKYcodS9oPiXV8ZMEi2g2XX0,10908 +bitblas/3rdparty/tvm/python/tvm/topi/x86/conv2d_avx_1x1.py,sha256=qp3oy3L0EqpJ_DQKnrFSjJ3MiJeNM_VpMvayfDmANmc,10572 +bitblas/3rdparty/tvm/python/tvm/topi/x86/conv2d_avx_common.py,sha256=NxcplUmhmHRGg9HCkpDdlCh0oXlCDSe2Y5Vs0fsSylk,6565 +bitblas/3rdparty/tvm/python/tvm/topi/x86/conv2d_int8.py,sha256=1Tx_j9QN05-O_0ITedIGQss0JTPpwA-QiOtb68WQPTI,9831 +bitblas/3rdparty/tvm/python/tvm/topi/x86/conv2d_transpose.py,sha256=r_-ELrbftp-c8skx0aAz5RL2W7FLd0HKSr439nMPb6k,2411 +bitblas/3rdparty/tvm/python/tvm/topi/x86/conv3d.py,sha256=ElRqxCkEXyQistfbl6Oe3yX4zzdwzwNyc-dwFaCOUoI,24797 +bitblas/3rdparty/tvm/python/tvm/topi/x86/conv3d_transpose.py,sha256=N96--CMkDxjcvKNFu39J_lfCc6emewz5hjweiw8WOPc,2257 +bitblas/3rdparty/tvm/python/tvm/topi/x86/dense.py,sha256=_PMuUEnxsXtc_Z49vbUrAgZlsK2hlljFYpnr0POKrFE,21809 +bitblas/3rdparty/tvm/python/tvm/topi/x86/dense_alter_op.py,sha256=WJBBmqKOW19g97AZe8U2Pek9hIFlX3Az-qq8iGxaz3k,5437 +bitblas/3rdparty/tvm/python/tvm/topi/x86/depthwise_conv2d.py,sha256=k-ltbOI5W3vP_j7bTE8Mh8bnwVm4wjoNXlm5WldWCjY,12259 +bitblas/3rdparty/tvm/python/tvm/topi/x86/group_conv2d.py,sha256=zk0oBXXidzMe7Wbps0IXQtTSsGJRssSeYBb2xhtlgAQ,12077 +bitblas/3rdparty/tvm/python/tvm/topi/x86/injective.py,sha256=sLC72erKCVcco06WUsYvAltDMpk9d_OQBmAxAI1DcZw,5471 +bitblas/3rdparty/tvm/python/tvm/topi/x86/math_alter_op.py,sha256=XHwmnmSmS2iS28HZxuthQsy1FOampq4ou51e4xBDo7E,1887 +bitblas/3rdparty/tvm/python/tvm/topi/x86/nn.py,sha256=P707ycj85jXBfZ7mq_kyt_a2WsWSO7AiCiB3Ik3nsrQ,4895 +bitblas/3rdparty/tvm/python/tvm/topi/x86/pooling.py,sha256=AhWNwlK2XNFvHZfMmL1H2bv8vNNEHmP83KcmhRioHlQ,5570 +bitblas/3rdparty/tvm/python/tvm/topi/x86/reduction.py,sha256=TYbxN0FFbXBpTdtFCnjv8Zn_ohCXbXvpmha9HxtdwGY,4378 +bitblas/3rdparty/tvm/python/tvm/topi/x86/roi_align.py,sha256=Nejmow-O5yXZIniNasN-PXdIxrgj39foA5BdZTripFc,11063 +bitblas/3rdparty/tvm/python/tvm/topi/x86/sparse.py,sha256=3GoWKQaofK1dR7WbGBrhq1R7pZ8QCkMsLcA1YsGz9hY,8988 +bitblas/3rdparty/tvm/python/tvm/topi/x86/tensor_intrin.py,sha256=HhtehGN06of6Erf87voPmbIjGIyB3kR11WppnJ_-ahY,21459 +bitblas/3rdparty/tvm/python/tvm/utils/__init__.py,sha256=LkwEYs4ATHuZrJ5HMxWJyKU4Ocpg53QRD3akWi7BOhU,891 +bitblas/3rdparty/tvm/python/tvm/utils/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/utils/roofline/__init__.py,sha256=9CmLsju4QD-ZC5jhBveKo-FNH4lecVqZH9lF1uuTYl0,10925 +bitblas/3rdparty/tvm/python/tvm/utils/roofline/__pycache__/__init__.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/utils/roofline/__pycache__/cuda.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/utils/roofline/__pycache__/registry.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/utils/roofline/__pycache__/x86.cpython-310.pyc,, +bitblas/3rdparty/tvm/python/tvm/utils/roofline/cuda.py,sha256=uTRa245YDXGapEnT3kk6pvYvmBITSJ3K3aLbMtKD5JA,15703 +bitblas/3rdparty/tvm/python/tvm/utils/roofline/registry.py,sha256=wEGVBsiGTAGaIN6YWhHIzmTdwMoPtIyobftpp7kbLVk,4019 +bitblas/3rdparty/tvm/python/tvm/utils/roofline/x86.py,sha256=G5pq6o2RKIjsxBoRXgE5bLHzEugllb-agl8SMFALg2o,12918 +bitblas/3rdparty/tvm/src/tl/tl_templates/cuda/common.h,sha256=90Qc8JfT9htT11qHctphBrwvDe-6Qzh5rrXLv3VOsT0,2282 +bitblas/3rdparty/tvm/src/tl/tl_templates/cuda/copy.h,sha256=KCAchwBXIGo0totXuhi79pK_ZR1VQ0Pru40tRdvfKe0,1973 +bitblas/3rdparty/tvm/src/tl/tl_templates/cuda/copy_sm90.h,sha256=MjHDrkxRG6IG6zpqQdUK3LaKqJ3CtdykqeOyyuEb9J4,9651 +bitblas/3rdparty/tvm/src/tl/tl_templates/cuda/gemm.h,sha256=krgY5l3lNo8tuxp99lSOKKN657Cs8PTaEiBs7CNDgU4,295 +bitblas/3rdparty/tvm/src/tl/tl_templates/cuda/gemm_sm70.h,sha256=LNL57sSiffCeUrK1fzhgbeQ5A5PIZ-jZNf4z24K4RX4,6765 +bitblas/3rdparty/tvm/src/tl/tl_templates/cuda/gemm_sm80.h,sha256=3zeqSkFIjrmkpl2ia3B9YoJcdBnkGxYl33S7KokFGy4,13217 +bitblas/3rdparty/tvm/src/tl/tl_templates/cuda/gemm_sm90.h,sha256=QmUuj68uyGJay8PmiQfJzjh3zN-YlAQfPpzN-KsFuds,8201 +bitblas/3rdparty/tvm/src/tl/tl_templates/cuda/ldsm.h,sha256=SJJH3GvSOg1IrQTwKYtaojOVUlYdK94RnigFML4MDx4,4459 +bitblas/3rdparty/tvm/src/tl/tl_templates/cuda/reduce.h,sha256=BcZETm2DnEwvyWwlAPtEEaPnvNrtZ-1ziw5TnO79xJM,1426 +bitblas/3rdparty/tvm/src/tl/tl_templates/cuda/threadblock_swizzle.h,sha256=_KafQD9l9kMcUSCpkJGJDQipGdnrxsVpwWJ44AWwVLo,1705 +bitblas/3rdparty/tvm/src/tl/tl_templates/hip/common.h,sha256=uMZq5NaLIwiYuXjPueAQ9C46tTE45Tj6ZngbQ_qDKm4,1789 +bitblas/3rdparty/tvm/src/tl/tl_templates/hip/copy.h,sha256=RyC5h3CGdwQUFqOC0tLtgomV2D8mieU0oPKPCxIfddM,2987 +bitblas/3rdparty/tvm/src/tl/tl_templates/hip/gemm.h,sha256=eXzdeOvSklsoUuPYAr7bih1gZcmzynJb9fzCsTxWJXI,8513 +bitblas/3rdparty/tvm/src/tl/tl_templates/hip/ldsm.h,sha256=vLJgG8CFI5VxsIOFjMoy9jNAkfxBX0EwkZBN7s5t9VI,33 +bitblas/3rdparty/tvm/src/tl/tl_templates/hip/reduce.h,sha256=5JAK3dmtxu7MScpODt4Mm_NN-XJRwh_ekRRdm6JcZFg,1308 +bitblas/3rdparty/tvm/src/tl/tl_templates/hip/threadblock_swizzle.h,sha256=dBkbi83Qqh-ctDIOzEhSAIwYvSWhB4DIIQ3K3pA8B-w,1815 +bitblas/3rdparty/tvm/version.py,sha256=D6B7NJ8XI64QonR-NwxG4hFvisQXQNnr7ltzstxu5jo,7491 +bitblas/__init__.py,sha256=kwuMoBoXq91perb_in-YaY0-xuh6TbpJ8yyfIyWL6ic,5743 +bitblas/__pycache__/__init__.cpython-310.pyc,, +bitblas/__pycache__/common.cpython-310.pyc,, +bitblas/base/__init__.py,sha256=O5_U9GVMEJTYF1C2DCSwOMCtIzpGuoBon_OFYPjxQ2Q,879 +bitblas/base/__pycache__/__init__.cpython-310.pyc,, +bitblas/base/__pycache__/analysis.cpython-310.pyc,, +bitblas/base/__pycache__/base_scheduler.cpython-310.pyc,, +bitblas/base/__pycache__/common_schedules.cpython-310.pyc,, +bitblas/base/__pycache__/operator_common.cpython-310.pyc,, +bitblas/base/__pycache__/schedule_rule.cpython-310.pyc,, +bitblas/base/__pycache__/tuner.cpython-310.pyc,, +bitblas/base/__pycache__/utils.cpython-310.pyc,, +bitblas/base/analysis.py,sha256=d7Yw6AgZDNVPdOpibdrDHdj7d7YRiTtoKU-KsVgL5H0,10144 +bitblas/base/arch/__init__.py,sha256=FrdUvPxWdhfShS8UtpOe_PH0dkB9dcgIjRbKTvMxKnw,1216 +bitblas/base/arch/__pycache__/__init__.cpython-310.pyc,, +bitblas/base/arch/__pycache__/arch_base.cpython-310.pyc,, +bitblas/base/arch/__pycache__/cdna.cpython-310.pyc,, +bitblas/base/arch/__pycache__/cpu.cpython-310.pyc,, +bitblas/base/arch/__pycache__/cuda.cpython-310.pyc,, +bitblas/base/arch/arch_base.py,sha256=9-fTujEwKdhK0VBkq95ZNV_jfQnUknHhgtf9A-3xY1Y,1717 +bitblas/base/arch/cdna.py,sha256=QQGmAnBg0VS2SrDZUsW2Z-PfBX4re5XBQGdHf4jCGaI,1216 +bitblas/base/arch/cpu.py,sha256=ptOYa-e8n3lJQv4PKEvhpPHhiHHf9G-vBYVUMRSz3Uw,694 +bitblas/base/arch/cuda.py,sha256=rWhGB5EKh_s-enENgDrX0EzUf5xneyfK_doxf-msKPA,4824 +bitblas/base/base_scheduler.py,sha256=YXvSmaDqm8l4RkWtzrZJHlR-0IwK7-0RQE-2aufKWrs,5093 +bitblas/base/common_schedules.py,sha256=oxRVhHcPQlca_uwqr1mfTh5e-MjL1OhVTZGcH2ySyas,4385 +bitblas/base/operator_common.py,sha256=dG-afGE_gPqX1vuXVV9e19YZUNXU5TKIa-E1yDLt79E,2631 +bitblas/base/roller/__init__.py,sha256=5z-sT0yMGOcJa8Q81z6VVx7yYG-F_axKx8rCU4OndP8,371 +bitblas/base/roller/__pycache__/__init__.cpython-310.pyc,, +bitblas/base/roller/__pycache__/bestfit.cpython-310.pyc,, +bitblas/base/roller/__pycache__/hint.cpython-310.pyc,, +bitblas/base/roller/__pycache__/node.cpython-310.pyc,, +bitblas/base/roller/__pycache__/rasterization.cpython-310.pyc,, +bitblas/base/roller/bestfit.py,sha256=Y5RqOG6Sa34Sg1BX61T6lEzZGJDkVtKUKXIDZSHQZYA,2248 +bitblas/base/roller/hint.py,sha256=uLdd8vrWlL6kZ5L4MlQazgvGas16rZs-tGpSv0XoGp0,7743 +bitblas/base/roller/node.py,sha256=Q_lXs6_fKKIU52TuYpPCpqVZTeIQVckM9WTmXC5WKkg,16148 +bitblas/base/roller/policy/__init__.py,sha256=9oVbiRmUdTEMOlGGKnThd7wsBAA-DpoLI5E3MDOSM04,150 +bitblas/base/roller/policy/__pycache__/__init__.cpython-310.pyc,, +bitblas/base/roller/policy/__pycache__/common.cpython-310.pyc,, +bitblas/base/roller/policy/__pycache__/default.cpython-310.pyc,, +bitblas/base/roller/policy/__pycache__/tensorcore.cpython-310.pyc,, +bitblas/base/roller/policy/common.py,sha256=ntVRfHIpxx2EYZ6HYFNskLiln1kKqSTNJCZ6F7PRchQ,1929 +bitblas/base/roller/policy/default.py,sha256=uGaRT084Q5FRR6tKlWxfhaRl5IneHn4OM7NBhSwx6Yo,28190 +bitblas/base/roller/policy/tensorcore.py,sha256=5acGQSHd4FXpDj2MRqbx6CjGxQB_ycJohLv3c-if6Z8,15767 +bitblas/base/roller/rasterization.py,sha256=NoyfyISbSJNKSxhc4m2Hz4HpBsBUe2i7GEoiraUMT2w,2776 +bitblas/base/roller/shape_inference/__init__.py,sha256=a1_MhNLa_S3aSeHycZnxLeyoQXRuBxxz5M-8YVG5Z_c,143 +bitblas/base/roller/shape_inference/__pycache__/__init__.cpython-310.pyc,, +bitblas/base/roller/shape_inference/__pycache__/common.cpython-310.pyc,, +bitblas/base/roller/shape_inference/__pycache__/tir.cpython-310.pyc,, +bitblas/base/roller/shape_inference/common.py,sha256=PQmuyFOL98mbiheyhq_7_7g2G-41D0OCaXza8yY8hJo,2638 +bitblas/base/roller/shape_inference/tir.py,sha256=PlcL-JT_ICXVyYpB9eB5_BsS5ZNFf-QoJGm9OyhEjfA,15471 +bitblas/base/schedule_rule.py,sha256=z_2EaGofDy9OwuGmI2MAAvau7zsNMsSWGV1RhJdCXv0,5209 +bitblas/base/tuner.py,sha256=WHN__A_pWAIjd1SMiP4B47lO_-RiHYtq4VItrMmuTTk,17094 +bitblas/base/utils.py,sha256=5pkRWJIwww3fw1Q1RszMYsipyqRxVlyY5cEoMKWnzsg,13440 +bitblas/benchmark/__init__.py,sha256=Pim2eV1QAdY5nAUgJKswG47mM7oI5mvzeadpO66f-CU,139 +bitblas/benchmark/__pycache__/__init__.cpython-310.pyc,, +bitblas/benchmark/operator/__init__.py,sha256=FPqx720VEdVM05076WbYtnT20sBPfnLsEz2I7qBUfCQ,5873 +bitblas/benchmark/operator/__pycache__/__init__.cpython-310.pyc,, +bitblas/builder/__init__.py,sha256=V1UuY7lIyrJori10cv4t4L_6XCYYRN2Vxy-oOugtBH8,178 +bitblas/builder/__pycache__/__init__.cpython-310.pyc,, +bitblas/builder/lib_generator/__init__.py,sha256=2w_WFzGat1iN1cg6XaErJ3kKqYdJ9hpHhixyycCKtJk,3883 +bitblas/builder/lib_generator/__pycache__/__init__.cpython-310.pyc,, +bitblas/builder/wrapper/__init__.py,sha256=Rd0WFeg5Z_7LmqMtgTyss7LhNbxPoGBVKyPQcgy_7B4,155 +bitblas/builder/wrapper/__pycache__/__init__.cpython-310.pyc,, +bitblas/builder/wrapper/__pycache__/base.cpython-310.pyc,, +bitblas/builder/wrapper/__pycache__/tir.cpython-310.pyc,, +bitblas/builder/wrapper/__pycache__/tl.cpython-310.pyc,, +bitblas/builder/wrapper/base.py,sha256=Tsd_I3eHzgQ-hZZ8B4iaQOmHKhEO_61ta0Z5c8IswHw,479 +bitblas/builder/wrapper/tir.py,sha256=OmSOkEHS7nZoQwPWmDfAi1lhYu2SBo3FpiguNdkNvrE,18501 +bitblas/builder/wrapper/tl.py,sha256=jPT5SrB-qsCdtOujQLbiCe03N8dqVw7P_B5L2R1rgZo,18796 +bitblas/cache/__init__.py,sha256=6Dd9Ui_Yan5e-9T58-T99aumYJW_l4kydDbd4FCc0OI,289 +bitblas/cache/__pycache__/__init__.cpython-310.pyc,, +bitblas/cache/__pycache__/operator.cpython-310.pyc,, +bitblas/cache/operator.py,sha256=GiF7TotMQThtEDA07CVhXgD-pDxHLsM6jGG42r-zyJw,7987 +bitblas/common.py,sha256=DCAAGKCQwsZliarZzDPLOZxP7FSX7JkuBScfTkGt3Yk,185 +bitblas/gpu/__init__.py,sha256=tBA1vFRQFnUl9vEydig8E_6dpbF5UncU0_KnAfcc2RU,900 +bitblas/gpu/__pycache__/__init__.cpython-310.pyc,, +bitblas/gpu/__pycache__/base.cpython-310.pyc,, +bitblas/gpu/__pycache__/element_wise.cpython-310.pyc,, +bitblas/gpu/__pycache__/fallback.cpython-310.pyc,, +bitblas/gpu/__pycache__/gemv.cpython-310.pyc,, +bitblas/gpu/__pycache__/gemv_dequantize.cpython-310.pyc,, +bitblas/gpu/__pycache__/general_reduction.cpython-310.pyc,, +bitblas/gpu/__pycache__/matmul.cpython-310.pyc,, +bitblas/gpu/__pycache__/matmul_analysis.cpython-310.pyc,, +bitblas/gpu/__pycache__/matmul_mfma.cpython-310.pyc,, +bitblas/gpu/__pycache__/matmul_mma.cpython-310.pyc,, +bitblas/gpu/__pycache__/matmul_mma_dequantize.cpython-310.pyc,, +bitblas/gpu/__pycache__/matmul_wmma.cpython-310.pyc,, +bitblas/gpu/__pycache__/reduction.cpython-310.pyc,, +bitblas/gpu/__pycache__/rmsnorm.cpython-310.pyc,, +bitblas/gpu/__pycache__/transpose.cpython-310.pyc,, +bitblas/gpu/__pycache__/utils.cpython-310.pyc,, +bitblas/gpu/base.py,sha256=t6oacPVCpWwaVs26n6ZtWRbktV0NPFyIFiGIwrrvrWA,1687 +bitblas/gpu/element_wise.py,sha256=XXa5ruqjynpX2xJBQ-l3Sj72XKNxQZNZ-6NArUaWOWw,3362 +bitblas/gpu/fallback.py,sha256=MYKzZQVklz-Ild2n0bVF-53wOs9srUFrnLyYy9KkfgA,3461 +bitblas/gpu/gemv.py,sha256=tNr_7sfABz12quKe5XsD6zmsEL3SkvhHs7bZ3Cr76f8,29247 +bitblas/gpu/gemv_dequantize.py,sha256=fSU2DO_tAppN9j0_TLybtMarC0B1N3w6tHKhZvn8sp0,15887 +bitblas/gpu/general_reduction.py,sha256=SN3VfgtMOb0VYHgV5KBrjY1MV-JU44OoTKY2JJ4Ali0,18392 +bitblas/gpu/intrin/__init__.py,sha256=99GkKE2NXMmw386IX4vHMEm75geb8YYYYIBGzLs12TA,180 +bitblas/gpu/intrin/__pycache__/__init__.cpython-310.pyc,, +bitblas/gpu/intrin/__pycache__/hip.cpython-310.pyc,, +bitblas/gpu/intrin/__pycache__/lop3.cpython-310.pyc,, +bitblas/gpu/intrin/hip.py,sha256=1fYlJb7VZdXbUqsQgzBi7ETBLtTAfosM45ARoKlcqrg,38514 +bitblas/gpu/intrin/lop3.py,sha256=vbWmYySo3jLejzNOP4UuKSWFt9RWN2ZcdsDhzTf7YSs,75273 +bitblas/gpu/matmul.py,sha256=mORt0De6LGBsiF8EI6JSqe94rWUWpC6JZg7tcscJcf8,29063 +bitblas/gpu/matmul_analysis.py,sha256=Ltxmapue5fH4fEVIERqTS4bmjl4VTn-bm1PwnHgjfTQ,32367 +bitblas/gpu/matmul_mfma.py,sha256=mWkjzl4aMXr9HNRLYv5JaqeN3DuAZqgxvyTrMxSVA4s,7330 +bitblas/gpu/matmul_mma.py,sha256=tnIXhbZ14_dYnZJXvwlSU-jlp1XKhjxcPU1Zh8CiQgw,29789 +bitblas/gpu/matmul_mma_dequantize.py,sha256=5-ZJ34ZMuq1dmuA5iF0hWH2ZrJ_Pcsi24_IZ7vyQkTE,97813 +bitblas/gpu/matmul_wmma.py,sha256=RZUPyNS67y85kYcX-fOdrnWGNslP08-njg9Bc9ySb5A,33996 +bitblas/gpu/reduction.py,sha256=kep2qMFOhUorGXsVccVkPkcfJCP1GqyJl_nolr7Kw6o,11549 +bitblas/gpu/rmsnorm.py,sha256=L7fUSAXs1Rze4yjzVf7XRl1PQFbun1ZdlmHS3EwsYRg,4833 +bitblas/gpu/transpose.py,sha256=sk-e-d0dS-pDkNjWEUrwyvUnQOgKrZh_IZmwR87bfvo,5112 +bitblas/gpu/utils.py,sha256=FG3GW33Vz31v36guI0w-7hwRfqu2j_sr_cNkE9416c8,2358 +bitblas/module/__init__.py,sha256=Y4-nh3OuqJYVJBeu1sCRU7_JfoZGDgqmY0pZLor7IOU,14835 +bitblas/module/__pycache__/__init__.cpython-310.pyc,, +bitblas/ops/__init__.py,sha256=bgNaFCUI0YORyJDGEFQlb7LDfqtGtf_K8NiDWpO_z0o,434 +bitblas/ops/__pycache__/__init__.cpython-310.pyc,, +bitblas/ops/__pycache__/general_matmul_splitk.cpython-310.pyc,, +bitblas/ops/__pycache__/operator.cpython-310.pyc,, +bitblas/ops/general_flashatten/__init__.py,sha256=KI8BqVVLxZYaMVezdXfuF5Mpgd78E7f00LUPaiDl1XY,7023 +bitblas/ops/general_flashatten/__pycache__/__init__.cpython-310.pyc,, +bitblas/ops/general_flashatten/tilelang/__init__.py,sha256=Ylr4Kj8ZXVk7d03bsskLEI-BpdliQO0yFTYqObwnrQg,867 +bitblas/ops/general_flashatten/tilelang/__pycache__/__init__.cpython-310.pyc,, +bitblas/ops/general_flashatten/tilelang/__pycache__/flashatten.cpython-310.pyc,, +bitblas/ops/general_flashatten/tilelang/flashatten.py,sha256=5MECRkicqzMh2VrNgzqtNRlWkfc3igYrnTeC0kHPrn0,12370 +bitblas/ops/general_matmul/__init__.py,sha256=t1-IiiwVli3DSqV8AZ6v5gKl-796ZvX_PHmhhUdqUdA,32348 +bitblas/ops/general_matmul/__pycache__/__init__.cpython-310.pyc,, +bitblas/ops/general_matmul/cuda/__init__.py,sha256=mOGfbc04rznUHS6fI4tdpEwDVGaER-bmy8Zg_mjG1kE,3416 +bitblas/ops/general_matmul/cuda/__pycache__/__init__.cpython-310.pyc,, +bitblas/ops/general_matmul/cuda/__pycache__/template.cpython-310.pyc,, +bitblas/ops/general_matmul/cuda/template.py,sha256=Jtg7vbqhV6mFXy8wQOitlG6kuDX5Gog3EmA2N3vY0DM,34571 +bitblas/ops/general_matmul/tilelang/__init__.py,sha256=HIog-luBqQnLkza1Q8b34Rr1QVu6tuiAy5sOry0vIPg,73 +bitblas/ops/general_matmul/tilelang/__pycache__/__init__.cpython-310.pyc,, +bitblas/ops/general_matmul/tilelang/dense/__init__.py,sha256=GsIDeEPyrLewKdb1HbVw6Nf9H1AreCUijD79i0AD3T4,6336 +bitblas/ops/general_matmul/tilelang/dense/__pycache__/__init__.cpython-310.pyc,, +bitblas/ops/general_matmul/tilelang/dense/__pycache__/base.cpython-310.pyc,, +bitblas/ops/general_matmul/tilelang/dense/__pycache__/gemv_simt.cpython-310.pyc,, +bitblas/ops/general_matmul/tilelang/dense/__pycache__/matmul.cpython-310.pyc,, +bitblas/ops/general_matmul/tilelang/dense/__pycache__/matmul_simt.cpython-310.pyc,, +bitblas/ops/general_matmul/tilelang/dense/__pycache__/matmul_tensorcore.cpython-310.pyc,, +bitblas/ops/general_matmul/tilelang/dense/__pycache__/matmul_wmma.cpython-310.pyc,, +bitblas/ops/general_matmul/tilelang/dense/base.py,sha256=581JUBhhgITngW3dIRGrrPlfDEg7tKmYuMRw0IJGkPw,1708 +bitblas/ops/general_matmul/tilelang/dense/gemv_simt.py,sha256=1k-IIdkGYgFxwP3uy98_Cxv_VA9PDY2Z7bUEkZmegs4,6659 +bitblas/ops/general_matmul/tilelang/dense/matmul.py,sha256=QmyuH8F6_dL6LK6nxR-PjSmqpZzMZEdappXmlfskRlc,10907 +bitblas/ops/general_matmul/tilelang/dense/matmul_simt.py,sha256=B19uayvYH1BcS9XB9H_sNvnsL1seT3JlVP8Jl5QdH2s,10972 +bitblas/ops/general_matmul/tilelang/dense/matmul_tensorcore.py,sha256=YsINzvievnAi9Bey2Z9wqNBTo9WiN9aKn8JYVyqVSos,59066 +bitblas/ops/general_matmul/tilelang/dense/matmul_wmma.py,sha256=f8-klSsVVRotdO7mtvr6NqYI1fuqi87icR4hiNtbUV0,3564 +bitblas/ops/general_matmul/tilelang/dequantize/__init__.py,sha256=AKh0LZQJIhAg8Pr_ZEK-oiloT5v7NUicTG-GTYvjjDs,2336 +bitblas/ops/general_matmul/tilelang/dequantize/__pycache__/__init__.cpython-310.pyc,, +bitblas/ops/general_matmul/tilelang/dequantize/__pycache__/base.cpython-310.pyc,, +bitblas/ops/general_matmul/tilelang/dequantize/__pycache__/gemv_dequantize_simt.cpython-310.pyc,, +bitblas/ops/general_matmul/tilelang/dequantize/__pycache__/matmul_dequantize.cpython-310.pyc,, +bitblas/ops/general_matmul/tilelang/dequantize/__pycache__/matmul_dequantize_simt.cpython-310.pyc,, +bitblas/ops/general_matmul/tilelang/dequantize/__pycache__/matmul_dequantize_tensorcore.cpython-310.pyc,, +bitblas/ops/general_matmul/tilelang/dequantize/__pycache__/matmul_dequantize_tensorcore_finegrained.cpython-310.pyc,, +bitblas/ops/general_matmul/tilelang/dequantize/__pycache__/matmul_dequantize_tensorcore_weight_transform.cpython-310.pyc,, +bitblas/ops/general_matmul/tilelang/dequantize/base.py,sha256=GVGYSSD1OTt0csXAywndNsqRaRaxz7TRbKKl1NKhgTk,3445 +bitblas/ops/general_matmul/tilelang/dequantize/gemv_dequantize_simt.py,sha256=7QXwPcAWV5aVN4v02aFIhMZbH-Hqgd9cPSQ1hyx7WZo,22471 +bitblas/ops/general_matmul/tilelang/dequantize/matmul_dequantize.py,sha256=v6SazwcT6_XEYmav0IuuCd0EsUnXf7WsW9giDZtd1Vk,12371 +bitblas/ops/general_matmul/tilelang/dequantize/matmul_dequantize_simt.py,sha256=F81HiJHtx-DUJpSB7nX9A_UMXrN-lWEt6JuzER2_Res,31246 +bitblas/ops/general_matmul/tilelang/dequantize/matmul_dequantize_tensorcore.py,sha256=cglq_sK_yIG9r_7eHDEhOEFbdfT9Z_J3xp2SulSWERA,29410 +bitblas/ops/general_matmul/tilelang/dequantize/matmul_dequantize_tensorcore_finegrained.py,sha256=2cO6hDn04l73MOgkSjOja1Rd38SdZEMTKFlx_HyFuOo,33423 +bitblas/ops/general_matmul/tilelang/dequantize/matmul_dequantize_tensorcore_weight_transform.py,sha256=mH5DbdFi-YXLM4UdW9x9Y_7c5W9Nrr8L_TMFKv-Xi4g,43414 +bitblas/ops/general_matmul/tirscript/__init__.py,sha256=p_KitNIR8cmCXsghnCVWZYOReHfEeMTT6q7HBSrI39I,281 +bitblas/ops/general_matmul/tirscript/__pycache__/__init__.cpython-310.pyc,, +bitblas/ops/general_matmul/tirscript/__pycache__/matmul_dequantize_impl.cpython-310.pyc,, +bitblas/ops/general_matmul/tirscript/__pycache__/matmul_impl.cpython-310.pyc,, +bitblas/ops/general_matmul/tirscript/matmul_dequantize_impl.py,sha256=_P0kw_qB5WnHbKDxI3f7_8F9cq5ptgSv7qKM2XRQCV4,36517 +bitblas/ops/general_matmul/tirscript/matmul_impl.py,sha256=oZDw541gBgtVDFINBaVQWR1aIGHjvYgzkIEyXo_O-s0,11059 +bitblas/ops/general_matmul_splitk.py,sha256=KL2Sqj5O4aCmm6tUNnM_CsERD6zfPae8sanbF5z3AvQ,7227 +bitblas/ops/impl/__init__.py,sha256=wVL1gu9X35iPtxi7Lu7tc11AccTdbDTDJ6vvI5GNb4w,142 +bitblas/ops/impl/__pycache__/__init__.cpython-310.pyc,, +bitblas/ops/impl/__pycache__/base.cpython-310.pyc,, +bitblas/ops/impl/__pycache__/batch_matmul_dequantize_impl.cpython-310.pyc,, +bitblas/ops/impl/__pycache__/batch_matmul_impl.cpython-310.pyc,, +bitblas/ops/impl/__pycache__/convolution2d_impl.cpython-310.pyc,, +bitblas/ops/impl/__pycache__/ladder_permutate_impl.cpython-310.pyc,, +bitblas/ops/impl/__pycache__/lop3_permutate_impl.cpython-310.pyc,, +bitblas/ops/impl/__pycache__/matmul_dequantize_impl.cpython-310.pyc,, +bitblas/ops/impl/__pycache__/matmul_dequantize_splitk_impl.cpython-310.pyc,, +bitblas/ops/impl/__pycache__/matmul_impl.cpython-310.pyc,, +bitblas/ops/impl/__pycache__/matmul_splitk_impl.cpython-310.pyc,, +bitblas/ops/impl/__pycache__/param_permutate_impl.cpython-310.pyc,, +bitblas/ops/impl/base.py,sha256=vXoBmjD4xfliGhiQH4UhNaMmhrFYUomtnavjg30u8Hw,492 +bitblas/ops/impl/batch_matmul_dequantize_impl.py,sha256=IPzyuuCA6ugTv68YsukWgo3JMBzYAUp4Aun0ttD-d88,13931 +bitblas/ops/impl/batch_matmul_impl.py,sha256=Gnf-JpNg-kmHM52gP0cFx4HpDMM7PsZu1nXOaOvUqN8,5035 +bitblas/ops/impl/convolution2d_impl.py,sha256=tsN2xfK95Rje931zEpYCm6cDP6iK3AwcmR2H5PL8K48,4937 +bitblas/ops/impl/ladder_permutate_impl.py,sha256=UDgzRIinGZxF9t-bv3dmwvNzHsKo9Y4WTezGyTyXH7c,3094 +bitblas/ops/impl/lop3_permutate_impl.py,sha256=5oMN35nOu3gTtut6qeS_RV4QJjYsW0aahIuNtvDxf5I,7116 +bitblas/ops/impl/matmul_dequantize_impl.py,sha256=Fe7zwuXdD4tYK3HwQ7ppTwX2BXMXJimY0ngQSjWBNLg,36143 +bitblas/ops/impl/matmul_dequantize_splitk_impl.py,sha256=WQmzB6BNHrVrDGMq8aknk3-oN7CKC6brgKhV4PBz9PE,21786 +bitblas/ops/impl/matmul_impl.py,sha256=ZGbBJxdzik58-N9ktTecwRR__aUO56o1rEqlMcMxtQ0,10932 +bitblas/ops/impl/matmul_splitk_impl.py,sha256=tHnC_wgV4NirYsOYhDqN5ulHk5HvNwYSYumcK0dRiEU,2865 +bitblas/ops/impl/param_permutate_impl.py,sha256=Z5aRZ-PVNrm7No2alaCH4kYo80zEgjFYhzm9gWE_LeM,2063 +bitblas/ops/ladder_permutate/__init__.py,sha256=lGdZz_bTMHOdIbqAYIVOw-sCLHZZVjcosSX6z13juis,3489 +bitblas/ops/ladder_permutate/__pycache__/__init__.cpython-310.pyc,, +bitblas/ops/ladder_permutate/__pycache__/ladder_permutate_impl.cpython-310.pyc,, +bitblas/ops/ladder_permutate/ladder_permutate_impl.py,sha256=WsuYykZtjuGGirFyMmngBKhSe9gdxKjRlNSdH-3JzQU,4259 +bitblas/ops/lop3_permutate/__init__.py,sha256=JA3Zqf-iU7YvqOAXK1BQgAs86zQXkdtMspCpVRyCqSg,2497 +bitblas/ops/lop3_permutate/__pycache__/__init__.cpython-310.pyc,, +bitblas/ops/lop3_permutate/__pycache__/lop3_permutate_impl.cpython-310.pyc,, +bitblas/ops/lop3_permutate/lop3_permutate_impl.py,sha256=pfV_Fo8s0DhU1Ca38zrkpzjEF6hYH9xKtLBlPvpU-9g,7176 +bitblas/ops/operator.py,sha256=MU2Wjqu9kolTME_5UFcTF84BcJUrrzRml9mt9VfDLyQ,22558 +bitblas/ops/quant_compress/__init__.py,sha256=j8Zvpp1ebtaAjo58QE0Bb4i87Bg2xwya9s93gvIVdU8,2397 +bitblas/ops/quant_compress/__pycache__/__init__.cpython-310.pyc,, +bitblas/ops/quant_compress/__pycache__/quant_compress_impl.cpython-310.pyc,, +bitblas/ops/quant_compress/quant_compress_impl.py,sha256=oz63wCpBNt-fY81eAyEFyqCfAdhm8RbjX_Dwi6Xa4-o,1571 +bitblas/quantization/__init__.py,sha256=HdpkXXMp338LC_7IcrVg_I9gyvgG04aav31ohPye_9A,532 +bitblas/quantization/__pycache__/__init__.cpython-310.pyc,, +bitblas/quantization/__pycache__/quantization.cpython-310.pyc,, +bitblas/quantization/__pycache__/utils.cpython-310.pyc,, +bitblas/quantization/quantization.py,sha256=TZH6Qi7v7BC6baTnVZTJB_QM99KIRy6zQJXNxuMlR9o,10361 +bitblas/quantization/utils.py,sha256=dVffIl6_fELJSKCt1G57fs-cBJ6S7F5a9PQmzA_Olzo,3836 +bitblas/relax/__init__.py,sha256=S9NFf71cnp2WwQkUgHIKo01aRoLj2Hy1G5XtA0YsfE0,275 +bitblas/relax/__pycache__/__init__.cpython-310.pyc,, +bitblas/relax/op/__init__.py,sha256=lPga1nwWZYr0EWcJuOCCPKHS4t5zrQB1XKYHlB-QOAY,140 +bitblas/relax/op/__pycache__/__init__.cpython-310.pyc,, +bitblas/relax/op/__pycache__/interleave_weight.cpython-310.pyc,, +bitblas/relax/op/interleave_weight.py,sha256=r1PnEqicoBhUMNRLVlMBxs5wEUj7qNDJJGbBQYYODQg,701 +bitblas/relax/transform/__init__.py,sha256=oXcv1R3keLsg10keam62Wqsdv60dcjxWVy7FusTCStI,261 +bitblas/relax/transform/__pycache__/__init__.cpython-310.pyc,, +bitblas/relax/transform/__pycache__/annotate_decode_block.cpython-310.pyc,, +bitblas/relax/transform/__pycache__/apply_fast_tuning.cpython-310.pyc,, +bitblas/relax/transform/__pycache__/weight_only_propagate.cpython-310.pyc,, +bitblas/relax/transform/annotate_decode_block.py,sha256=Utd2vpSToEkeP8WnVhFpOZuyz6_lLWOmSyGxlrc81Ak,5079 +bitblas/relax/transform/apply_fast_tuning.py,sha256=fEhVSfQrQGmQM4bWIjyRN8Wy7tK12KUGbIz9qtKV1-E,8558 +bitblas/relax/transform/weight_only_propagate.py,sha256=4kq6n7J-ddzQkqKPv77QpTvSpj5cZWRwfUK3Xip5qjw,17560 +bitblas/testing/__init__.py,sha256=Y0g-JfRvIF2ydvVYYPPfBW1DVxF8u7zZGr8jsrURLrI,3330 +bitblas/testing/__pycache__/__init__.cpython-310.pyc,, +bitblas/tl/__init__.py,sha256=p8gpUAghNf4r7ypvLexuX3opbPaQpzpJJojR93REyzw,318 +bitblas/tl/__pycache__/__init__.cpython-310.pyc,, +bitblas/tl/__pycache__/base_hint.cpython-310.pyc,, +bitblas/tl/__pycache__/base_layout.cpython-310.pyc,, +bitblas/tl/__pycache__/mfma_layout.cpython-310.pyc,, +bitblas/tl/__pycache__/mfma_macro_generator.cpython-310.pyc,, +bitblas/tl/__pycache__/mma_layout.cpython-310.pyc,, +bitblas/tl/__pycache__/mma_macro_generator.cpython-310.pyc,, +bitblas/tl/__pycache__/tuner.cpython-310.pyc,, +bitblas/tl/__pycache__/utils.cpython-310.pyc,, +bitblas/tl/__pycache__/wmma_macro_generator.cpython-310.pyc,, +bitblas/tl/base_hint.py,sha256=d8i4_ljrOnQbEVKmwAnhhnJSryZsytLaIR3BeRPObAk,2600 +bitblas/tl/base_layout.py,sha256=c-TE38rW2DnyDuR_fuHvGu7UjExBq-enLyK-EGT3vg0,359 +bitblas/tl/mfma_layout.py,sha256=zRIMYub4_TOOP5COZITo01Kr73nlVaN41qE8YPZswkI,3168 +bitblas/tl/mfma_macro_generator.py,sha256=-H0-tu2wda6corXdbOYI-tnm9Yn6ES-Vlz3Dr9rv3as,16156 +bitblas/tl/mma_layout.py,sha256=yuYbOLNdWVL9VO1ygEvnv-dT4QL9YZqJZCiHdp0QNEQ,5063 +bitblas/tl/mma_macro_generator.py,sha256=PYNwCFA1TxXoG_P3cULKEOu4OuqoEyBk-9FzsUfNgjU,34289 +bitblas/tl/tuner.py,sha256=9EELKaLrXJYFNsCK2gmKA5_Cg95lbtrpyLDH9KkOOGg,7258 +bitblas/tl/utils.py,sha256=UbXhWp86oP-X1ei3lXiA1h4IIkeJrKwyzk8qNgGk3mI,3751 +bitblas/tl/wmma_macro_generator.py,sha256=wNK_lPfDPABSIDC0TZRPVuS2Y_cToNNN9C_2eeUiJ1A,6289 +bitblas/utils/__init__.py,sha256=fBp-5YKzpj7CaIYaMa-MKYOIrmX8SOLAkymzKbUbZvo,1388 +bitblas/utils/__pycache__/__init__.cpython-310.pyc,, +bitblas/utils/__pycache__/post_process.cpython-310.pyc,, +bitblas/utils/__pycache__/rtmod_analysis.cpython-310.pyc,, +bitblas/utils/__pycache__/target_detector.cpython-310.pyc,, +bitblas/utils/__pycache__/tensor_adapter.cpython-310.pyc,, +bitblas/utils/__pycache__/weight_propagate.cpython-310.pyc,, +bitblas/utils/post_process.py,sha256=tgsAMs9Yf1CHT2-wI1UaJ5St_75Ke7sNcfuIXaOP0F4,2010 +bitblas/utils/rtmod_analysis.py,sha256=CgA4QQsC7F77tkFk0fB617kqEEf6KzI1Kf_qf4Xi43w,6452 +bitblas/utils/target_detector.py,sha256=Ej3OIoEmUG3m5Xwp309fjvmzlTIoo9HN3WAlLIi0770,3573 +bitblas/utils/tensor_adapter.py,sha256=gAi3I_XJvYB_OB6swCRmUxkh7_8EzxQP6gHtCkXFoAg,5616 +bitblas/utils/weight_propagate.py,sha256=CyVPCzaS6Ao7rwpKUm8y7coDXoyG9_rkP6av4cjPTyI,1039 diff --git a/venv/lib/python3.10/site-packages/bitblas-0.1.0.dist-info/REQUESTED b/venv/lib/python3.10/site-packages/bitblas-0.1.0.dist-info/REQUESTED new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/venv/lib/python3.10/site-packages/bitblas-0.1.0.dist-info/WHEEL b/venv/lib/python3.10/site-packages/bitblas-0.1.0.dist-info/WHEEL new file mode 100644 index 0000000000000000000000000000000000000000..e9e30f4f7877fc7584c4b9373fc0f7890957732e --- /dev/null +++ b/venv/lib/python3.10/site-packages/bitblas-0.1.0.dist-info/WHEEL @@ -0,0 +1,5 @@ +Wheel-Version: 1.0 +Generator: bdist_wheel (0.38.4) +Root-Is-Purelib: true +Tag: py3-none-manylinux1_x86_64 + diff --git a/venv/lib/python3.10/site-packages/bitblas-0.1.0.dist-info/top_level.txt b/venv/lib/python3.10/site-packages/bitblas-0.1.0.dist-info/top_level.txt new file mode 100644 index 0000000000000000000000000000000000000000..aed35d5757f24a06f7039ea789cff8ab57c2e1df --- /dev/null +++ b/venv/lib/python3.10/site-packages/bitblas-0.1.0.dist-info/top_level.txt @@ -0,0 +1 @@ +bitblas diff --git a/venv/lib/python3.10/site-packages/cached_path/__init__.py b/venv/lib/python3.10/site-packages/cached_path/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..c056c0bc71a98186864f55112b7bdc9ce54497c4 --- /dev/null +++ b/venv/lib/python3.10/site-packages/cached_path/__init__.py @@ -0,0 +1,39 @@ +""" +The idea behind **cached-path** is to provide a unified, simple, extendable interface for accessing +both local and remote files. +This can be used behind other APIs that need to access files agnostic to where they are located. + +For remote files, **cached-path** supports several different schemes out-of-the-box in addition +``http`` and ``https``, including ``s3`` for AWS S3, ``gs`` for Google Cloud Storage, +and ``hf`` for HuggingFace Hub. See :func:`cached_path.cached_path()` for more details. + +You can also extend **cached-path** to support other schemes with :func:`add_scheme_client()`. +""" + +from ._cached_path import cached_path +from .bytes_range import get_bytes_range +from .common import get_cache_dir, set_cache_dir +from .progress import get_download_progress +from .schemes import SchemeClient, add_scheme_client +from .util import ( + check_tarfile, + filename_to_url, + find_latest_cached, + is_url_or_existing_file, + resource_to_filename, +) + +__all__ = [ + "cached_path", + "get_bytes_range", + "get_cache_dir", + "set_cache_dir", + "get_download_progress", + "SchemeClient", + "add_scheme_client", + "check_tarfile", + "filename_to_url", + "find_latest_cached", + "is_url_or_existing_file", + "resource_to_filename", +] diff --git a/venv/lib/python3.10/site-packages/cached_path/__pycache__/__init__.cpython-310.pyc b/venv/lib/python3.10/site-packages/cached_path/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..91b121ad7f55c0a7dcc0cb9372e4a1ae79c4f402 Binary files /dev/null and b/venv/lib/python3.10/site-packages/cached_path/__pycache__/__init__.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/cached_path/__pycache__/_cached_path.cpython-310.pyc b/venv/lib/python3.10/site-packages/cached_path/__pycache__/_cached_path.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8a58b35443439fbea7b98496d35a80a26b553b14 Binary files /dev/null and b/venv/lib/python3.10/site-packages/cached_path/__pycache__/_cached_path.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/cached_path/__pycache__/bytes_range.cpython-310.pyc b/venv/lib/python3.10/site-packages/cached_path/__pycache__/bytes_range.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..237c78d615f901b80ebc99ea85641ace0e06d8f3 Binary files /dev/null and b/venv/lib/python3.10/site-packages/cached_path/__pycache__/bytes_range.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/cached_path/__pycache__/cache_file.cpython-310.pyc b/venv/lib/python3.10/site-packages/cached_path/__pycache__/cache_file.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..83714578e42cfa309b0ef618d216bd9a309a7f37 Binary files /dev/null and b/venv/lib/python3.10/site-packages/cached_path/__pycache__/cache_file.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/cached_path/__pycache__/common.cpython-310.pyc b/venv/lib/python3.10/site-packages/cached_path/__pycache__/common.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6dfab41573c2943b730e885d4e7fe6391dedc90e Binary files /dev/null and b/venv/lib/python3.10/site-packages/cached_path/__pycache__/common.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/cached_path/__pycache__/file_lock.cpython-310.pyc b/venv/lib/python3.10/site-packages/cached_path/__pycache__/file_lock.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b485337a6ccd7b4e11b17c06c70c9df62735a84d Binary files /dev/null and b/venv/lib/python3.10/site-packages/cached_path/__pycache__/file_lock.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/cached_path/__pycache__/meta.cpython-310.pyc b/venv/lib/python3.10/site-packages/cached_path/__pycache__/meta.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3d92ea8595c07ffc832efd3674d6ffd97a46e634 Binary files /dev/null and b/venv/lib/python3.10/site-packages/cached_path/__pycache__/meta.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/cached_path/__pycache__/progress.cpython-310.pyc b/venv/lib/python3.10/site-packages/cached_path/__pycache__/progress.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a8b82e8da070a0f03b1629a185c124e99c7ad249 Binary files /dev/null and b/venv/lib/python3.10/site-packages/cached_path/__pycache__/progress.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/cached_path/__pycache__/testing.cpython-310.pyc b/venv/lib/python3.10/site-packages/cached_path/__pycache__/testing.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c169ed15832edc76d217c0d62e9ddbb1c7572ac4 Binary files /dev/null and b/venv/lib/python3.10/site-packages/cached_path/__pycache__/testing.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/cached_path/__pycache__/util.cpython-310.pyc b/venv/lib/python3.10/site-packages/cached_path/__pycache__/util.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..77ada87c21dec393c7bd1eb860b1694197da69ed Binary files /dev/null and b/venv/lib/python3.10/site-packages/cached_path/__pycache__/util.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/cached_path/__pycache__/version.cpython-310.pyc b/venv/lib/python3.10/site-packages/cached_path/__pycache__/version.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9573f6613ee743fae89078617e5d177f92c6b789 Binary files /dev/null and b/venv/lib/python3.10/site-packages/cached_path/__pycache__/version.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/cached_path/_cached_path.py b/venv/lib/python3.10/site-packages/cached_path/_cached_path.py new file mode 100644 index 0000000000000000000000000000000000000000..788b2b0f6e66b7a52fd1fcda0d8d2f85d75ddb35 --- /dev/null +++ b/venv/lib/python3.10/site-packages/cached_path/_cached_path.py @@ -0,0 +1,405 @@ +import logging +import os +import shutil +import tarfile +import tempfile +from pathlib import Path +from typing import TYPE_CHECKING, Dict, Optional, Tuple +from urllib.parse import urlparse +from zipfile import ZipFile, is_zipfile + +from .cache_file import CacheFile +from .common import PathOrStr, get_cache_dir +from .file_lock import FileLock +from .meta import Meta +from .schemes import ( + SchemeClient, + get_scheme_client, + get_supported_schemes, + hf_get_from_cache, +) +from .util import ( + _lock_file_path, + _meta_file_path, + check_tarfile, + find_latest_cached, + resource_to_filename, +) + +if TYPE_CHECKING: + from rich.progress import Progress + +logger = logging.getLogger("cached_path") + + +def _is_rarfile(path: PathOrStr, url_or_filename: PathOrStr) -> bool: + try: + import rarfile + + return rarfile.is_rarfile(path) + except ImportError: + if str(url_or_filename).lower().endswith(".rar"): + import warnings + + warnings.warn( + f"The file has a 'rar' extension but rarfile is unavailable: {url_or_filename}" + "\nSee https://rarfile.readthedocs.io/" + ) + + return False + + +def _is_archive(file_path: PathOrStr, url_or_filename) -> bool: + return ( + is_zipfile(file_path) + or tarfile.is_tarfile(file_path) + or _is_rarfile(file_path, url_or_filename) + ) + + +def cached_path( + url_or_filename: PathOrStr, + cache_dir: Optional[PathOrStr] = None, + extract_archive: bool = False, + force_extract: bool = False, + quiet: bool = False, + progress: Optional["Progress"] = None, + headers: Optional[Dict[str, str]] = None, +) -> Path: + """ + Given something that might be a URL or local path, determine which. + If it's a remote resource, download the file and cache it, and + then return the path to the cached file. If it's already a local path, + make sure the file exists and return the path. + + For URLs, the following schemes are all supported out-of-the-box: + + * ``http`` and ``https``, + * ``s3`` for objects on `AWS S3`_, + * ``gs`` for objects on `Google Cloud Storage (GCS)`_, and + * ``hf`` for objects or repositories on `HuggingFace Hub`_. + + If you have `Beaker-py`_ installed you can also use URLs of the form: + ``beaker://{user_name}/{dataset_name}/{file_path}``. + + You can also extend ``cached_path()`` to handle more schemes with :func:`add_scheme_client()`. + + .. _AWS S3: https://aws.amazon.com/s3/ + .. _Google Cloud Storage (GCS): https://cloud.google.com/storage + .. _HuggingFace Hub: https://huggingface.co/ + .. _Beaker-py: https://github.com/allenai/beaker-py + + Examples + -------- + + To download a file over ``https``:: + + cached_path("https://github.com/allenai/cached_path/blob/main/README.md") + + To download an object on GCS:: + + cached_path("gs://allennlp-public-models/lerc-2020-11-18.tar.gz") + + To download the PyTorch weights for the model `epwalsh/bert-xsmall-dummy`_ + on HuggingFace, you could do:: + + cached_path("hf://epwalsh/bert-xsmall-dummy/pytorch_model.bin") + + For paths or URLs that point to a tarfile or zipfile, you can append the path + to a specific file within the archive to the ``url_or_filename``, preceeded by a "!". + The archive will be automatically extracted (provided you set ``extract_archive`` to ``True``), + returning the local path to the specific file. For example:: + + cached_path("model.tar.gz!weights.th", extract_archive=True) + + .. _epwalsh/bert-xsmall-dummy: https://huggingface.co/epwalsh/bert-xsmall-dummy + + Parameters + ---------- + + url_or_filename : + A URL or path to parse and possibly download. + + cache_dir : + The directory to cache downloads. If not specified, the global default cache directory + will be used (``~/.cache/cached_path``). This can be set to something else with + :func:`set_cache_dir()`. + + extract_archive : + If ``True``, then zip or tar.gz archives will be automatically extracted. + In which case the directory is returned. + + force_extract : + If ``True`` and the file is an archive file, it will be extracted regardless + of whether or not the extracted directory already exists. + + .. caution:: + Use this flag with caution! This can lead to race conditions if used + from multiple processes on the same file. + + quiet : + If ``True``, progress displays won't be printed. + + progress : + A custom progress display to use. If not set and ``quiet=False``, a default display + from :func:`~cached_path.get_download_progress()` will be used. + + headers : + Custom headers to add to HTTP requests. + Example: ``{"Authorization": "Bearer YOUR_TOKEN"}`` for private resources. + Only used for HTTP/HTTPS resources. + + Returns + ------- + :class:`pathlib.Path` + The local path to the (potentially cached) resource. + + Raises + ------ + ``FileNotFoundError`` + + If the resource cannot be found locally or remotely. + + ``ValueError`` + When the URL is invalid. + + ``Other errors`` + Other error types are possible as well depending on the client used to fetch + the resource. + + """ + if not isinstance(url_or_filename, str): + url_or_filename = str(url_or_filename) + + file_path: Path + extraction_path: Optional[Path] = None + etag: Optional[str] = None + + # If we're using the /a/b/foo.zip!c/d/file.txt syntax, handle it here. + exclamation_index = url_or_filename.find("!") + if extract_archive and exclamation_index >= 0: + archive_path = url_or_filename[:exclamation_index] + file_name = url_or_filename[exclamation_index + 1 :] + + # Call 'cached_path' recursively now to get the local path to the archive itself. + cached_archive_path = cached_path( + archive_path, + cache_dir=cache_dir, + extract_archive=True, + force_extract=force_extract, + quiet=quiet, + progress=progress, + headers=headers, + ) + if not cached_archive_path.is_dir(): + raise ValueError( + f"{url_or_filename} uses the ! syntax, but does not specify an archive file." + ) + + # Now return the full path to the desired file within the extracted archive, + # provided it exists. + file_path = cached_archive_path / file_name + if not file_path.exists(): + raise FileNotFoundError(f"'{file_name}' not found within '{archive_path}'") + + return file_path + + parsed = urlparse(url_or_filename) + + if parsed.scheme in get_supported_schemes(): + # URL, so get it from the cache (downloading if necessary) + file_path, etag = get_from_cache( + url_or_filename, cache_dir, quiet=quiet, progress=progress, headers=headers + ) + + if extract_archive and _is_archive(file_path, url_or_filename): + # This is the path the file should be extracted to. + # For example ~/.cached_path/cache/234234.21341 -> ~/.cached_path/cache/234234.21341-extracted + extraction_path = file_path.parent / (file_path.name + "-extracted") + elif parsed.scheme == "file": + return cached_path(url_or_filename.replace("file://", "", 1)) + else: + orig_url_or_filename = url_or_filename + url_or_filename = Path(url_or_filename).expanduser() + cache_dir = Path(cache_dir if cache_dir else get_cache_dir()).expanduser() + cache_dir.mkdir(parents=True, exist_ok=True) + + if url_or_filename.exists(): + # File, and it exists. + file_path = url_or_filename + # Normalize the path. + url_or_filename = url_or_filename.resolve() + if extract_archive and file_path.is_file() and _is_archive(file_path, url_or_filename): + # We'll use a unique directory within the cache to root to extract the archive to. + # The name of the directory is a hash of the resource file path and it's modification + # time. That way, if the file changes, we'll know when to extract it again. + extraction_name = ( + resource_to_filename(url_or_filename, str(os.path.getmtime(file_path))) + + "-extracted" + ) + extraction_path = cache_dir / extraction_name + elif parsed.scheme == "": + # File, but it doesn't exist. + raise FileNotFoundError(f"file {url_or_filename} not found") + else: + # Something unknown + raise ValueError(f"unable to parse {orig_url_or_filename} as a URL or as a local path") + + if extraction_path is not None: + # If the extracted directory already exists (and is non-empty), then no + # need to create a lock file and extract again unless `force_extract=True`. + if os.path.isdir(extraction_path) and os.listdir(extraction_path) and not force_extract: + return extraction_path + + # Extract it. + with FileLock(_lock_file_path(extraction_path)): + # Check again if the directory exists now that we've acquired the lock. + if os.path.isdir(extraction_path) and os.listdir(extraction_path): + if force_extract: + logger.warning( + "Extraction directory for %s (%s) already exists, " + "overwriting it since 'force_extract' is 'True'", + url_or_filename, + extraction_path, + ) + else: + return extraction_path + + logger.info("Extracting %s to %s", url_or_filename, extraction_path) + shutil.rmtree(extraction_path, ignore_errors=True) + + # We extract first to a temporary directory in case something goes wrong + # during the extraction process so we don't end up with a corrupted cache. + tmp_extraction_dir = tempfile.mkdtemp(dir=os.path.split(extraction_path)[0]) + try: + if tarfile.is_tarfile(file_path): + with tarfile.open(file_path) as tar_file: + check_tarfile(tar_file) + tar_file.extractall(tmp_extraction_dir) + elif _is_rarfile(file_path, url_or_filename): + import rarfile + + with rarfile.RarFile(file_path) as rar_file: + rar_file.extractall(tmp_extraction_dir) + else: + with ZipFile(file_path) as zip_file: + zip_file.extractall(tmp_extraction_dir) + # Extraction was successful, rename temp directory to final + # cache directory and dump the meta data. + os.replace(tmp_extraction_dir, extraction_path) + meta = Meta.new( + url_or_filename, + extraction_path, + etag=etag, + extraction_dir=True, + ) + meta.to_file() + finally: + shutil.rmtree(tmp_extraction_dir, ignore_errors=True) + + return extraction_path + + return file_path + + +def get_from_cache( + url: str, + cache_dir: Optional[PathOrStr] = None, + quiet: bool = False, + progress: Optional["Progress"] = None, + no_downloads: bool = False, + _client: Optional[SchemeClient] = None, + headers: Optional[Dict[str, str]] = None, +) -> Tuple[Path, Optional[str]]: + """ + Given a URL, look for the corresponding dataset in the local cache. + If it's not there, download it. Then return the path to the cached file and the ETag. + """ + if url.startswith("hf://"): + return hf_get_from_cache(url, cache_dir), None + + cache_dir = Path(cache_dir if cache_dir else get_cache_dir()).expanduser() + cache_dir.mkdir(parents=True, exist_ok=True) + client = _client or get_scheme_client(url, headers=headers) + + # Get eTag to add to filename, if it exists. + try: + etag = client.get_etag() + except client.recoverable_errors: # type: ignore + # We might be offline, in which case we don't want to throw an error + # just yet. Instead, we'll try to use the latest cached version of the + # target resource, if it exists. We'll only throw an exception if we + # haven't cached the resource at all yet. + logger.warning( + "Connection error occurred while trying to fetch ETag for %s. " + "Will attempt to use latest cached version of resource", + url, + ) + latest_cached = find_latest_cached(url, cache_dir) + if latest_cached: + logger.info( + "ETag request failed with recoverable error, using latest cached version of %s: %s", + url, + latest_cached, + ) + meta = Meta.from_path(_meta_file_path(latest_cached)) + return latest_cached, meta.etag + else: + logger.error( + "ETag request failed with recoverable error, but no cached version of %s could be found", + url, + ) + raise + + filename = resource_to_filename(url, etag) + + # Get cache path to put the file. + cache_path = cache_dir / filename + + # Multiple processes may be trying to cache the same file at once, so we need + # to be a little careful to avoid race conditions. We do this using a lock file. + # Only one process can own this lock file at a time, and a process will block + # on the call to `lock.acquire()` until the process currently holding the lock + # releases it. + logger.debug("waiting to acquire lock on %s", cache_path) + with FileLock(_lock_file_path(cache_path), read_only_ok=True): + if os.path.exists(cache_path): + logger.info("cache of %s is up-to-date", url) + elif no_downloads: + raise FileNotFoundError(cache_path) + else: + size = client.get_size() + with CacheFile(cache_path) as cache_file: + logger.info("%s not found in cache, downloading to %s", url, cache_path) + + from .progress import BufferedWriterWithProgress, get_download_progress + + start_and_cleanup = progress is None + progress = progress or get_download_progress(quiet=quiet) + + if start_and_cleanup: + progress.start() + + try: + display_url = url if len(url) <= 30 else f"\N{HORIZONTAL ELLIPSIS}{url[-30:]}" + task_id = progress.add_task(f"Downloading [cyan i]{display_url}[/]", total=size) + writer_with_progress = BufferedWriterWithProgress(cache_file, progress, task_id) + client.get_resource(writer_with_progress) + progress.update( + task_id, + total=writer_with_progress.total_written, + completed=writer_with_progress.total_written, + ) + finally: + if start_and_cleanup: + progress.stop() + + logger.debug("creating metadata file for %s", cache_path) + meta = Meta.new( + url, + cache_path, + etag=etag, + ) + meta.to_file() + + return cache_path, etag diff --git a/venv/lib/python3.10/site-packages/cached_path/bytes_range.py b/venv/lib/python3.10/site-packages/cached_path/bytes_range.py new file mode 100644 index 0000000000000000000000000000000000000000..824da8d26a1289bf0d1cf4476380942d88e347c7 --- /dev/null +++ b/venv/lib/python3.10/site-packages/cached_path/bytes_range.py @@ -0,0 +1,140 @@ +from typing import TYPE_CHECKING, Optional +from urllib.parse import urlparse + +from ._cached_path import cached_path, get_from_cache +from .common import PathOrStr +from .schemes import get_scheme_client, get_supported_schemes + +if TYPE_CHECKING: + from rich.progress import Progress + + +def get_bytes_range( + url_or_filename: PathOrStr, + index: int, + length: int, + cache_dir: Optional[PathOrStr] = None, + extract_archive: bool = False, + force_extract: bool = False, + quiet: bool = False, + progress: Optional["Progress"] = None, +) -> bytes: + """ + Get a range of up to ``length`` bytes starting at ``index``. + + In some cases the entire file may need to be downloaded, such as when the server does not support + a range download or when you're trying to get a bytes range from a file within an archive. + + .. caution:: + You may get less than ``length`` bytes sometimes, such as when fetching a range from an HTTP + resource starting at 0 since headers will be omitted in the bytes returned. + + Parameters + ---------- + + url_or_filename : + A URL or path to parse and possibly download. + + index : + The index of the byte to start at. + + length : + The number of bytes to read. + + cache_dir : + The directory to cache downloads. If not specified, the global default cache directory + will be used (``~/.cache/cached_path``). This can be set to something else with + :func:`set_cache_dir()`. + + This is only relevant when the bytes range cannot be obtained directly from the resource. + + extract_archive : + Set this to ``True`` when you want to get a bytes range from a file within an archive. + In this case the ``url_or_filename`` must contain an "!" followed by the relative path of the file + within the archive, e.g. "s3://my-archive.tar.gz!my-file.txt". + + Note that the entire archive has to be downloaded in this case. + + force_extract : + If ``True`` and the resource is a file within an archive (when the path contains an "!" and + ``extract_archive=True``), it will be extracted regardless of whether or not the extracted + directory already exists. + + .. caution:: + Use this flag with caution! This can lead to race conditions if used + from multiple processes on the same file. + + quiet : + If ``True``, progress displays won't be printed. + + This is only relevant when the bytes range cannot be obtained directly from the resource. + + progress : + A custom progress display to use. If not set and ``quiet=False``, a default display + from :func:`~cached_path.get_download_progress()` will be used. + + This is only relevant when the bytes range cannot be obtained directly from the resource. + """ + if not isinstance(url_or_filename, str): + url_or_filename = str(url_or_filename) + + # If we're using the /a/b/foo.zip!c/d/file.txt syntax, handle it here. + exclamation_index = url_or_filename.find("!") + if extract_archive and exclamation_index >= 0: + archive_path = url_or_filename[:exclamation_index] + file_name = url_or_filename[exclamation_index + 1 :] + + # Call 'cached_path' now to get the local path to the archive itself. + cached_archive_path = cached_path( + archive_path, + cache_dir=cache_dir, + extract_archive=True, + force_extract=force_extract, + quiet=quiet, + progress=progress, + ) + if not cached_archive_path.is_dir(): + raise ValueError( + f"{url_or_filename} uses the ! syntax, but does not specify an archive file." + ) + + # Now load bytes from the desired file within the extracted archive, provided it exists. + file_path = cached_archive_path / file_name + if not file_path.exists(): + raise FileNotFoundError(f"'{file_name}' not found within '{archive_path}'") + + return _bytes_range_from_file(file_path, index, length) + + if urlparse(url_or_filename).scheme in get_supported_schemes(): + # URL, so use the scheme client. + client = get_scheme_client(url_or_filename) + + # Check if file is already downloaded. + try: + cache_path, _ = get_from_cache( + url_or_filename, + cache_dir=cache_dir, + quiet=quiet, + progress=progress, + no_downloads=True, + _client=client, + ) + return _bytes_range_from_file(cache_path, index, length) + except FileNotFoundError: + pass + + # Otherwise try streaming bytes directly. + try: + return client.get_bytes_range(index, length) + except NotImplementedError: + # fall back to downloading the whole file. + pass + + file_path = cached_path(url_or_filename, cache_dir=cache_dir, quiet=quiet, progress=progress) + return _bytes_range_from_file(file_path, index, length) + + +def _bytes_range_from_file(path: PathOrStr, index: int, length: int) -> bytes: + with open(path, "rb") as f: + f.seek(index) + return f.read(length) diff --git a/venv/lib/python3.10/site-packages/cached_path/cache_file.py b/venv/lib/python3.10/site-packages/cached_path/cache_file.py new file mode 100644 index 0000000000000000000000000000000000000000..bcf76c9fb86e03c58fcbe777f9c4a44a7cd13a22 --- /dev/null +++ b/venv/lib/python3.10/site-packages/cached_path/cache_file.py @@ -0,0 +1,46 @@ +import logging +import os +import tempfile +from pathlib import Path + +from .common import PathOrStr + +logger = logging.getLogger(__name__) + + +class CacheFile: + """ + This is a context manager that makes robust caching easier. + + On `__enter__`, an IO handle to a temporarily file is returned, which can + be treated as if it's the actual cache file. + + On `__exit__`, the temporarily file is renamed to the cache file. If anything + goes wrong while writing to the temporary file, it will be removed. + """ + + def __init__(self, cache_filename: PathOrStr, mode: str = "w+b", suffix: str = ".tmp") -> None: + self.cache_filename = Path(cache_filename) + self.cache_directory = os.path.dirname(self.cache_filename) + self.mode = mode + self.temp_file = tempfile.NamedTemporaryFile( + self.mode, dir=self.cache_directory, delete=False, suffix=suffix + ) + + def __enter__(self): + return self.temp_file + + def __exit__(self, exc_type, exc_value, traceback): + self.temp_file.close() + if exc_value is None: + # Success. + logger.debug( + "Renaming temp file %s to cache at %s", self.temp_file.name, self.cache_filename + ) + # Rename the temp file to the actual cache filename. + os.replace(self.temp_file.name, self.cache_filename) + return True + # Something went wrong, remove the temp file. + logger.debug("removing temp file %s", self.temp_file.name) + os.remove(self.temp_file.name) + return False diff --git a/venv/lib/python3.10/site-packages/cached_path/common.py b/venv/lib/python3.10/site-packages/cached_path/common.py new file mode 100644 index 0000000000000000000000000000000000000000..4059acaa536824548cd5d2bea5e8d3d00211067a --- /dev/null +++ b/venv/lib/python3.10/site-packages/cached_path/common.py @@ -0,0 +1,42 @@ +import os +from os import PathLike +from pathlib import Path +from typing import Tuple, Union +from urllib.parse import urlparse + +PathOrStr = Union[str, PathLike] + +CACHE_DIRECTORY: PathOrStr = Path( + os.getenv("CACHED_PATH_CACHE_ROOT", Path.home() / ".cache" / "cached_path") +) +""" +The default global cache directory. +""" + + +def _split_cloud_path(url: str, provider: str) -> Tuple[str, str]: + """Split a full s3 path into the bucket name and path.""" + parsed = urlparse(url) + if not parsed.netloc or not parsed.path: + raise ValueError("bad {} path {}".format(provider, url)) + bucket_name = parsed.netloc + provider_path = parsed.path + # Remove '/' at beginning of path. + if provider_path.startswith("/"): + provider_path = provider_path[1:] + return bucket_name, provider_path + + +def set_cache_dir(cache_dir: PathOrStr) -> None: + """ + Set the global default cache directory. + """ + global CACHE_DIRECTORY + CACHE_DIRECTORY = Path(cache_dir) + + +def get_cache_dir() -> Path: + """ + Get the global default cache directory. + """ + return Path(CACHE_DIRECTORY) diff --git a/venv/lib/python3.10/site-packages/cached_path/file_lock.py b/venv/lib/python3.10/site-packages/cached_path/file_lock.py new file mode 100644 index 0000000000000000000000000000000000000000..486d510ac773eff8c13ac06d9fcbdaa55d66cb16 --- /dev/null +++ b/venv/lib/python3.10/site-packages/cached_path/file_lock.py @@ -0,0 +1,51 @@ +import os +import warnings +from typing import Optional + +from filelock import AcquireReturnProxy +from filelock import FileLock as _FileLock + +from .common import PathOrStr + + +class FileLock(_FileLock): + """ + This is just a subclass of the `FileLock` class from the `filelock` library, except that + it adds an additional argument to the `__init__` method: `read_only_ok`. + + By default this flag is `False`, which an exception will be thrown when a lock + can't be acquired due to lack of write permissions. + But if this flag is set to `True`, a warning will be emitted instead of an error when + the lock already exists but the lock can't be acquired because write access is blocked. + """ + + def __init__(self, lock_file: PathOrStr, timeout=-1, read_only_ok: bool = False) -> None: + super().__init__(str(lock_file), timeout=timeout) + self._read_only_ok = read_only_ok + + def acquire( # type: ignore[override] + self, + timeout=None, + poll_interval=0.05, + **kwargs, + ) -> Optional[AcquireReturnProxy]: + try: + return super().acquire(timeout=timeout, poll_interval=poll_interval, **kwargs) + except OSError as err: + # OSError could be a lot of different things, but what we're looking + # for in particular are permission errors, such as: + # - errno 1 - EPERM - "Operation not permitted" + # - errno 13 - EACCES - "Permission denied" + # - errno 30 - EROFS - "Read-only file system" + if err.errno not in (1, 13, 30): + raise + + if os.path.isfile(self.lock_file) and self._read_only_ok: + warnings.warn( + f"Lacking permissions required to obtain lock '{self.lock_file}'. " + "Race conditions are possible if other processes are writing to the same resource.", + UserWarning, + ) + return None + else: + raise diff --git a/venv/lib/python3.10/site-packages/cached_path/meta.py b/venv/lib/python3.10/site-packages/cached_path/meta.py new file mode 100644 index 0000000000000000000000000000000000000000..6422ee31adf33e90957b97d6881264979003acbe --- /dev/null +++ b/venv/lib/python3.10/site-packages/cached_path/meta.py @@ -0,0 +1,111 @@ +import json +import os +import time +from dataclasses import asdict, dataclass +from typing import Optional, Set + +from .common import PathOrStr + + +@dataclass +class Meta: + """ + Any resource that is downloaded to - or extracted in - the cache directory will + have a meta JSON file written next to it, which corresponds to an instance + of this class. + + In older versions of AllenNLP, this meta document just had two fields: 'url' and + 'etag'. The 'url' field is now the more general 'resource' field, but these old + meta files are still compatible when a `Meta` is instantiated with the `.from_path()` + class method. + """ + + resource: str + """ + URL or normalized path to the resource. + """ + + cached_path: str + """ + Path to the corresponding cached version of the resource. + """ + + creation_time: float + """ + The unix timestamp of when the corresponding resource was cached or extracted. + """ + + size: int = 0 + """ + The size of the corresponding resource, in bytes. + """ + + etag: Optional[str] = None + """ + Optional ETag associated with the current cached version of the resource. + """ + + extraction_dir: bool = False + """ + Does this meta corresponded to an extraction directory? + """ + + @classmethod + def new( + cls, + resource: PathOrStr, + cached_path: PathOrStr, + *, + etag: Optional[str] = None, + extraction_dir: bool = False, + ) -> "Meta": + return cls( # type: ignore + resource=str(resource), + cached_path=str(cached_path), + creation_time=time.time(), + size=cls.get_resource_size(cached_path), + etag=etag, + extraction_dir=extraction_dir, + ) + + def to_file(self) -> None: + with open(self.cached_path + ".json", "w") as meta_file: + json.dump(asdict(self), meta_file) + + @classmethod + def from_path(cls, path: PathOrStr) -> "Meta": + path = str(path) + with open(path) as meta_file: + data = json.load(meta_file) + # For backwards compat: + if "resource" not in data: + data["resource"] = data.pop("url") + if "creation_time" not in data: + data["creation_time"] = os.path.getmtime(path[:-5]) + if "extraction_dir" not in data and path.endswith("-extracted.json"): + data["extraction_dir"] = True + if "cached_path" not in data: + data["cached_path"] = path[:-5] + if "size" not in data: + data["size"] = cls.get_resource_size(data["cached_path"]) + return cls(**data) # type: ignore + + @staticmethod + def get_resource_size(path: PathOrStr) -> int: + """ + Get the size of a file or directory. + """ + if os.path.isfile(path): + return os.path.getsize(path) + inodes: Set[int] = set() + total_size = 0 + for dirpath, _, filenames in os.walk(str(path)): + for f in filenames: + fp = os.path.join(dirpath, f) + # skip if it is symbolic link or the same as a file we've already accounted + # for (this could happen with hard links). + inode = os.stat(fp).st_ino + if not os.path.islink(fp) and inode not in inodes: + inodes.add(inode) + total_size += os.path.getsize(fp) + return total_size diff --git a/venv/lib/python3.10/site-packages/cached_path/progress.py b/venv/lib/python3.10/site-packages/cached_path/progress.py new file mode 100644 index 0000000000000000000000000000000000000000..cf1dbf7243ee34439937a38342f155fc19aa2130 --- /dev/null +++ b/venv/lib/python3.10/site-packages/cached_path/progress.py @@ -0,0 +1,138 @@ +import io +from typing import List, Optional + +from rich.progress import BarColumn, DownloadColumn, Progress, TaskID, TimeElapsedColumn + + +class QuietProgress: + """ + A mock `Progress` class that does absolutely nothing. + We use this when users pass `quiet=True` since rich's `Progress` still + prints empty lines with `quiet=True`. + """ + + def start(self, *args, **kwargs): + del args, kwargs + + def stop(self, *args, **kwargs): + del args, kwargs + + def update(self, *args, **kwargs): + del args, kwargs + + def add_task(self, *args, **kwargs): + del args, kwargs + + def advance(self, *args, **kwargs): + del args, kwargs + + def stop_task(self, *args, **kwargs): + del args, kwargs + + def __enter__(self): + return self + + def __exit__(self, *args, **kwargs): # type: ignore + del args, kwargs + + +class BufferedWriterWithProgress(io.BufferedWriter): + def __init__(self, handle: io.BufferedWriter, progress: Progress, task_id: TaskID): + self.handle = handle + self.progress = progress + self.task_id = task_id + self.total_written = 0 + self.handle.mode + + @property + def mode(self): + return self.handle.mode + + @property + def closed(self) -> bool: + return self.handle.closed + + def __enter__(self) -> "BufferedWriterWithProgress": + self.handle.__enter__() + return self + + def __exit__(self, exc_type, exc_val, exc_tb): + del exc_type, exc_val, exc_tb + self.close() + + def close(self): + self.handle.close() + + def fileno(self): + return self.handle.fileno() + + def flush(self): + self.handle.flush() + + def isatty(self) -> bool: + return self.handle.isatty() + + def readable(self) -> bool: + return self.handle.readable() + + def seekable(self) -> bool: + return self.handle.seekable() + + def writable(self) -> bool: + return True + + def read(self, size: Optional[int] = -1) -> bytes: + return self.handle.read(size) + + def read1(self, size: int = -1, /) -> bytes: + return self.handle.read1(size) + + def readinto(self, b): + return self.handle.readinto(b) + + def readinto1(self, b): + return self.handle.readinto1(b) + + def readline(self, size: Optional[int] = -1) -> bytes: + return self.handle.readline(size) + + def readlines(self, hint: int = -1) -> List[bytes]: + return self.handle.readlines(hint) + + def write(self, b) -> int: + n = self.handle.write(b) + self.total_written += n + self.progress.advance(self.task_id, n) + return n + + def writelines(self, lines): + return self.handle.writelines(lines) + + def seek(self, offset: int, whence: int = 0) -> int: + pos = self.handle.seek(offset, whence) + # self.progress.update(self.task_id, completed=pos) + return pos + + def tell(self) -> int: + return self.handle.tell() + + @property + def raw(self): + return self.handle.raw + + def detach(self): + return self.handle.detach() + + +def get_download_progress(quiet: bool = False) -> Progress: + if quiet: + return QuietProgress() # type: ignore + else: + return Progress( + "[progress.description]{task.description}", + BarColumn(), + "[progress.percentage]{task.percentage:>3.0f}%", + TimeElapsedColumn(), + DownloadColumn(), + # disable=quiet, + ) diff --git a/venv/lib/python3.10/site-packages/cached_path/schemes/__init__.py b/venv/lib/python3.10/site-packages/cached_path/schemes/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d3fd97ad2064b101d9fdafb30cffea209fff07c2 --- /dev/null +++ b/venv/lib/python3.10/site-packages/cached_path/schemes/__init__.py @@ -0,0 +1,84 @@ +import logging +from typing import Dict, Optional, Set, Type + +from .gs import GsClient +from .hf import hf_get_from_cache +from .http import HttpClient +from .r2 import R2Client +from .s3 import S3Client +from .scheme_client import SchemeClient + +__all__ = ["GsClient", "HttpClient", "S3Client", "R2Client", "SchemeClient", "hf_get_from_cache"] + +try: + from .beaker import BeakerClient + + __all__.append("BeakerClient") +except (ImportError, ModuleNotFoundError): + BeakerClient = None # type: ignore + + +_SCHEME_TO_CLIENT = {} + +logger = logging.getLogger(__name__) + + +def add_scheme_client(client: Type[SchemeClient]) -> None: + """ + Add a new :class:`SchemeClient`. + + This can be used to extend :func:`cached_path.cached_path()` to handle custom schemes, or handle + existing schemes differently. + """ + global _SCHEME_TO_CLIENT + if isinstance(client.scheme, tuple): + for scheme in client.scheme: + _SCHEME_TO_CLIENT[scheme] = client + elif isinstance(client.scheme, str): + _SCHEME_TO_CLIENT[client.scheme] = client + else: + raise ValueError(f"Unexpected type for {client} scheme: {client.scheme}") + + +for client in (HttpClient, S3Client, R2Client, GsClient): + add_scheme_client(client) # type: ignore +if BeakerClient is not None: + add_scheme_client(BeakerClient) + + +def get_scheme_client(resource: str, headers: Optional[Dict[str, str]] = None) -> SchemeClient: + """ + Get the right client for the given resource. + + Parameters + ---------- + resource : str + The URL or path to the resource. + headers : Optional[Dict[str, str]], optional + Custom headers to add to HTTP requests, by default None. + Example: {"Authorization": "Bearer YOUR_TOKEN"} for private resources. + Only used for HTTP/HTTPS resources. + + Returns + ------- + SchemeClient + The appropriate client for the resource. + """ + maybe_scheme = resource.split("://")[0] + client_cls = _SCHEME_TO_CLIENT.get(maybe_scheme, HttpClient) + + if headers: + if issubclass(client_cls, HttpClient): + return client_cls(resource, headers=headers) + else: + msg = f"Headers are only supported for HTTP/HTTPS resources, got {client_cls.__name__}" + logger.warning(msg) + + return client_cls(resource) + + +def get_supported_schemes() -> Set[str]: + """ + Return all supported URL schemes. + """ + return set(_SCHEME_TO_CLIENT.keys()) | {"hf"} diff --git a/venv/lib/python3.10/site-packages/cached_path/schemes/__pycache__/__init__.cpython-310.pyc b/venv/lib/python3.10/site-packages/cached_path/schemes/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..16e6fb7a6d38f494756858c56afec55fdf66072e Binary files /dev/null and b/venv/lib/python3.10/site-packages/cached_path/schemes/__pycache__/__init__.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/cached_path/schemes/__pycache__/beaker.cpython-310.pyc b/venv/lib/python3.10/site-packages/cached_path/schemes/__pycache__/beaker.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c8815a843c11734cf0efa6da8d48b3d39f1d7c54 Binary files /dev/null and b/venv/lib/python3.10/site-packages/cached_path/schemes/__pycache__/beaker.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/cached_path/schemes/__pycache__/gs.cpython-310.pyc b/venv/lib/python3.10/site-packages/cached_path/schemes/__pycache__/gs.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c7ec66ce6936a1916b17fd3293b02324451c6b4d Binary files /dev/null and b/venv/lib/python3.10/site-packages/cached_path/schemes/__pycache__/gs.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/cached_path/schemes/__pycache__/hf.cpython-310.pyc b/venv/lib/python3.10/site-packages/cached_path/schemes/__pycache__/hf.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4b9dfacd2516a253b472e165cc265080672edd04 Binary files /dev/null and b/venv/lib/python3.10/site-packages/cached_path/schemes/__pycache__/hf.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/cached_path/schemes/__pycache__/http.cpython-310.pyc b/venv/lib/python3.10/site-packages/cached_path/schemes/__pycache__/http.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6cf0905374467be41b8a52e5854fdee8a4ddd3db Binary files /dev/null and b/venv/lib/python3.10/site-packages/cached_path/schemes/__pycache__/http.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/cached_path/schemes/__pycache__/r2.cpython-310.pyc b/venv/lib/python3.10/site-packages/cached_path/schemes/__pycache__/r2.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ab63a05183d8428883118a173b47b09d4f2949b0 Binary files /dev/null and b/venv/lib/python3.10/site-packages/cached_path/schemes/__pycache__/r2.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/cached_path/schemes/__pycache__/s3.cpython-310.pyc b/venv/lib/python3.10/site-packages/cached_path/schemes/__pycache__/s3.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2975252e863e1370d1a79da6cffe07c023426832 Binary files /dev/null and b/venv/lib/python3.10/site-packages/cached_path/schemes/__pycache__/s3.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/cached_path/schemes/__pycache__/scheme_client.cpython-310.pyc b/venv/lib/python3.10/site-packages/cached_path/schemes/__pycache__/scheme_client.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..401b73e4c61608ea5e8a9bf49ae999a94caa83f2 Binary files /dev/null and b/venv/lib/python3.10/site-packages/cached_path/schemes/__pycache__/scheme_client.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/cached_path/schemes/beaker.py b/venv/lib/python3.10/site-packages/cached_path/schemes/beaker.py new file mode 100644 index 0000000000000000000000000000000000000000..ce5f1bdd7296370f0066b425d21e9632e28ccf9c --- /dev/null +++ b/venv/lib/python3.10/site-packages/cached_path/schemes/beaker.py @@ -0,0 +1,45 @@ +import io +from pathlib import Path +from typing import Optional + +from beaker import Beaker, ChecksumFailedError, DatasetNotFound, DatasetReadError + +from .scheme_client import SchemeClient + + +class BeakerClient(SchemeClient): + scheme = ("beaker",) + recoverable_errors = SchemeClient.recoverable_errors + (DatasetReadError, ChecksumFailedError) + + def __init__(self, resource: str) -> None: + super().__init__(resource) + self.beaker = Beaker.from_env() + # Beaker resources should be in the form "{user}/{dataset_name}/{path}/{to}/{file}" + path = Path(resource.split("://")[1]) + if len(path.parts) < 2: + raise ValueError( + f"Invalid beaker resource URL '{resource}'. " + "Resources should be in the form 'beaker://{user_name}/{dataset_name}/{path_to_file}' " + "or beaker://{dataset_id}/{path_to_file}." + ) + + try: + user, dataset_name, *filepath_parts = path.parts + self.dataset = self.beaker.dataset.get(f"{user}/{dataset_name}") + except DatasetNotFound: + dataset_id, *filepath_parts = path.parts + self.dataset = self.beaker.dataset.get(dataset_id) + + self.filepath = "/".join(filepath_parts) + self.file_info = self.beaker.dataset.file_info(self.dataset, self.filepath) + + def get_etag(self) -> Optional[str]: + return None if self.file_info.digest is None else str(self.file_info.digest) + + def get_size(self) -> Optional[int]: + return self.file_info.size + + def get_resource(self, temp_file: io.BufferedWriter) -> None: + for chunk in self.beaker.dataset.stream_file(self.dataset, self.filepath, quiet=True): + if chunk: + temp_file.write(chunk) diff --git a/venv/lib/python3.10/site-packages/cached_path/schemes/gs.py b/venv/lib/python3.10/site-packages/cached_path/schemes/gs.py new file mode 100644 index 0000000000000000000000000000000000000000..1eeea8b310442ea1040fad259a0121e4759e917e --- /dev/null +++ b/venv/lib/python3.10/site-packages/cached_path/schemes/gs.py @@ -0,0 +1,71 @@ +""" +Google Cloud Storage. +""" + +import io +from functools import cache +from typing import Optional, Tuple + +from google.api_core.exceptions import NotFound +from google.auth.exceptions import DefaultCredentialsError +from google.cloud import storage +from google.cloud.storage.blob import Blob +from google.cloud.storage.retry import DEFAULT_RETRY + +from ..common import _split_cloud_path +from .scheme_client import SchemeClient + + +class GsClient(SchemeClient): + scheme = "gs" + + def __init__(self, resource: str) -> None: + super().__init__(resource) + self.blob = GsClient.get_gcs_blob(resource) + self._loaded = False + + def load(self): + if not self._loaded: + try: + self.blob.reload() + self._loaded = True + except NotFound as exc: + raise FileNotFoundError(self.resource) from exc + + def get_etag(self) -> Optional[str]: + self.load() + return self.blob.etag or self.blob.md5_hash + + def get_size(self) -> Optional[int]: + self.load() + return self.blob.size + + def get_resource(self, temp_file: io.BufferedWriter) -> None: + self.load() + self.blob.download_to_file(temp_file, checksum="md5", retry=DEFAULT_RETRY) + + def get_bytes_range(self, index: int, length: int) -> bytes: + self.load() + return self.blob.download_as_bytes(start=index, end=index + length - 1) + + @staticmethod + def split_gcs_path(resource: str) -> Tuple[str, str]: + return _split_cloud_path(resource, "gs") + + @staticmethod + def get_gcs_blob(resource: str) -> Blob: + gcs_client = _get_gcs_client() + bucket_name, gcs_path = GsClient.split_gcs_path(resource) + bucket = gcs_client.bucket(bucket_name) + blob = bucket.blob(gcs_path) + return blob + + +@cache +def _get_gcs_client() -> storage.Client: + try: + client = storage.Client() + except DefaultCredentialsError: + client = storage.Client.create_anonymous_client() + + return client diff --git a/venv/lib/python3.10/site-packages/cached_path/schemes/hf.py b/venv/lib/python3.10/site-packages/cached_path/schemes/hf.py new file mode 100644 index 0000000000000000000000000000000000000000..a497d89b36013af9e734b6c3d9afa2182630c959 --- /dev/null +++ b/venv/lib/python3.10/site-packages/cached_path/schemes/hf.py @@ -0,0 +1,80 @@ +""" +HuggingFace Hub. + +Unlike the other schemes, we don't implement a `SchemeClient` subclass here because +`huggingface_hub` handles the caching logic internally in essentially the same way. +""" + +from pathlib import Path +from typing import Optional + +import huggingface_hub as hf_hub +import requests # type: ignore[import-untyped] +from huggingface_hub.utils import ( + EntryNotFoundError, + RepositoryNotFoundError, + RevisionNotFoundError, +) + +from ..common import PathOrStr +from ..version import VERSION + + +def hf_hub_download( + model_identifier: str, filename: Optional[str], cache_dir: Optional[PathOrStr] = None +) -> Path: + revision: Optional[str] + if "@" in model_identifier: + repo_id = model_identifier.split("@")[0] + revision = model_identifier.split("@")[1] + else: + repo_id = model_identifier + revision = None + + if filename is not None: + return Path( + hf_hub.hf_hub_download( + repo_id=repo_id, + filename=filename, + revision=revision, + library_name="cached_path", + library_version=VERSION, + cache_dir=cache_dir, + ) + ) + else: + return Path(hf_hub.snapshot_download(repo_id, revision=revision, cache_dir=cache_dir)) + + +def hf_get_from_cache(url: str, cache_dir: Optional[PathOrStr] = None) -> Path: + if cache_dir is not None: + cache_dir = Path(cache_dir).expanduser() + cache_dir.mkdir(parents=True, exist_ok=True) + + # Remove the 'hf://' prefix + identifier = url[5:] + + if identifier.count("/") > 1: + filename = "/".join(identifier.split("/")[2:]) + model_identifier = "/".join(identifier.split("/")[:2]) + return hf_hub_download(model_identifier, filename, cache_dir) + elif identifier.count("/") == 1: + # 'hf://' URLs like 'hf://xxxx/yyyy' are potentially ambiguous, + # because this could refer to either: + # 1. the file 'yyyy' in the 'xxxx' repository, or + # 2. the repo 'yyyy' under the user/org name 'xxxx'. + # We default to (1), but if we get a 404 error or 401 error then we try (2) + try: + model_identifier, filename = identifier.split("/") + return hf_hub_download(model_identifier, filename, cache_dir) + except (RepositoryNotFoundError, RevisionNotFoundError, EntryNotFoundError): + return hf_hub_download(identifier, None, cache_dir) + except requests.exceptions.HTTPError as exc: + if exc.response is not None and exc.response.status_code in {401, 404}: + return hf_hub_download(identifier, None, cache_dir) + else: + raise + except ValueError: + return hf_hub_download(identifier, None, cache_dir) + else: + return hf_hub_download(identifier, None, cache_dir) diff --git a/venv/lib/python3.10/site-packages/cached_path/schemes/http.py b/venv/lib/python3.10/site-packages/cached_path/schemes/http.py new file mode 100644 index 0000000000000000000000000000000000000000..8bf2ba45e79d36797f5610d05c03b050edfee644 --- /dev/null +++ b/venv/lib/python3.10/site-packages/cached_path/schemes/http.py @@ -0,0 +1,120 @@ +import io +from typing import Dict, Optional + +import requests # type: ignore[import-untyped] +from requests.adapters import HTTPAdapter # type: ignore[import-untyped] +from urllib3.exceptions import MaxRetryError +from urllib3.util.retry import Retry + +from .scheme_client import SchemeClient + +RECOVERABLE_SERVER_ERROR_CODES = (502, 503, 504) + + +class RecoverableServerError(requests.exceptions.HTTPError): + """ + Server returned one of `RECOVERABLE_SERVER_ERROR_CODES`. + """ + + +def session_with_backoff(headers: Optional[Dict[str, str]] = None) -> requests.Session: + """ + We ran into an issue where http requests to s3 were timing out, + possibly because we were making too many requests too quickly. + This helper function returns a requests session that has retry-with-backoff + built in. See + . + + Parameters + ---------- + headers : Optional[Dict[str, str]], optional + Custom headers to add to all requests, by default None + """ + session = requests.Session() + retries = Retry(total=5, backoff_factor=1, status_forcelist=RECOVERABLE_SERVER_ERROR_CODES) + session.mount("http://", HTTPAdapter(max_retries=retries)) + session.mount("https://", HTTPAdapter(max_retries=retries)) + + # Add custom headers if provided + if headers: + session.headers.update(headers) + + return session + + +class HttpClient(SchemeClient): + scheme = ("http", "https") + recoverable_errors = SchemeClient.recoverable_errors + (RecoverableServerError,) + + def __init__(self, resource: str, headers: Optional[Dict[str, str]] = None) -> None: + """ + Initialize an HTTP client for the given resource. + + Parameters + ---------- + resource : str + The URL to the resource. + headers : Optional[Dict[str, str]], optional + Custom headers to add to all requests, by default None. + Example: {"Authorization": "Bearer YOUR_TOKEN"} for private resources. + """ + super().__init__(resource) + self._head_response = None + self.headers = headers or {} + + @property + def head_response(self): + if self._head_response is None: + try: + with session_with_backoff(self.headers) as session: + response = session.head(self.resource, allow_redirects=True) + except MaxRetryError as e: + raise RecoverableServerError(e.reason) + self.validate_response(response) + self._head_response = response + return self._head_response + else: + return self._head_response + + def get_etag(self) -> Optional[str]: + return self.head_response.headers.get("ETag") + + def get_size(self) -> Optional[int]: + content_length = self.head_response.headers.get("Content-Length") + return None if content_length is None else int(content_length) + + def get_resource(self, temp_file: io.BufferedWriter) -> None: + with session_with_backoff(self.headers) as session: + try: + response = session.get(self.resource, stream=True) + except MaxRetryError as e: + raise RecoverableServerError(e.reason) + self.validate_response(response) + for chunk in response.iter_content(chunk_size=1024): + if chunk: # filter out keep-alive new chunks + temp_file.write(chunk) + + # TODO (epwalsh): There may be a better way to do this, but... + # HTTP range requests don't necessarily match our expectation in this context. For example, the range might + # implicitly include header data, but we usually don't care about that. The server might also + # interpret the range relative to an encoding of the data, not the underlying data itself. + # So to avoid unexpected behavior we resort to the default behavior of downloading the whole file + # and returning the desired bytes range from the cached content. + # def get_bytes_range(self, index: int, length: int) -> bytes: + # with session_with_backoff() as session: + # try: + # response = session.get( + # self.resource, headers={"Range": f"bytes={index}-{index+length-1}"} + # ) + # except MaxRetryError as e: + # raise RecoverableServerError(e.reason) + # self.validate_response(response) + # # 'content' might contain the full file if the server doesn't support the "Range" header. + # return response.content[:length] + + def validate_response(self, response): + if response.status_code == 404: + raise FileNotFoundError(self.resource) + if response.status_code in RECOVERABLE_SERVER_ERROR_CODES: + raise RecoverableServerError(response=response) + response.raise_for_status() diff --git a/venv/lib/python3.10/site-packages/cached_path/schemes/r2.py b/venv/lib/python3.10/site-packages/cached_path/schemes/r2.py new file mode 100644 index 0000000000000000000000000000000000000000..d4bea20edb075d71cc1f8a79ca9653849157de2e --- /dev/null +++ b/venv/lib/python3.10/site-packages/cached_path/schemes/r2.py @@ -0,0 +1,95 @@ +""" +Cloudflare R2. +""" + +import io +import os +from functools import cache +from typing import Optional + +import boto3.dynamodb +import boto3.session +import botocore.exceptions +from botocore.config import Config + +from ..common import _split_cloud_path +from .scheme_client import SchemeClient + + +class R2Client(SchemeClient): + recoverable_errors = SchemeClient.recoverable_errors + ( + botocore.exceptions.HTTPClientError, + botocore.exceptions.ConnectionError, + ) + + scheme = "r2" + + def __init__(self, resource: str) -> None: + SchemeClient.__init__(self, resource) + self.bucket_name, self.path = _split_cloud_path(resource, "r2") + + self.s3 = _get_s3_resource_client() + self.object_info = None + + def _ensure_object_info(self): + if self.object_info is None: + try: + self.object_info = self.s3.head_object(Bucket=self.bucket_name, Key=self.path) + except botocore.exceptions.ClientError as e: + if e.response["ResponseMetadata"]["HTTPStatusCode"] == 404: + raise FileNotFoundError(f"File {self.resource} not found") from e + raise + + def get_etag(self) -> Optional[str]: + self._ensure_object_info() + assert self.object_info is not None + return self.object_info.get("ETag") + + def get_size(self) -> Optional[int]: + self._ensure_object_info() + assert self.object_info is not None + return self.object_info.get("ContentLength") + + def get_resource(self, temp_file: io.BufferedWriter) -> None: + self._ensure_object_info() + self.s3.download_fileobj(Fileobj=temp_file, Bucket=self.bucket_name, Key=self.path) + + def get_bytes_range(self, index: int, length: int) -> bytes: + self._ensure_object_info() + response = self.s3.get_object( + Bucket=self.bucket_name, Key=self.path, Range=f"bytes={index}-{index+length-1}" + ) + return response["Body"].read() + + +@cache +def _get_s3_resource_client(): + # find credentials + endpoint_url = os.environ.get("R2_ENDPOINT_URL") + if endpoint_url is None: + raise ValueError( + "R2 endpoint url is not set. Did you forget to set the 'R2_ENDPOINT_URL' env var?" + ) + profile_name = os.environ.get("R2_PROFILE") + access_key_id = os.environ.get("R2_ACCESS_KEY_ID") + secret_access_key = os.environ.get("R2_SECRET_ACCESS_KEY") + if access_key_id is not None and secret_access_key is not None: + session_kwargs = { + "aws_access_key_id": access_key_id, + "aws_secret_access_key": secret_access_key, + } + elif profile_name is not None: + session_kwargs = {"profile_name": profile_name} + else: + raise ValueError( + "To authenticate for R2, you either have to set the 'R2_PROFILE' env var and set up this profile, " + "or set R2_ACCESS_KEY_ID and R2_SECRET_ACCESS_KEY." + ) + + s3_session = boto3.session.Session(**session_kwargs) + return s3_session.client( + service_name="s3", + endpoint_url=endpoint_url, + region_name="auto", + config=Config(retries={"max_attempts": 10, "mode": "standard"}), + ) diff --git a/venv/lib/python3.10/site-packages/cached_path/schemes/s3.py b/venv/lib/python3.10/site-packages/cached_path/schemes/s3.py new file mode 100644 index 0000000000000000000000000000000000000000..e83189a4054a157b38c11b6e81fc52eb5da22790 --- /dev/null +++ b/venv/lib/python3.10/site-packages/cached_path/schemes/s3.py @@ -0,0 +1,74 @@ +""" +AWS S3. +""" + +import io +from functools import cache +from typing import Optional, Tuple + +import boto3.session +import botocore.client +import botocore.exceptions + +from ..common import _split_cloud_path +from .scheme_client import SchemeClient + + +class S3Client(SchemeClient): + recoverable_errors = SchemeClient.recoverable_errors + ( + botocore.exceptions.HTTPClientError, + botocore.exceptions.ConnectionError, + ) + scheme = "s3" + + def __init__(self, resource: str) -> None: + super().__init__(resource) + bucket_name, s3_path = S3Client.split_s3_path(resource) + s3_resource = _get_s3_resource_client() + self.s3_object = s3_resource.Object(bucket_name, s3_path) # type: ignore + self._loaded = False + + def load(self): + if not self._loaded: + try: + self.s3_object.load() + self._loaded = True + except botocore.exceptions.ClientError as exc: + if int(exc.response["Error"]["Code"]) == 404: + raise FileNotFoundError("file {} not found".format(self.resource)) from exc + else: + raise + + def get_etag(self) -> Optional[str]: + self.load() + return self.s3_object.e_tag + + def get_size(self) -> Optional[int]: + self.load() + return self.s3_object.content_length + + def get_resource(self, temp_file: io.BufferedWriter) -> None: + self.load() + self.s3_object.download_fileobj(temp_file) + + def get_bytes_range(self, index: int, length: int) -> bytes: + self.load() + return self.s3_object.get(Range=f"bytes={index}-{index + length - 1}")["Body"].read() + + @staticmethod + def split_s3_path(url: str) -> Tuple[str, str]: + return _split_cloud_path(url, "s3") + + +@cache +def _get_s3_resource_client(): + session = boto3.session.Session() + if session.get_credentials() is None: + # Use unsigned requests. + resource_client = session.resource( + "s3", config=botocore.client.Config(signature_version=botocore.UNSIGNED) + ) + else: + resource_client = session.resource("s3") + + return resource_client diff --git a/venv/lib/python3.10/site-packages/cached_path/schemes/scheme_client.py b/venv/lib/python3.10/site-packages/cached_path/schemes/scheme_client.py new file mode 100644 index 0000000000000000000000000000000000000000..8a00648b474c6b13dc3febac99c67d37c6cd433d --- /dev/null +++ b/venv/lib/python3.10/site-packages/cached_path/schemes/scheme_client.py @@ -0,0 +1,124 @@ +import io +from abc import ABC, abstractmethod +from typing import ClassVar, Optional, Tuple, Type, Union + +import requests # type: ignore[import-untyped] + + +class SchemeClient(ABC): + """ + A client used for caching remote resources corresponding to URLs with a particular scheme. + + Subclasses must define the :attr:`scheme` class variable and implement + :meth:`get_etag()` and :meth:`get_resource()`. + + .. important:: + Take care when implementing subclasses to raise the right error types + from :meth:`get_etag()` and :meth:`get_resource()`. + """ + + recoverable_errors: ClassVar[Tuple[Type[BaseException], ...]] = ( + requests.exceptions.ConnectionError, + requests.exceptions.Timeout, + ) + """ + Subclasses can override this to define error types that will be treated as recoverable. + + If ``cached_path()`` catches of one these errors while calling :meth:`get_etag()`, it + will log a warning and return the latest cached version if there is one, otherwise + it will propogate the error. + """ + + scheme: ClassVar[Union[str, Tuple[str, ...]]] = tuple() + """ + The scheme or schemes that the client will be used for (e.g. "http"). + """ + + def __init__(self, resource: str) -> None: + self.resource = resource + + @abstractmethod + def get_etag(self) -> Optional[str]: + """ + Get the Etag or an equivalent version identifier associated with the resource. + + Returns + ------- + ``Optional[str]`` + The ETag as a ``str`` or ``None`` if there is no ETag associated with + the resource. + + Raises + ------ + ``FileNotFoundError`` + If the resource doesn't exist. + + ``Recoverable error`` + Any error type defined in ``SchemeClient.recoverable_errors`` will + be treated as a recoverable error. + + This means that when of these is caught by ``cached_path()``, + it will look for cached versions of the given resource and return the + latest version if there are any. + + Otherwise the error is propogated. + + ``Other errors`` + Any other error type can be raised. These errors will be treated non-recoverable + and will be propogated immediately by ``cached_path()``. + """ + raise NotImplementedError + + @abstractmethod + def get_size(self) -> Optional[int]: + """ + Get the size of the resource in bytes (if known). + + Returns + ------- + ``Optional[int]`` + The size (in bytes). + + Raises + ------ + ``FileNotFoundError`` + If the resource doesn't exist. + + ``Recoverable error`` + Any error type defined in ``SchemeClient.recoverable_errors`` will + be treated as a recoverable error. + + This means that when of these is caught by ``cached_path()``, the size + will be ignored. + + ``Other errors`` + Any other error type can be raised. These errors will be treated non-recoverable + and will be propogated immediately by ``cached_path()``. + """ + raise NotImplementedError + + @abstractmethod + def get_resource(self, temp_file: io.BufferedWriter) -> None: + """ + Download the resource to the given temporary file. + + Raises + ------ + ``FileNotFoundError`` + If the resource doesn't exist. + + ``Other errors`` + Any other error type can be raised. These errors will be treated non-recoverable + and will be propagated immediately by ``cached_path()``. + """ + raise NotImplementedError + + def get_bytes_range(self, index: int, length: int) -> bytes: + """ + Get a sequence of ``length`` bytes from the resource, starting at ``index`` bytes. + + If a scheme provides a direct way of downloading a bytes range, the scheme client + should implement that. Otherwise the entire file has to be downloaded. + """ + del index, length + raise NotImplementedError diff --git a/venv/lib/python3.10/site-packages/cached_path/testing.py b/venv/lib/python3.10/site-packages/cached_path/testing.py new file mode 100644 index 0000000000000000000000000000000000000000..1445f4c19c056b58bceb72e3f9af3ec7e54d861a --- /dev/null +++ b/venv/lib/python3.10/site-packages/cached_path/testing.py @@ -0,0 +1,38 @@ +import logging +import os +import shutil +import tempfile +from pathlib import Path + +from .common import get_cache_dir, set_cache_dir + + +class BaseTestClass: + """ + A custom testing class that disables some of the more verbose + logging and that creates and destroys a temp directory as a test fixture. + """ + + PROJECT_ROOT = (Path(__file__).parent / "..").resolve() + MODULE_ROOT = PROJECT_ROOT / "cached_path" + TOOLS_ROOT = MODULE_ROOT / "tools" + TESTS_ROOT = PROJECT_ROOT / "tests" + FIXTURES_ROOT = PROJECT_ROOT / "test_fixtures" + + def setup_method(self): + logging.basicConfig( + format="%(asctime)s - %(levelname)s - %(name)s - %(message)s", level=logging.DEBUG + ) + # Disabling some of the more verbose logging statements that typically aren't very helpful + # in tests. + logging.getLogger("urllib3.connectionpool").disabled = True + + self.TEST_DIR = Path(tempfile.mkdtemp(prefix="cached_path_tests")) + os.makedirs(self.TEST_DIR, exist_ok=True) + + self._initial_cache_dir = get_cache_dir() + set_cache_dir(self.TEST_DIR) + + def teardown_method(self): + set_cache_dir(self._initial_cache_dir) + shutil.rmtree(self.TEST_DIR) diff --git a/venv/lib/python3.10/site-packages/cached_path/util.py b/venv/lib/python3.10/site-packages/cached_path/util.py new file mode 100644 index 0000000000000000000000000000000000000000..26527390fe6f589e54f26a010a2f0a403dff929b --- /dev/null +++ b/venv/lib/python3.10/site-packages/cached_path/util.py @@ -0,0 +1,139 @@ +import os +import tarfile +from hashlib import sha256 +from pathlib import Path +from typing import List, Optional, Tuple +from urllib.parse import urlparse + +from .common import PathOrStr, get_cache_dir +from .meta import Meta + + +def resource_to_filename(resource: PathOrStr, etag: Optional[str] = None) -> str: + """ + Convert a ``resource`` into a hashed filename in a repeatable way. + If ``etag`` is specified, append its hash to the resources', delimited + by a period. + + THis is essentially the inverse of :func:`filename_to_url()`. + """ + resource_bytes = str(resource).encode("utf-8") + resource_hash = sha256(resource_bytes) + filename = resource_hash.hexdigest() + + if etag: + etag_bytes = etag.encode("utf-8") + etag_hash = sha256(etag_bytes) + filename += "." + etag_hash.hexdigest() + + return filename + + +def filename_to_url( + filename: str, cache_dir: Optional[PathOrStr] = None +) -> Tuple[str, Optional[str]]: + """ + Return the URL and etag (which may be ``None``) stored for ``filename``. + Raises :exc:`FileNotFoundError` if ``filename`` or its stored metadata do not exist. + + This is essentially the inverse of :func:`resource_to_filename()`. + """ + cache_dir = cache_dir if cache_dir else get_cache_dir() + cache_path = os.path.join(cache_dir, filename) + if not os.path.exists(cache_path): + raise FileNotFoundError("file {} not found".format(cache_path)) + + meta_path = cache_path + ".json" + if not os.path.exists(meta_path): + raise FileNotFoundError("file {} not found".format(meta_path)) + + metadata = Meta.from_path(meta_path) + return metadata.resource, metadata.etag + + +def find_latest_cached( + url: str, cache_dir: Optional[PathOrStr] = None, verbose: bool = False +) -> Optional[Path]: + """ + Get the path to the latest cached version of a given resource. + """ + cache_dir = Path(cache_dir if cache_dir else get_cache_dir()) + filename = resource_to_filename(url) + candidates: List[Tuple[Path, float]] = [] + for path in cache_dir.glob(f"{filename}*"): + if verbose: + print(path, path.suffix, path.name) + if path.suffix in {".json", ".lock"} or path.name.endswith("-extracted"): + continue + mtime = path.stat().st_mtime + candidates.append((path, mtime)) + # Sort candidates by modification time, newest first. + candidates.sort(key=lambda x: x[1], reverse=True) + if candidates: + return candidates[0][0] + return None + + +def check_tarfile(tar_file: tarfile.TarFile): + """Tar files can contain files outside of the extraction directory, or symlinks that point + outside the extraction directory. We also don't want any block devices fifos, or other + weird file types extracted. This checks for those issues and throws an exception if there + is a problem.""" + base_path = os.path.join("tmp", "pathtest") + base_path = os.path.normpath(base_path) + + def normalize_path(path: str) -> str: + path = path.rstrip("/") + path = path.replace("/", os.sep) + path = os.path.join(base_path, path) + path = os.path.normpath(path) + return path + + for tarinfo in tar_file: + if not ( + tarinfo.isreg() + or tarinfo.isdir() + or tarinfo.isfile() + or tarinfo.islnk() + or tarinfo.issym() + ): + raise ValueError( + f"Tar file {str(tar_file.name)} contains invalid member {tarinfo.name}." + ) + + target_path = normalize_path(tarinfo.name) + if os.path.commonprefix([base_path, target_path]) != base_path: + raise ValueError( + f"Tar file {str(tar_file.name)} is trying to create a file outside of its extraction directory." + ) + + if tarinfo.islnk() or tarinfo.issym(): + target_path = normalize_path(tarinfo.linkname) + if os.path.commonprefix([base_path, target_path]) != base_path: + raise ValueError( + f"Tar file {str(tar_file.name)} is trying to link to a file " + "outside of its extraction directory." + ) + + +def is_url_or_existing_file(url_or_filename: PathOrStr) -> bool: + """ + Given something that might be a URL or local path, + determine if it's actually a url or the path to an existing file. + """ + if url_or_filename is None: + return False + + from .schemes import get_supported_schemes + + url_or_filename = os.path.expanduser(str(url_or_filename)) + parsed = urlparse(url_or_filename) + return parsed.scheme in get_supported_schemes() or os.path.exists(url_or_filename) + + +def _lock_file_path(cache_path: Path) -> Path: + return cache_path.parent / (cache_path.name + ".lock") + + +def _meta_file_path(cache_path: Path) -> Path: + return cache_path.parent / (cache_path.name + ".json") diff --git a/venv/lib/python3.10/site-packages/cached_path/version.py b/venv/lib/python3.10/site-packages/cached_path/version.py new file mode 100644 index 0000000000000000000000000000000000000000..8a89bd89d22ba2b1cb028b411a0156a5365d4eb2 --- /dev/null +++ b/venv/lib/python3.10/site-packages/cached_path/version.py @@ -0,0 +1,13 @@ +import os + +_MAJOR = "1" +_MINOR = "7" +# On main and in a nightly release the patch should be one ahead of the last +# released build. +_PATCH = "3" +# This is mainly for nightly builds which have the suffix ".dev$DATE". See +# https://semver.org/#is-v123-a-semantic-version for the semantics. +_SUFFIX = os.environ.get("CACHED_PATH_VERSION_SUFFIX", "") + +VERSION_SHORT = "{0}.{1}".format(_MAJOR, _MINOR) +VERSION = "{0}.{1}.{2}{3}".format(_MAJOR, _MINOR, _PATCH, _SUFFIX) diff --git a/venv/lib/python3.10/site-packages/cffi/__init__.py b/venv/lib/python3.10/site-packages/cffi/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..c99ec3d481788c39ea12dc57e4b61547176c8e88 --- /dev/null +++ b/venv/lib/python3.10/site-packages/cffi/__init__.py @@ -0,0 +1,14 @@ +__all__ = ['FFI', 'VerificationError', 'VerificationMissing', 'CDefError', + 'FFIError'] + +from .api import FFI +from .error import CDefError, FFIError, VerificationError, VerificationMissing +from .error import PkgConfigError + +__version__ = "2.0.0" +__version_info__ = (2, 0, 0) + +# The verifier module file names are based on the CRC32 of a string that +# contains the following version number. It may be older than __version__ +# if nothing is clearly incompatible. +__version_verifier_modules__ = "0.8.6" diff --git a/venv/lib/python3.10/site-packages/cffi/__pycache__/__init__.cpython-310.pyc b/venv/lib/python3.10/site-packages/cffi/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ee414ee991bac9930d83ebedcc2990757b712e9a Binary files /dev/null and b/venv/lib/python3.10/site-packages/cffi/__pycache__/__init__.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/cffi/__pycache__/_imp_emulation.cpython-310.pyc b/venv/lib/python3.10/site-packages/cffi/__pycache__/_imp_emulation.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2ca6566c3f71152aef00ba0e4c5ac0739255354b Binary files /dev/null and b/venv/lib/python3.10/site-packages/cffi/__pycache__/_imp_emulation.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/cffi/__pycache__/_shimmed_dist_utils.cpython-310.pyc b/venv/lib/python3.10/site-packages/cffi/__pycache__/_shimmed_dist_utils.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8f6ae7920d7a5f7d2267ce288fb2e39ef9d07da2 Binary files /dev/null and b/venv/lib/python3.10/site-packages/cffi/__pycache__/_shimmed_dist_utils.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/cffi/__pycache__/api.cpython-310.pyc b/venv/lib/python3.10/site-packages/cffi/__pycache__/api.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7965f38c7e4d2bbf6762e74521dc676886c60375 Binary files /dev/null and b/venv/lib/python3.10/site-packages/cffi/__pycache__/api.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/cffi/__pycache__/backend_ctypes.cpython-310.pyc b/venv/lib/python3.10/site-packages/cffi/__pycache__/backend_ctypes.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..89a0d0035cf6ddde93df9c04c851ea7da2af0f00 Binary files /dev/null and b/venv/lib/python3.10/site-packages/cffi/__pycache__/backend_ctypes.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/cffi/__pycache__/cffi_opcode.cpython-310.pyc b/venv/lib/python3.10/site-packages/cffi/__pycache__/cffi_opcode.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f8be1c17aca89811681753272edec36eda2007a3 Binary files /dev/null and b/venv/lib/python3.10/site-packages/cffi/__pycache__/cffi_opcode.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/cffi/__pycache__/commontypes.cpython-310.pyc b/venv/lib/python3.10/site-packages/cffi/__pycache__/commontypes.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a623d295a3e628e664318a8a3ebbddae4a43c395 Binary files /dev/null and b/venv/lib/python3.10/site-packages/cffi/__pycache__/commontypes.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/cffi/__pycache__/cparser.cpython-310.pyc b/venv/lib/python3.10/site-packages/cffi/__pycache__/cparser.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d744f2d9214992e82c16e9c79ab8cd20df740769 Binary files /dev/null and b/venv/lib/python3.10/site-packages/cffi/__pycache__/cparser.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/cffi/__pycache__/error.cpython-310.pyc b/venv/lib/python3.10/site-packages/cffi/__pycache__/error.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2b700f6ac3774792f7bfdc8d8e27ccdaf9440c93 Binary files /dev/null and b/venv/lib/python3.10/site-packages/cffi/__pycache__/error.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/cffi/__pycache__/ffiplatform.cpython-310.pyc b/venv/lib/python3.10/site-packages/cffi/__pycache__/ffiplatform.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f3f4550fc38e679f5ae518288f3801d880e4600e Binary files /dev/null and b/venv/lib/python3.10/site-packages/cffi/__pycache__/ffiplatform.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/cffi/__pycache__/lock.cpython-310.pyc b/venv/lib/python3.10/site-packages/cffi/__pycache__/lock.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e42cb72cb3a74f0c7312f7d9d39f794a42dcd06a Binary files /dev/null and b/venv/lib/python3.10/site-packages/cffi/__pycache__/lock.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/cffi/__pycache__/model.cpython-310.pyc b/venv/lib/python3.10/site-packages/cffi/__pycache__/model.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..16745557072c62611dc3a28217658a4a904194d2 Binary files /dev/null and b/venv/lib/python3.10/site-packages/cffi/__pycache__/model.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/cffi/__pycache__/pkgconfig.cpython-310.pyc b/venv/lib/python3.10/site-packages/cffi/__pycache__/pkgconfig.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d1fd75d48f6bb9eafcbe168324dc524be3cfb35a Binary files /dev/null and b/venv/lib/python3.10/site-packages/cffi/__pycache__/pkgconfig.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/cffi/__pycache__/recompiler.cpython-310.pyc b/venv/lib/python3.10/site-packages/cffi/__pycache__/recompiler.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8ce8fec850ce84eb197b0da887be9e590c04a909 Binary files /dev/null and b/venv/lib/python3.10/site-packages/cffi/__pycache__/recompiler.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/cffi/__pycache__/setuptools_ext.cpython-310.pyc b/venv/lib/python3.10/site-packages/cffi/__pycache__/setuptools_ext.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..bb294b7cd12c5773eb3b52d19484617730c50aac Binary files /dev/null and b/venv/lib/python3.10/site-packages/cffi/__pycache__/setuptools_ext.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/cffi/__pycache__/vengine_cpy.cpython-310.pyc b/venv/lib/python3.10/site-packages/cffi/__pycache__/vengine_cpy.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..df5e7820526e4c2528aa9e4b74f05aab025b1ae9 Binary files /dev/null and b/venv/lib/python3.10/site-packages/cffi/__pycache__/vengine_cpy.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/cffi/__pycache__/vengine_gen.cpython-310.pyc b/venv/lib/python3.10/site-packages/cffi/__pycache__/vengine_gen.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5e9fd635b0cad5d78a1a9aae2c603c6f7910e8ff Binary files /dev/null and b/venv/lib/python3.10/site-packages/cffi/__pycache__/vengine_gen.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/cffi/__pycache__/verifier.cpython-310.pyc b/venv/lib/python3.10/site-packages/cffi/__pycache__/verifier.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5e7b5b278e64b964eba68802b44239c386c16997 Binary files /dev/null and b/venv/lib/python3.10/site-packages/cffi/__pycache__/verifier.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/cffi/_cffi_errors.h b/venv/lib/python3.10/site-packages/cffi/_cffi_errors.h new file mode 100644 index 0000000000000000000000000000000000000000..158e0590346a9a8b2ab047ac1bd23bcb3af21398 --- /dev/null +++ b/venv/lib/python3.10/site-packages/cffi/_cffi_errors.h @@ -0,0 +1,149 @@ +#ifndef CFFI_MESSAGEBOX +# ifdef _MSC_VER +# define CFFI_MESSAGEBOX 1 +# else +# define CFFI_MESSAGEBOX 0 +# endif +#endif + + +#if CFFI_MESSAGEBOX +/* Windows only: logic to take the Python-CFFI embedding logic + initialization errors and display them in a background thread + with MessageBox. The idea is that if the whole program closes + as a result of this problem, then likely it is already a console + program and you can read the stderr output in the console too. + If it is not a console program, then it will likely show its own + dialog to complain, or generally not abruptly close, and for this + case the background thread should stay alive. +*/ +static void *volatile _cffi_bootstrap_text; + +static PyObject *_cffi_start_error_capture(void) +{ + PyObject *result = NULL; + PyObject *x, *m, *bi; + + if (InterlockedCompareExchangePointer(&_cffi_bootstrap_text, + (void *)1, NULL) != NULL) + return (PyObject *)1; + + m = PyImport_AddModule("_cffi_error_capture"); + if (m == NULL) + goto error; + + result = PyModule_GetDict(m); + if (result == NULL) + goto error; + +#if PY_MAJOR_VERSION >= 3 + bi = PyImport_ImportModule("builtins"); +#else + bi = PyImport_ImportModule("__builtin__"); +#endif + if (bi == NULL) + goto error; + PyDict_SetItemString(result, "__builtins__", bi); + Py_DECREF(bi); + + x = PyRun_String( + "import sys\n" + "class FileLike:\n" + " def write(self, x):\n" + " try:\n" + " of.write(x)\n" + " except: pass\n" + " self.buf += x\n" + " def flush(self):\n" + " pass\n" + "fl = FileLike()\n" + "fl.buf = ''\n" + "of = sys.stderr\n" + "sys.stderr = fl\n" + "def done():\n" + " sys.stderr = of\n" + " return fl.buf\n", /* make sure the returned value stays alive */ + Py_file_input, + result, result); + Py_XDECREF(x); + + error: + if (PyErr_Occurred()) + { + PyErr_WriteUnraisable(Py_None); + PyErr_Clear(); + } + return result; +} + +#pragma comment(lib, "user32.lib") + +static DWORD WINAPI _cffi_bootstrap_dialog(LPVOID ignored) +{ + Sleep(666); /* may be interrupted if the whole process is closing */ +#if PY_MAJOR_VERSION >= 3 + MessageBoxW(NULL, (wchar_t *)_cffi_bootstrap_text, + L"Python-CFFI error", + MB_OK | MB_ICONERROR); +#else + MessageBoxA(NULL, (char *)_cffi_bootstrap_text, + "Python-CFFI error", + MB_OK | MB_ICONERROR); +#endif + _cffi_bootstrap_text = NULL; + return 0; +} + +static void _cffi_stop_error_capture(PyObject *ecap) +{ + PyObject *s; + void *text; + + if (ecap == (PyObject *)1) + return; + + if (ecap == NULL) + goto error; + + s = PyRun_String("done()", Py_eval_input, ecap, ecap); + if (s == NULL) + goto error; + + /* Show a dialog box, but in a background thread, and + never show multiple dialog boxes at once. */ +#if PY_MAJOR_VERSION >= 3 + text = PyUnicode_AsWideCharString(s, NULL); +#else + text = PyString_AsString(s); +#endif + + _cffi_bootstrap_text = text; + + if (text != NULL) + { + HANDLE h; + h = CreateThread(NULL, 0, _cffi_bootstrap_dialog, + NULL, 0, NULL); + if (h != NULL) + CloseHandle(h); + } + /* decref the string, but it should stay alive as 'fl.buf' + in the small module above. It will really be freed only if + we later get another similar error. So it's a leak of at + most one copy of the small module. That's fine for this + situation which is usually a "fatal error" anyway. */ + Py_DECREF(s); + PyErr_Clear(); + return; + + error: + _cffi_bootstrap_text = NULL; + PyErr_Clear(); +} + +#else + +static PyObject *_cffi_start_error_capture(void) { return NULL; } +static void _cffi_stop_error_capture(PyObject *ecap) { } + +#endif diff --git a/venv/lib/python3.10/site-packages/cffi/_cffi_include.h b/venv/lib/python3.10/site-packages/cffi/_cffi_include.h new file mode 100644 index 0000000000000000000000000000000000000000..908a1d7343f1869bc8818ca8e786f2c94a4732d2 --- /dev/null +++ b/venv/lib/python3.10/site-packages/cffi/_cffi_include.h @@ -0,0 +1,389 @@ +#define _CFFI_ + +/* We try to define Py_LIMITED_API before including Python.h. + + Mess: we can only define it if Py_DEBUG, Py_TRACE_REFS and + Py_REF_DEBUG are not defined. This is a best-effort approximation: + we can learn about Py_DEBUG from pyconfig.h, but it is unclear if + the same works for the other two macros. Py_DEBUG implies them, + but not the other way around. + + The implementation is messy (issue #350): on Windows, with _MSC_VER, + we have to define Py_LIMITED_API even before including pyconfig.h. + In that case, we guess what pyconfig.h will do to the macros above, + and check our guess after the #include. + + Note that on Windows, with CPython 3.x, you need >= 3.5 and virtualenv + version >= 16.0.0. With older versions of either, you don't get a + copy of PYTHON3.DLL in the virtualenv. We can't check the version of + CPython *before* we even include pyconfig.h. ffi.set_source() puts + a ``#define _CFFI_NO_LIMITED_API'' at the start of this file if it is + running on Windows < 3.5, as an attempt at fixing it, but that's + arguably wrong because it may not be the target version of Python. + Still better than nothing I guess. As another workaround, you can + remove the definition of Py_LIMITED_API here. + + See also 'py_limited_api' in cffi/setuptools_ext.py. +*/ +#if !defined(_CFFI_USE_EMBEDDING) && !defined(Py_LIMITED_API) +# ifdef _MSC_VER +# if !defined(_DEBUG) && !defined(Py_DEBUG) && !defined(Py_TRACE_REFS) && !defined(Py_REF_DEBUG) && !defined(_CFFI_NO_LIMITED_API) +# define Py_LIMITED_API +# endif +# include + /* sanity-check: Py_LIMITED_API will cause crashes if any of these + are also defined. Normally, the Python file PC/pyconfig.h does not + cause any of these to be defined, with the exception that _DEBUG + causes Py_DEBUG. Double-check that. */ +# ifdef Py_LIMITED_API +# if defined(Py_DEBUG) +# error "pyconfig.h unexpectedly defines Py_DEBUG, but Py_LIMITED_API is set" +# endif +# if defined(Py_TRACE_REFS) +# error "pyconfig.h unexpectedly defines Py_TRACE_REFS, but Py_LIMITED_API is set" +# endif +# if defined(Py_REF_DEBUG) +# error "pyconfig.h unexpectedly defines Py_REF_DEBUG, but Py_LIMITED_API is set" +# endif +# endif +# else +# include +# if !defined(Py_DEBUG) && !defined(Py_TRACE_REFS) && !defined(Py_REF_DEBUG) && !defined(_CFFI_NO_LIMITED_API) +# define Py_LIMITED_API +# endif +# endif +#endif + +#include +#ifdef __cplusplus +extern "C" { +#endif +#include +#include "parse_c_type.h" + +/* this block of #ifs should be kept exactly identical between + c/_cffi_backend.c, cffi/vengine_cpy.py, cffi/vengine_gen.py + and cffi/_cffi_include.h */ +#if defined(_MSC_VER) +# include /* for alloca() */ +# if _MSC_VER < 1600 /* MSVC < 2010 */ + typedef __int8 int8_t; + typedef __int16 int16_t; + typedef __int32 int32_t; + typedef __int64 int64_t; + typedef unsigned __int8 uint8_t; + typedef unsigned __int16 uint16_t; + typedef unsigned __int32 uint32_t; + typedef unsigned __int64 uint64_t; + typedef __int8 int_least8_t; + typedef __int16 int_least16_t; + typedef __int32 int_least32_t; + typedef __int64 int_least64_t; + typedef unsigned __int8 uint_least8_t; + typedef unsigned __int16 uint_least16_t; + typedef unsigned __int32 uint_least32_t; + typedef unsigned __int64 uint_least64_t; + typedef __int8 int_fast8_t; + typedef __int16 int_fast16_t; + typedef __int32 int_fast32_t; + typedef __int64 int_fast64_t; + typedef unsigned __int8 uint_fast8_t; + typedef unsigned __int16 uint_fast16_t; + typedef unsigned __int32 uint_fast32_t; + typedef unsigned __int64 uint_fast64_t; + typedef __int64 intmax_t; + typedef unsigned __int64 uintmax_t; +# else +# include +# endif +# if _MSC_VER < 1800 /* MSVC < 2013 */ +# ifndef __cplusplus + typedef unsigned char _Bool; +# endif +# endif +# define _cffi_float_complex_t _Fcomplex /* include for it */ +# define _cffi_double_complex_t _Dcomplex /* include for it */ +#else +# include +# if (defined (__SVR4) && defined (__sun)) || defined(_AIX) || defined(__hpux) +# include +# endif +# define _cffi_float_complex_t float _Complex +# define _cffi_double_complex_t double _Complex +#endif + +#ifdef __GNUC__ +# define _CFFI_UNUSED_FN __attribute__((unused)) +#else +# define _CFFI_UNUSED_FN /* nothing */ +#endif + +#ifdef __cplusplus +# ifndef _Bool + typedef bool _Bool; /* semi-hackish: C++ has no _Bool; bool is builtin */ +# endif +#endif + +/********** CPython-specific section **********/ +#ifndef PYPY_VERSION + + +#if PY_MAJOR_VERSION >= 3 +# define PyInt_FromLong PyLong_FromLong +#endif + +#define _cffi_from_c_double PyFloat_FromDouble +#define _cffi_from_c_float PyFloat_FromDouble +#define _cffi_from_c_long PyInt_FromLong +#define _cffi_from_c_ulong PyLong_FromUnsignedLong +#define _cffi_from_c_longlong PyLong_FromLongLong +#define _cffi_from_c_ulonglong PyLong_FromUnsignedLongLong +#define _cffi_from_c__Bool PyBool_FromLong + +#define _cffi_to_c_double PyFloat_AsDouble +#define _cffi_to_c_float PyFloat_AsDouble + +#define _cffi_from_c_int(x, type) \ + (((type)-1) > 0 ? /* unsigned */ \ + (sizeof(type) < sizeof(long) ? \ + PyInt_FromLong((long)x) : \ + sizeof(type) == sizeof(long) ? \ + PyLong_FromUnsignedLong((unsigned long)x) : \ + PyLong_FromUnsignedLongLong((unsigned long long)x)) : \ + (sizeof(type) <= sizeof(long) ? \ + PyInt_FromLong((long)x) : \ + PyLong_FromLongLong((long long)x))) + +#define _cffi_to_c_int(o, type) \ + ((type)( \ + sizeof(type) == 1 ? (((type)-1) > 0 ? (type)_cffi_to_c_u8(o) \ + : (type)_cffi_to_c_i8(o)) : \ + sizeof(type) == 2 ? (((type)-1) > 0 ? (type)_cffi_to_c_u16(o) \ + : (type)_cffi_to_c_i16(o)) : \ + sizeof(type) == 4 ? (((type)-1) > 0 ? (type)_cffi_to_c_u32(o) \ + : (type)_cffi_to_c_i32(o)) : \ + sizeof(type) == 8 ? (((type)-1) > 0 ? (type)_cffi_to_c_u64(o) \ + : (type)_cffi_to_c_i64(o)) : \ + (Py_FatalError("unsupported size for type " #type), (type)0))) + +#define _cffi_to_c_i8 \ + ((int(*)(PyObject *))_cffi_exports[1]) +#define _cffi_to_c_u8 \ + ((int(*)(PyObject *))_cffi_exports[2]) +#define _cffi_to_c_i16 \ + ((int(*)(PyObject *))_cffi_exports[3]) +#define _cffi_to_c_u16 \ + ((int(*)(PyObject *))_cffi_exports[4]) +#define _cffi_to_c_i32 \ + ((int(*)(PyObject *))_cffi_exports[5]) +#define _cffi_to_c_u32 \ + ((unsigned int(*)(PyObject *))_cffi_exports[6]) +#define _cffi_to_c_i64 \ + ((long long(*)(PyObject *))_cffi_exports[7]) +#define _cffi_to_c_u64 \ + ((unsigned long long(*)(PyObject *))_cffi_exports[8]) +#define _cffi_to_c_char \ + ((int(*)(PyObject *))_cffi_exports[9]) +#define _cffi_from_c_pointer \ + ((PyObject *(*)(char *, struct _cffi_ctypedescr *))_cffi_exports[10]) +#define _cffi_to_c_pointer \ + ((char *(*)(PyObject *, struct _cffi_ctypedescr *))_cffi_exports[11]) +#define _cffi_get_struct_layout \ + not used any more +#define _cffi_restore_errno \ + ((void(*)(void))_cffi_exports[13]) +#define _cffi_save_errno \ + ((void(*)(void))_cffi_exports[14]) +#define _cffi_from_c_char \ + ((PyObject *(*)(char))_cffi_exports[15]) +#define _cffi_from_c_deref \ + ((PyObject *(*)(char *, struct _cffi_ctypedescr *))_cffi_exports[16]) +#define _cffi_to_c \ + ((int(*)(char *, struct _cffi_ctypedescr *, PyObject *))_cffi_exports[17]) +#define _cffi_from_c_struct \ + ((PyObject *(*)(char *, struct _cffi_ctypedescr *))_cffi_exports[18]) +#define _cffi_to_c_wchar_t \ + ((_cffi_wchar_t(*)(PyObject *))_cffi_exports[19]) +#define _cffi_from_c_wchar_t \ + ((PyObject *(*)(_cffi_wchar_t))_cffi_exports[20]) +#define _cffi_to_c_long_double \ + ((long double(*)(PyObject *))_cffi_exports[21]) +#define _cffi_to_c__Bool \ + ((_Bool(*)(PyObject *))_cffi_exports[22]) +#define _cffi_prepare_pointer_call_argument \ + ((Py_ssize_t(*)(struct _cffi_ctypedescr *, \ + PyObject *, char **))_cffi_exports[23]) +#define _cffi_convert_array_from_object \ + ((int(*)(char *, struct _cffi_ctypedescr *, PyObject *))_cffi_exports[24]) +#define _CFFI_CPIDX 25 +#define _cffi_call_python \ + ((void(*)(struct _cffi_externpy_s *, char *))_cffi_exports[_CFFI_CPIDX]) +#define _cffi_to_c_wchar3216_t \ + ((int(*)(PyObject *))_cffi_exports[26]) +#define _cffi_from_c_wchar3216_t \ + ((PyObject *(*)(int))_cffi_exports[27]) +#define _CFFI_NUM_EXPORTS 28 + +struct _cffi_ctypedescr; + +static void *_cffi_exports[_CFFI_NUM_EXPORTS]; + +#define _cffi_type(index) ( \ + assert((((uintptr_t)_cffi_types[index]) & 1) == 0), \ + (struct _cffi_ctypedescr *)_cffi_types[index]) + +static PyObject *_cffi_init(const char *module_name, Py_ssize_t version, + const struct _cffi_type_context_s *ctx) +{ + PyObject *module, *o_arg, *new_module; + void *raw[] = { + (void *)module_name, + (void *)version, + (void *)_cffi_exports, + (void *)ctx, + }; + + module = PyImport_ImportModule("_cffi_backend"); + if (module == NULL) + goto failure; + + o_arg = PyLong_FromVoidPtr((void *)raw); + if (o_arg == NULL) + goto failure; + + new_module = PyObject_CallMethod( + module, (char *)"_init_cffi_1_0_external_module", (char *)"O", o_arg); + + Py_DECREF(o_arg); + Py_DECREF(module); + return new_module; + + failure: + Py_XDECREF(module); + return NULL; +} + + +#ifdef HAVE_WCHAR_H +typedef wchar_t _cffi_wchar_t; +#else +typedef uint16_t _cffi_wchar_t; /* same random pick as _cffi_backend.c */ +#endif + +_CFFI_UNUSED_FN static uint16_t _cffi_to_c_char16_t(PyObject *o) +{ + if (sizeof(_cffi_wchar_t) == 2) + return (uint16_t)_cffi_to_c_wchar_t(o); + else + return (uint16_t)_cffi_to_c_wchar3216_t(o); +} + +_CFFI_UNUSED_FN static PyObject *_cffi_from_c_char16_t(uint16_t x) +{ + if (sizeof(_cffi_wchar_t) == 2) + return _cffi_from_c_wchar_t((_cffi_wchar_t)x); + else + return _cffi_from_c_wchar3216_t((int)x); +} + +_CFFI_UNUSED_FN static int _cffi_to_c_char32_t(PyObject *o) +{ + if (sizeof(_cffi_wchar_t) == 4) + return (int)_cffi_to_c_wchar_t(o); + else + return (int)_cffi_to_c_wchar3216_t(o); +} + +_CFFI_UNUSED_FN static PyObject *_cffi_from_c_char32_t(unsigned int x) +{ + if (sizeof(_cffi_wchar_t) == 4) + return _cffi_from_c_wchar_t((_cffi_wchar_t)x); + else + return _cffi_from_c_wchar3216_t((int)x); +} + +union _cffi_union_alignment_u { + unsigned char m_char; + unsigned short m_short; + unsigned int m_int; + unsigned long m_long; + unsigned long long m_longlong; + float m_float; + double m_double; + long double m_longdouble; +}; + +struct _cffi_freeme_s { + struct _cffi_freeme_s *next; + union _cffi_union_alignment_u alignment; +}; + +_CFFI_UNUSED_FN static int +_cffi_convert_array_argument(struct _cffi_ctypedescr *ctptr, PyObject *arg, + char **output_data, Py_ssize_t datasize, + struct _cffi_freeme_s **freeme) +{ + char *p; + if (datasize < 0) + return -1; + + p = *output_data; + if (p == NULL) { + struct _cffi_freeme_s *fp = (struct _cffi_freeme_s *)PyObject_Malloc( + offsetof(struct _cffi_freeme_s, alignment) + (size_t)datasize); + if (fp == NULL) + return -1; + fp->next = *freeme; + *freeme = fp; + p = *output_data = (char *)&fp->alignment; + } + memset((void *)p, 0, (size_t)datasize); + return _cffi_convert_array_from_object(p, ctptr, arg); +} + +_CFFI_UNUSED_FN static void +_cffi_free_array_arguments(struct _cffi_freeme_s *freeme) +{ + do { + void *p = (void *)freeme; + freeme = freeme->next; + PyObject_Free(p); + } while (freeme != NULL); +} + +/********** end CPython-specific section **********/ +#else +_CFFI_UNUSED_FN +static void (*_cffi_call_python_org)(struct _cffi_externpy_s *, char *); +# define _cffi_call_python _cffi_call_python_org +#endif + + +#define _cffi_array_len(array) (sizeof(array) / sizeof((array)[0])) + +#define _cffi_prim_int(size, sign) \ + ((size) == 1 ? ((sign) ? _CFFI_PRIM_INT8 : _CFFI_PRIM_UINT8) : \ + (size) == 2 ? ((sign) ? _CFFI_PRIM_INT16 : _CFFI_PRIM_UINT16) : \ + (size) == 4 ? ((sign) ? _CFFI_PRIM_INT32 : _CFFI_PRIM_UINT32) : \ + (size) == 8 ? ((sign) ? _CFFI_PRIM_INT64 : _CFFI_PRIM_UINT64) : \ + _CFFI__UNKNOWN_PRIM) + +#define _cffi_prim_float(size) \ + ((size) == sizeof(float) ? _CFFI_PRIM_FLOAT : \ + (size) == sizeof(double) ? _CFFI_PRIM_DOUBLE : \ + (size) == sizeof(long double) ? _CFFI__UNKNOWN_LONG_DOUBLE : \ + _CFFI__UNKNOWN_FLOAT_PRIM) + +#define _cffi_check_int(got, got_nonpos, expected) \ + ((got_nonpos) == (expected <= 0) && \ + (got) == (unsigned long long)expected) + +#ifdef MS_WIN32 +# define _cffi_stdcall __stdcall +#else +# define _cffi_stdcall /* nothing */ +#endif + +#ifdef __cplusplus +} +#endif diff --git a/venv/lib/python3.10/site-packages/cffi/_embedding.h b/venv/lib/python3.10/site-packages/cffi/_embedding.h new file mode 100644 index 0000000000000000000000000000000000000000..64c04f67cacb5d9f2aeb295e0e48a07720d07076 --- /dev/null +++ b/venv/lib/python3.10/site-packages/cffi/_embedding.h @@ -0,0 +1,550 @@ + +/***** Support code for embedding *****/ + +#ifdef __cplusplus +extern "C" { +#endif + + +#if defined(_WIN32) +# define CFFI_DLLEXPORT __declspec(dllexport) +#elif defined(__GNUC__) +# define CFFI_DLLEXPORT __attribute__((visibility("default"))) +#else +# define CFFI_DLLEXPORT /* nothing */ +#endif + + +/* There are two global variables of type _cffi_call_python_fnptr: + + * _cffi_call_python, which we declare just below, is the one called + by ``extern "Python"`` implementations. + + * _cffi_call_python_org, which on CPython is actually part of the + _cffi_exports[] array, is the function pointer copied from + _cffi_backend. If _cffi_start_python() fails, then this is set + to NULL; otherwise, it should never be NULL. + + After initialization is complete, both are equal. However, the + first one remains equal to &_cffi_start_and_call_python until the + very end of initialization, when we are (or should be) sure that + concurrent threads also see a completely initialized world, and + only then is it changed. +*/ +#undef _cffi_call_python +typedef void (*_cffi_call_python_fnptr)(struct _cffi_externpy_s *, char *); +static void _cffi_start_and_call_python(struct _cffi_externpy_s *, char *); +static _cffi_call_python_fnptr _cffi_call_python = &_cffi_start_and_call_python; + + +#ifndef _MSC_VER + /* --- Assuming a GCC not infinitely old --- */ +# define cffi_compare_and_swap(l,o,n) __sync_bool_compare_and_swap(l,o,n) +# define cffi_write_barrier() __sync_synchronize() +# if !defined(__amd64__) && !defined(__x86_64__) && \ + !defined(__i386__) && !defined(__i386) +# define cffi_read_barrier() __sync_synchronize() +# else +# define cffi_read_barrier() (void)0 +# endif +#else + /* --- Windows threads version --- */ +# include +# define cffi_compare_and_swap(l,o,n) \ + (InterlockedCompareExchangePointer(l,n,o) == (o)) +# define cffi_write_barrier() InterlockedCompareExchange(&_cffi_dummy,0,0) +# define cffi_read_barrier() (void)0 +static volatile LONG _cffi_dummy; +#endif + +#ifdef WITH_THREAD +# ifndef _MSC_VER +# include + static pthread_mutex_t _cffi_embed_startup_lock; +# else + static CRITICAL_SECTION _cffi_embed_startup_lock; +# endif + static char _cffi_embed_startup_lock_ready = 0; +#endif + +static void _cffi_acquire_reentrant_mutex(void) +{ + static void *volatile lock = NULL; + + while (!cffi_compare_and_swap(&lock, NULL, (void *)1)) { + /* should ideally do a spin loop instruction here, but + hard to do it portably and doesn't really matter I + think: pthread_mutex_init() should be very fast, and + this is only run at start-up anyway. */ + } + +#ifdef WITH_THREAD + if (!_cffi_embed_startup_lock_ready) { +# ifndef _MSC_VER + pthread_mutexattr_t attr; + pthread_mutexattr_init(&attr); + pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE); + pthread_mutex_init(&_cffi_embed_startup_lock, &attr); +# else + InitializeCriticalSection(&_cffi_embed_startup_lock); +# endif + _cffi_embed_startup_lock_ready = 1; + } +#endif + + while (!cffi_compare_and_swap(&lock, (void *)1, NULL)) + ; + +#ifndef _MSC_VER + pthread_mutex_lock(&_cffi_embed_startup_lock); +#else + EnterCriticalSection(&_cffi_embed_startup_lock); +#endif +} + +static void _cffi_release_reentrant_mutex(void) +{ +#ifndef _MSC_VER + pthread_mutex_unlock(&_cffi_embed_startup_lock); +#else + LeaveCriticalSection(&_cffi_embed_startup_lock); +#endif +} + + +/********** CPython-specific section **********/ +#ifndef PYPY_VERSION + +#include "_cffi_errors.h" + + +#define _cffi_call_python_org _cffi_exports[_CFFI_CPIDX] + +PyMODINIT_FUNC _CFFI_PYTHON_STARTUP_FUNC(void); /* forward */ + +static void _cffi_py_initialize(void) +{ + /* XXX use initsigs=0, which "skips initialization registration of + signal handlers, which might be useful when Python is + embedded" according to the Python docs. But review and think + if it should be a user-controllable setting. + + XXX we should also give a way to write errors to a buffer + instead of to stderr. + + XXX if importing 'site' fails, CPython (any version) calls + exit(). Should we try to work around this behavior here? + */ + Py_InitializeEx(0); +} + +static int _cffi_initialize_python(void) +{ + /* This initializes Python, imports _cffi_backend, and then the + present .dll/.so is set up as a CPython C extension module. + */ + int result; + PyGILState_STATE state; + PyObject *pycode=NULL, *global_dict=NULL, *x; + PyObject *builtins; + + state = PyGILState_Ensure(); + + /* Call the initxxx() function from the present module. It will + create and initialize us as a CPython extension module, instead + of letting the startup Python code do it---it might reimport + the same .dll/.so and get maybe confused on some platforms. + It might also have troubles locating the .dll/.so again for all + I know. + */ + (void)_CFFI_PYTHON_STARTUP_FUNC(); + if (PyErr_Occurred()) + goto error; + + /* Now run the Python code provided to ffi.embedding_init_code(). + */ + pycode = Py_CompileString(_CFFI_PYTHON_STARTUP_CODE, + "", + Py_file_input); + if (pycode == NULL) + goto error; + global_dict = PyDict_New(); + if (global_dict == NULL) + goto error; + builtins = PyEval_GetBuiltins(); + if (builtins == NULL) + goto error; + if (PyDict_SetItemString(global_dict, "__builtins__", builtins) < 0) + goto error; + x = PyEval_EvalCode( +#if PY_MAJOR_VERSION < 3 + (PyCodeObject *) +#endif + pycode, global_dict, global_dict); + if (x == NULL) + goto error; + Py_DECREF(x); + + /* Done! Now if we've been called from + _cffi_start_and_call_python() in an ``extern "Python"``, we can + only hope that the Python code did correctly set up the + corresponding @ffi.def_extern() function. Otherwise, the + general logic of ``extern "Python"`` functions (inside the + _cffi_backend module) will find that the reference is still + missing and print an error. + */ + result = 0; + done: + Py_XDECREF(pycode); + Py_XDECREF(global_dict); + PyGILState_Release(state); + return result; + + error:; + { + /* Print as much information as potentially useful. + Debugging load-time failures with embedding is not fun + */ + PyObject *ecap; + PyObject *exception, *v, *tb, *f, *modules, *mod; + PyErr_Fetch(&exception, &v, &tb); + ecap = _cffi_start_error_capture(); + f = PySys_GetObject((char *)"stderr"); + if (f != NULL && f != Py_None) { + PyFile_WriteString( + "Failed to initialize the Python-CFFI embedding logic:\n\n", f); + } + + if (exception != NULL) { + PyErr_NormalizeException(&exception, &v, &tb); + PyErr_Display(exception, v, tb); + } + Py_XDECREF(exception); + Py_XDECREF(v); + Py_XDECREF(tb); + + if (f != NULL && f != Py_None) { + PyFile_WriteString("\nFrom: " _CFFI_MODULE_NAME + "\ncompiled with cffi version: 2.0.0" + "\n_cffi_backend module: ", f); + modules = PyImport_GetModuleDict(); + mod = PyDict_GetItemString(modules, "_cffi_backend"); + if (mod == NULL) { + PyFile_WriteString("not loaded", f); + } + else { + v = PyObject_GetAttrString(mod, "__file__"); + PyFile_WriteObject(v, f, 0); + Py_XDECREF(v); + } + PyFile_WriteString("\nsys.path: ", f); + PyFile_WriteObject(PySys_GetObject((char *)"path"), f, 0); + PyFile_WriteString("\n\n", f); + } + _cffi_stop_error_capture(ecap); + } + result = -1; + goto done; +} + +#if PY_VERSION_HEX < 0x03080000 +PyAPI_DATA(char *) _PyParser_TokenNames[]; /* from CPython */ +#endif + +static int _cffi_carefully_make_gil(void) +{ + /* This does the basic initialization of Python. It can be called + completely concurrently from unrelated threads. It assumes + that we don't hold the GIL before (if it exists), and we don't + hold it afterwards. + + (What it really does used to be completely different in Python 2 + and Python 3, with the Python 2 solution avoiding the spin-lock + around the Py_InitializeEx() call. However, after recent changes + to CPython 2.7 (issue #358) it no longer works. So we use the + Python 3 solution everywhere.) + + This initializes Python by calling Py_InitializeEx(). + Important: this must not be called concurrently at all. + So we use a global variable as a simple spin lock. This global + variable must be from 'libpythonX.Y.so', not from this + cffi-based extension module, because it must be shared from + different cffi-based extension modules. + + In Python < 3.8, we choose + _PyParser_TokenNames[0] as a completely arbitrary pointer value + that is never written to. The default is to point to the + string "ENDMARKER". We change it temporarily to point to the + next character in that string. (Yes, I know it's REALLY + obscure.) + + In Python >= 3.8, this string array is no longer writable, so + instead we pick PyCapsuleType.tp_version_tag. We can't change + Python < 3.8 because someone might use a mixture of cffi + embedded modules, some of which were compiled before this file + changed. + + In Python >= 3.12, this stopped working because that particular + tp_version_tag gets modified during interpreter startup. It's + arguably a bad idea before 3.12 too, but again we can't change + that because someone might use a mixture of cffi embedded + modules, and no-one reported a bug so far. In Python >= 3.12 + we go instead for PyCapsuleType.tp_as_buffer, which is supposed + to always be NULL. We write to it temporarily a pointer to + a struct full of NULLs, which is semantically the same. + */ + +#ifdef WITH_THREAD +# if PY_VERSION_HEX < 0x03080000 + char *volatile *lock = (char *volatile *)_PyParser_TokenNames; + char *old_value, *locked_value; + + while (1) { /* spin loop */ + old_value = *lock; + locked_value = old_value + 1; + if (old_value[0] == 'E') { + assert(old_value[1] == 'N'); + if (cffi_compare_and_swap(lock, old_value, locked_value)) + break; + } + else { + assert(old_value[0] == 'N'); + /* should ideally do a spin loop instruction here, but + hard to do it portably and doesn't really matter I + think: PyEval_InitThreads() should be very fast, and + this is only run at start-up anyway. */ + } + } +# else +# if PY_VERSION_HEX < 0x030C0000 + int volatile *lock = (int volatile *)&PyCapsule_Type.tp_version_tag; + int old_value, locked_value = -42; + assert(!(PyCapsule_Type.tp_flags & Py_TPFLAGS_HAVE_VERSION_TAG)); +# else + static struct ebp_s { PyBufferProcs buf; int mark; } empty_buffer_procs; + empty_buffer_procs.mark = -42; + PyBufferProcs *volatile *lock = (PyBufferProcs *volatile *) + &PyCapsule_Type.tp_as_buffer; + PyBufferProcs *old_value, *locked_value = &empty_buffer_procs.buf; +# endif + + while (1) { /* spin loop */ + old_value = *lock; + if (old_value == 0) { + if (cffi_compare_and_swap(lock, old_value, locked_value)) + break; + } + else { +# if PY_VERSION_HEX < 0x030C0000 + assert(old_value == locked_value); +# else + /* The pointer should point to a possibly different + empty_buffer_procs from another C extension module */ + assert(((struct ebp_s *)old_value)->mark == -42); +# endif + /* should ideally do a spin loop instruction here, but + hard to do it portably and doesn't really matter I + think: PyEval_InitThreads() should be very fast, and + this is only run at start-up anyway. */ + } + } +# endif +#endif + + /* call Py_InitializeEx() */ + if (!Py_IsInitialized()) { + _cffi_py_initialize(); +#if PY_VERSION_HEX < 0x03070000 + PyEval_InitThreads(); +#endif + PyEval_SaveThread(); /* release the GIL */ + /* the returned tstate must be the one that has been stored into the + autoTLSkey by _PyGILState_Init() called from Py_Initialize(). */ + } + else { +#if PY_VERSION_HEX < 0x03070000 + /* PyEval_InitThreads() is always a no-op from CPython 3.7 */ + PyGILState_STATE state = PyGILState_Ensure(); + PyEval_InitThreads(); + PyGILState_Release(state); +#endif + } + +#ifdef WITH_THREAD + /* release the lock */ + while (!cffi_compare_and_swap(lock, locked_value, old_value)) + ; +#endif + + return 0; +} + +/********** end CPython-specific section **********/ + + +#else + + +/********** PyPy-specific section **********/ + +PyMODINIT_FUNC _CFFI_PYTHON_STARTUP_FUNC(const void *[]); /* forward */ + +static struct _cffi_pypy_init_s { + const char *name; + void *func; /* function pointer */ + const char *code; +} _cffi_pypy_init = { + _CFFI_MODULE_NAME, + _CFFI_PYTHON_STARTUP_FUNC, + _CFFI_PYTHON_STARTUP_CODE, +}; + +extern int pypy_carefully_make_gil(const char *); +extern int pypy_init_embedded_cffi_module(int, struct _cffi_pypy_init_s *); + +static int _cffi_carefully_make_gil(void) +{ + return pypy_carefully_make_gil(_CFFI_MODULE_NAME); +} + +static int _cffi_initialize_python(void) +{ + return pypy_init_embedded_cffi_module(0xB011, &_cffi_pypy_init); +} + +/********** end PyPy-specific section **********/ + + +#endif + + +#ifdef __GNUC__ +__attribute__((noinline)) +#endif +static _cffi_call_python_fnptr _cffi_start_python(void) +{ + /* Delicate logic to initialize Python. This function can be + called multiple times concurrently, e.g. when the process calls + its first ``extern "Python"`` functions in multiple threads at + once. It can also be called recursively, in which case we must + ignore it. We also have to consider what occurs if several + different cffi-based extensions reach this code in parallel + threads---it is a different copy of the code, then, and we + can't have any shared global variable unless it comes from + 'libpythonX.Y.so'. + + Idea: + + * _cffi_carefully_make_gil(): "carefully" call + PyEval_InitThreads() (possibly with Py_InitializeEx() first). + + * then we use a (local) custom lock to make sure that a call to this + cffi-based extension will wait if another call to the *same* + extension is running the initialization in another thread. + It is reentrant, so that a recursive call will not block, but + only one from a different thread. + + * then we grab the GIL and (Python 2) we call Py_InitializeEx(). + At this point, concurrent calls to Py_InitializeEx() are not + possible: we have the GIL. + + * do the rest of the specific initialization, which may + temporarily release the GIL but not the custom lock. + Only release the custom lock when we are done. + */ + static char called = 0; + + if (_cffi_carefully_make_gil() != 0) + return NULL; + + _cffi_acquire_reentrant_mutex(); + + /* Here the GIL exists, but we don't have it. We're only protected + from concurrency by the reentrant mutex. */ + + /* This file only initializes the embedded module once, the first + time this is called, even if there are subinterpreters. */ + if (!called) { + called = 1; /* invoke _cffi_initialize_python() only once, + but don't set '_cffi_call_python' right now, + otherwise concurrent threads won't call + this function at all (we need them to wait) */ + if (_cffi_initialize_python() == 0) { + /* now initialization is finished. Switch to the fast-path. */ + + /* We would like nobody to see the new value of + '_cffi_call_python' without also seeing the rest of the + data initialized. However, this is not possible. But + the new value of '_cffi_call_python' is the function + 'cffi_call_python()' from _cffi_backend. So: */ + cffi_write_barrier(); + /* ^^^ we put a write barrier here, and a corresponding + read barrier at the start of cffi_call_python(). This + ensures that after that read barrier, we see everything + done here before the write barrier. + */ + + assert(_cffi_call_python_org != NULL); + _cffi_call_python = (_cffi_call_python_fnptr)_cffi_call_python_org; + } + else { + /* initialization failed. Reset this to NULL, even if it was + already set to some other value. Future calls to + _cffi_start_python() are still forced to occur, and will + always return NULL from now on. */ + _cffi_call_python_org = NULL; + } + } + + _cffi_release_reentrant_mutex(); + + return (_cffi_call_python_fnptr)_cffi_call_python_org; +} + +static +void _cffi_start_and_call_python(struct _cffi_externpy_s *externpy, char *args) +{ + _cffi_call_python_fnptr fnptr; + int current_err = errno; +#ifdef _MSC_VER + int current_lasterr = GetLastError(); +#endif + fnptr = _cffi_start_python(); + if (fnptr == NULL) { + fprintf(stderr, "function %s() called, but initialization code " + "failed. Returning 0.\n", externpy->name); + memset(args, 0, externpy->size_of_result); + } +#ifdef _MSC_VER + SetLastError(current_lasterr); +#endif + errno = current_err; + + if (fnptr != NULL) + fnptr(externpy, args); +} + + +/* The cffi_start_python() function makes sure Python is initialized + and our cffi module is set up. It can be called manually from the + user C code. The same effect is obtained automatically from any + dll-exported ``extern "Python"`` function. This function returns + -1 if initialization failed, 0 if all is OK. */ +_CFFI_UNUSED_FN +static int cffi_start_python(void) +{ + if (_cffi_call_python == &_cffi_start_and_call_python) { + if (_cffi_start_python() == NULL) + return -1; + } + cffi_read_barrier(); + return 0; +} + +#undef cffi_compare_and_swap +#undef cffi_write_barrier +#undef cffi_read_barrier + +#ifdef __cplusplus +} +#endif diff --git a/venv/lib/python3.10/site-packages/cffi/_imp_emulation.py b/venv/lib/python3.10/site-packages/cffi/_imp_emulation.py new file mode 100644 index 0000000000000000000000000000000000000000..136abdddf9d1276095e6f6724298ac19811c136a --- /dev/null +++ b/venv/lib/python3.10/site-packages/cffi/_imp_emulation.py @@ -0,0 +1,83 @@ + +try: + # this works on Python < 3.12 + from imp import * + +except ImportError: + # this is a limited emulation for Python >= 3.12. + # Note that this is used only for tests or for the old ffi.verify(). + # This is copied from the source code of Python 3.11. + + from _imp import (acquire_lock, release_lock, + is_builtin, is_frozen) + + from importlib._bootstrap import _load + + from importlib import machinery + import os + import sys + import tokenize + + SEARCH_ERROR = 0 + PY_SOURCE = 1 + PY_COMPILED = 2 + C_EXTENSION = 3 + PY_RESOURCE = 4 + PKG_DIRECTORY = 5 + C_BUILTIN = 6 + PY_FROZEN = 7 + PY_CODERESOURCE = 8 + IMP_HOOK = 9 + + def get_suffixes(): + extensions = [(s, 'rb', C_EXTENSION) + for s in machinery.EXTENSION_SUFFIXES] + source = [(s, 'r', PY_SOURCE) for s in machinery.SOURCE_SUFFIXES] + bytecode = [(s, 'rb', PY_COMPILED) for s in machinery.BYTECODE_SUFFIXES] + return extensions + source + bytecode + + def find_module(name, path=None): + if not isinstance(name, str): + raise TypeError("'name' must be a str, not {}".format(type(name))) + elif not isinstance(path, (type(None), list)): + # Backwards-compatibility + raise RuntimeError("'path' must be None or a list, " + "not {}".format(type(path))) + + if path is None: + if is_builtin(name): + return None, None, ('', '', C_BUILTIN) + elif is_frozen(name): + return None, None, ('', '', PY_FROZEN) + else: + path = sys.path + + for entry in path: + package_directory = os.path.join(entry, name) + for suffix in ['.py', machinery.BYTECODE_SUFFIXES[0]]: + package_file_name = '__init__' + suffix + file_path = os.path.join(package_directory, package_file_name) + if os.path.isfile(file_path): + return None, package_directory, ('', '', PKG_DIRECTORY) + for suffix, mode, type_ in get_suffixes(): + file_name = name + suffix + file_path = os.path.join(entry, file_name) + if os.path.isfile(file_path): + break + else: + continue + break # Break out of outer loop when breaking out of inner loop. + else: + raise ImportError(name, name=name) + + encoding = None + if 'b' not in mode: + with open(file_path, 'rb') as file: + encoding = tokenize.detect_encoding(file.readline)[0] + file = open(file_path, mode, encoding=encoding) + return file, file_path, (suffix, mode, type_) + + def load_dynamic(name, path, file=None): + loader = machinery.ExtensionFileLoader(name, path) + spec = machinery.ModuleSpec(name=name, loader=loader, origin=path) + return _load(spec) diff --git a/venv/lib/python3.10/site-packages/cffi/_shimmed_dist_utils.py b/venv/lib/python3.10/site-packages/cffi/_shimmed_dist_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..c3d23128189fc121bff3f86b19330b0ac5ce0a45 --- /dev/null +++ b/venv/lib/python3.10/site-packages/cffi/_shimmed_dist_utils.py @@ -0,0 +1,45 @@ +""" +Temporary shim module to indirect the bits of distutils we need from setuptools/distutils while providing useful +error messages beyond `No module named 'distutils' on Python >= 3.12, or when setuptools' vendored distutils is broken. + +This is a compromise to avoid a hard-dep on setuptools for Python >= 3.12, since many users don't need runtime compilation support from CFFI. +""" +import sys + +try: + # import setuptools first; this is the most robust way to ensure its embedded distutils is available + # (the .pth shim should usually work, but this is even more robust) + import setuptools +except Exception as ex: + if sys.version_info >= (3, 12): + # Python 3.12 has no built-in distutils to fall back on, so any import problem is fatal + raise Exception("This CFFI feature requires setuptools on Python >= 3.12. The setuptools module is missing or non-functional.") from ex + + # silently ignore on older Pythons (support fallback to stdlib distutils where available) +else: + del setuptools + +try: + # bring in just the bits of distutils we need, whether they really came from setuptools or stdlib-embedded distutils + from distutils import log, sysconfig + from distutils.ccompiler import CCompiler + from distutils.command.build_ext import build_ext + from distutils.core import Distribution, Extension + from distutils.dir_util import mkpath + from distutils.errors import DistutilsSetupError, CompileError, LinkError + from distutils.log import set_threshold, set_verbosity + + if sys.platform == 'win32': + try: + # FUTURE: msvc9compiler module was removed in setuptools 74; consider removing, as it's only used by an ancient patch in `recompiler` + from distutils.msvc9compiler import MSVCCompiler + except ImportError: + MSVCCompiler = None +except Exception as ex: + if sys.version_info >= (3, 12): + raise Exception("This CFFI feature requires setuptools on Python >= 3.12. Please install the setuptools package.") from ex + + # anything older, just let the underlying distutils import error fly + raise Exception("This CFFI feature requires distutils. Please install the distutils or setuptools package.") from ex + +del sys diff --git a/venv/lib/python3.10/site-packages/cffi/api.py b/venv/lib/python3.10/site-packages/cffi/api.py new file mode 100644 index 0000000000000000000000000000000000000000..5a474f3da9288e51df2ab93f7c40372955986265 --- /dev/null +++ b/venv/lib/python3.10/site-packages/cffi/api.py @@ -0,0 +1,967 @@ +import sys, types +from .lock import allocate_lock +from .error import CDefError +from . import model + +try: + callable +except NameError: + # Python 3.1 + from collections import Callable + callable = lambda x: isinstance(x, Callable) + +try: + basestring +except NameError: + # Python 3.x + basestring = str + +_unspecified = object() + + + +class FFI(object): + r''' + The main top-level class that you instantiate once, or once per module. + + Example usage: + + ffi = FFI() + ffi.cdef(""" + int printf(const char *, ...); + """) + + C = ffi.dlopen(None) # standard library + -or- + C = ffi.verify() # use a C compiler: verify the decl above is right + + C.printf("hello, %s!\n", ffi.new("char[]", "world")) + ''' + + def __init__(self, backend=None): + """Create an FFI instance. The 'backend' argument is used to + select a non-default backend, mostly for tests. + """ + if backend is None: + # You need PyPy (>= 2.0 beta), or a CPython (>= 2.6) with + # _cffi_backend.so compiled. + import _cffi_backend as backend + from . import __version__ + if backend.__version__ != __version__: + # bad version! Try to be as explicit as possible. + if hasattr(backend, '__file__'): + # CPython + raise Exception("Version mismatch: this is the 'cffi' package version %s, located in %r. When we import the top-level '_cffi_backend' extension module, we get version %s, located in %r. The two versions should be equal; check your installation." % ( + __version__, __file__, + backend.__version__, backend.__file__)) + else: + # PyPy + raise Exception("Version mismatch: this is the 'cffi' package version %s, located in %r. This interpreter comes with a built-in '_cffi_backend' module, which is version %s. The two versions should be equal; check your installation." % ( + __version__, __file__, backend.__version__)) + # (If you insist you can also try to pass the option + # 'backend=backend_ctypes.CTypesBackend()', but don't + # rely on it! It's probably not going to work well.) + + from . import cparser + self._backend = backend + self._lock = allocate_lock() + self._parser = cparser.Parser() + self._cached_btypes = {} + self._parsed_types = types.ModuleType('parsed_types').__dict__ + self._new_types = types.ModuleType('new_types').__dict__ + self._function_caches = [] + self._libraries = [] + self._cdefsources = [] + self._included_ffis = [] + self._windows_unicode = None + self._init_once_cache = {} + self._cdef_version = None + self._embedding = None + self._typecache = model.get_typecache(backend) + if hasattr(backend, 'set_ffi'): + backend.set_ffi(self) + for name in list(backend.__dict__): + if name.startswith('RTLD_'): + setattr(self, name, getattr(backend, name)) + # + with self._lock: + self.BVoidP = self._get_cached_btype(model.voidp_type) + self.BCharA = self._get_cached_btype(model.char_array_type) + if isinstance(backend, types.ModuleType): + # _cffi_backend: attach these constants to the class + if not hasattr(FFI, 'NULL'): + FFI.NULL = self.cast(self.BVoidP, 0) + FFI.CData, FFI.CType = backend._get_types() + else: + # ctypes backend: attach these constants to the instance + self.NULL = self.cast(self.BVoidP, 0) + self.CData, self.CType = backend._get_types() + self.buffer = backend.buffer + + def cdef(self, csource, override=False, packed=False, pack=None): + """Parse the given C source. This registers all declared functions, + types, and global variables. The functions and global variables can + then be accessed via either 'ffi.dlopen()' or 'ffi.verify()'. + The types can be used in 'ffi.new()' and other functions. + If 'packed' is specified as True, all structs declared inside this + cdef are packed, i.e. laid out without any field alignment at all. + Alternatively, 'pack' can be a small integer, and requests for + alignment greater than that are ignored (pack=1 is equivalent to + packed=True). + """ + self._cdef(csource, override=override, packed=packed, pack=pack) + + def embedding_api(self, csource, packed=False, pack=None): + self._cdef(csource, packed=packed, pack=pack, dllexport=True) + if self._embedding is None: + self._embedding = '' + + def _cdef(self, csource, override=False, **options): + if not isinstance(csource, str): # unicode, on Python 2 + if not isinstance(csource, basestring): + raise TypeError("cdef() argument must be a string") + csource = csource.encode('ascii') + with self._lock: + self._cdef_version = object() + self._parser.parse(csource, override=override, **options) + self._cdefsources.append(csource) + if override: + for cache in self._function_caches: + cache.clear() + finishlist = self._parser._recomplete + if finishlist: + self._parser._recomplete = [] + for tp in finishlist: + tp.finish_backend_type(self, finishlist) + + def dlopen(self, name, flags=0): + """Load and return a dynamic library identified by 'name'. + The standard C library can be loaded by passing None. + Note that functions and types declared by 'ffi.cdef()' are not + linked to a particular library, just like C headers; in the + library we only look for the actual (untyped) symbols. + """ + if not (isinstance(name, basestring) or + name is None or + isinstance(name, self.CData)): + raise TypeError("dlopen(name): name must be a file name, None, " + "or an already-opened 'void *' handle") + with self._lock: + lib, function_cache = _make_ffi_library(self, name, flags) + self._function_caches.append(function_cache) + self._libraries.append(lib) + return lib + + def dlclose(self, lib): + """Close a library obtained with ffi.dlopen(). After this call, + access to functions or variables from the library will fail + (possibly with a segmentation fault). + """ + type(lib).__cffi_close__(lib) + + def _typeof_locked(self, cdecl): + # call me with the lock! + key = cdecl + if key in self._parsed_types: + return self._parsed_types[key] + # + if not isinstance(cdecl, str): # unicode, on Python 2 + cdecl = cdecl.encode('ascii') + # + type = self._parser.parse_type(cdecl) + really_a_function_type = type.is_raw_function + if really_a_function_type: + type = type.as_function_pointer() + btype = self._get_cached_btype(type) + result = btype, really_a_function_type + self._parsed_types[key] = result + return result + + def _typeof(self, cdecl, consider_function_as_funcptr=False): + # string -> ctype object + try: + result = self._parsed_types[cdecl] + except KeyError: + with self._lock: + result = self._typeof_locked(cdecl) + # + btype, really_a_function_type = result + if really_a_function_type and not consider_function_as_funcptr: + raise CDefError("the type %r is a function type, not a " + "pointer-to-function type" % (cdecl,)) + return btype + + def typeof(self, cdecl): + """Parse the C type given as a string and return the + corresponding object. + It can also be used on 'cdata' instance to get its C type. + """ + if isinstance(cdecl, basestring): + return self._typeof(cdecl) + if isinstance(cdecl, self.CData): + return self._backend.typeof(cdecl) + if isinstance(cdecl, types.BuiltinFunctionType): + res = _builtin_function_type(cdecl) + if res is not None: + return res + if (isinstance(cdecl, types.FunctionType) + and hasattr(cdecl, '_cffi_base_type')): + with self._lock: + return self._get_cached_btype(cdecl._cffi_base_type) + raise TypeError(type(cdecl)) + + def sizeof(self, cdecl): + """Return the size in bytes of the argument. It can be a + string naming a C type, or a 'cdata' instance. + """ + if isinstance(cdecl, basestring): + BType = self._typeof(cdecl) + return self._backend.sizeof(BType) + else: + return self._backend.sizeof(cdecl) + + def alignof(self, cdecl): + """Return the natural alignment size in bytes of the C type + given as a string. + """ + if isinstance(cdecl, basestring): + cdecl = self._typeof(cdecl) + return self._backend.alignof(cdecl) + + def offsetof(self, cdecl, *fields_or_indexes): + """Return the offset of the named field inside the given + structure or array, which must be given as a C type name. + You can give several field names in case of nested structures. + You can also give numeric values which correspond to array + items, in case of an array type. + """ + if isinstance(cdecl, basestring): + cdecl = self._typeof(cdecl) + return self._typeoffsetof(cdecl, *fields_or_indexes)[1] + + def new(self, cdecl, init=None): + """Allocate an instance according to the specified C type and + return a pointer to it. The specified C type must be either a + pointer or an array: ``new('X *')`` allocates an X and returns + a pointer to it, whereas ``new('X[n]')`` allocates an array of + n X'es and returns an array referencing it (which works + mostly like a pointer, like in C). You can also use + ``new('X[]', n)`` to allocate an array of a non-constant + length n. + + The memory is initialized following the rules of declaring a + global variable in C: by default it is zero-initialized, but + an explicit initializer can be given which can be used to + fill all or part of the memory. + + When the returned object goes out of scope, the memory + is freed. In other words the returned object has + ownership of the value of type 'cdecl' that it points to. This + means that the raw data can be used as long as this object is + kept alive, but must not be used for a longer time. Be careful + about that when copying the pointer to the memory somewhere + else, e.g. into another structure. + """ + if isinstance(cdecl, basestring): + cdecl = self._typeof(cdecl) + return self._backend.newp(cdecl, init) + + def new_allocator(self, alloc=None, free=None, + should_clear_after_alloc=True): + """Return a new allocator, i.e. a function that behaves like ffi.new() + but uses the provided low-level 'alloc' and 'free' functions. + + 'alloc' is called with the size as argument. If it returns NULL, a + MemoryError is raised. 'free' is called with the result of 'alloc' + as argument. Both can be either Python function or directly C + functions. If 'free' is None, then no free function is called. + If both 'alloc' and 'free' are None, the default is used. + + If 'should_clear_after_alloc' is set to False, then the memory + returned by 'alloc' is assumed to be already cleared (or you are + fine with garbage); otherwise CFFI will clear it. + """ + compiled_ffi = self._backend.FFI() + allocator = compiled_ffi.new_allocator(alloc, free, + should_clear_after_alloc) + def allocate(cdecl, init=None): + if isinstance(cdecl, basestring): + cdecl = self._typeof(cdecl) + return allocator(cdecl, init) + return allocate + + def cast(self, cdecl, source): + """Similar to a C cast: returns an instance of the named C + type initialized with the given 'source'. The source is + casted between integers or pointers of any type. + """ + if isinstance(cdecl, basestring): + cdecl = self._typeof(cdecl) + return self._backend.cast(cdecl, source) + + def string(self, cdata, maxlen=-1): + """Return a Python string (or unicode string) from the 'cdata'. + If 'cdata' is a pointer or array of characters or bytes, returns + the null-terminated string. The returned string extends until + the first null character, or at most 'maxlen' characters. If + 'cdata' is an array then 'maxlen' defaults to its length. + + If 'cdata' is a pointer or array of wchar_t, returns a unicode + string following the same rules. + + If 'cdata' is a single character or byte or a wchar_t, returns + it as a string or unicode string. + + If 'cdata' is an enum, returns the value of the enumerator as a + string, or 'NUMBER' if the value is out of range. + """ + return self._backend.string(cdata, maxlen) + + def unpack(self, cdata, length): + """Unpack an array of C data of the given length, + returning a Python string/unicode/list. + + If 'cdata' is a pointer to 'char', returns a byte string. + It does not stop at the first null. This is equivalent to: + ffi.buffer(cdata, length)[:] + + If 'cdata' is a pointer to 'wchar_t', returns a unicode string. + 'length' is measured in wchar_t's; it is not the size in bytes. + + If 'cdata' is a pointer to anything else, returns a list of + 'length' items. This is a faster equivalent to: + [cdata[i] for i in range(length)] + """ + return self._backend.unpack(cdata, length) + + #def buffer(self, cdata, size=-1): + # """Return a read-write buffer object that references the raw C data + # pointed to by the given 'cdata'. The 'cdata' must be a pointer or + # an array. Can be passed to functions expecting a buffer, or directly + # manipulated with: + # + # buf[:] get a copy of it in a regular string, or + # buf[idx] as a single character + # buf[:] = ... + # buf[idx] = ... change the content + # """ + # note that 'buffer' is a type, set on this instance by __init__ + + def from_buffer(self, cdecl, python_buffer=_unspecified, + require_writable=False): + """Return a cdata of the given type pointing to the data of the + given Python object, which must support the buffer interface. + Note that this is not meant to be used on the built-in types + str or unicode (you can build 'char[]' arrays explicitly) + but only on objects containing large quantities of raw data + in some other format, like 'array.array' or numpy arrays. + + The first argument is optional and default to 'char[]'. + """ + if python_buffer is _unspecified: + cdecl, python_buffer = self.BCharA, cdecl + elif isinstance(cdecl, basestring): + cdecl = self._typeof(cdecl) + return self._backend.from_buffer(cdecl, python_buffer, + require_writable) + + def memmove(self, dest, src, n): + """ffi.memmove(dest, src, n) copies n bytes of memory from src to dest. + + Like the C function memmove(), the memory areas may overlap; + apart from that it behaves like the C function memcpy(). + + 'src' can be any cdata ptr or array, or any Python buffer object. + 'dest' can be any cdata ptr or array, or a writable Python buffer + object. The size to copy, 'n', is always measured in bytes. + + Unlike other methods, this one supports all Python buffer including + byte strings and bytearrays---but it still does not support + non-contiguous buffers. + """ + return self._backend.memmove(dest, src, n) + + def callback(self, cdecl, python_callable=None, error=None, onerror=None): + """Return a callback object or a decorator making such a + callback object. 'cdecl' must name a C function pointer type. + The callback invokes the specified 'python_callable' (which may + be provided either directly or via a decorator). Important: the + callback object must be manually kept alive for as long as the + callback may be invoked from the C level. + """ + def callback_decorator_wrap(python_callable): + if not callable(python_callable): + raise TypeError("the 'python_callable' argument " + "is not callable") + return self._backend.callback(cdecl, python_callable, + error, onerror) + if isinstance(cdecl, basestring): + cdecl = self._typeof(cdecl, consider_function_as_funcptr=True) + if python_callable is None: + return callback_decorator_wrap # decorator mode + else: + return callback_decorator_wrap(python_callable) # direct mode + + def getctype(self, cdecl, replace_with=''): + """Return a string giving the C type 'cdecl', which may be itself + a string or a object. If 'replace_with' is given, it gives + extra text to append (or insert for more complicated C types), like + a variable name, or '*' to get actually the C type 'pointer-to-cdecl'. + """ + if isinstance(cdecl, basestring): + cdecl = self._typeof(cdecl) + replace_with = replace_with.strip() + if (replace_with.startswith('*') + and '&[' in self._backend.getcname(cdecl, '&')): + replace_with = '(%s)' % replace_with + elif replace_with and not replace_with[0] in '[(': + replace_with = ' ' + replace_with + return self._backend.getcname(cdecl, replace_with) + + def gc(self, cdata, destructor, size=0): + """Return a new cdata object that points to the same + data. Later, when this new cdata object is garbage-collected, + 'destructor(old_cdata_object)' will be called. + + The optional 'size' gives an estimate of the size, used to + trigger the garbage collection more eagerly. So far only used + on PyPy. It tells the GC that the returned object keeps alive + roughly 'size' bytes of external memory. + """ + return self._backend.gcp(cdata, destructor, size) + + def _get_cached_btype(self, type): + assert self._lock.acquire(False) is False + # call me with the lock! + try: + BType = self._cached_btypes[type] + except KeyError: + finishlist = [] + BType = type.get_cached_btype(self, finishlist) + for type in finishlist: + type.finish_backend_type(self, finishlist) + return BType + + def verify(self, source='', tmpdir=None, **kwargs): + """Verify that the current ffi signatures compile on this + machine, and return a dynamic library object. The dynamic + library can be used to call functions and access global + variables declared in this 'ffi'. The library is compiled + by the C compiler: it gives you C-level API compatibility + (including calling macros). This is unlike 'ffi.dlopen()', + which requires binary compatibility in the signatures. + """ + from .verifier import Verifier, _caller_dir_pycache + # + # If set_unicode(True) was called, insert the UNICODE and + # _UNICODE macro declarations + if self._windows_unicode: + self._apply_windows_unicode(kwargs) + # + # Set the tmpdir here, and not in Verifier.__init__: it picks + # up the caller's directory, which we want to be the caller of + # ffi.verify(), as opposed to the caller of Veritier(). + tmpdir = tmpdir or _caller_dir_pycache() + # + # Make a Verifier() and use it to load the library. + self.verifier = Verifier(self, source, tmpdir, **kwargs) + lib = self.verifier.load_library() + # + # Save the loaded library for keep-alive purposes, even + # if the caller doesn't keep it alive itself (it should). + self._libraries.append(lib) + return lib + + def _get_errno(self): + return self._backend.get_errno() + def _set_errno(self, errno): + self._backend.set_errno(errno) + errno = property(_get_errno, _set_errno, None, + "the value of 'errno' from/to the C calls") + + def getwinerror(self, code=-1): + return self._backend.getwinerror(code) + + def _pointer_to(self, ctype): + with self._lock: + return model.pointer_cache(self, ctype) + + def addressof(self, cdata, *fields_or_indexes): + """Return the address of a . + If 'fields_or_indexes' are given, returns the address of that + field or array item in the structure or array, recursively in + case of nested structures. + """ + try: + ctype = self._backend.typeof(cdata) + except TypeError: + if '__addressof__' in type(cdata).__dict__: + return type(cdata).__addressof__(cdata, *fields_or_indexes) + raise + if fields_or_indexes: + ctype, offset = self._typeoffsetof(ctype, *fields_or_indexes) + else: + if ctype.kind == "pointer": + raise TypeError("addressof(pointer)") + offset = 0 + ctypeptr = self._pointer_to(ctype) + return self._backend.rawaddressof(ctypeptr, cdata, offset) + + def _typeoffsetof(self, ctype, field_or_index, *fields_or_indexes): + ctype, offset = self._backend.typeoffsetof(ctype, field_or_index) + for field1 in fields_or_indexes: + ctype, offset1 = self._backend.typeoffsetof(ctype, field1, 1) + offset += offset1 + return ctype, offset + + def include(self, ffi_to_include): + """Includes the typedefs, structs, unions and enums defined + in another FFI instance. Usage is similar to a #include in C, + where a part of the program might include types defined in + another part for its own usage. Note that the include() + method has no effect on functions, constants and global + variables, which must anyway be accessed directly from the + lib object returned by the original FFI instance. + """ + if not isinstance(ffi_to_include, FFI): + raise TypeError("ffi.include() expects an argument that is also of" + " type cffi.FFI, not %r" % ( + type(ffi_to_include).__name__,)) + if ffi_to_include is self: + raise ValueError("self.include(self)") + with ffi_to_include._lock: + with self._lock: + self._parser.include(ffi_to_include._parser) + self._cdefsources.append('[') + self._cdefsources.extend(ffi_to_include._cdefsources) + self._cdefsources.append(']') + self._included_ffis.append(ffi_to_include) + + def new_handle(self, x): + return self._backend.newp_handle(self.BVoidP, x) + + def from_handle(self, x): + return self._backend.from_handle(x) + + def release(self, x): + self._backend.release(x) + + def set_unicode(self, enabled_flag): + """Windows: if 'enabled_flag' is True, enable the UNICODE and + _UNICODE defines in C, and declare the types like TCHAR and LPTCSTR + to be (pointers to) wchar_t. If 'enabled_flag' is False, + declare these types to be (pointers to) plain 8-bit characters. + This is mostly for backward compatibility; you usually want True. + """ + if self._windows_unicode is not None: + raise ValueError("set_unicode() can only be called once") + enabled_flag = bool(enabled_flag) + if enabled_flag: + self.cdef("typedef wchar_t TBYTE;" + "typedef wchar_t TCHAR;" + "typedef const wchar_t *LPCTSTR;" + "typedef const wchar_t *PCTSTR;" + "typedef wchar_t *LPTSTR;" + "typedef wchar_t *PTSTR;" + "typedef TBYTE *PTBYTE;" + "typedef TCHAR *PTCHAR;") + else: + self.cdef("typedef char TBYTE;" + "typedef char TCHAR;" + "typedef const char *LPCTSTR;" + "typedef const char *PCTSTR;" + "typedef char *LPTSTR;" + "typedef char *PTSTR;" + "typedef TBYTE *PTBYTE;" + "typedef TCHAR *PTCHAR;") + self._windows_unicode = enabled_flag + + def _apply_windows_unicode(self, kwds): + defmacros = kwds.get('define_macros', ()) + if not isinstance(defmacros, (list, tuple)): + raise TypeError("'define_macros' must be a list or tuple") + defmacros = list(defmacros) + [('UNICODE', '1'), + ('_UNICODE', '1')] + kwds['define_macros'] = defmacros + + def _apply_embedding_fix(self, kwds): + # must include an argument like "-lpython2.7" for the compiler + def ensure(key, value): + lst = kwds.setdefault(key, []) + if value not in lst: + lst.append(value) + # + if '__pypy__' in sys.builtin_module_names: + import os + if sys.platform == "win32": + # we need 'libpypy-c.lib'. Current distributions of + # pypy (>= 4.1) contain it as 'libs/python27.lib'. + pythonlib = "python{0[0]}{0[1]}".format(sys.version_info) + if hasattr(sys, 'prefix'): + ensure('library_dirs', os.path.join(sys.prefix, 'libs')) + else: + # we need 'libpypy-c.{so,dylib}', which should be by + # default located in 'sys.prefix/bin' for installed + # systems. + if sys.version_info < (3,): + pythonlib = "pypy-c" + else: + pythonlib = "pypy3-c" + if hasattr(sys, 'prefix'): + ensure('library_dirs', os.path.join(sys.prefix, 'bin')) + # On uninstalled pypy's, the libpypy-c is typically found in + # .../pypy/goal/. + if hasattr(sys, 'prefix'): + ensure('library_dirs', os.path.join(sys.prefix, 'pypy', 'goal')) + else: + if sys.platform == "win32": + template = "python%d%d" + if hasattr(sys, 'gettotalrefcount'): + template += '_d' + else: + try: + import sysconfig + except ImportError: # 2.6 + from cffi._shimmed_dist_utils import sysconfig + template = "python%d.%d" + if sysconfig.get_config_var('DEBUG_EXT'): + template += sysconfig.get_config_var('DEBUG_EXT') + pythonlib = (template % + (sys.hexversion >> 24, (sys.hexversion >> 16) & 0xff)) + if hasattr(sys, 'abiflags'): + pythonlib += sys.abiflags + ensure('libraries', pythonlib) + if sys.platform == "win32": + ensure('extra_link_args', '/MANIFEST') + + def set_source(self, module_name, source, source_extension='.c', **kwds): + import os + if hasattr(self, '_assigned_source'): + raise ValueError("set_source() cannot be called several times " + "per ffi object") + if not isinstance(module_name, basestring): + raise TypeError("'module_name' must be a string") + if os.sep in module_name or (os.altsep and os.altsep in module_name): + raise ValueError("'module_name' must not contain '/': use a dotted " + "name to make a 'package.module' location") + self._assigned_source = (str(module_name), source, + source_extension, kwds) + + def set_source_pkgconfig(self, module_name, pkgconfig_libs, source, + source_extension='.c', **kwds): + from . import pkgconfig + if not isinstance(pkgconfig_libs, list): + raise TypeError("the pkgconfig_libs argument must be a list " + "of package names") + kwds2 = pkgconfig.flags_from_pkgconfig(pkgconfig_libs) + pkgconfig.merge_flags(kwds, kwds2) + self.set_source(module_name, source, source_extension, **kwds) + + def distutils_extension(self, tmpdir='build', verbose=True): + from cffi._shimmed_dist_utils import mkpath + from .recompiler import recompile + # + if not hasattr(self, '_assigned_source'): + if hasattr(self, 'verifier'): # fallback, 'tmpdir' ignored + return self.verifier.get_extension() + raise ValueError("set_source() must be called before" + " distutils_extension()") + module_name, source, source_extension, kwds = self._assigned_source + if source is None: + raise TypeError("distutils_extension() is only for C extension " + "modules, not for dlopen()-style pure Python " + "modules") + mkpath(tmpdir) + ext, updated = recompile(self, module_name, + source, tmpdir=tmpdir, extradir=tmpdir, + source_extension=source_extension, + call_c_compiler=False, **kwds) + if verbose: + if updated: + sys.stderr.write("regenerated: %r\n" % (ext.sources[0],)) + else: + sys.stderr.write("not modified: %r\n" % (ext.sources[0],)) + return ext + + def emit_c_code(self, filename): + from .recompiler import recompile + # + if not hasattr(self, '_assigned_source'): + raise ValueError("set_source() must be called before emit_c_code()") + module_name, source, source_extension, kwds = self._assigned_source + if source is None: + raise TypeError("emit_c_code() is only for C extension modules, " + "not for dlopen()-style pure Python modules") + recompile(self, module_name, source, + c_file=filename, call_c_compiler=False, + uses_ffiplatform=False, **kwds) + + def emit_python_code(self, filename): + from .recompiler import recompile + # + if not hasattr(self, '_assigned_source'): + raise ValueError("set_source() must be called before emit_c_code()") + module_name, source, source_extension, kwds = self._assigned_source + if source is not None: + raise TypeError("emit_python_code() is only for dlopen()-style " + "pure Python modules, not for C extension modules") + recompile(self, module_name, source, + c_file=filename, call_c_compiler=False, + uses_ffiplatform=False, **kwds) + + def compile(self, tmpdir='.', verbose=0, target=None, debug=None): + """The 'target' argument gives the final file name of the + compiled DLL. Use '*' to force distutils' choice, suitable for + regular CPython C API modules. Use a file name ending in '.*' + to ask for the system's default extension for dynamic libraries + (.so/.dll/.dylib). + + The default is '*' when building a non-embedded C API extension, + and (module_name + '.*') when building an embedded library. + """ + from .recompiler import recompile + # + if not hasattr(self, '_assigned_source'): + raise ValueError("set_source() must be called before compile()") + module_name, source, source_extension, kwds = self._assigned_source + return recompile(self, module_name, source, tmpdir=tmpdir, + target=target, source_extension=source_extension, + compiler_verbose=verbose, debug=debug, **kwds) + + def init_once(self, func, tag): + # Read _init_once_cache[tag], which is either (False, lock) if + # we're calling the function now in some thread, or (True, result). + # Don't call setdefault() in most cases, to avoid allocating and + # immediately freeing a lock; but still use setdefaut() to avoid + # races. + try: + x = self._init_once_cache[tag] + except KeyError: + x = self._init_once_cache.setdefault(tag, (False, allocate_lock())) + # Common case: we got (True, result), so we return the result. + if x[0]: + return x[1] + # Else, it's a lock. Acquire it to serialize the following tests. + with x[1]: + # Read again from _init_once_cache the current status. + x = self._init_once_cache[tag] + if x[0]: + return x[1] + # Call the function and store the result back. + result = func() + self._init_once_cache[tag] = (True, result) + return result + + def embedding_init_code(self, pysource): + if self._embedding: + raise ValueError("embedding_init_code() can only be called once") + # fix 'pysource' before it gets dumped into the C file: + # - remove empty lines at the beginning, so it starts at "line 1" + # - dedent, if all non-empty lines are indented + # - check for SyntaxErrors + import re + match = re.match(r'\s*\n', pysource) + if match: + pysource = pysource[match.end():] + lines = pysource.splitlines() or [''] + prefix = re.match(r'\s*', lines[0]).group() + for i in range(1, len(lines)): + line = lines[i] + if line.rstrip(): + while not line.startswith(prefix): + prefix = prefix[:-1] + i = len(prefix) + lines = [line[i:]+'\n' for line in lines] + pysource = ''.join(lines) + # + compile(pysource, "cffi_init", "exec") + # + self._embedding = pysource + + def def_extern(self, *args, **kwds): + raise ValueError("ffi.def_extern() is only available on API-mode FFI " + "objects") + + def list_types(self): + """Returns the user type names known to this FFI instance. + This returns a tuple containing three lists of names: + (typedef_names, names_of_structs, names_of_unions) + """ + typedefs = [] + structs = [] + unions = [] + for key in self._parser._declarations: + if key.startswith('typedef '): + typedefs.append(key[8:]) + elif key.startswith('struct '): + structs.append(key[7:]) + elif key.startswith('union '): + unions.append(key[6:]) + typedefs.sort() + structs.sort() + unions.sort() + return (typedefs, structs, unions) + + +def _load_backend_lib(backend, name, flags): + import os + if not isinstance(name, basestring): + if sys.platform != "win32" or name is not None: + return backend.load_library(name, flags) + name = "c" # Windows: load_library(None) fails, but this works + # on Python 2 (backward compatibility hack only) + first_error = None + if '.' in name or '/' in name or os.sep in name: + try: + return backend.load_library(name, flags) + except OSError as e: + first_error = e + import ctypes.util + path = ctypes.util.find_library(name) + if path is None: + if name == "c" and sys.platform == "win32" and sys.version_info >= (3,): + raise OSError("dlopen(None) cannot work on Windows for Python 3 " + "(see http://bugs.python.org/issue23606)") + msg = ("ctypes.util.find_library() did not manage " + "to locate a library called %r" % (name,)) + if first_error is not None: + msg = "%s. Additionally, %s" % (first_error, msg) + raise OSError(msg) + return backend.load_library(path, flags) + +def _make_ffi_library(ffi, libname, flags): + backend = ffi._backend + backendlib = _load_backend_lib(backend, libname, flags) + # + def accessor_function(name): + key = 'function ' + name + tp, _ = ffi._parser._declarations[key] + BType = ffi._get_cached_btype(tp) + value = backendlib.load_function(BType, name) + library.__dict__[name] = value + # + def accessor_variable(name): + key = 'variable ' + name + tp, _ = ffi._parser._declarations[key] + BType = ffi._get_cached_btype(tp) + read_variable = backendlib.read_variable + write_variable = backendlib.write_variable + setattr(FFILibrary, name, property( + lambda self: read_variable(BType, name), + lambda self, value: write_variable(BType, name, value))) + # + def addressof_var(name): + try: + return addr_variables[name] + except KeyError: + with ffi._lock: + if name not in addr_variables: + key = 'variable ' + name + tp, _ = ffi._parser._declarations[key] + BType = ffi._get_cached_btype(tp) + if BType.kind != 'array': + BType = model.pointer_cache(ffi, BType) + p = backendlib.load_function(BType, name) + addr_variables[name] = p + return addr_variables[name] + # + def accessor_constant(name): + raise NotImplementedError("non-integer constant '%s' cannot be " + "accessed from a dlopen() library" % (name,)) + # + def accessor_int_constant(name): + library.__dict__[name] = ffi._parser._int_constants[name] + # + accessors = {} + accessors_version = [False] + addr_variables = {} + # + def update_accessors(): + if accessors_version[0] is ffi._cdef_version: + return + # + for key, (tp, _) in ffi._parser._declarations.items(): + if not isinstance(tp, model.EnumType): + tag, name = key.split(' ', 1) + if tag == 'function': + accessors[name] = accessor_function + elif tag == 'variable': + accessors[name] = accessor_variable + elif tag == 'constant': + accessors[name] = accessor_constant + else: + for i, enumname in enumerate(tp.enumerators): + def accessor_enum(name, tp=tp, i=i): + tp.check_not_partial() + library.__dict__[name] = tp.enumvalues[i] + accessors[enumname] = accessor_enum + for name in ffi._parser._int_constants: + accessors.setdefault(name, accessor_int_constant) + accessors_version[0] = ffi._cdef_version + # + def make_accessor(name): + with ffi._lock: + if name in library.__dict__ or name in FFILibrary.__dict__: + return # added by another thread while waiting for the lock + if name not in accessors: + update_accessors() + if name not in accessors: + raise AttributeError(name) + accessors[name](name) + # + class FFILibrary(object): + def __getattr__(self, name): + make_accessor(name) + return getattr(self, name) + def __setattr__(self, name, value): + try: + property = getattr(self.__class__, name) + except AttributeError: + make_accessor(name) + setattr(self, name, value) + else: + property.__set__(self, value) + def __dir__(self): + with ffi._lock: + update_accessors() + return accessors.keys() + def __addressof__(self, name): + if name in library.__dict__: + return library.__dict__[name] + if name in FFILibrary.__dict__: + return addressof_var(name) + make_accessor(name) + if name in library.__dict__: + return library.__dict__[name] + if name in FFILibrary.__dict__: + return addressof_var(name) + raise AttributeError("cffi library has no function or " + "global variable named '%s'" % (name,)) + def __cffi_close__(self): + backendlib.close_lib() + self.__dict__.clear() + # + if isinstance(libname, basestring): + try: + if not isinstance(libname, str): # unicode, on Python 2 + libname = libname.encode('utf-8') + FFILibrary.__name__ = 'FFILibrary_%s' % libname + except UnicodeError: + pass + library = FFILibrary() + return library, library.__dict__ + +def _builtin_function_type(func): + # a hack to make at least ffi.typeof(builtin_function) work, + # if the builtin function was obtained by 'vengine_cpy'. + import sys + try: + module = sys.modules[func.__module__] + ffi = module._cffi_original_ffi + types_of_builtin_funcs = module._cffi_types_of_builtin_funcs + tp = types_of_builtin_funcs[func] + except (KeyError, AttributeError, TypeError): + return None + else: + with ffi._lock: + return ffi._get_cached_btype(tp) diff --git a/venv/lib/python3.10/site-packages/cffi/backend_ctypes.py b/venv/lib/python3.10/site-packages/cffi/backend_ctypes.py new file mode 100644 index 0000000000000000000000000000000000000000..e7956a79cfb1c3d28a2ad22a40b261ae7dbbbb5f --- /dev/null +++ b/venv/lib/python3.10/site-packages/cffi/backend_ctypes.py @@ -0,0 +1,1121 @@ +import ctypes, ctypes.util, operator, sys +from . import model + +if sys.version_info < (3,): + bytechr = chr +else: + unicode = str + long = int + xrange = range + bytechr = lambda num: bytes([num]) + +class CTypesType(type): + pass + +class CTypesData(object): + __metaclass__ = CTypesType + __slots__ = ['__weakref__'] + __name__ = '' + + def __init__(self, *args): + raise TypeError("cannot instantiate %r" % (self.__class__,)) + + @classmethod + def _newp(cls, init): + raise TypeError("expected a pointer or array ctype, got '%s'" + % (cls._get_c_name(),)) + + @staticmethod + def _to_ctypes(value): + raise TypeError + + @classmethod + def _arg_to_ctypes(cls, *value): + try: + ctype = cls._ctype + except AttributeError: + raise TypeError("cannot create an instance of %r" % (cls,)) + if value: + res = cls._to_ctypes(*value) + if not isinstance(res, ctype): + res = cls._ctype(res) + else: + res = cls._ctype() + return res + + @classmethod + def _create_ctype_obj(cls, init): + if init is None: + return cls._arg_to_ctypes() + else: + return cls._arg_to_ctypes(init) + + @staticmethod + def _from_ctypes(ctypes_value): + raise TypeError + + @classmethod + def _get_c_name(cls, replace_with=''): + return cls._reftypename.replace(' &', replace_with) + + @classmethod + def _fix_class(cls): + cls.__name__ = 'CData<%s>' % (cls._get_c_name(),) + cls.__qualname__ = 'CData<%s>' % (cls._get_c_name(),) + cls.__module__ = 'ffi' + + def _get_own_repr(self): + raise NotImplementedError + + def _addr_repr(self, address): + if address == 0: + return 'NULL' + else: + if address < 0: + address += 1 << (8*ctypes.sizeof(ctypes.c_void_p)) + return '0x%x' % address + + def __repr__(self, c_name=None): + own = self._get_own_repr() + return '' % (c_name or self._get_c_name(), own) + + def _convert_to_address(self, BClass): + if BClass is None: + raise TypeError("cannot convert %r to an address" % ( + self._get_c_name(),)) + else: + raise TypeError("cannot convert %r to %r" % ( + self._get_c_name(), BClass._get_c_name())) + + @classmethod + def _get_size(cls): + return ctypes.sizeof(cls._ctype) + + def _get_size_of_instance(self): + return ctypes.sizeof(self._ctype) + + @classmethod + def _cast_from(cls, source): + raise TypeError("cannot cast to %r" % (cls._get_c_name(),)) + + def _cast_to_integer(self): + return self._convert_to_address(None) + + @classmethod + def _alignment(cls): + return ctypes.alignment(cls._ctype) + + def __iter__(self): + raise TypeError("cdata %r does not support iteration" % ( + self._get_c_name()),) + + def _make_cmp(name): + cmpfunc = getattr(operator, name) + def cmp(self, other): + v_is_ptr = not isinstance(self, CTypesGenericPrimitive) + w_is_ptr = (isinstance(other, CTypesData) and + not isinstance(other, CTypesGenericPrimitive)) + if v_is_ptr and w_is_ptr: + return cmpfunc(self._convert_to_address(None), + other._convert_to_address(None)) + elif v_is_ptr or w_is_ptr: + return NotImplemented + else: + if isinstance(self, CTypesGenericPrimitive): + self = self._value + if isinstance(other, CTypesGenericPrimitive): + other = other._value + return cmpfunc(self, other) + cmp.func_name = name + return cmp + + __eq__ = _make_cmp('__eq__') + __ne__ = _make_cmp('__ne__') + __lt__ = _make_cmp('__lt__') + __le__ = _make_cmp('__le__') + __gt__ = _make_cmp('__gt__') + __ge__ = _make_cmp('__ge__') + + def __hash__(self): + return hash(self._convert_to_address(None)) + + def _to_string(self, maxlen): + raise TypeError("string(): %r" % (self,)) + + +class CTypesGenericPrimitive(CTypesData): + __slots__ = [] + + def __hash__(self): + return hash(self._value) + + def _get_own_repr(self): + return repr(self._from_ctypes(self._value)) + + +class CTypesGenericArray(CTypesData): + __slots__ = [] + + @classmethod + def _newp(cls, init): + return cls(init) + + def __iter__(self): + for i in xrange(len(self)): + yield self[i] + + def _get_own_repr(self): + return self._addr_repr(ctypes.addressof(self._blob)) + + +class CTypesGenericPtr(CTypesData): + __slots__ = ['_address', '_as_ctype_ptr'] + _automatic_casts = False + kind = "pointer" + + @classmethod + def _newp(cls, init): + return cls(init) + + @classmethod + def _cast_from(cls, source): + if source is None: + address = 0 + elif isinstance(source, CTypesData): + address = source._cast_to_integer() + elif isinstance(source, (int, long)): + address = source + else: + raise TypeError("bad type for cast to %r: %r" % + (cls, type(source).__name__)) + return cls._new_pointer_at(address) + + @classmethod + def _new_pointer_at(cls, address): + self = cls.__new__(cls) + self._address = address + self._as_ctype_ptr = ctypes.cast(address, cls._ctype) + return self + + def _get_own_repr(self): + try: + return self._addr_repr(self._address) + except AttributeError: + return '???' + + def _cast_to_integer(self): + return self._address + + def __nonzero__(self): + return bool(self._address) + __bool__ = __nonzero__ + + @classmethod + def _to_ctypes(cls, value): + if not isinstance(value, CTypesData): + raise TypeError("unexpected %s object" % type(value).__name__) + address = value._convert_to_address(cls) + return ctypes.cast(address, cls._ctype) + + @classmethod + def _from_ctypes(cls, ctypes_ptr): + address = ctypes.cast(ctypes_ptr, ctypes.c_void_p).value or 0 + return cls._new_pointer_at(address) + + @classmethod + def _initialize(cls, ctypes_ptr, value): + if value: + ctypes_ptr.contents = cls._to_ctypes(value).contents + + def _convert_to_address(self, BClass): + if (BClass in (self.__class__, None) or BClass._automatic_casts + or self._automatic_casts): + return self._address + else: + return CTypesData._convert_to_address(self, BClass) + + +class CTypesBaseStructOrUnion(CTypesData): + __slots__ = ['_blob'] + + @classmethod + def _create_ctype_obj(cls, init): + # may be overridden + raise TypeError("cannot instantiate opaque type %s" % (cls,)) + + def _get_own_repr(self): + return self._addr_repr(ctypes.addressof(self._blob)) + + @classmethod + def _offsetof(cls, fieldname): + return getattr(cls._ctype, fieldname).offset + + def _convert_to_address(self, BClass): + if getattr(BClass, '_BItem', None) is self.__class__: + return ctypes.addressof(self._blob) + else: + return CTypesData._convert_to_address(self, BClass) + + @classmethod + def _from_ctypes(cls, ctypes_struct_or_union): + self = cls.__new__(cls) + self._blob = ctypes_struct_or_union + return self + + @classmethod + def _to_ctypes(cls, value): + return value._blob + + def __repr__(self, c_name=None): + return CTypesData.__repr__(self, c_name or self._get_c_name(' &')) + + +class CTypesBackend(object): + + PRIMITIVE_TYPES = { + 'char': ctypes.c_char, + 'short': ctypes.c_short, + 'int': ctypes.c_int, + 'long': ctypes.c_long, + 'long long': ctypes.c_longlong, + 'signed char': ctypes.c_byte, + 'unsigned char': ctypes.c_ubyte, + 'unsigned short': ctypes.c_ushort, + 'unsigned int': ctypes.c_uint, + 'unsigned long': ctypes.c_ulong, + 'unsigned long long': ctypes.c_ulonglong, + 'float': ctypes.c_float, + 'double': ctypes.c_double, + '_Bool': ctypes.c_bool, + } + + for _name in ['unsigned long long', 'unsigned long', + 'unsigned int', 'unsigned short', 'unsigned char']: + _size = ctypes.sizeof(PRIMITIVE_TYPES[_name]) + PRIMITIVE_TYPES['uint%d_t' % (8*_size)] = PRIMITIVE_TYPES[_name] + if _size == ctypes.sizeof(ctypes.c_void_p): + PRIMITIVE_TYPES['uintptr_t'] = PRIMITIVE_TYPES[_name] + if _size == ctypes.sizeof(ctypes.c_size_t): + PRIMITIVE_TYPES['size_t'] = PRIMITIVE_TYPES[_name] + + for _name in ['long long', 'long', 'int', 'short', 'signed char']: + _size = ctypes.sizeof(PRIMITIVE_TYPES[_name]) + PRIMITIVE_TYPES['int%d_t' % (8*_size)] = PRIMITIVE_TYPES[_name] + if _size == ctypes.sizeof(ctypes.c_void_p): + PRIMITIVE_TYPES['intptr_t'] = PRIMITIVE_TYPES[_name] + PRIMITIVE_TYPES['ptrdiff_t'] = PRIMITIVE_TYPES[_name] + if _size == ctypes.sizeof(ctypes.c_size_t): + PRIMITIVE_TYPES['ssize_t'] = PRIMITIVE_TYPES[_name] + + + def __init__(self): + self.RTLD_LAZY = 0 # not supported anyway by ctypes + self.RTLD_NOW = 0 + self.RTLD_GLOBAL = ctypes.RTLD_GLOBAL + self.RTLD_LOCAL = ctypes.RTLD_LOCAL + + def set_ffi(self, ffi): + self.ffi = ffi + + def _get_types(self): + return CTypesData, CTypesType + + def load_library(self, path, flags=0): + cdll = ctypes.CDLL(path, flags) + return CTypesLibrary(self, cdll) + + def new_void_type(self): + class CTypesVoid(CTypesData): + __slots__ = [] + _reftypename = 'void &' + @staticmethod + def _from_ctypes(novalue): + return None + @staticmethod + def _to_ctypes(novalue): + if novalue is not None: + raise TypeError("None expected, got %s object" % + (type(novalue).__name__,)) + return None + CTypesVoid._fix_class() + return CTypesVoid + + def new_primitive_type(self, name): + if name == 'wchar_t': + raise NotImplementedError(name) + ctype = self.PRIMITIVE_TYPES[name] + if name == 'char': + kind = 'char' + elif name in ('float', 'double'): + kind = 'float' + else: + if name in ('signed char', 'unsigned char'): + kind = 'byte' + elif name == '_Bool': + kind = 'bool' + else: + kind = 'int' + is_signed = (ctype(-1).value == -1) + # + def _cast_source_to_int(source): + if isinstance(source, (int, long, float)): + source = int(source) + elif isinstance(source, CTypesData): + source = source._cast_to_integer() + elif isinstance(source, bytes): + source = ord(source) + elif source is None: + source = 0 + else: + raise TypeError("bad type for cast to %r: %r" % + (CTypesPrimitive, type(source).__name__)) + return source + # + kind1 = kind + class CTypesPrimitive(CTypesGenericPrimitive): + __slots__ = ['_value'] + _ctype = ctype + _reftypename = '%s &' % name + kind = kind1 + + def __init__(self, value): + self._value = value + + @staticmethod + def _create_ctype_obj(init): + if init is None: + return ctype() + return ctype(CTypesPrimitive._to_ctypes(init)) + + if kind == 'int' or kind == 'byte': + @classmethod + def _cast_from(cls, source): + source = _cast_source_to_int(source) + source = ctype(source).value # cast within range + return cls(source) + def __int__(self): + return self._value + + if kind == 'bool': + @classmethod + def _cast_from(cls, source): + if not isinstance(source, (int, long, float)): + source = _cast_source_to_int(source) + return cls(bool(source)) + def __int__(self): + return int(self._value) + + if kind == 'char': + @classmethod + def _cast_from(cls, source): + source = _cast_source_to_int(source) + source = bytechr(source & 0xFF) + return cls(source) + def __int__(self): + return ord(self._value) + + if kind == 'float': + @classmethod + def _cast_from(cls, source): + if isinstance(source, float): + pass + elif isinstance(source, CTypesGenericPrimitive): + if hasattr(source, '__float__'): + source = float(source) + else: + source = int(source) + else: + source = _cast_source_to_int(source) + source = ctype(source).value # fix precision + return cls(source) + def __int__(self): + return int(self._value) + def __float__(self): + return self._value + + _cast_to_integer = __int__ + + if kind == 'int' or kind == 'byte' or kind == 'bool': + @staticmethod + def _to_ctypes(x): + if not isinstance(x, (int, long)): + if isinstance(x, CTypesData): + x = int(x) + else: + raise TypeError("integer expected, got %s" % + type(x).__name__) + if ctype(x).value != x: + if not is_signed and x < 0: + raise OverflowError("%s: negative integer" % name) + else: + raise OverflowError("%s: integer out of bounds" + % name) + return x + + if kind == 'char': + @staticmethod + def _to_ctypes(x): + if isinstance(x, bytes) and len(x) == 1: + return x + if isinstance(x, CTypesPrimitive): # > + return x._value + raise TypeError("character expected, got %s" % + type(x).__name__) + def __nonzero__(self): + return ord(self._value) != 0 + else: + def __nonzero__(self): + return self._value != 0 + __bool__ = __nonzero__ + + if kind == 'float': + @staticmethod + def _to_ctypes(x): + if not isinstance(x, (int, long, float, CTypesData)): + raise TypeError("float expected, got %s" % + type(x).__name__) + return ctype(x).value + + @staticmethod + def _from_ctypes(value): + return getattr(value, 'value', value) + + @staticmethod + def _initialize(blob, init): + blob.value = CTypesPrimitive._to_ctypes(init) + + if kind == 'char': + def _to_string(self, maxlen): + return self._value + if kind == 'byte': + def _to_string(self, maxlen): + return chr(self._value & 0xff) + # + CTypesPrimitive._fix_class() + return CTypesPrimitive + + def new_pointer_type(self, BItem): + getbtype = self.ffi._get_cached_btype + if BItem is getbtype(model.PrimitiveType('char')): + kind = 'charp' + elif BItem in (getbtype(model.PrimitiveType('signed char')), + getbtype(model.PrimitiveType('unsigned char'))): + kind = 'bytep' + elif BItem is getbtype(model.void_type): + kind = 'voidp' + else: + kind = 'generic' + # + class CTypesPtr(CTypesGenericPtr): + __slots__ = ['_own'] + if kind == 'charp': + __slots__ += ['__as_strbuf'] + _BItem = BItem + if hasattr(BItem, '_ctype'): + _ctype = ctypes.POINTER(BItem._ctype) + _bitem_size = ctypes.sizeof(BItem._ctype) + else: + _ctype = ctypes.c_void_p + if issubclass(BItem, CTypesGenericArray): + _reftypename = BItem._get_c_name('(* &)') + else: + _reftypename = BItem._get_c_name(' * &') + + def __init__(self, init): + ctypeobj = BItem._create_ctype_obj(init) + if kind == 'charp': + self.__as_strbuf = ctypes.create_string_buffer( + ctypeobj.value + b'\x00') + self._as_ctype_ptr = ctypes.cast( + self.__as_strbuf, self._ctype) + else: + self._as_ctype_ptr = ctypes.pointer(ctypeobj) + self._address = ctypes.cast(self._as_ctype_ptr, + ctypes.c_void_p).value + self._own = True + + def __add__(self, other): + if isinstance(other, (int, long)): + return self._new_pointer_at(self._address + + other * self._bitem_size) + else: + return NotImplemented + + def __sub__(self, other): + if isinstance(other, (int, long)): + return self._new_pointer_at(self._address - + other * self._bitem_size) + elif type(self) is type(other): + return (self._address - other._address) // self._bitem_size + else: + return NotImplemented + + def __getitem__(self, index): + if getattr(self, '_own', False) and index != 0: + raise IndexError + return BItem._from_ctypes(self._as_ctype_ptr[index]) + + def __setitem__(self, index, value): + self._as_ctype_ptr[index] = BItem._to_ctypes(value) + + if kind == 'charp' or kind == 'voidp': + @classmethod + def _arg_to_ctypes(cls, *value): + if value and isinstance(value[0], bytes): + return ctypes.c_char_p(value[0]) + else: + return super(CTypesPtr, cls)._arg_to_ctypes(*value) + + if kind == 'charp' or kind == 'bytep': + def _to_string(self, maxlen): + if maxlen < 0: + maxlen = sys.maxsize + p = ctypes.cast(self._as_ctype_ptr, + ctypes.POINTER(ctypes.c_char)) + n = 0 + while n < maxlen and p[n] != b'\x00': + n += 1 + return b''.join([p[i] for i in range(n)]) + + def _get_own_repr(self): + if getattr(self, '_own', False): + return 'owning %d bytes' % ( + ctypes.sizeof(self._as_ctype_ptr.contents),) + return super(CTypesPtr, self)._get_own_repr() + # + if (BItem is self.ffi._get_cached_btype(model.void_type) or + BItem is self.ffi._get_cached_btype(model.PrimitiveType('char'))): + CTypesPtr._automatic_casts = True + # + CTypesPtr._fix_class() + return CTypesPtr + + def new_array_type(self, CTypesPtr, length): + if length is None: + brackets = ' &[]' + else: + brackets = ' &[%d]' % length + BItem = CTypesPtr._BItem + getbtype = self.ffi._get_cached_btype + if BItem is getbtype(model.PrimitiveType('char')): + kind = 'char' + elif BItem in (getbtype(model.PrimitiveType('signed char')), + getbtype(model.PrimitiveType('unsigned char'))): + kind = 'byte' + else: + kind = 'generic' + # + class CTypesArray(CTypesGenericArray): + __slots__ = ['_blob', '_own'] + if length is not None: + _ctype = BItem._ctype * length + else: + __slots__.append('_ctype') + _reftypename = BItem._get_c_name(brackets) + _declared_length = length + _CTPtr = CTypesPtr + + def __init__(self, init): + if length is None: + if isinstance(init, (int, long)): + len1 = init + init = None + elif kind == 'char' and isinstance(init, bytes): + len1 = len(init) + 1 # extra null + else: + init = tuple(init) + len1 = len(init) + self._ctype = BItem._ctype * len1 + self._blob = self._ctype() + self._own = True + if init is not None: + self._initialize(self._blob, init) + + @staticmethod + def _initialize(blob, init): + if isinstance(init, bytes): + init = [init[i:i+1] for i in range(len(init))] + else: + if isinstance(init, CTypesGenericArray): + if (len(init) != len(blob) or + not isinstance(init, CTypesArray)): + raise TypeError("length/type mismatch: %s" % (init,)) + init = tuple(init) + if len(init) > len(blob): + raise IndexError("too many initializers") + addr = ctypes.cast(blob, ctypes.c_void_p).value + PTR = ctypes.POINTER(BItem._ctype) + itemsize = ctypes.sizeof(BItem._ctype) + for i, value in enumerate(init): + p = ctypes.cast(addr + i * itemsize, PTR) + BItem._initialize(p.contents, value) + + def __len__(self): + return len(self._blob) + + def __getitem__(self, index): + if not (0 <= index < len(self._blob)): + raise IndexError + return BItem._from_ctypes(self._blob[index]) + + def __setitem__(self, index, value): + if not (0 <= index < len(self._blob)): + raise IndexError + self._blob[index] = BItem._to_ctypes(value) + + if kind == 'char' or kind == 'byte': + def _to_string(self, maxlen): + if maxlen < 0: + maxlen = len(self._blob) + p = ctypes.cast(self._blob, + ctypes.POINTER(ctypes.c_char)) + n = 0 + while n < maxlen and p[n] != b'\x00': + n += 1 + return b''.join([p[i] for i in range(n)]) + + def _get_own_repr(self): + if getattr(self, '_own', False): + return 'owning %d bytes' % (ctypes.sizeof(self._blob),) + return super(CTypesArray, self)._get_own_repr() + + def _convert_to_address(self, BClass): + if BClass in (CTypesPtr, None) or BClass._automatic_casts: + return ctypes.addressof(self._blob) + else: + return CTypesData._convert_to_address(self, BClass) + + @staticmethod + def _from_ctypes(ctypes_array): + self = CTypesArray.__new__(CTypesArray) + self._blob = ctypes_array + return self + + @staticmethod + def _arg_to_ctypes(value): + return CTypesPtr._arg_to_ctypes(value) + + def __add__(self, other): + if isinstance(other, (int, long)): + return CTypesPtr._new_pointer_at( + ctypes.addressof(self._blob) + + other * ctypes.sizeof(BItem._ctype)) + else: + return NotImplemented + + @classmethod + def _cast_from(cls, source): + raise NotImplementedError("casting to %r" % ( + cls._get_c_name(),)) + # + CTypesArray._fix_class() + return CTypesArray + + def _new_struct_or_union(self, kind, name, base_ctypes_class): + # + class struct_or_union(base_ctypes_class): + pass + struct_or_union.__name__ = '%s_%s' % (kind, name) + kind1 = kind + # + class CTypesStructOrUnion(CTypesBaseStructOrUnion): + __slots__ = ['_blob'] + _ctype = struct_or_union + _reftypename = '%s &' % (name,) + _kind = kind = kind1 + # + CTypesStructOrUnion._fix_class() + return CTypesStructOrUnion + + def new_struct_type(self, name): + return self._new_struct_or_union('struct', name, ctypes.Structure) + + def new_union_type(self, name): + return self._new_struct_or_union('union', name, ctypes.Union) + + def complete_struct_or_union(self, CTypesStructOrUnion, fields, tp, + totalsize=-1, totalalignment=-1, sflags=0, + pack=0): + if totalsize >= 0 or totalalignment >= 0: + raise NotImplementedError("the ctypes backend of CFFI does not support " + "structures completed by verify(); please " + "compile and install the _cffi_backend module.") + struct_or_union = CTypesStructOrUnion._ctype + fnames = [fname for (fname, BField, bitsize) in fields] + btypes = [BField for (fname, BField, bitsize) in fields] + bitfields = [bitsize for (fname, BField, bitsize) in fields] + # + bfield_types = {} + cfields = [] + for (fname, BField, bitsize) in fields: + if bitsize < 0: + cfields.append((fname, BField._ctype)) + bfield_types[fname] = BField + else: + cfields.append((fname, BField._ctype, bitsize)) + bfield_types[fname] = Ellipsis + if sflags & 8: + struct_or_union._pack_ = 1 + elif pack: + struct_or_union._pack_ = pack + struct_or_union._fields_ = cfields + CTypesStructOrUnion._bfield_types = bfield_types + # + @staticmethod + def _create_ctype_obj(init): + result = struct_or_union() + if init is not None: + initialize(result, init) + return result + CTypesStructOrUnion._create_ctype_obj = _create_ctype_obj + # + def initialize(blob, init): + if is_union: + if len(init) > 1: + raise ValueError("union initializer: %d items given, but " + "only one supported (use a dict if needed)" + % (len(init),)) + if not isinstance(init, dict): + if isinstance(init, (bytes, unicode)): + raise TypeError("union initializer: got a str") + init = tuple(init) + if len(init) > len(fnames): + raise ValueError("too many values for %s initializer" % + CTypesStructOrUnion._get_c_name()) + init = dict(zip(fnames, init)) + addr = ctypes.addressof(blob) + for fname, value in init.items(): + BField, bitsize = name2fieldtype[fname] + assert bitsize < 0, \ + "not implemented: initializer with bit fields" + offset = CTypesStructOrUnion._offsetof(fname) + PTR = ctypes.POINTER(BField._ctype) + p = ctypes.cast(addr + offset, PTR) + BField._initialize(p.contents, value) + is_union = CTypesStructOrUnion._kind == 'union' + name2fieldtype = dict(zip(fnames, zip(btypes, bitfields))) + # + for fname, BField, bitsize in fields: + if fname == '': + raise NotImplementedError("nested anonymous structs/unions") + if hasattr(CTypesStructOrUnion, fname): + raise ValueError("the field name %r conflicts in " + "the ctypes backend" % fname) + if bitsize < 0: + def getter(self, fname=fname, BField=BField, + offset=CTypesStructOrUnion._offsetof(fname), + PTR=ctypes.POINTER(BField._ctype)): + addr = ctypes.addressof(self._blob) + p = ctypes.cast(addr + offset, PTR) + return BField._from_ctypes(p.contents) + def setter(self, value, fname=fname, BField=BField): + setattr(self._blob, fname, BField._to_ctypes(value)) + # + if issubclass(BField, CTypesGenericArray): + setter = None + if BField._declared_length == 0: + def getter(self, fname=fname, BFieldPtr=BField._CTPtr, + offset=CTypesStructOrUnion._offsetof(fname), + PTR=ctypes.POINTER(BField._ctype)): + addr = ctypes.addressof(self._blob) + p = ctypes.cast(addr + offset, PTR) + return BFieldPtr._from_ctypes(p) + # + else: + def getter(self, fname=fname, BField=BField): + return BField._from_ctypes(getattr(self._blob, fname)) + def setter(self, value, fname=fname, BField=BField): + # xxx obscure workaround + value = BField._to_ctypes(value) + oldvalue = getattr(self._blob, fname) + setattr(self._blob, fname, value) + if value != getattr(self._blob, fname): + setattr(self._blob, fname, oldvalue) + raise OverflowError("value too large for bitfield") + setattr(CTypesStructOrUnion, fname, property(getter, setter)) + # + CTypesPtr = self.ffi._get_cached_btype(model.PointerType(tp)) + for fname in fnames: + if hasattr(CTypesPtr, fname): + raise ValueError("the field name %r conflicts in " + "the ctypes backend" % fname) + def getter(self, fname=fname): + return getattr(self[0], fname) + def setter(self, value, fname=fname): + setattr(self[0], fname, value) + setattr(CTypesPtr, fname, property(getter, setter)) + + def new_function_type(self, BArgs, BResult, has_varargs): + nameargs = [BArg._get_c_name() for BArg in BArgs] + if has_varargs: + nameargs.append('...') + nameargs = ', '.join(nameargs) + # + class CTypesFunctionPtr(CTypesGenericPtr): + __slots__ = ['_own_callback', '_name'] + _ctype = ctypes.CFUNCTYPE(getattr(BResult, '_ctype', None), + *[BArg._ctype for BArg in BArgs], + use_errno=True) + _reftypename = BResult._get_c_name('(* &)(%s)' % (nameargs,)) + + def __init__(self, init, error=None): + # create a callback to the Python callable init() + import traceback + assert not has_varargs, "varargs not supported for callbacks" + if getattr(BResult, '_ctype', None) is not None: + error = BResult._from_ctypes( + BResult._create_ctype_obj(error)) + else: + error = None + def callback(*args): + args2 = [] + for arg, BArg in zip(args, BArgs): + args2.append(BArg._from_ctypes(arg)) + try: + res2 = init(*args2) + res2 = BResult._to_ctypes(res2) + except: + traceback.print_exc() + res2 = error + if issubclass(BResult, CTypesGenericPtr): + if res2: + res2 = ctypes.cast(res2, ctypes.c_void_p).value + # .value: http://bugs.python.org/issue1574593 + else: + res2 = None + #print repr(res2) + return res2 + if issubclass(BResult, CTypesGenericPtr): + # The only pointers callbacks can return are void*s: + # http://bugs.python.org/issue5710 + callback_ctype = ctypes.CFUNCTYPE( + ctypes.c_void_p, + *[BArg._ctype for BArg in BArgs], + use_errno=True) + else: + callback_ctype = CTypesFunctionPtr._ctype + self._as_ctype_ptr = callback_ctype(callback) + self._address = ctypes.cast(self._as_ctype_ptr, + ctypes.c_void_p).value + self._own_callback = init + + @staticmethod + def _initialize(ctypes_ptr, value): + if value: + raise NotImplementedError("ctypes backend: not supported: " + "initializers for function pointers") + + def __repr__(self): + c_name = getattr(self, '_name', None) + if c_name: + i = self._reftypename.index('(* &)') + if self._reftypename[i-1] not in ' )*': + c_name = ' ' + c_name + c_name = self._reftypename.replace('(* &)', c_name) + return CTypesData.__repr__(self, c_name) + + def _get_own_repr(self): + if getattr(self, '_own_callback', None) is not None: + return 'calling %r' % (self._own_callback,) + return super(CTypesFunctionPtr, self)._get_own_repr() + + def __call__(self, *args): + if has_varargs: + assert len(args) >= len(BArgs) + extraargs = args[len(BArgs):] + args = args[:len(BArgs)] + else: + assert len(args) == len(BArgs) + ctypes_args = [] + for arg, BArg in zip(args, BArgs): + ctypes_args.append(BArg._arg_to_ctypes(arg)) + if has_varargs: + for i, arg in enumerate(extraargs): + if arg is None: + ctypes_args.append(ctypes.c_void_p(0)) # NULL + continue + if not isinstance(arg, CTypesData): + raise TypeError( + "argument %d passed in the variadic part " + "needs to be a cdata object (got %s)" % + (1 + len(BArgs) + i, type(arg).__name__)) + ctypes_args.append(arg._arg_to_ctypes(arg)) + result = self._as_ctype_ptr(*ctypes_args) + return BResult._from_ctypes(result) + # + CTypesFunctionPtr._fix_class() + return CTypesFunctionPtr + + def new_enum_type(self, name, enumerators, enumvalues, CTypesInt): + assert isinstance(name, str) + reverse_mapping = dict(zip(reversed(enumvalues), + reversed(enumerators))) + # + class CTypesEnum(CTypesInt): + __slots__ = [] + _reftypename = '%s &' % name + + def _get_own_repr(self): + value = self._value + try: + return '%d: %s' % (value, reverse_mapping[value]) + except KeyError: + return str(value) + + def _to_string(self, maxlen): + value = self._value + try: + return reverse_mapping[value] + except KeyError: + return str(value) + # + CTypesEnum._fix_class() + return CTypesEnum + + def get_errno(self): + return ctypes.get_errno() + + def set_errno(self, value): + ctypes.set_errno(value) + + def string(self, b, maxlen=-1): + return b._to_string(maxlen) + + def buffer(self, bptr, size=-1): + raise NotImplementedError("buffer() with ctypes backend") + + def sizeof(self, cdata_or_BType): + if isinstance(cdata_or_BType, CTypesData): + return cdata_or_BType._get_size_of_instance() + else: + assert issubclass(cdata_or_BType, CTypesData) + return cdata_or_BType._get_size() + + def alignof(self, BType): + assert issubclass(BType, CTypesData) + return BType._alignment() + + def newp(self, BType, source): + if not issubclass(BType, CTypesData): + raise TypeError + return BType._newp(source) + + def cast(self, BType, source): + return BType._cast_from(source) + + def callback(self, BType, source, error, onerror): + assert onerror is None # XXX not implemented + return BType(source, error) + + _weakref_cache_ref = None + + def gcp(self, cdata, destructor, size=0): + if self._weakref_cache_ref is None: + import weakref + class MyRef(weakref.ref): + def __eq__(self, other): + myref = self() + return self is other or ( + myref is not None and myref is other()) + def __ne__(self, other): + return not (self == other) + def __hash__(self): + try: + return self._hash + except AttributeError: + self._hash = hash(self()) + return self._hash + self._weakref_cache_ref = {}, MyRef + weak_cache, MyRef = self._weakref_cache_ref + + if destructor is None: + try: + del weak_cache[MyRef(cdata)] + except KeyError: + raise TypeError("Can remove destructor only on a object " + "previously returned by ffi.gc()") + return None + + def remove(k): + cdata, destructor = weak_cache.pop(k, (None, None)) + if destructor is not None: + destructor(cdata) + + new_cdata = self.cast(self.typeof(cdata), cdata) + assert new_cdata is not cdata + weak_cache[MyRef(new_cdata, remove)] = (cdata, destructor) + return new_cdata + + typeof = type + + def getcname(self, BType, replace_with): + return BType._get_c_name(replace_with) + + def typeoffsetof(self, BType, fieldname, num=0): + if isinstance(fieldname, str): + if num == 0 and issubclass(BType, CTypesGenericPtr): + BType = BType._BItem + if not issubclass(BType, CTypesBaseStructOrUnion): + raise TypeError("expected a struct or union ctype") + BField = BType._bfield_types[fieldname] + if BField is Ellipsis: + raise TypeError("not supported for bitfields") + return (BField, BType._offsetof(fieldname)) + elif isinstance(fieldname, (int, long)): + if issubclass(BType, CTypesGenericArray): + BType = BType._CTPtr + if not issubclass(BType, CTypesGenericPtr): + raise TypeError("expected an array or ptr ctype") + BItem = BType._BItem + offset = BItem._get_size() * fieldname + if offset > sys.maxsize: + raise OverflowError + return (BItem, offset) + else: + raise TypeError(type(fieldname)) + + def rawaddressof(self, BTypePtr, cdata, offset=None): + if isinstance(cdata, CTypesBaseStructOrUnion): + ptr = ctypes.pointer(type(cdata)._to_ctypes(cdata)) + elif isinstance(cdata, CTypesGenericPtr): + if offset is None or not issubclass(type(cdata)._BItem, + CTypesBaseStructOrUnion): + raise TypeError("unexpected cdata type") + ptr = type(cdata)._to_ctypes(cdata) + elif isinstance(cdata, CTypesGenericArray): + ptr = type(cdata)._to_ctypes(cdata) + else: + raise TypeError("expected a ") + if offset: + ptr = ctypes.cast( + ctypes.c_void_p( + ctypes.cast(ptr, ctypes.c_void_p).value + offset), + type(ptr)) + return BTypePtr._from_ctypes(ptr) + + +class CTypesLibrary(object): + + def __init__(self, backend, cdll): + self.backend = backend + self.cdll = cdll + + def load_function(self, BType, name): + c_func = getattr(self.cdll, name) + funcobj = BType._from_ctypes(c_func) + funcobj._name = name + return funcobj + + def read_variable(self, BType, name): + try: + ctypes_obj = BType._ctype.in_dll(self.cdll, name) + except AttributeError as e: + raise NotImplementedError(e) + return BType._from_ctypes(ctypes_obj) + + def write_variable(self, BType, name, value): + new_ctypes_obj = BType._to_ctypes(value) + ctypes_obj = BType._ctype.in_dll(self.cdll, name) + ctypes.memmove(ctypes.addressof(ctypes_obj), + ctypes.addressof(new_ctypes_obj), + ctypes.sizeof(BType._ctype)) diff --git a/venv/lib/python3.10/site-packages/cffi/cffi_opcode.py b/venv/lib/python3.10/site-packages/cffi/cffi_opcode.py new file mode 100644 index 0000000000000000000000000000000000000000..6421df62134ce43a10d72b3b404102681574abf3 --- /dev/null +++ b/venv/lib/python3.10/site-packages/cffi/cffi_opcode.py @@ -0,0 +1,187 @@ +from .error import VerificationError + +class CffiOp(object): + def __init__(self, op, arg): + self.op = op + self.arg = arg + + def as_c_expr(self): + if self.op is None: + assert isinstance(self.arg, str) + return '(_cffi_opcode_t)(%s)' % (self.arg,) + classname = CLASS_NAME[self.op] + return '_CFFI_OP(_CFFI_OP_%s, %s)' % (classname, self.arg) + + def as_python_bytes(self): + if self.op is None and self.arg.isdigit(): + value = int(self.arg) # non-negative: '-' not in self.arg + if value >= 2**31: + raise OverflowError("cannot emit %r: limited to 2**31-1" + % (self.arg,)) + return format_four_bytes(value) + if isinstance(self.arg, str): + raise VerificationError("cannot emit to Python: %r" % (self.arg,)) + return format_four_bytes((self.arg << 8) | self.op) + + def __str__(self): + classname = CLASS_NAME.get(self.op, self.op) + return '(%s %s)' % (classname, self.arg) + +def format_four_bytes(num): + return '\\x%02X\\x%02X\\x%02X\\x%02X' % ( + (num >> 24) & 0xFF, + (num >> 16) & 0xFF, + (num >> 8) & 0xFF, + (num ) & 0xFF) + +OP_PRIMITIVE = 1 +OP_POINTER = 3 +OP_ARRAY = 5 +OP_OPEN_ARRAY = 7 +OP_STRUCT_UNION = 9 +OP_ENUM = 11 +OP_FUNCTION = 13 +OP_FUNCTION_END = 15 +OP_NOOP = 17 +OP_BITFIELD = 19 +OP_TYPENAME = 21 +OP_CPYTHON_BLTN_V = 23 # varargs +OP_CPYTHON_BLTN_N = 25 # noargs +OP_CPYTHON_BLTN_O = 27 # O (i.e. a single arg) +OP_CONSTANT = 29 +OP_CONSTANT_INT = 31 +OP_GLOBAL_VAR = 33 +OP_DLOPEN_FUNC = 35 +OP_DLOPEN_CONST = 37 +OP_GLOBAL_VAR_F = 39 +OP_EXTERN_PYTHON = 41 + +PRIM_VOID = 0 +PRIM_BOOL = 1 +PRIM_CHAR = 2 +PRIM_SCHAR = 3 +PRIM_UCHAR = 4 +PRIM_SHORT = 5 +PRIM_USHORT = 6 +PRIM_INT = 7 +PRIM_UINT = 8 +PRIM_LONG = 9 +PRIM_ULONG = 10 +PRIM_LONGLONG = 11 +PRIM_ULONGLONG = 12 +PRIM_FLOAT = 13 +PRIM_DOUBLE = 14 +PRIM_LONGDOUBLE = 15 + +PRIM_WCHAR = 16 +PRIM_INT8 = 17 +PRIM_UINT8 = 18 +PRIM_INT16 = 19 +PRIM_UINT16 = 20 +PRIM_INT32 = 21 +PRIM_UINT32 = 22 +PRIM_INT64 = 23 +PRIM_UINT64 = 24 +PRIM_INTPTR = 25 +PRIM_UINTPTR = 26 +PRIM_PTRDIFF = 27 +PRIM_SIZE = 28 +PRIM_SSIZE = 29 +PRIM_INT_LEAST8 = 30 +PRIM_UINT_LEAST8 = 31 +PRIM_INT_LEAST16 = 32 +PRIM_UINT_LEAST16 = 33 +PRIM_INT_LEAST32 = 34 +PRIM_UINT_LEAST32 = 35 +PRIM_INT_LEAST64 = 36 +PRIM_UINT_LEAST64 = 37 +PRIM_INT_FAST8 = 38 +PRIM_UINT_FAST8 = 39 +PRIM_INT_FAST16 = 40 +PRIM_UINT_FAST16 = 41 +PRIM_INT_FAST32 = 42 +PRIM_UINT_FAST32 = 43 +PRIM_INT_FAST64 = 44 +PRIM_UINT_FAST64 = 45 +PRIM_INTMAX = 46 +PRIM_UINTMAX = 47 +PRIM_FLOATCOMPLEX = 48 +PRIM_DOUBLECOMPLEX = 49 +PRIM_CHAR16 = 50 +PRIM_CHAR32 = 51 + +_NUM_PRIM = 52 +_UNKNOWN_PRIM = -1 +_UNKNOWN_FLOAT_PRIM = -2 +_UNKNOWN_LONG_DOUBLE = -3 + +_IO_FILE_STRUCT = -1 + +PRIMITIVE_TO_INDEX = { + 'char': PRIM_CHAR, + 'short': PRIM_SHORT, + 'int': PRIM_INT, + 'long': PRIM_LONG, + 'long long': PRIM_LONGLONG, + 'signed char': PRIM_SCHAR, + 'unsigned char': PRIM_UCHAR, + 'unsigned short': PRIM_USHORT, + 'unsigned int': PRIM_UINT, + 'unsigned long': PRIM_ULONG, + 'unsigned long long': PRIM_ULONGLONG, + 'float': PRIM_FLOAT, + 'double': PRIM_DOUBLE, + 'long double': PRIM_LONGDOUBLE, + '_cffi_float_complex_t': PRIM_FLOATCOMPLEX, + '_cffi_double_complex_t': PRIM_DOUBLECOMPLEX, + '_Bool': PRIM_BOOL, + 'wchar_t': PRIM_WCHAR, + 'char16_t': PRIM_CHAR16, + 'char32_t': PRIM_CHAR32, + 'int8_t': PRIM_INT8, + 'uint8_t': PRIM_UINT8, + 'int16_t': PRIM_INT16, + 'uint16_t': PRIM_UINT16, + 'int32_t': PRIM_INT32, + 'uint32_t': PRIM_UINT32, + 'int64_t': PRIM_INT64, + 'uint64_t': PRIM_UINT64, + 'intptr_t': PRIM_INTPTR, + 'uintptr_t': PRIM_UINTPTR, + 'ptrdiff_t': PRIM_PTRDIFF, + 'size_t': PRIM_SIZE, + 'ssize_t': PRIM_SSIZE, + 'int_least8_t': PRIM_INT_LEAST8, + 'uint_least8_t': PRIM_UINT_LEAST8, + 'int_least16_t': PRIM_INT_LEAST16, + 'uint_least16_t': PRIM_UINT_LEAST16, + 'int_least32_t': PRIM_INT_LEAST32, + 'uint_least32_t': PRIM_UINT_LEAST32, + 'int_least64_t': PRIM_INT_LEAST64, + 'uint_least64_t': PRIM_UINT_LEAST64, + 'int_fast8_t': PRIM_INT_FAST8, + 'uint_fast8_t': PRIM_UINT_FAST8, + 'int_fast16_t': PRIM_INT_FAST16, + 'uint_fast16_t': PRIM_UINT_FAST16, + 'int_fast32_t': PRIM_INT_FAST32, + 'uint_fast32_t': PRIM_UINT_FAST32, + 'int_fast64_t': PRIM_INT_FAST64, + 'uint_fast64_t': PRIM_UINT_FAST64, + 'intmax_t': PRIM_INTMAX, + 'uintmax_t': PRIM_UINTMAX, + } + +F_UNION = 0x01 +F_CHECK_FIELDS = 0x02 +F_PACKED = 0x04 +F_EXTERNAL = 0x08 +F_OPAQUE = 0x10 + +G_FLAGS = dict([('_CFFI_' + _key, globals()[_key]) + for _key in ['F_UNION', 'F_CHECK_FIELDS', 'F_PACKED', + 'F_EXTERNAL', 'F_OPAQUE']]) + +CLASS_NAME = {} +for _name, _value in list(globals().items()): + if _name.startswith('OP_') and isinstance(_value, int): + CLASS_NAME[_value] = _name[3:] diff --git a/venv/lib/python3.10/site-packages/cffi/commontypes.py b/venv/lib/python3.10/site-packages/cffi/commontypes.py new file mode 100644 index 0000000000000000000000000000000000000000..d4dae3517009fc3f7ccaf01d97d10df098700d06 --- /dev/null +++ b/venv/lib/python3.10/site-packages/cffi/commontypes.py @@ -0,0 +1,82 @@ +import sys +from . import model +from .error import FFIError + + +COMMON_TYPES = {} + +try: + # fetch "bool" and all simple Windows types + from _cffi_backend import _get_common_types + _get_common_types(COMMON_TYPES) +except ImportError: + pass + +COMMON_TYPES['FILE'] = model.unknown_type('FILE', '_IO_FILE') +COMMON_TYPES['bool'] = '_Bool' # in case we got ImportError above +COMMON_TYPES['float _Complex'] = '_cffi_float_complex_t' +COMMON_TYPES['double _Complex'] = '_cffi_double_complex_t' + +for _type in model.PrimitiveType.ALL_PRIMITIVE_TYPES: + if _type.endswith('_t'): + COMMON_TYPES[_type] = _type +del _type + +_CACHE = {} + +def resolve_common_type(parser, commontype): + try: + return _CACHE[commontype] + except KeyError: + cdecl = COMMON_TYPES.get(commontype, commontype) + if not isinstance(cdecl, str): + result, quals = cdecl, 0 # cdecl is already a BaseType + elif cdecl in model.PrimitiveType.ALL_PRIMITIVE_TYPES: + result, quals = model.PrimitiveType(cdecl), 0 + elif cdecl == 'set-unicode-needed': + raise FFIError("The Windows type %r is only available after " + "you call ffi.set_unicode()" % (commontype,)) + else: + if commontype == cdecl: + raise FFIError( + "Unsupported type: %r. Please look at " + "http://cffi.readthedocs.io/en/latest/cdef.html#ffi-cdef-limitations " + "and file an issue if you think this type should really " + "be supported." % (commontype,)) + result, quals = parser.parse_type_and_quals(cdecl) # recursive + + assert isinstance(result, model.BaseTypeByIdentity) + _CACHE[commontype] = result, quals + return result, quals + + +# ____________________________________________________________ +# extra types for Windows (most of them are in commontypes.c) + + +def win_common_types(): + return { + "UNICODE_STRING": model.StructType( + "_UNICODE_STRING", + ["Length", + "MaximumLength", + "Buffer"], + [model.PrimitiveType("unsigned short"), + model.PrimitiveType("unsigned short"), + model.PointerType(model.PrimitiveType("wchar_t"))], + [-1, -1, -1]), + "PUNICODE_STRING": "UNICODE_STRING *", + "PCUNICODE_STRING": "const UNICODE_STRING *", + + "TBYTE": "set-unicode-needed", + "TCHAR": "set-unicode-needed", + "LPCTSTR": "set-unicode-needed", + "PCTSTR": "set-unicode-needed", + "LPTSTR": "set-unicode-needed", + "PTSTR": "set-unicode-needed", + "PTBYTE": "set-unicode-needed", + "PTCHAR": "set-unicode-needed", + } + +if sys.platform == 'win32': + COMMON_TYPES.update(win_common_types()) diff --git a/venv/lib/python3.10/site-packages/cffi/cparser.py b/venv/lib/python3.10/site-packages/cffi/cparser.py new file mode 100644 index 0000000000000000000000000000000000000000..dd590d8743d1828eb6139401b2269d173f487b6c --- /dev/null +++ b/venv/lib/python3.10/site-packages/cffi/cparser.py @@ -0,0 +1,1015 @@ +from . import model +from .commontypes import COMMON_TYPES, resolve_common_type +from .error import FFIError, CDefError +try: + from . import _pycparser as pycparser +except ImportError: + import pycparser +import weakref, re, sys + +try: + if sys.version_info < (3,): + import thread as _thread + else: + import _thread + lock = _thread.allocate_lock() +except ImportError: + lock = None + +def _workaround_for_static_import_finders(): + # Issue #392: packaging tools like cx_Freeze can not find these + # because pycparser uses exec dynamic import. This is an obscure + # workaround. This function is never called. + import pycparser.yacctab + import pycparser.lextab + +CDEF_SOURCE_STRING = "" +_r_comment = re.compile(r"/\*.*?\*/|//([^\n\\]|\\.)*?$", + re.DOTALL | re.MULTILINE) +_r_define = re.compile(r"^\s*#\s*define\s+([A-Za-z_][A-Za-z_0-9]*)" + r"\b((?:[^\n\\]|\\.)*?)$", + re.DOTALL | re.MULTILINE) +_r_line_directive = re.compile(r"^[ \t]*#[ \t]*(?:line|\d+)\b.*$", re.MULTILINE) +_r_partial_enum = re.compile(r"=\s*\.\.\.\s*[,}]|\.\.\.\s*\}") +_r_enum_dotdotdot = re.compile(r"__dotdotdot\d+__$") +_r_partial_array = re.compile(r"\[\s*\.\.\.\s*\]") +_r_words = re.compile(r"\w+|\S") +_parser_cache = None +_r_int_literal = re.compile(r"-?0?x?[0-9a-f]+[lu]*$", re.IGNORECASE) +_r_stdcall1 = re.compile(r"\b(__stdcall|WINAPI)\b") +_r_stdcall2 = re.compile(r"[(]\s*(__stdcall|WINAPI)\b") +_r_cdecl = re.compile(r"\b__cdecl\b") +_r_extern_python = re.compile(r'\bextern\s*"' + r'(Python|Python\s*\+\s*C|C\s*\+\s*Python)"\s*.') +_r_star_const_space = re.compile( # matches "* const " + r"[*]\s*((const|volatile|restrict)\b\s*)+") +_r_int_dotdotdot = re.compile(r"(\b(int|long|short|signed|unsigned|char)\s*)+" + r"\.\.\.") +_r_float_dotdotdot = re.compile(r"\b(double|float)\s*\.\.\.") + +def _get_parser(): + global _parser_cache + if _parser_cache is None: + _parser_cache = pycparser.CParser() + return _parser_cache + +def _workaround_for_old_pycparser(csource): + # Workaround for a pycparser issue (fixed between pycparser 2.10 and + # 2.14): "char*const***" gives us a wrong syntax tree, the same as + # for "char***(*const)". This means we can't tell the difference + # afterwards. But "char(*const(***))" gives us the right syntax + # tree. The issue only occurs if there are several stars in + # sequence with no parenthesis in between, just possibly qualifiers. + # Attempt to fix it by adding some parentheses in the source: each + # time we see "* const" or "* const *", we add an opening + # parenthesis before each star---the hard part is figuring out where + # to close them. + parts = [] + while True: + match = _r_star_const_space.search(csource) + if not match: + break + #print repr(''.join(parts)+csource), '=>', + parts.append(csource[:match.start()]) + parts.append('('); closing = ')' + parts.append(match.group()) # e.g. "* const " + endpos = match.end() + if csource.startswith('*', endpos): + parts.append('('); closing += ')' + level = 0 + i = endpos + while i < len(csource): + c = csource[i] + if c == '(': + level += 1 + elif c == ')': + if level == 0: + break + level -= 1 + elif c in ',;=': + if level == 0: + break + i += 1 + csource = csource[endpos:i] + closing + csource[i:] + #print repr(''.join(parts)+csource) + parts.append(csource) + return ''.join(parts) + +def _preprocess_extern_python(csource): + # input: `extern "Python" int foo(int);` or + # `extern "Python" { int foo(int); }` + # output: + # void __cffi_extern_python_start; + # int foo(int); + # void __cffi_extern_python_stop; + # + # input: `extern "Python+C" int foo(int);` + # output: + # void __cffi_extern_python_plus_c_start; + # int foo(int); + # void __cffi_extern_python_stop; + parts = [] + while True: + match = _r_extern_python.search(csource) + if not match: + break + endpos = match.end() - 1 + #print + #print ''.join(parts)+csource + #print '=>' + parts.append(csource[:match.start()]) + if 'C' in match.group(1): + parts.append('void __cffi_extern_python_plus_c_start; ') + else: + parts.append('void __cffi_extern_python_start; ') + if csource[endpos] == '{': + # grouping variant + closing = csource.find('}', endpos) + if closing < 0: + raise CDefError("'extern \"Python\" {': no '}' found") + if csource.find('{', endpos + 1, closing) >= 0: + raise NotImplementedError("cannot use { } inside a block " + "'extern \"Python\" { ... }'") + parts.append(csource[endpos+1:closing]) + csource = csource[closing+1:] + else: + # non-grouping variant + semicolon = csource.find(';', endpos) + if semicolon < 0: + raise CDefError("'extern \"Python\": no ';' found") + parts.append(csource[endpos:semicolon+1]) + csource = csource[semicolon+1:] + parts.append(' void __cffi_extern_python_stop;') + #print ''.join(parts)+csource + #print + parts.append(csource) + return ''.join(parts) + +def _warn_for_string_literal(csource): + if '"' not in csource: + return + for line in csource.splitlines(): + if '"' in line and not line.lstrip().startswith('#'): + import warnings + warnings.warn("String literal found in cdef() or type source. " + "String literals are ignored here, but you should " + "remove them anyway because some character sequences " + "confuse pre-parsing.") + break + +def _warn_for_non_extern_non_static_global_variable(decl): + if not decl.storage: + import warnings + warnings.warn("Global variable '%s' in cdef(): for consistency " + "with C it should have a storage class specifier " + "(usually 'extern')" % (decl.name,)) + +def _remove_line_directives(csource): + # _r_line_directive matches whole lines, without the final \n, if they + # start with '#line' with some spacing allowed, or '#NUMBER'. This + # function stores them away and replaces them with exactly the string + # '#line@N', where N is the index in the list 'line_directives'. + line_directives = [] + def replace(m): + i = len(line_directives) + line_directives.append(m.group()) + return '#line@%d' % i + csource = _r_line_directive.sub(replace, csource) + return csource, line_directives + +def _put_back_line_directives(csource, line_directives): + def replace(m): + s = m.group() + if not s.startswith('#line@'): + raise AssertionError("unexpected #line directive " + "(should have been processed and removed") + return line_directives[int(s[6:])] + return _r_line_directive.sub(replace, csource) + +def _preprocess(csource): + # First, remove the lines of the form '#line N "filename"' because + # the "filename" part could confuse the rest + csource, line_directives = _remove_line_directives(csource) + # Remove comments. NOTE: this only work because the cdef() section + # should not contain any string literals (except in line directives)! + def replace_keeping_newlines(m): + return ' ' + m.group().count('\n') * '\n' + csource = _r_comment.sub(replace_keeping_newlines, csource) + # Remove the "#define FOO x" lines + macros = {} + for match in _r_define.finditer(csource): + macroname, macrovalue = match.groups() + macrovalue = macrovalue.replace('\\\n', '').strip() + macros[macroname] = macrovalue + csource = _r_define.sub('', csource) + # + if pycparser.__version__ < '2.14': + csource = _workaround_for_old_pycparser(csource) + # + # BIG HACK: replace WINAPI or __stdcall with "volatile const". + # It doesn't make sense for the return type of a function to be + # "volatile volatile const", so we abuse it to detect __stdcall... + # Hack number 2 is that "int(volatile *fptr)();" is not valid C + # syntax, so we place the "volatile" before the opening parenthesis. + csource = _r_stdcall2.sub(' volatile volatile const(', csource) + csource = _r_stdcall1.sub(' volatile volatile const ', csource) + csource = _r_cdecl.sub(' ', csource) + # + # Replace `extern "Python"` with start/end markers + csource = _preprocess_extern_python(csource) + # + # Now there should not be any string literal left; warn if we get one + _warn_for_string_literal(csource) + # + # Replace "[...]" with "[__dotdotdotarray__]" + csource = _r_partial_array.sub('[__dotdotdotarray__]', csource) + # + # Replace "...}" with "__dotdotdotNUM__}". This construction should + # occur only at the end of enums; at the end of structs we have "...;}" + # and at the end of vararg functions "...);". Also replace "=...[,}]" + # with ",__dotdotdotNUM__[,}]": this occurs in the enums too, when + # giving an unknown value. + matches = list(_r_partial_enum.finditer(csource)) + for number, match in enumerate(reversed(matches)): + p = match.start() + if csource[p] == '=': + p2 = csource.find('...', p, match.end()) + assert p2 > p + csource = '%s,__dotdotdot%d__ %s' % (csource[:p], number, + csource[p2+3:]) + else: + assert csource[p:p+3] == '...' + csource = '%s __dotdotdot%d__ %s' % (csource[:p], number, + csource[p+3:]) + # Replace "int ..." or "unsigned long int..." with "__dotdotdotint__" + csource = _r_int_dotdotdot.sub(' __dotdotdotint__ ', csource) + # Replace "float ..." or "double..." with "__dotdotdotfloat__" + csource = _r_float_dotdotdot.sub(' __dotdotdotfloat__ ', csource) + # Replace all remaining "..." with the same name, "__dotdotdot__", + # which is declared with a typedef for the purpose of C parsing. + csource = csource.replace('...', ' __dotdotdot__ ') + # Finally, put back the line directives + csource = _put_back_line_directives(csource, line_directives) + return csource, macros + +def _common_type_names(csource): + # Look in the source for what looks like usages of types from the + # list of common types. A "usage" is approximated here as the + # appearance of the word, minus a "definition" of the type, which + # is the last word in a "typedef" statement. Approximative only + # but should be fine for all the common types. + look_for_words = set(COMMON_TYPES) + look_for_words.add(';') + look_for_words.add(',') + look_for_words.add('(') + look_for_words.add(')') + look_for_words.add('typedef') + words_used = set() + is_typedef = False + paren = 0 + previous_word = '' + for word in _r_words.findall(csource): + if word in look_for_words: + if word == ';': + if is_typedef: + words_used.discard(previous_word) + look_for_words.discard(previous_word) + is_typedef = False + elif word == 'typedef': + is_typedef = True + paren = 0 + elif word == '(': + paren += 1 + elif word == ')': + paren -= 1 + elif word == ',': + if is_typedef and paren == 0: + words_used.discard(previous_word) + look_for_words.discard(previous_word) + else: # word in COMMON_TYPES + words_used.add(word) + previous_word = word + return words_used + + +class Parser(object): + + def __init__(self): + self._declarations = {} + self._included_declarations = set() + self._anonymous_counter = 0 + self._structnode2type = weakref.WeakKeyDictionary() + self._options = {} + self._int_constants = {} + self._recomplete = [] + self._uses_new_feature = None + + def _parse(self, csource): + csource, macros = _preprocess(csource) + # XXX: for more efficiency we would need to poke into the + # internals of CParser... the following registers the + # typedefs, because their presence or absence influences the + # parsing itself (but what they are typedef'ed to plays no role) + ctn = _common_type_names(csource) + typenames = [] + for name in sorted(self._declarations): + if name.startswith('typedef '): + name = name[8:] + typenames.append(name) + ctn.discard(name) + typenames += sorted(ctn) + # + csourcelines = [] + csourcelines.append('# 1 ""') + for typename in typenames: + csourcelines.append('typedef int %s;' % typename) + csourcelines.append('typedef int __dotdotdotint__, __dotdotdotfloat__,' + ' __dotdotdot__;') + # this forces pycparser to consider the following in the file + # called from line 1 + csourcelines.append('# 1 "%s"' % (CDEF_SOURCE_STRING,)) + csourcelines.append(csource) + csourcelines.append('') # see test_missing_newline_bug + fullcsource = '\n'.join(csourcelines) + if lock is not None: + lock.acquire() # pycparser is not thread-safe... + try: + ast = _get_parser().parse(fullcsource) + except pycparser.c_parser.ParseError as e: + self.convert_pycparser_error(e, csource) + finally: + if lock is not None: + lock.release() + # csource will be used to find buggy source text + return ast, macros, csource + + def _convert_pycparser_error(self, e, csource): + # xxx look for ":NUM:" at the start of str(e) + # and interpret that as a line number. This will not work if + # the user gives explicit ``# NUM "FILE"`` directives. + line = None + msg = str(e) + match = re.match(r"%s:(\d+):" % (CDEF_SOURCE_STRING,), msg) + if match: + linenum = int(match.group(1), 10) + csourcelines = csource.splitlines() + if 1 <= linenum <= len(csourcelines): + line = csourcelines[linenum-1] + return line + + def convert_pycparser_error(self, e, csource): + line = self._convert_pycparser_error(e, csource) + + msg = str(e) + if line: + msg = 'cannot parse "%s"\n%s' % (line.strip(), msg) + else: + msg = 'parse error\n%s' % (msg,) + raise CDefError(msg) + + def parse(self, csource, override=False, packed=False, pack=None, + dllexport=False): + if packed: + if packed != True: + raise ValueError("'packed' should be False or True; use " + "'pack' to give another value") + if pack: + raise ValueError("cannot give both 'pack' and 'packed'") + pack = 1 + elif pack: + if pack & (pack - 1): + raise ValueError("'pack' must be a power of two, not %r" % + (pack,)) + else: + pack = 0 + prev_options = self._options + try: + self._options = {'override': override, + 'packed': pack, + 'dllexport': dllexport} + self._internal_parse(csource) + finally: + self._options = prev_options + + def _internal_parse(self, csource): + ast, macros, csource = self._parse(csource) + # add the macros + self._process_macros(macros) + # find the first "__dotdotdot__" and use that as a separator + # between the repeated typedefs and the real csource + iterator = iter(ast.ext) + for decl in iterator: + if decl.name == '__dotdotdot__': + break + else: + assert 0 + current_decl = None + # + try: + self._inside_extern_python = '__cffi_extern_python_stop' + for decl in iterator: + current_decl = decl + if isinstance(decl, pycparser.c_ast.Decl): + self._parse_decl(decl) + elif isinstance(decl, pycparser.c_ast.Typedef): + if not decl.name: + raise CDefError("typedef does not declare any name", + decl) + quals = 0 + if (isinstance(decl.type.type, pycparser.c_ast.IdentifierType) and + decl.type.type.names[-1].startswith('__dotdotdot')): + realtype = self._get_unknown_type(decl) + elif (isinstance(decl.type, pycparser.c_ast.PtrDecl) and + isinstance(decl.type.type, pycparser.c_ast.TypeDecl) and + isinstance(decl.type.type.type, + pycparser.c_ast.IdentifierType) and + decl.type.type.type.names[-1].startswith('__dotdotdot')): + realtype = self._get_unknown_ptr_type(decl) + else: + realtype, quals = self._get_type_and_quals( + decl.type, name=decl.name, partial_length_ok=True, + typedef_example="*(%s *)0" % (decl.name,)) + self._declare('typedef ' + decl.name, realtype, quals=quals) + elif decl.__class__.__name__ == 'Pragma': + # skip pragma, only in pycparser 2.15 + import warnings + warnings.warn( + "#pragma in cdef() are entirely ignored. " + "They should be removed for now, otherwise your " + "code might behave differently in a future version " + "of CFFI if #pragma support gets added. Note that " + "'#pragma pack' needs to be replaced with the " + "'packed' keyword argument to cdef().") + else: + raise CDefError("unexpected <%s>: this construct is valid " + "C but not valid in cdef()" % + decl.__class__.__name__, decl) + except CDefError as e: + if len(e.args) == 1: + e.args = e.args + (current_decl,) + raise + except FFIError as e: + msg = self._convert_pycparser_error(e, csource) + if msg: + e.args = (e.args[0] + "\n *** Err: %s" % msg,) + raise + + def _add_constants(self, key, val): + if key in self._int_constants: + if self._int_constants[key] == val: + return # ignore identical double declarations + raise FFIError( + "multiple declarations of constant: %s" % (key,)) + self._int_constants[key] = val + + def _add_integer_constant(self, name, int_str): + int_str = int_str.lower().rstrip("ul") + neg = int_str.startswith('-') + if neg: + int_str = int_str[1:] + # "010" is not valid oct in py3 + if (int_str.startswith("0") and int_str != '0' + and not int_str.startswith("0x")): + int_str = "0o" + int_str[1:] + pyvalue = int(int_str, 0) + if neg: + pyvalue = -pyvalue + self._add_constants(name, pyvalue) + self._declare('macro ' + name, pyvalue) + + def _process_macros(self, macros): + for key, value in macros.items(): + value = value.strip() + if _r_int_literal.match(value): + self._add_integer_constant(key, value) + elif value == '...': + self._declare('macro ' + key, value) + else: + raise CDefError( + 'only supports one of the following syntax:\n' + ' #define %s ... (literally dot-dot-dot)\n' + ' #define %s NUMBER (with NUMBER an integer' + ' constant, decimal/hex/octal)\n' + 'got:\n' + ' #define %s %s' + % (key, key, key, value)) + + def _declare_function(self, tp, quals, decl): + tp = self._get_type_pointer(tp, quals) + if self._options.get('dllexport'): + tag = 'dllexport_python ' + elif self._inside_extern_python == '__cffi_extern_python_start': + tag = 'extern_python ' + elif self._inside_extern_python == '__cffi_extern_python_plus_c_start': + tag = 'extern_python_plus_c ' + else: + tag = 'function ' + self._declare(tag + decl.name, tp) + + def _parse_decl(self, decl): + node = decl.type + if isinstance(node, pycparser.c_ast.FuncDecl): + tp, quals = self._get_type_and_quals(node, name=decl.name) + assert isinstance(tp, model.RawFunctionType) + self._declare_function(tp, quals, decl) + else: + if isinstance(node, pycparser.c_ast.Struct): + self._get_struct_union_enum_type('struct', node) + elif isinstance(node, pycparser.c_ast.Union): + self._get_struct_union_enum_type('union', node) + elif isinstance(node, pycparser.c_ast.Enum): + self._get_struct_union_enum_type('enum', node) + elif not decl.name: + raise CDefError("construct does not declare any variable", + decl) + # + if decl.name: + tp, quals = self._get_type_and_quals(node, + partial_length_ok=True) + if tp.is_raw_function: + self._declare_function(tp, quals, decl) + elif (tp.is_integer_type() and + hasattr(decl, 'init') and + hasattr(decl.init, 'value') and + _r_int_literal.match(decl.init.value)): + self._add_integer_constant(decl.name, decl.init.value) + elif (tp.is_integer_type() and + isinstance(decl.init, pycparser.c_ast.UnaryOp) and + decl.init.op == '-' and + hasattr(decl.init.expr, 'value') and + _r_int_literal.match(decl.init.expr.value)): + self._add_integer_constant(decl.name, + '-' + decl.init.expr.value) + elif (tp is model.void_type and + decl.name.startswith('__cffi_extern_python_')): + # hack: `extern "Python"` in the C source is replaced + # with "void __cffi_extern_python_start;" and + # "void __cffi_extern_python_stop;" + self._inside_extern_python = decl.name + else: + if self._inside_extern_python !='__cffi_extern_python_stop': + raise CDefError( + "cannot declare constants or " + "variables with 'extern \"Python\"'") + if (quals & model.Q_CONST) and not tp.is_array_type: + self._declare('constant ' + decl.name, tp, quals=quals) + else: + _warn_for_non_extern_non_static_global_variable(decl) + self._declare('variable ' + decl.name, tp, quals=quals) + + def parse_type(self, cdecl): + return self.parse_type_and_quals(cdecl)[0] + + def parse_type_and_quals(self, cdecl): + ast, macros = self._parse('void __dummy(\n%s\n);' % cdecl)[:2] + assert not macros + exprnode = ast.ext[-1].type.args.params[0] + if isinstance(exprnode, pycparser.c_ast.ID): + raise CDefError("unknown identifier '%s'" % (exprnode.name,)) + return self._get_type_and_quals(exprnode.type) + + def _declare(self, name, obj, included=False, quals=0): + if name in self._declarations: + prevobj, prevquals = self._declarations[name] + if prevobj is obj and prevquals == quals: + return + if not self._options.get('override'): + raise FFIError( + "multiple declarations of %s (for interactive usage, " + "try cdef(xx, override=True))" % (name,)) + assert '__dotdotdot__' not in name.split() + self._declarations[name] = (obj, quals) + if included: + self._included_declarations.add(obj) + + def _extract_quals(self, type): + quals = 0 + if isinstance(type, (pycparser.c_ast.TypeDecl, + pycparser.c_ast.PtrDecl)): + if 'const' in type.quals: + quals |= model.Q_CONST + if 'volatile' in type.quals: + quals |= model.Q_VOLATILE + if 'restrict' in type.quals: + quals |= model.Q_RESTRICT + return quals + + def _get_type_pointer(self, type, quals, declname=None): + if isinstance(type, model.RawFunctionType): + return type.as_function_pointer() + if (isinstance(type, model.StructOrUnionOrEnum) and + type.name.startswith('$') and type.name[1:].isdigit() and + type.forcename is None and declname is not None): + return model.NamedPointerType(type, declname, quals) + return model.PointerType(type, quals) + + def _get_type_and_quals(self, typenode, name=None, partial_length_ok=False, + typedef_example=None): + # first, dereference typedefs, if we have it already parsed, we're good + if (isinstance(typenode, pycparser.c_ast.TypeDecl) and + isinstance(typenode.type, pycparser.c_ast.IdentifierType) and + len(typenode.type.names) == 1 and + ('typedef ' + typenode.type.names[0]) in self._declarations): + tp, quals = self._declarations['typedef ' + typenode.type.names[0]] + quals |= self._extract_quals(typenode) + return tp, quals + # + if isinstance(typenode, pycparser.c_ast.ArrayDecl): + # array type + if typenode.dim is None: + length = None + else: + length = self._parse_constant( + typenode.dim, partial_length_ok=partial_length_ok) + # a hack: in 'typedef int foo_t[...][...];', don't use '...' as + # the length but use directly the C expression that would be + # generated by recompiler.py. This lets the typedef be used in + # many more places within recompiler.py + if typedef_example is not None: + if length == '...': + length = '_cffi_array_len(%s)' % (typedef_example,) + typedef_example = "*" + typedef_example + # + tp, quals = self._get_type_and_quals(typenode.type, + partial_length_ok=partial_length_ok, + typedef_example=typedef_example) + return model.ArrayType(tp, length), quals + # + if isinstance(typenode, pycparser.c_ast.PtrDecl): + # pointer type + itemtype, itemquals = self._get_type_and_quals(typenode.type) + tp = self._get_type_pointer(itemtype, itemquals, declname=name) + quals = self._extract_quals(typenode) + return tp, quals + # + if isinstance(typenode, pycparser.c_ast.TypeDecl): + quals = self._extract_quals(typenode) + type = typenode.type + if isinstance(type, pycparser.c_ast.IdentifierType): + # assume a primitive type. get it from .names, but reduce + # synonyms to a single chosen combination + names = list(type.names) + if names != ['signed', 'char']: # keep this unmodified + prefixes = {} + while names: + name = names[0] + if name in ('short', 'long', 'signed', 'unsigned'): + prefixes[name] = prefixes.get(name, 0) + 1 + del names[0] + else: + break + # ignore the 'signed' prefix below, and reorder the others + newnames = [] + for prefix in ('unsigned', 'short', 'long'): + for i in range(prefixes.get(prefix, 0)): + newnames.append(prefix) + if not names: + names = ['int'] # implicitly + if names == ['int']: # but kill it if 'short' or 'long' + if 'short' in prefixes or 'long' in prefixes: + names = [] + names = newnames + names + ident = ' '.join(names) + if ident == 'void': + return model.void_type, quals + if ident == '__dotdotdot__': + raise FFIError(':%d: bad usage of "..."' % + typenode.coord.line) + tp0, quals0 = resolve_common_type(self, ident) + return tp0, (quals | quals0) + # + if isinstance(type, pycparser.c_ast.Struct): + # 'struct foobar' + tp = self._get_struct_union_enum_type('struct', type, name) + return tp, quals + # + if isinstance(type, pycparser.c_ast.Union): + # 'union foobar' + tp = self._get_struct_union_enum_type('union', type, name) + return tp, quals + # + if isinstance(type, pycparser.c_ast.Enum): + # 'enum foobar' + tp = self._get_struct_union_enum_type('enum', type, name) + return tp, quals + # + if isinstance(typenode, pycparser.c_ast.FuncDecl): + # a function type + return self._parse_function_type(typenode, name), 0 + # + # nested anonymous structs or unions end up here + if isinstance(typenode, pycparser.c_ast.Struct): + return self._get_struct_union_enum_type('struct', typenode, name, + nested=True), 0 + if isinstance(typenode, pycparser.c_ast.Union): + return self._get_struct_union_enum_type('union', typenode, name, + nested=True), 0 + # + raise FFIError(":%d: bad or unsupported type declaration" % + typenode.coord.line) + + def _parse_function_type(self, typenode, funcname=None): + params = list(getattr(typenode.args, 'params', [])) + for i, arg in enumerate(params): + if not hasattr(arg, 'type'): + raise CDefError("%s arg %d: unknown type '%s'" + " (if you meant to use the old C syntax of giving" + " untyped arguments, it is not supported)" + % (funcname or 'in expression', i + 1, + getattr(arg, 'name', '?'))) + ellipsis = ( + len(params) > 0 and + isinstance(params[-1].type, pycparser.c_ast.TypeDecl) and + isinstance(params[-1].type.type, + pycparser.c_ast.IdentifierType) and + params[-1].type.type.names == ['__dotdotdot__']) + if ellipsis: + params.pop() + if not params: + raise CDefError( + "%s: a function with only '(...)' as argument" + " is not correct C" % (funcname or 'in expression')) + args = [self._as_func_arg(*self._get_type_and_quals(argdeclnode.type)) + for argdeclnode in params] + if not ellipsis and args == [model.void_type]: + args = [] + result, quals = self._get_type_and_quals(typenode.type) + # the 'quals' on the result type are ignored. HACK: we absure them + # to detect __stdcall functions: we textually replace "__stdcall" + # with "volatile volatile const" above. + abi = None + if hasattr(typenode.type, 'quals'): # else, probable syntax error anyway + if typenode.type.quals[-3:] == ['volatile', 'volatile', 'const']: + abi = '__stdcall' + return model.RawFunctionType(tuple(args), result, ellipsis, abi) + + def _as_func_arg(self, type, quals): + if isinstance(type, model.ArrayType): + return model.PointerType(type.item, quals) + elif isinstance(type, model.RawFunctionType): + return type.as_function_pointer() + else: + return type + + def _get_struct_union_enum_type(self, kind, type, name=None, nested=False): + # First, a level of caching on the exact 'type' node of the AST. + # This is obscure, but needed because pycparser "unrolls" declarations + # such as "typedef struct { } foo_t, *foo_p" and we end up with + # an AST that is not a tree, but a DAG, with the "type" node of the + # two branches foo_t and foo_p of the trees being the same node. + # It's a bit silly but detecting "DAG-ness" in the AST tree seems + # to be the only way to distinguish this case from two independent + # structs. See test_struct_with_two_usages. + try: + return self._structnode2type[type] + except KeyError: + pass + # + # Note that this must handle parsing "struct foo" any number of + # times and always return the same StructType object. Additionally, + # one of these times (not necessarily the first), the fields of + # the struct can be specified with "struct foo { ...fields... }". + # If no name is given, then we have to create a new anonymous struct + # with no caching; in this case, the fields are either specified + # right now or never. + # + force_name = name + name = type.name + # + # get the type or create it if needed + if name is None: + # 'force_name' is used to guess a more readable name for + # anonymous structs, for the common case "typedef struct { } foo". + if force_name is not None: + explicit_name = '$%s' % force_name + else: + self._anonymous_counter += 1 + explicit_name = '$%d' % self._anonymous_counter + tp = None + else: + explicit_name = name + key = '%s %s' % (kind, name) + tp, _ = self._declarations.get(key, (None, None)) + # + if tp is None: + if kind == 'struct': + tp = model.StructType(explicit_name, None, None, None) + elif kind == 'union': + tp = model.UnionType(explicit_name, None, None, None) + elif kind == 'enum': + if explicit_name == '__dotdotdot__': + raise CDefError("Enums cannot be declared with ...") + tp = self._build_enum_type(explicit_name, type.values) + else: + raise AssertionError("kind = %r" % (kind,)) + if name is not None: + self._declare(key, tp) + else: + if kind == 'enum' and type.values is not None: + raise NotImplementedError( + "enum %s: the '{}' declaration should appear on the first " + "time the enum is mentioned, not later" % explicit_name) + if not tp.forcename: + tp.force_the_name(force_name) + if tp.forcename and '$' in tp.name: + self._declare('anonymous %s' % tp.forcename, tp) + # + self._structnode2type[type] = tp + # + # enums: done here + if kind == 'enum': + return tp + # + # is there a 'type.decls'? If yes, then this is the place in the + # C sources that declare the fields. If no, then just return the + # existing type, possibly still incomplete. + if type.decls is None: + return tp + # + if tp.fldnames is not None: + raise CDefError("duplicate declaration of struct %s" % name) + fldnames = [] + fldtypes = [] + fldbitsize = [] + fldquals = [] + for decl in type.decls: + if (isinstance(decl.type, pycparser.c_ast.IdentifierType) and + ''.join(decl.type.names) == '__dotdotdot__'): + # XXX pycparser is inconsistent: 'names' should be a list + # of strings, but is sometimes just one string. Use + # str.join() as a way to cope with both. + self._make_partial(tp, nested) + continue + if decl.bitsize is None: + bitsize = -1 + else: + bitsize = self._parse_constant(decl.bitsize) + self._partial_length = False + type, fqual = self._get_type_and_quals(decl.type, + partial_length_ok=True) + if self._partial_length: + self._make_partial(tp, nested) + if isinstance(type, model.StructType) and type.partial: + self._make_partial(tp, nested) + fldnames.append(decl.name or '') + fldtypes.append(type) + fldbitsize.append(bitsize) + fldquals.append(fqual) + tp.fldnames = tuple(fldnames) + tp.fldtypes = tuple(fldtypes) + tp.fldbitsize = tuple(fldbitsize) + tp.fldquals = tuple(fldquals) + if fldbitsize != [-1] * len(fldbitsize): + if isinstance(tp, model.StructType) and tp.partial: + raise NotImplementedError("%s: using both bitfields and '...;'" + % (tp,)) + tp.packed = self._options.get('packed') + if tp.completed: # must be re-completed: it is not opaque any more + tp.completed = 0 + self._recomplete.append(tp) + return tp + + def _make_partial(self, tp, nested): + if not isinstance(tp, model.StructOrUnion): + raise CDefError("%s cannot be partial" % (tp,)) + if not tp.has_c_name() and not nested: + raise NotImplementedError("%s is partial but has no C name" %(tp,)) + tp.partial = True + + def _parse_constant(self, exprnode, partial_length_ok=False): + # for now, limited to expressions that are an immediate number + # or positive/negative number + if isinstance(exprnode, pycparser.c_ast.Constant): + s = exprnode.value + if '0' <= s[0] <= '9': + s = s.rstrip('uUlL') + try: + if s.startswith('0'): + return int(s, 8) + else: + return int(s, 10) + except ValueError: + if len(s) > 1: + if s.lower()[0:2] == '0x': + return int(s, 16) + elif s.lower()[0:2] == '0b': + return int(s, 2) + raise CDefError("invalid constant %r" % (s,)) + elif s[0] == "'" and s[-1] == "'" and ( + len(s) == 3 or (len(s) == 4 and s[1] == "\\")): + return ord(s[-2]) + else: + raise CDefError("invalid constant %r" % (s,)) + # + if (isinstance(exprnode, pycparser.c_ast.UnaryOp) and + exprnode.op == '+'): + return self._parse_constant(exprnode.expr) + # + if (isinstance(exprnode, pycparser.c_ast.UnaryOp) and + exprnode.op == '-'): + return -self._parse_constant(exprnode.expr) + # load previously defined int constant + if (isinstance(exprnode, pycparser.c_ast.ID) and + exprnode.name in self._int_constants): + return self._int_constants[exprnode.name] + # + if (isinstance(exprnode, pycparser.c_ast.ID) and + exprnode.name == '__dotdotdotarray__'): + if partial_length_ok: + self._partial_length = True + return '...' + raise FFIError(":%d: unsupported '[...]' here, cannot derive " + "the actual array length in this context" + % exprnode.coord.line) + # + if isinstance(exprnode, pycparser.c_ast.BinaryOp): + left = self._parse_constant(exprnode.left) + right = self._parse_constant(exprnode.right) + if exprnode.op == '+': + return left + right + elif exprnode.op == '-': + return left - right + elif exprnode.op == '*': + return left * right + elif exprnode.op == '/': + return self._c_div(left, right) + elif exprnode.op == '%': + return left - self._c_div(left, right) * right + elif exprnode.op == '<<': + return left << right + elif exprnode.op == '>>': + return left >> right + elif exprnode.op == '&': + return left & right + elif exprnode.op == '|': + return left | right + elif exprnode.op == '^': + return left ^ right + # + raise FFIError(":%d: unsupported expression: expected a " + "simple numeric constant" % exprnode.coord.line) + + def _c_div(self, a, b): + result = a // b + if ((a < 0) ^ (b < 0)) and (a % b) != 0: + result += 1 + return result + + def _build_enum_type(self, explicit_name, decls): + if decls is not None: + partial = False + enumerators = [] + enumvalues = [] + nextenumvalue = 0 + for enum in decls.enumerators: + if _r_enum_dotdotdot.match(enum.name): + partial = True + continue + if enum.value is not None: + nextenumvalue = self._parse_constant(enum.value) + enumerators.append(enum.name) + enumvalues.append(nextenumvalue) + self._add_constants(enum.name, nextenumvalue) + nextenumvalue += 1 + enumerators = tuple(enumerators) + enumvalues = tuple(enumvalues) + tp = model.EnumType(explicit_name, enumerators, enumvalues) + tp.partial = partial + else: # opaque enum + tp = model.EnumType(explicit_name, (), ()) + return tp + + def include(self, other): + for name, (tp, quals) in other._declarations.items(): + if name.startswith('anonymous $enum_$'): + continue # fix for test_anonymous_enum_include + kind = name.split(' ', 1)[0] + if kind in ('struct', 'union', 'enum', 'anonymous', 'typedef'): + self._declare(name, tp, included=True, quals=quals) + for k, v in other._int_constants.items(): + self._add_constants(k, v) + + def _get_unknown_type(self, decl): + typenames = decl.type.type.names + if typenames == ['__dotdotdot__']: + return model.unknown_type(decl.name) + + if typenames == ['__dotdotdotint__']: + if self._uses_new_feature is None: + self._uses_new_feature = "'typedef int... %s'" % decl.name + return model.UnknownIntegerType(decl.name) + + if typenames == ['__dotdotdotfloat__']: + # note: not for 'long double' so far + if self._uses_new_feature is None: + self._uses_new_feature = "'typedef float... %s'" % decl.name + return model.UnknownFloatType(decl.name) + + raise FFIError(':%d: unsupported usage of "..." in typedef' + % decl.coord.line) + + def _get_unknown_ptr_type(self, decl): + if decl.type.type.type.names == ['__dotdotdot__']: + return model.unknown_ptr_type(decl.name) + raise FFIError(':%d: unsupported usage of "..." in typedef' + % decl.coord.line) diff --git a/venv/lib/python3.10/site-packages/cffi/error.py b/venv/lib/python3.10/site-packages/cffi/error.py new file mode 100644 index 0000000000000000000000000000000000000000..0a27247c32a381ab7cecedd0f985b781619c1ea5 --- /dev/null +++ b/venv/lib/python3.10/site-packages/cffi/error.py @@ -0,0 +1,31 @@ + +class FFIError(Exception): + __module__ = 'cffi' + +class CDefError(Exception): + __module__ = 'cffi' + def __str__(self): + try: + current_decl = self.args[1] + filename = current_decl.coord.file + linenum = current_decl.coord.line + prefix = '%s:%d: ' % (filename, linenum) + except (AttributeError, TypeError, IndexError): + prefix = '' + return '%s%s' % (prefix, self.args[0]) + +class VerificationError(Exception): + """ An error raised when verification fails + """ + __module__ = 'cffi' + +class VerificationMissing(Exception): + """ An error raised when incomplete structures are passed into + cdef, but no verification has been done + """ + __module__ = 'cffi' + +class PkgConfigError(Exception): + """ An error raised for missing modules in pkg-config + """ + __module__ = 'cffi' diff --git a/venv/lib/python3.10/site-packages/cffi/ffiplatform.py b/venv/lib/python3.10/site-packages/cffi/ffiplatform.py new file mode 100644 index 0000000000000000000000000000000000000000..adca28f1a480bb04a11977d26457fe8886139043 --- /dev/null +++ b/venv/lib/python3.10/site-packages/cffi/ffiplatform.py @@ -0,0 +1,113 @@ +import sys, os +from .error import VerificationError + + +LIST_OF_FILE_NAMES = ['sources', 'include_dirs', 'library_dirs', + 'extra_objects', 'depends'] + +def get_extension(srcfilename, modname, sources=(), **kwds): + from cffi._shimmed_dist_utils import Extension + allsources = [srcfilename] + for src in sources: + allsources.append(os.path.normpath(src)) + return Extension(name=modname, sources=allsources, **kwds) + +def compile(tmpdir, ext, compiler_verbose=0, debug=None): + """Compile a C extension module using distutils.""" + + saved_environ = os.environ.copy() + try: + outputfilename = _build(tmpdir, ext, compiler_verbose, debug) + outputfilename = os.path.abspath(outputfilename) + finally: + # workaround for a distutils bugs where some env vars can + # become longer and longer every time it is used + for key, value in saved_environ.items(): + if os.environ.get(key) != value: + os.environ[key] = value + return outputfilename + +def _build(tmpdir, ext, compiler_verbose=0, debug=None): + # XXX compact but horrible :-( + from cffi._shimmed_dist_utils import Distribution, CompileError, LinkError, set_threshold, set_verbosity + + dist = Distribution({'ext_modules': [ext]}) + dist.parse_config_files() + options = dist.get_option_dict('build_ext') + if debug is None: + debug = sys.flags.debug + options['debug'] = ('ffiplatform', debug) + options['force'] = ('ffiplatform', True) + options['build_lib'] = ('ffiplatform', tmpdir) + options['build_temp'] = ('ffiplatform', tmpdir) + # + try: + old_level = set_threshold(0) or 0 + try: + set_verbosity(compiler_verbose) + dist.run_command('build_ext') + cmd_obj = dist.get_command_obj('build_ext') + [soname] = cmd_obj.get_outputs() + finally: + set_threshold(old_level) + except (CompileError, LinkError) as e: + raise VerificationError('%s: %s' % (e.__class__.__name__, e)) + # + return soname + +try: + from os.path import samefile +except ImportError: + def samefile(f1, f2): + return os.path.abspath(f1) == os.path.abspath(f2) + +def maybe_relative_path(path): + if not os.path.isabs(path): + return path # already relative + dir = path + names = [] + while True: + prevdir = dir + dir, name = os.path.split(prevdir) + if dir == prevdir or not dir: + return path # failed to make it relative + names.append(name) + try: + if samefile(dir, os.curdir): + names.reverse() + return os.path.join(*names) + except OSError: + pass + +# ____________________________________________________________ + +try: + int_or_long = (int, long) + import cStringIO +except NameError: + int_or_long = int # Python 3 + import io as cStringIO + +def _flatten(x, f): + if isinstance(x, str): + f.write('%ds%s' % (len(x), x)) + elif isinstance(x, dict): + keys = sorted(x.keys()) + f.write('%dd' % len(keys)) + for key in keys: + _flatten(key, f) + _flatten(x[key], f) + elif isinstance(x, (list, tuple)): + f.write('%dl' % len(x)) + for value in x: + _flatten(value, f) + elif isinstance(x, int_or_long): + f.write('%di' % (x,)) + else: + raise TypeError( + "the keywords to verify() contains unsupported object %r" % (x,)) + +def flatten(x): + f = cStringIO.StringIO() + _flatten(x, f) + return f.getvalue() diff --git a/venv/lib/python3.10/site-packages/cffi/lock.py b/venv/lib/python3.10/site-packages/cffi/lock.py new file mode 100644 index 0000000000000000000000000000000000000000..db91b7158c4ee9aa653462fe38e79ed1b553db87 --- /dev/null +++ b/venv/lib/python3.10/site-packages/cffi/lock.py @@ -0,0 +1,30 @@ +import sys + +if sys.version_info < (3,): + try: + from thread import allocate_lock + except ImportError: + from dummy_thread import allocate_lock +else: + try: + from _thread import allocate_lock + except ImportError: + from _dummy_thread import allocate_lock + + +##import sys +##l1 = allocate_lock + +##class allocate_lock(object): +## def __init__(self): +## self._real = l1() +## def __enter__(self): +## for i in range(4, 0, -1): +## print sys._getframe(i).f_code +## print +## return self._real.__enter__() +## def __exit__(self, *args): +## return self._real.__exit__(*args) +## def acquire(self, f): +## assert f is False +## return self._real.acquire(f) diff --git a/venv/lib/python3.10/site-packages/cffi/model.py b/venv/lib/python3.10/site-packages/cffi/model.py new file mode 100644 index 0000000000000000000000000000000000000000..e5f4cae3e84c73cd09980dabd2ec571d455fe0c1 --- /dev/null +++ b/venv/lib/python3.10/site-packages/cffi/model.py @@ -0,0 +1,618 @@ +import types +import weakref + +from .lock import allocate_lock +from .error import CDefError, VerificationError, VerificationMissing + +# type qualifiers +Q_CONST = 0x01 +Q_RESTRICT = 0x02 +Q_VOLATILE = 0x04 + +def qualify(quals, replace_with): + if quals & Q_CONST: + replace_with = ' const ' + replace_with.lstrip() + if quals & Q_VOLATILE: + replace_with = ' volatile ' + replace_with.lstrip() + if quals & Q_RESTRICT: + # It seems that __restrict is supported by gcc and msvc. + # If you hit some different compiler, add a #define in + # _cffi_include.h for it (and in its copies, documented there) + replace_with = ' __restrict ' + replace_with.lstrip() + return replace_with + + +class BaseTypeByIdentity(object): + is_array_type = False + is_raw_function = False + + def get_c_name(self, replace_with='', context='a C file', quals=0): + result = self.c_name_with_marker + assert result.count('&') == 1 + # some logic duplication with ffi.getctype()... :-( + replace_with = replace_with.strip() + if replace_with: + if replace_with.startswith('*') and '&[' in result: + replace_with = '(%s)' % replace_with + elif not replace_with[0] in '[(': + replace_with = ' ' + replace_with + replace_with = qualify(quals, replace_with) + result = result.replace('&', replace_with) + if '$' in result: + raise VerificationError( + "cannot generate '%s' in %s: unknown type name" + % (self._get_c_name(), context)) + return result + + def _get_c_name(self): + return self.c_name_with_marker.replace('&', '') + + def has_c_name(self): + return '$' not in self._get_c_name() + + def is_integer_type(self): + return False + + def get_cached_btype(self, ffi, finishlist, can_delay=False): + try: + BType = ffi._cached_btypes[self] + except KeyError: + BType = self.build_backend_type(ffi, finishlist) + BType2 = ffi._cached_btypes.setdefault(self, BType) + assert BType2 is BType + return BType + + def __repr__(self): + return '<%s>' % (self._get_c_name(),) + + def _get_items(self): + return [(name, getattr(self, name)) for name in self._attrs_] + + +class BaseType(BaseTypeByIdentity): + + def __eq__(self, other): + return (self.__class__ == other.__class__ and + self._get_items() == other._get_items()) + + def __ne__(self, other): + return not self == other + + def __hash__(self): + return hash((self.__class__, tuple(self._get_items()))) + + +class VoidType(BaseType): + _attrs_ = () + + def __init__(self): + self.c_name_with_marker = 'void&' + + def build_backend_type(self, ffi, finishlist): + return global_cache(self, ffi, 'new_void_type') + +void_type = VoidType() + + +class BasePrimitiveType(BaseType): + def is_complex_type(self): + return False + + +class PrimitiveType(BasePrimitiveType): + _attrs_ = ('name',) + + ALL_PRIMITIVE_TYPES = { + 'char': 'c', + 'short': 'i', + 'int': 'i', + 'long': 'i', + 'long long': 'i', + 'signed char': 'i', + 'unsigned char': 'i', + 'unsigned short': 'i', + 'unsigned int': 'i', + 'unsigned long': 'i', + 'unsigned long long': 'i', + 'float': 'f', + 'double': 'f', + 'long double': 'f', + '_cffi_float_complex_t': 'j', + '_cffi_double_complex_t': 'j', + '_Bool': 'i', + # the following types are not primitive in the C sense + 'wchar_t': 'c', + 'char16_t': 'c', + 'char32_t': 'c', + 'int8_t': 'i', + 'uint8_t': 'i', + 'int16_t': 'i', + 'uint16_t': 'i', + 'int32_t': 'i', + 'uint32_t': 'i', + 'int64_t': 'i', + 'uint64_t': 'i', + 'int_least8_t': 'i', + 'uint_least8_t': 'i', + 'int_least16_t': 'i', + 'uint_least16_t': 'i', + 'int_least32_t': 'i', + 'uint_least32_t': 'i', + 'int_least64_t': 'i', + 'uint_least64_t': 'i', + 'int_fast8_t': 'i', + 'uint_fast8_t': 'i', + 'int_fast16_t': 'i', + 'uint_fast16_t': 'i', + 'int_fast32_t': 'i', + 'uint_fast32_t': 'i', + 'int_fast64_t': 'i', + 'uint_fast64_t': 'i', + 'intptr_t': 'i', + 'uintptr_t': 'i', + 'intmax_t': 'i', + 'uintmax_t': 'i', + 'ptrdiff_t': 'i', + 'size_t': 'i', + 'ssize_t': 'i', + } + + def __init__(self, name): + assert name in self.ALL_PRIMITIVE_TYPES + self.name = name + self.c_name_with_marker = name + '&' + + def is_char_type(self): + return self.ALL_PRIMITIVE_TYPES[self.name] == 'c' + def is_integer_type(self): + return self.ALL_PRIMITIVE_TYPES[self.name] == 'i' + def is_float_type(self): + return self.ALL_PRIMITIVE_TYPES[self.name] == 'f' + def is_complex_type(self): + return self.ALL_PRIMITIVE_TYPES[self.name] == 'j' + + def build_backend_type(self, ffi, finishlist): + return global_cache(self, ffi, 'new_primitive_type', self.name) + + +class UnknownIntegerType(BasePrimitiveType): + _attrs_ = ('name',) + + def __init__(self, name): + self.name = name + self.c_name_with_marker = name + '&' + + def is_integer_type(self): + return True + + def build_backend_type(self, ffi, finishlist): + raise NotImplementedError("integer type '%s' can only be used after " + "compilation" % self.name) + +class UnknownFloatType(BasePrimitiveType): + _attrs_ = ('name', ) + + def __init__(self, name): + self.name = name + self.c_name_with_marker = name + '&' + + def build_backend_type(self, ffi, finishlist): + raise NotImplementedError("float type '%s' can only be used after " + "compilation" % self.name) + + +class BaseFunctionType(BaseType): + _attrs_ = ('args', 'result', 'ellipsis', 'abi') + + def __init__(self, args, result, ellipsis, abi=None): + self.args = args + self.result = result + self.ellipsis = ellipsis + self.abi = abi + # + reprargs = [arg._get_c_name() for arg in self.args] + if self.ellipsis: + reprargs.append('...') + reprargs = reprargs or ['void'] + replace_with = self._base_pattern % (', '.join(reprargs),) + if abi is not None: + replace_with = replace_with[:1] + abi + ' ' + replace_with[1:] + self.c_name_with_marker = ( + self.result.c_name_with_marker.replace('&', replace_with)) + + +class RawFunctionType(BaseFunctionType): + # Corresponds to a C type like 'int(int)', which is the C type of + # a function, but not a pointer-to-function. The backend has no + # notion of such a type; it's used temporarily by parsing. + _base_pattern = '(&)(%s)' + is_raw_function = True + + def build_backend_type(self, ffi, finishlist): + raise CDefError("cannot render the type %r: it is a function " + "type, not a pointer-to-function type" % (self,)) + + def as_function_pointer(self): + return FunctionPtrType(self.args, self.result, self.ellipsis, self.abi) + + +class FunctionPtrType(BaseFunctionType): + _base_pattern = '(*&)(%s)' + + def build_backend_type(self, ffi, finishlist): + result = self.result.get_cached_btype(ffi, finishlist) + args = [] + for tp in self.args: + args.append(tp.get_cached_btype(ffi, finishlist)) + abi_args = () + if self.abi == "__stdcall": + if not self.ellipsis: # __stdcall ignored for variadic funcs + try: + abi_args = (ffi._backend.FFI_STDCALL,) + except AttributeError: + pass + return global_cache(self, ffi, 'new_function_type', + tuple(args), result, self.ellipsis, *abi_args) + + def as_raw_function(self): + return RawFunctionType(self.args, self.result, self.ellipsis, self.abi) + + +class PointerType(BaseType): + _attrs_ = ('totype', 'quals') + + def __init__(self, totype, quals=0): + self.totype = totype + self.quals = quals + extra = " *&" + if totype.is_array_type: + extra = "(%s)" % (extra.lstrip(),) + extra = qualify(quals, extra) + self.c_name_with_marker = totype.c_name_with_marker.replace('&', extra) + + def build_backend_type(self, ffi, finishlist): + BItem = self.totype.get_cached_btype(ffi, finishlist, can_delay=True) + return global_cache(self, ffi, 'new_pointer_type', BItem) + +voidp_type = PointerType(void_type) + +def ConstPointerType(totype): + return PointerType(totype, Q_CONST) + +const_voidp_type = ConstPointerType(void_type) + + +class NamedPointerType(PointerType): + _attrs_ = ('totype', 'name') + + def __init__(self, totype, name, quals=0): + PointerType.__init__(self, totype, quals) + self.name = name + self.c_name_with_marker = name + '&' + + +class ArrayType(BaseType): + _attrs_ = ('item', 'length') + is_array_type = True + + def __init__(self, item, length): + self.item = item + self.length = length + # + if length is None: + brackets = '&[]' + elif length == '...': + brackets = '&[/*...*/]' + else: + brackets = '&[%s]' % length + self.c_name_with_marker = ( + self.item.c_name_with_marker.replace('&', brackets)) + + def length_is_unknown(self): + return isinstance(self.length, str) + + def resolve_length(self, newlength): + return ArrayType(self.item, newlength) + + def build_backend_type(self, ffi, finishlist): + if self.length_is_unknown(): + raise CDefError("cannot render the type %r: unknown length" % + (self,)) + self.item.get_cached_btype(ffi, finishlist) # force the item BType + BPtrItem = PointerType(self.item).get_cached_btype(ffi, finishlist) + return global_cache(self, ffi, 'new_array_type', BPtrItem, self.length) + +char_array_type = ArrayType(PrimitiveType('char'), None) + + +class StructOrUnionOrEnum(BaseTypeByIdentity): + _attrs_ = ('name',) + forcename = None + + def build_c_name_with_marker(self): + name = self.forcename or '%s %s' % (self.kind, self.name) + self.c_name_with_marker = name + '&' + + def force_the_name(self, forcename): + self.forcename = forcename + self.build_c_name_with_marker() + + def get_official_name(self): + assert self.c_name_with_marker.endswith('&') + return self.c_name_with_marker[:-1] + + +class StructOrUnion(StructOrUnionOrEnum): + fixedlayout = None + completed = 0 + partial = False + packed = 0 + + def __init__(self, name, fldnames, fldtypes, fldbitsize, fldquals=None): + self.name = name + self.fldnames = fldnames + self.fldtypes = fldtypes + self.fldbitsize = fldbitsize + self.fldquals = fldquals + self.build_c_name_with_marker() + + def anonymous_struct_fields(self): + if self.fldtypes is not None: + for name, type in zip(self.fldnames, self.fldtypes): + if name == '' and isinstance(type, StructOrUnion): + yield type + + def enumfields(self, expand_anonymous_struct_union=True): + fldquals = self.fldquals + if fldquals is None: + fldquals = (0,) * len(self.fldnames) + for name, type, bitsize, quals in zip(self.fldnames, self.fldtypes, + self.fldbitsize, fldquals): + if (name == '' and isinstance(type, StructOrUnion) + and expand_anonymous_struct_union): + # nested anonymous struct/union + for result in type.enumfields(): + yield result + else: + yield (name, type, bitsize, quals) + + def force_flatten(self): + # force the struct or union to have a declaration that lists + # directly all fields returned by enumfields(), flattening + # nested anonymous structs/unions. + names = [] + types = [] + bitsizes = [] + fldquals = [] + for name, type, bitsize, quals in self.enumfields(): + names.append(name) + types.append(type) + bitsizes.append(bitsize) + fldquals.append(quals) + self.fldnames = tuple(names) + self.fldtypes = tuple(types) + self.fldbitsize = tuple(bitsizes) + self.fldquals = tuple(fldquals) + + def get_cached_btype(self, ffi, finishlist, can_delay=False): + BType = StructOrUnionOrEnum.get_cached_btype(self, ffi, finishlist, + can_delay) + if not can_delay: + self.finish_backend_type(ffi, finishlist) + return BType + + def finish_backend_type(self, ffi, finishlist): + if self.completed: + if self.completed != 2: + raise NotImplementedError("recursive structure declaration " + "for '%s'" % (self.name,)) + return + BType = ffi._cached_btypes[self] + # + self.completed = 1 + # + if self.fldtypes is None: + pass # not completing it: it's an opaque struct + # + elif self.fixedlayout is None: + fldtypes = [tp.get_cached_btype(ffi, finishlist) + for tp in self.fldtypes] + lst = list(zip(self.fldnames, fldtypes, self.fldbitsize)) + extra_flags = () + if self.packed: + if self.packed == 1: + extra_flags = (8,) # SF_PACKED + else: + extra_flags = (0, self.packed) + ffi._backend.complete_struct_or_union(BType, lst, self, + -1, -1, *extra_flags) + # + else: + fldtypes = [] + fieldofs, fieldsize, totalsize, totalalignment = self.fixedlayout + for i in range(len(self.fldnames)): + fsize = fieldsize[i] + ftype = self.fldtypes[i] + # + if isinstance(ftype, ArrayType) and ftype.length_is_unknown(): + # fix the length to match the total size + BItemType = ftype.item.get_cached_btype(ffi, finishlist) + nlen, nrest = divmod(fsize, ffi.sizeof(BItemType)) + if nrest != 0: + self._verification_error( + "field '%s.%s' has a bogus size?" % ( + self.name, self.fldnames[i] or '{}')) + ftype = ftype.resolve_length(nlen) + self.fldtypes = (self.fldtypes[:i] + (ftype,) + + self.fldtypes[i+1:]) + # + BFieldType = ftype.get_cached_btype(ffi, finishlist) + if isinstance(ftype, ArrayType) and ftype.length is None: + assert fsize == 0 + else: + bitemsize = ffi.sizeof(BFieldType) + if bitemsize != fsize: + self._verification_error( + "field '%s.%s' is declared as %d bytes, but is " + "really %d bytes" % (self.name, + self.fldnames[i] or '{}', + bitemsize, fsize)) + fldtypes.append(BFieldType) + # + lst = list(zip(self.fldnames, fldtypes, self.fldbitsize, fieldofs)) + ffi._backend.complete_struct_or_union(BType, lst, self, + totalsize, totalalignment) + self.completed = 2 + + def _verification_error(self, msg): + raise VerificationError(msg) + + def check_not_partial(self): + if self.partial and self.fixedlayout is None: + raise VerificationMissing(self._get_c_name()) + + def build_backend_type(self, ffi, finishlist): + self.check_not_partial() + finishlist.append(self) + # + return global_cache(self, ffi, 'new_%s_type' % self.kind, + self.get_official_name(), key=self) + + +class StructType(StructOrUnion): + kind = 'struct' + + +class UnionType(StructOrUnion): + kind = 'union' + + +class EnumType(StructOrUnionOrEnum): + kind = 'enum' + partial = False + partial_resolved = False + + def __init__(self, name, enumerators, enumvalues, baseinttype=None): + self.name = name + self.enumerators = enumerators + self.enumvalues = enumvalues + self.baseinttype = baseinttype + self.build_c_name_with_marker() + + def force_the_name(self, forcename): + StructOrUnionOrEnum.force_the_name(self, forcename) + if self.forcename is None: + name = self.get_official_name() + self.forcename = '$' + name.replace(' ', '_') + + def check_not_partial(self): + if self.partial and not self.partial_resolved: + raise VerificationMissing(self._get_c_name()) + + def build_backend_type(self, ffi, finishlist): + self.check_not_partial() + base_btype = self.build_baseinttype(ffi, finishlist) + return global_cache(self, ffi, 'new_enum_type', + self.get_official_name(), + self.enumerators, self.enumvalues, + base_btype, key=self) + + def build_baseinttype(self, ffi, finishlist): + if self.baseinttype is not None: + return self.baseinttype.get_cached_btype(ffi, finishlist) + # + if self.enumvalues: + smallest_value = min(self.enumvalues) + largest_value = max(self.enumvalues) + else: + import warnings + try: + # XXX! The goal is to ensure that the warnings.warn() + # will not suppress the warning. We want to get it + # several times if we reach this point several times. + __warningregistry__.clear() + except NameError: + pass + warnings.warn("%r has no values explicitly defined; " + "guessing that it is equivalent to 'unsigned int'" + % self._get_c_name()) + smallest_value = largest_value = 0 + if smallest_value < 0: # needs a signed type + sign = 1 + candidate1 = PrimitiveType("int") + candidate2 = PrimitiveType("long") + else: + sign = 0 + candidate1 = PrimitiveType("unsigned int") + candidate2 = PrimitiveType("unsigned long") + btype1 = candidate1.get_cached_btype(ffi, finishlist) + btype2 = candidate2.get_cached_btype(ffi, finishlist) + size1 = ffi.sizeof(btype1) + size2 = ffi.sizeof(btype2) + if (smallest_value >= ((-1) << (8*size1-1)) and + largest_value < (1 << (8*size1-sign))): + return btype1 + if (smallest_value >= ((-1) << (8*size2-1)) and + largest_value < (1 << (8*size2-sign))): + return btype2 + raise CDefError("%s values don't all fit into either 'long' " + "or 'unsigned long'" % self._get_c_name()) + +def unknown_type(name, structname=None): + if structname is None: + structname = '$%s' % name + tp = StructType(structname, None, None, None) + tp.force_the_name(name) + tp.origin = "unknown_type" + return tp + +def unknown_ptr_type(name, structname=None): + if structname is None: + structname = '$$%s' % name + tp = StructType(structname, None, None, None) + return NamedPointerType(tp, name) + + +global_lock = allocate_lock() +_typecache_cffi_backend = weakref.WeakValueDictionary() + +def get_typecache(backend): + # returns _typecache_cffi_backend if backend is the _cffi_backend + # module, or type(backend).__typecache if backend is an instance of + # CTypesBackend (or some FakeBackend class during tests) + if isinstance(backend, types.ModuleType): + return _typecache_cffi_backend + with global_lock: + if not hasattr(type(backend), '__typecache'): + type(backend).__typecache = weakref.WeakValueDictionary() + return type(backend).__typecache + +def global_cache(srctype, ffi, funcname, *args, **kwds): + key = kwds.pop('key', (funcname, args)) + assert not kwds + try: + return ffi._typecache[key] + except KeyError: + pass + try: + res = getattr(ffi._backend, funcname)(*args) + except NotImplementedError as e: + raise NotImplementedError("%s: %r: %s" % (funcname, srctype, e)) + # note that setdefault() on WeakValueDictionary is not atomic + # and contains a rare bug (http://bugs.python.org/issue19542); + # we have to use a lock and do it ourselves + cache = ffi._typecache + with global_lock: + res1 = cache.get(key) + if res1 is None: + cache[key] = res + return res + else: + return res1 + +def pointer_cache(ffi, BType): + return global_cache('?', ffi, 'new_pointer_type', BType) + +def attach_exception_info(e, name): + if e.args and type(e.args[0]) is str: + e.args = ('%s: %s' % (name, e.args[0]),) + e.args[1:] diff --git a/venv/lib/python3.10/site-packages/cffi/parse_c_type.h b/venv/lib/python3.10/site-packages/cffi/parse_c_type.h new file mode 100644 index 0000000000000000000000000000000000000000..84e4ef85659eb63e6453d8af9f024f1866182342 --- /dev/null +++ b/venv/lib/python3.10/site-packages/cffi/parse_c_type.h @@ -0,0 +1,181 @@ + +/* This part is from file 'cffi/parse_c_type.h'. It is copied at the + beginning of C sources generated by CFFI's ffi.set_source(). */ + +typedef void *_cffi_opcode_t; + +#define _CFFI_OP(opcode, arg) (_cffi_opcode_t)(opcode | (((uintptr_t)(arg)) << 8)) +#define _CFFI_GETOP(cffi_opcode) ((unsigned char)(uintptr_t)cffi_opcode) +#define _CFFI_GETARG(cffi_opcode) (((intptr_t)cffi_opcode) >> 8) + +#define _CFFI_OP_PRIMITIVE 1 +#define _CFFI_OP_POINTER 3 +#define _CFFI_OP_ARRAY 5 +#define _CFFI_OP_OPEN_ARRAY 7 +#define _CFFI_OP_STRUCT_UNION 9 +#define _CFFI_OP_ENUM 11 +#define _CFFI_OP_FUNCTION 13 +#define _CFFI_OP_FUNCTION_END 15 +#define _CFFI_OP_NOOP 17 +#define _CFFI_OP_BITFIELD 19 +#define _CFFI_OP_TYPENAME 21 +#define _CFFI_OP_CPYTHON_BLTN_V 23 // varargs +#define _CFFI_OP_CPYTHON_BLTN_N 25 // noargs +#define _CFFI_OP_CPYTHON_BLTN_O 27 // O (i.e. a single arg) +#define _CFFI_OP_CONSTANT 29 +#define _CFFI_OP_CONSTANT_INT 31 +#define _CFFI_OP_GLOBAL_VAR 33 +#define _CFFI_OP_DLOPEN_FUNC 35 +#define _CFFI_OP_DLOPEN_CONST 37 +#define _CFFI_OP_GLOBAL_VAR_F 39 +#define _CFFI_OP_EXTERN_PYTHON 41 + +#define _CFFI_PRIM_VOID 0 +#define _CFFI_PRIM_BOOL 1 +#define _CFFI_PRIM_CHAR 2 +#define _CFFI_PRIM_SCHAR 3 +#define _CFFI_PRIM_UCHAR 4 +#define _CFFI_PRIM_SHORT 5 +#define _CFFI_PRIM_USHORT 6 +#define _CFFI_PRIM_INT 7 +#define _CFFI_PRIM_UINT 8 +#define _CFFI_PRIM_LONG 9 +#define _CFFI_PRIM_ULONG 10 +#define _CFFI_PRIM_LONGLONG 11 +#define _CFFI_PRIM_ULONGLONG 12 +#define _CFFI_PRIM_FLOAT 13 +#define _CFFI_PRIM_DOUBLE 14 +#define _CFFI_PRIM_LONGDOUBLE 15 + +#define _CFFI_PRIM_WCHAR 16 +#define _CFFI_PRIM_INT8 17 +#define _CFFI_PRIM_UINT8 18 +#define _CFFI_PRIM_INT16 19 +#define _CFFI_PRIM_UINT16 20 +#define _CFFI_PRIM_INT32 21 +#define _CFFI_PRIM_UINT32 22 +#define _CFFI_PRIM_INT64 23 +#define _CFFI_PRIM_UINT64 24 +#define _CFFI_PRIM_INTPTR 25 +#define _CFFI_PRIM_UINTPTR 26 +#define _CFFI_PRIM_PTRDIFF 27 +#define _CFFI_PRIM_SIZE 28 +#define _CFFI_PRIM_SSIZE 29 +#define _CFFI_PRIM_INT_LEAST8 30 +#define _CFFI_PRIM_UINT_LEAST8 31 +#define _CFFI_PRIM_INT_LEAST16 32 +#define _CFFI_PRIM_UINT_LEAST16 33 +#define _CFFI_PRIM_INT_LEAST32 34 +#define _CFFI_PRIM_UINT_LEAST32 35 +#define _CFFI_PRIM_INT_LEAST64 36 +#define _CFFI_PRIM_UINT_LEAST64 37 +#define _CFFI_PRIM_INT_FAST8 38 +#define _CFFI_PRIM_UINT_FAST8 39 +#define _CFFI_PRIM_INT_FAST16 40 +#define _CFFI_PRIM_UINT_FAST16 41 +#define _CFFI_PRIM_INT_FAST32 42 +#define _CFFI_PRIM_UINT_FAST32 43 +#define _CFFI_PRIM_INT_FAST64 44 +#define _CFFI_PRIM_UINT_FAST64 45 +#define _CFFI_PRIM_INTMAX 46 +#define _CFFI_PRIM_UINTMAX 47 +#define _CFFI_PRIM_FLOATCOMPLEX 48 +#define _CFFI_PRIM_DOUBLECOMPLEX 49 +#define _CFFI_PRIM_CHAR16 50 +#define _CFFI_PRIM_CHAR32 51 + +#define _CFFI__NUM_PRIM 52 +#define _CFFI__UNKNOWN_PRIM (-1) +#define _CFFI__UNKNOWN_FLOAT_PRIM (-2) +#define _CFFI__UNKNOWN_LONG_DOUBLE (-3) + +#define _CFFI__IO_FILE_STRUCT (-1) + + +struct _cffi_global_s { + const char *name; + void *address; + _cffi_opcode_t type_op; + void *size_or_direct_fn; // OP_GLOBAL_VAR: size, or 0 if unknown + // OP_CPYTHON_BLTN_*: addr of direct function +}; + +struct _cffi_getconst_s { + unsigned long long value; + const struct _cffi_type_context_s *ctx; + int gindex; +}; + +struct _cffi_struct_union_s { + const char *name; + int type_index; // -> _cffi_types, on a OP_STRUCT_UNION + int flags; // _CFFI_F_* flags below + size_t size; + int alignment; + int first_field_index; // -> _cffi_fields array + int num_fields; +}; +#define _CFFI_F_UNION 0x01 // is a union, not a struct +#define _CFFI_F_CHECK_FIELDS 0x02 // complain if fields are not in the + // "standard layout" or if some are missing +#define _CFFI_F_PACKED 0x04 // for CHECK_FIELDS, assume a packed struct +#define _CFFI_F_EXTERNAL 0x08 // in some other ffi.include() +#define _CFFI_F_OPAQUE 0x10 // opaque + +struct _cffi_field_s { + const char *name; + size_t field_offset; + size_t field_size; + _cffi_opcode_t field_type_op; +}; + +struct _cffi_enum_s { + const char *name; + int type_index; // -> _cffi_types, on a OP_ENUM + int type_prim; // _CFFI_PRIM_xxx + const char *enumerators; // comma-delimited string +}; + +struct _cffi_typename_s { + const char *name; + int type_index; /* if opaque, points to a possibly artificial + OP_STRUCT which is itself opaque */ +}; + +struct _cffi_type_context_s { + _cffi_opcode_t *types; + const struct _cffi_global_s *globals; + const struct _cffi_field_s *fields; + const struct _cffi_struct_union_s *struct_unions; + const struct _cffi_enum_s *enums; + const struct _cffi_typename_s *typenames; + int num_globals; + int num_struct_unions; + int num_enums; + int num_typenames; + const char *const *includes; + int num_types; + int flags; /* future extension */ +}; + +struct _cffi_parse_info_s { + const struct _cffi_type_context_s *ctx; + _cffi_opcode_t *output; + unsigned int output_size; + size_t error_location; + const char *error_message; +}; + +struct _cffi_externpy_s { + const char *name; + size_t size_of_result; + void *reserved1, *reserved2; +}; + +#ifdef _CFFI_INTERNAL +static int parse_c_type(struct _cffi_parse_info_s *info, const char *input); +static int search_in_globals(const struct _cffi_type_context_s *ctx, + const char *search, size_t search_len); +static int search_in_struct_unions(const struct _cffi_type_context_s *ctx, + const char *search, size_t search_len); +#endif diff --git a/venv/lib/python3.10/site-packages/cffi/pkgconfig.py b/venv/lib/python3.10/site-packages/cffi/pkgconfig.py new file mode 100644 index 0000000000000000000000000000000000000000..5c93f15a60e6f904b2dd108d6e22044a5890bcb4 --- /dev/null +++ b/venv/lib/python3.10/site-packages/cffi/pkgconfig.py @@ -0,0 +1,121 @@ +# pkg-config, https://www.freedesktop.org/wiki/Software/pkg-config/ integration for cffi +import sys, os, subprocess + +from .error import PkgConfigError + + +def merge_flags(cfg1, cfg2): + """Merge values from cffi config flags cfg2 to cf1 + + Example: + merge_flags({"libraries": ["one"]}, {"libraries": ["two"]}) + {"libraries": ["one", "two"]} + """ + for key, value in cfg2.items(): + if key not in cfg1: + cfg1[key] = value + else: + if not isinstance(cfg1[key], list): + raise TypeError("cfg1[%r] should be a list of strings" % (key,)) + if not isinstance(value, list): + raise TypeError("cfg2[%r] should be a list of strings" % (key,)) + cfg1[key].extend(value) + return cfg1 + + +def call(libname, flag, encoding=sys.getfilesystemencoding()): + """Calls pkg-config and returns the output if found + """ + a = ["pkg-config", "--print-errors"] + a.append(flag) + a.append(libname) + try: + pc = subprocess.Popen(a, stdout=subprocess.PIPE, stderr=subprocess.PIPE) + except EnvironmentError as e: + raise PkgConfigError("cannot run pkg-config: %s" % (str(e).strip(),)) + + bout, berr = pc.communicate() + if pc.returncode != 0: + try: + berr = berr.decode(encoding) + except Exception: + pass + raise PkgConfigError(berr.strip()) + + if sys.version_info >= (3,) and not isinstance(bout, str): # Python 3.x + try: + bout = bout.decode(encoding) + except UnicodeDecodeError: + raise PkgConfigError("pkg-config %s %s returned bytes that cannot " + "be decoded with encoding %r:\n%r" % + (flag, libname, encoding, bout)) + + if os.altsep != '\\' and '\\' in bout: + raise PkgConfigError("pkg-config %s %s returned an unsupported " + "backslash-escaped output:\n%r" % + (flag, libname, bout)) + return bout + + +def flags_from_pkgconfig(libs): + r"""Return compiler line flags for FFI.set_source based on pkg-config output + + Usage + ... + ffibuilder.set_source("_foo", pkgconfig = ["libfoo", "libbar >= 1.8.3"]) + + If pkg-config is installed on build machine, then arguments include_dirs, + library_dirs, libraries, define_macros, extra_compile_args and + extra_link_args are extended with an output of pkg-config for libfoo and + libbar. + + Raises PkgConfigError in case the pkg-config call fails. + """ + + def get_include_dirs(string): + return [x[2:] for x in string.split() if x.startswith("-I")] + + def get_library_dirs(string): + return [x[2:] for x in string.split() if x.startswith("-L")] + + def get_libraries(string): + return [x[2:] for x in string.split() if x.startswith("-l")] + + # convert -Dfoo=bar to list of tuples [("foo", "bar")] expected by distutils + def get_macros(string): + def _macro(x): + x = x[2:] # drop "-D" + if '=' in x: + return tuple(x.split("=", 1)) # "-Dfoo=bar" => ("foo", "bar") + else: + return (x, None) # "-Dfoo" => ("foo", None) + return [_macro(x) for x in string.split() if x.startswith("-D")] + + def get_other_cflags(string): + return [x for x in string.split() if not x.startswith("-I") and + not x.startswith("-D")] + + def get_other_libs(string): + return [x for x in string.split() if not x.startswith("-L") and + not x.startswith("-l")] + + # return kwargs for given libname + def kwargs(libname): + fse = sys.getfilesystemencoding() + all_cflags = call(libname, "--cflags") + all_libs = call(libname, "--libs") + return { + "include_dirs": get_include_dirs(all_cflags), + "library_dirs": get_library_dirs(all_libs), + "libraries": get_libraries(all_libs), + "define_macros": get_macros(all_cflags), + "extra_compile_args": get_other_cflags(all_cflags), + "extra_link_args": get_other_libs(all_libs), + } + + # merge all arguments together + ret = {} + for libname in libs: + lib_flags = kwargs(libname) + merge_flags(ret, lib_flags) + return ret diff --git a/venv/lib/python3.10/site-packages/cffi/recompiler.py b/venv/lib/python3.10/site-packages/cffi/recompiler.py new file mode 100644 index 0000000000000000000000000000000000000000..7734a34863330766984a00d3ff496393471aebfd --- /dev/null +++ b/venv/lib/python3.10/site-packages/cffi/recompiler.py @@ -0,0 +1,1598 @@ +import io, os, sys, sysconfig +from . import ffiplatform, model +from .error import VerificationError +from .cffi_opcode import * + +VERSION_BASE = 0x2601 +VERSION_EMBEDDED = 0x2701 +VERSION_CHAR16CHAR32 = 0x2801 + +USE_LIMITED_API = ((sys.platform != 'win32' or sys.version_info < (3, 0) or + sys.version_info >= (3, 5)) and + not sysconfig.get_config_var("Py_GIL_DISABLED")) # free-threaded doesn't yet support limited API + +class GlobalExpr: + def __init__(self, name, address, type_op, size=0, check_value=0): + self.name = name + self.address = address + self.type_op = type_op + self.size = size + self.check_value = check_value + + def as_c_expr(self): + return ' { "%s", (void *)%s, %s, (void *)%s },' % ( + self.name, self.address, self.type_op.as_c_expr(), self.size) + + def as_python_expr(self): + return "b'%s%s',%d" % (self.type_op.as_python_bytes(), self.name, + self.check_value) + +class FieldExpr: + def __init__(self, name, field_offset, field_size, fbitsize, field_type_op): + self.name = name + self.field_offset = field_offset + self.field_size = field_size + self.fbitsize = fbitsize + self.field_type_op = field_type_op + + def as_c_expr(self): + spaces = " " * len(self.name) + return (' { "%s", %s,\n' % (self.name, self.field_offset) + + ' %s %s,\n' % (spaces, self.field_size) + + ' %s %s },' % (spaces, self.field_type_op.as_c_expr())) + + def as_python_expr(self): + raise NotImplementedError + + def as_field_python_expr(self): + if self.field_type_op.op == OP_NOOP: + size_expr = '' + elif self.field_type_op.op == OP_BITFIELD: + size_expr = format_four_bytes(self.fbitsize) + else: + raise NotImplementedError + return "b'%s%s%s'" % (self.field_type_op.as_python_bytes(), + size_expr, + self.name) + +class StructUnionExpr: + def __init__(self, name, type_index, flags, size, alignment, comment, + first_field_index, c_fields): + self.name = name + self.type_index = type_index + self.flags = flags + self.size = size + self.alignment = alignment + self.comment = comment + self.first_field_index = first_field_index + self.c_fields = c_fields + + def as_c_expr(self): + return (' { "%s", %d, %s,' % (self.name, self.type_index, self.flags) + + '\n %s, %s, ' % (self.size, self.alignment) + + '%d, %d ' % (self.first_field_index, len(self.c_fields)) + + ('/* %s */ ' % self.comment if self.comment else '') + + '},') + + def as_python_expr(self): + flags = eval(self.flags, G_FLAGS) + fields_expr = [c_field.as_field_python_expr() + for c_field in self.c_fields] + return "(b'%s%s%s',%s)" % ( + format_four_bytes(self.type_index), + format_four_bytes(flags), + self.name, + ','.join(fields_expr)) + +class EnumExpr: + def __init__(self, name, type_index, size, signed, allenums): + self.name = name + self.type_index = type_index + self.size = size + self.signed = signed + self.allenums = allenums + + def as_c_expr(self): + return (' { "%s", %d, _cffi_prim_int(%s, %s),\n' + ' "%s" },' % (self.name, self.type_index, + self.size, self.signed, self.allenums)) + + def as_python_expr(self): + prim_index = { + (1, 0): PRIM_UINT8, (1, 1): PRIM_INT8, + (2, 0): PRIM_UINT16, (2, 1): PRIM_INT16, + (4, 0): PRIM_UINT32, (4, 1): PRIM_INT32, + (8, 0): PRIM_UINT64, (8, 1): PRIM_INT64, + }[self.size, self.signed] + return "b'%s%s%s\\x00%s'" % (format_four_bytes(self.type_index), + format_four_bytes(prim_index), + self.name, self.allenums) + +class TypenameExpr: + def __init__(self, name, type_index): + self.name = name + self.type_index = type_index + + def as_c_expr(self): + return ' { "%s", %d },' % (self.name, self.type_index) + + def as_python_expr(self): + return "b'%s%s'" % (format_four_bytes(self.type_index), self.name) + + +# ____________________________________________________________ + + +class Recompiler: + _num_externpy = 0 + + def __init__(self, ffi, module_name, target_is_python=False): + self.ffi = ffi + self.module_name = module_name + self.target_is_python = target_is_python + self._version = VERSION_BASE + + def needs_version(self, ver): + self._version = max(self._version, ver) + + def collect_type_table(self): + self._typesdict = {} + self._generate("collecttype") + # + all_decls = sorted(self._typesdict, key=str) + # + # prepare all FUNCTION bytecode sequences first + self.cffi_types = [] + for tp in all_decls: + if tp.is_raw_function: + assert self._typesdict[tp] is None + self._typesdict[tp] = len(self.cffi_types) + self.cffi_types.append(tp) # placeholder + for tp1 in tp.args: + assert isinstance(tp1, (model.VoidType, + model.BasePrimitiveType, + model.PointerType, + model.StructOrUnionOrEnum, + model.FunctionPtrType)) + if self._typesdict[tp1] is None: + self._typesdict[tp1] = len(self.cffi_types) + self.cffi_types.append(tp1) # placeholder + self.cffi_types.append('END') # placeholder + # + # prepare all OTHER bytecode sequences + for tp in all_decls: + if not tp.is_raw_function and self._typesdict[tp] is None: + self._typesdict[tp] = len(self.cffi_types) + self.cffi_types.append(tp) # placeholder + if tp.is_array_type and tp.length is not None: + self.cffi_types.append('LEN') # placeholder + assert None not in self._typesdict.values() + # + # collect all structs and unions and enums + self._struct_unions = {} + self._enums = {} + for tp in all_decls: + if isinstance(tp, model.StructOrUnion): + self._struct_unions[tp] = None + elif isinstance(tp, model.EnumType): + self._enums[tp] = None + for i, tp in enumerate(sorted(self._struct_unions, + key=lambda tp: tp.name)): + self._struct_unions[tp] = i + for i, tp in enumerate(sorted(self._enums, + key=lambda tp: tp.name)): + self._enums[tp] = i + # + # emit all bytecode sequences now + for tp in all_decls: + method = getattr(self, '_emit_bytecode_' + tp.__class__.__name__) + method(tp, self._typesdict[tp]) + # + # consistency check + for op in self.cffi_types: + assert isinstance(op, CffiOp) + self.cffi_types = tuple(self.cffi_types) # don't change any more + + def _enum_fields(self, tp): + # When producing C, expand all anonymous struct/union fields. + # That's necessary to have C code checking the offsets of the + # individual fields contained in them. When producing Python, + # don't do it and instead write it like it is, with the + # corresponding fields having an empty name. Empty names are + # recognized at runtime when we import the generated Python + # file. + expand_anonymous_struct_union = not self.target_is_python + return tp.enumfields(expand_anonymous_struct_union) + + def _do_collect_type(self, tp): + if not isinstance(tp, model.BaseTypeByIdentity): + if isinstance(tp, tuple): + for x in tp: + self._do_collect_type(x) + return + if tp not in self._typesdict: + self._typesdict[tp] = None + if isinstance(tp, model.FunctionPtrType): + self._do_collect_type(tp.as_raw_function()) + elif isinstance(tp, model.StructOrUnion): + if tp.fldtypes is not None and ( + tp not in self.ffi._parser._included_declarations): + for name1, tp1, _, _ in self._enum_fields(tp): + self._do_collect_type(self._field_type(tp, name1, tp1)) + else: + for _, x in tp._get_items(): + self._do_collect_type(x) + + def _generate(self, step_name): + lst = self.ffi._parser._declarations.items() + for name, (tp, quals) in sorted(lst): + kind, realname = name.split(' ', 1) + try: + method = getattr(self, '_generate_cpy_%s_%s' % (kind, + step_name)) + except AttributeError: + raise VerificationError( + "not implemented in recompile(): %r" % name) + try: + self._current_quals = quals + method(tp, realname) + except Exception as e: + model.attach_exception_info(e, name) + raise + + # ---------- + + ALL_STEPS = ["global", "field", "struct_union", "enum", "typename"] + + def collect_step_tables(self): + # collect the declarations for '_cffi_globals', '_cffi_typenames', etc. + self._lsts = {} + for step_name in self.ALL_STEPS: + self._lsts[step_name] = [] + self._seen_struct_unions = set() + self._generate("ctx") + self._add_missing_struct_unions() + # + for step_name in self.ALL_STEPS: + lst = self._lsts[step_name] + if step_name != "field": + lst.sort(key=lambda entry: entry.name) + self._lsts[step_name] = tuple(lst) # don't change any more + # + # check for a possible internal inconsistency: _cffi_struct_unions + # should have been generated with exactly self._struct_unions + lst = self._lsts["struct_union"] + for tp, i in self._struct_unions.items(): + assert i < len(lst) + assert lst[i].name == tp.name + assert len(lst) == len(self._struct_unions) + # same with enums + lst = self._lsts["enum"] + for tp, i in self._enums.items(): + assert i < len(lst) + assert lst[i].name == tp.name + assert len(lst) == len(self._enums) + + # ---------- + + def _prnt(self, what=''): + self._f.write(what + '\n') + + def write_source_to_f(self, f, preamble): + if self.target_is_python: + assert preamble is None + self.write_py_source_to_f(f) + else: + assert preamble is not None + self.write_c_source_to_f(f, preamble) + + def _rel_readlines(self, filename): + g = open(os.path.join(os.path.dirname(__file__), filename), 'r') + lines = g.readlines() + g.close() + return lines + + def write_c_source_to_f(self, f, preamble): + self._f = f + prnt = self._prnt + if self.ffi._embedding is not None: + prnt('#define _CFFI_USE_EMBEDDING') + if not USE_LIMITED_API: + prnt('#define _CFFI_NO_LIMITED_API') + # + # first the '#include' (actually done by inlining the file's content) + lines = self._rel_readlines('_cffi_include.h') + i = lines.index('#include "parse_c_type.h"\n') + lines[i:i+1] = self._rel_readlines('parse_c_type.h') + prnt(''.join(lines)) + # + # if we have ffi._embedding != None, we give it here as a macro + # and include an extra file + base_module_name = self.module_name.split('.')[-1] + if self.ffi._embedding is not None: + prnt('#define _CFFI_MODULE_NAME "%s"' % (self.module_name,)) + prnt('static const char _CFFI_PYTHON_STARTUP_CODE[] = {') + self._print_string_literal_in_array(self.ffi._embedding) + prnt('0 };') + prnt('#ifdef PYPY_VERSION') + prnt('# define _CFFI_PYTHON_STARTUP_FUNC _cffi_pypyinit_%s' % ( + base_module_name,)) + prnt('#elif PY_MAJOR_VERSION >= 3') + prnt('# define _CFFI_PYTHON_STARTUP_FUNC PyInit_%s' % ( + base_module_name,)) + prnt('#else') + prnt('# define _CFFI_PYTHON_STARTUP_FUNC init%s' % ( + base_module_name,)) + prnt('#endif') + lines = self._rel_readlines('_embedding.h') + i = lines.index('#include "_cffi_errors.h"\n') + lines[i:i+1] = self._rel_readlines('_cffi_errors.h') + prnt(''.join(lines)) + self.needs_version(VERSION_EMBEDDED) + # + # then paste the C source given by the user, verbatim. + prnt('/************************************************************/') + prnt() + prnt(preamble) + prnt() + prnt('/************************************************************/') + prnt() + # + # the declaration of '_cffi_types' + prnt('static void *_cffi_types[] = {') + typeindex2type = dict([(i, tp) for (tp, i) in self._typesdict.items()]) + for i, op in enumerate(self.cffi_types): + comment = '' + if i in typeindex2type: + comment = ' // ' + typeindex2type[i]._get_c_name() + prnt('/* %2d */ %s,%s' % (i, op.as_c_expr(), comment)) + if not self.cffi_types: + prnt(' 0') + prnt('};') + prnt() + # + # call generate_cpy_xxx_decl(), for every xxx found from + # ffi._parser._declarations. This generates all the functions. + self._seen_constants = set() + self._generate("decl") + # + # the declaration of '_cffi_globals' and '_cffi_typenames' + nums = {} + for step_name in self.ALL_STEPS: + lst = self._lsts[step_name] + nums[step_name] = len(lst) + if nums[step_name] > 0: + prnt('static const struct _cffi_%s_s _cffi_%ss[] = {' % ( + step_name, step_name)) + for entry in lst: + prnt(entry.as_c_expr()) + prnt('};') + prnt() + # + # the declaration of '_cffi_includes' + if self.ffi._included_ffis: + prnt('static const char * const _cffi_includes[] = {') + for ffi_to_include in self.ffi._included_ffis: + try: + included_module_name, included_source = ( + ffi_to_include._assigned_source[:2]) + except AttributeError: + raise VerificationError( + "ffi object %r includes %r, but the latter has not " + "been prepared with set_source()" % ( + self.ffi, ffi_to_include,)) + if included_source is None: + raise VerificationError( + "not implemented yet: ffi.include() of a Python-based " + "ffi inside a C-based ffi") + prnt(' "%s",' % (included_module_name,)) + prnt(' NULL') + prnt('};') + prnt() + # + # the declaration of '_cffi_type_context' + prnt('static const struct _cffi_type_context_s _cffi_type_context = {') + prnt(' _cffi_types,') + for step_name in self.ALL_STEPS: + if nums[step_name] > 0: + prnt(' _cffi_%ss,' % step_name) + else: + prnt(' NULL, /* no %ss */' % step_name) + for step_name in self.ALL_STEPS: + if step_name != "field": + prnt(' %d, /* num_%ss */' % (nums[step_name], step_name)) + if self.ffi._included_ffis: + prnt(' _cffi_includes,') + else: + prnt(' NULL, /* no includes */') + prnt(' %d, /* num_types */' % (len(self.cffi_types),)) + flags = 0 + if self._num_externpy > 0 or self.ffi._embedding is not None: + flags |= 1 # set to mean that we use extern "Python" + prnt(' %d, /* flags */' % flags) + prnt('};') + prnt() + # + # the init function + prnt('#ifdef __GNUC__') + prnt('# pragma GCC visibility push(default) /* for -fvisibility= */') + prnt('#endif') + prnt() + prnt('#ifdef PYPY_VERSION') + prnt('PyMODINIT_FUNC') + prnt('_cffi_pypyinit_%s(const void *p[])' % (base_module_name,)) + prnt('{') + if flags & 1: + prnt(' if (((intptr_t)p[0]) >= 0x0A03) {') + prnt(' _cffi_call_python_org = ' + '(void(*)(struct _cffi_externpy_s *, char *))p[1];') + prnt(' }') + prnt(' p[0] = (const void *)0x%x;' % self._version) + prnt(' p[1] = &_cffi_type_context;') + prnt('#if PY_MAJOR_VERSION >= 3') + prnt(' return NULL;') + prnt('#endif') + prnt('}') + # on Windows, distutils insists on putting init_cffi_xyz in + # 'export_symbols', so instead of fighting it, just give up and + # give it one + prnt('# ifdef _MSC_VER') + prnt(' PyMODINIT_FUNC') + prnt('# if PY_MAJOR_VERSION >= 3') + prnt(' PyInit_%s(void) { return NULL; }' % (base_module_name,)) + prnt('# else') + prnt(' init%s(void) { }' % (base_module_name,)) + prnt('# endif') + prnt('# endif') + prnt('#elif PY_MAJOR_VERSION >= 3') + prnt('PyMODINIT_FUNC') + prnt('PyInit_%s(void)' % (base_module_name,)) + prnt('{') + prnt(' return _cffi_init("%s", 0x%x, &_cffi_type_context);' % ( + self.module_name, self._version)) + prnt('}') + prnt('#else') + prnt('PyMODINIT_FUNC') + prnt('init%s(void)' % (base_module_name,)) + prnt('{') + prnt(' _cffi_init("%s", 0x%x, &_cffi_type_context);' % ( + self.module_name, self._version)) + prnt('}') + prnt('#endif') + prnt() + prnt('#ifdef __GNUC__') + prnt('# pragma GCC visibility pop') + prnt('#endif') + self._version = None + + def _to_py(self, x): + if isinstance(x, str): + return "b'%s'" % (x,) + if isinstance(x, (list, tuple)): + rep = [self._to_py(item) for item in x] + if len(rep) == 1: + rep.append('') + return "(%s)" % (','.join(rep),) + return x.as_python_expr() # Py2: unicode unexpected; Py3: bytes unexp. + + def write_py_source_to_f(self, f): + self._f = f + prnt = self._prnt + # + # header + prnt("# auto-generated file") + prnt("import _cffi_backend") + # + # the 'import' of the included ffis + num_includes = len(self.ffi._included_ffis or ()) + for i in range(num_includes): + ffi_to_include = self.ffi._included_ffis[i] + try: + included_module_name, included_source = ( + ffi_to_include._assigned_source[:2]) + except AttributeError: + raise VerificationError( + "ffi object %r includes %r, but the latter has not " + "been prepared with set_source()" % ( + self.ffi, ffi_to_include,)) + if included_source is not None: + raise VerificationError( + "not implemented yet: ffi.include() of a C-based " + "ffi inside a Python-based ffi") + prnt('from %s import ffi as _ffi%d' % (included_module_name, i)) + prnt() + prnt("ffi = _cffi_backend.FFI('%s'," % (self.module_name,)) + prnt(" _version = 0x%x," % (self._version,)) + self._version = None + # + # the '_types' keyword argument + self.cffi_types = tuple(self.cffi_types) # don't change any more + types_lst = [op.as_python_bytes() for op in self.cffi_types] + prnt(' _types = %s,' % (self._to_py(''.join(types_lst)),)) + typeindex2type = dict([(i, tp) for (tp, i) in self._typesdict.items()]) + # + # the keyword arguments from ALL_STEPS + for step_name in self.ALL_STEPS: + lst = self._lsts[step_name] + if len(lst) > 0 and step_name != "field": + prnt(' _%ss = %s,' % (step_name, self._to_py(lst))) + # + # the '_includes' keyword argument + if num_includes > 0: + prnt(' _includes = (%s,),' % ( + ', '.join(['_ffi%d' % i for i in range(num_includes)]),)) + # + # the footer + prnt(')') + + # ---------- + + def _gettypenum(self, type): + # a KeyError here is a bug. please report it! :-) + return self._typesdict[type] + + def _convert_funcarg_to_c(self, tp, fromvar, tovar, errcode): + extraarg = '' + if isinstance(tp, model.BasePrimitiveType) and not tp.is_complex_type(): + if tp.is_integer_type() and tp.name != '_Bool': + converter = '_cffi_to_c_int' + extraarg = ', %s' % tp.name + elif isinstance(tp, model.UnknownFloatType): + # don't check with is_float_type(): it may be a 'long + # double' here, and _cffi_to_c_double would loose precision + converter = '(%s)_cffi_to_c_double' % (tp.get_c_name(''),) + else: + cname = tp.get_c_name('') + converter = '(%s)_cffi_to_c_%s' % (cname, + tp.name.replace(' ', '_')) + if cname in ('char16_t', 'char32_t'): + self.needs_version(VERSION_CHAR16CHAR32) + errvalue = '-1' + # + elif isinstance(tp, model.PointerType): + self._convert_funcarg_to_c_ptr_or_array(tp, fromvar, + tovar, errcode) + return + # + elif (isinstance(tp, model.StructOrUnionOrEnum) or + isinstance(tp, model.BasePrimitiveType)): + # a struct (not a struct pointer) as a function argument; + # or, a complex (the same code works) + self._prnt(' if (_cffi_to_c((char *)&%s, _cffi_type(%d), %s) < 0)' + % (tovar, self._gettypenum(tp), fromvar)) + self._prnt(' %s;' % errcode) + return + # + elif isinstance(tp, model.FunctionPtrType): + converter = '(%s)_cffi_to_c_pointer' % tp.get_c_name('') + extraarg = ', _cffi_type(%d)' % self._gettypenum(tp) + errvalue = 'NULL' + # + else: + raise NotImplementedError(tp) + # + self._prnt(' %s = %s(%s%s);' % (tovar, converter, fromvar, extraarg)) + self._prnt(' if (%s == (%s)%s && PyErr_Occurred())' % ( + tovar, tp.get_c_name(''), errvalue)) + self._prnt(' %s;' % errcode) + + def _extra_local_variables(self, tp, localvars, freelines): + if isinstance(tp, model.PointerType): + localvars.add('Py_ssize_t datasize') + localvars.add('struct _cffi_freeme_s *large_args_free = NULL') + freelines.add('if (large_args_free != NULL)' + ' _cffi_free_array_arguments(large_args_free);') + + def _convert_funcarg_to_c_ptr_or_array(self, tp, fromvar, tovar, errcode): + self._prnt(' datasize = _cffi_prepare_pointer_call_argument(') + self._prnt(' _cffi_type(%d), %s, (char **)&%s);' % ( + self._gettypenum(tp), fromvar, tovar)) + self._prnt(' if (datasize != 0) {') + self._prnt(' %s = ((size_t)datasize) <= 640 ? ' + '(%s)alloca((size_t)datasize) : NULL;' % ( + tovar, tp.get_c_name(''))) + self._prnt(' if (_cffi_convert_array_argument(_cffi_type(%d), %s, ' + '(char **)&%s,' % (self._gettypenum(tp), fromvar, tovar)) + self._prnt(' datasize, &large_args_free) < 0)') + self._prnt(' %s;' % errcode) + self._prnt(' }') + + def _convert_expr_from_c(self, tp, var, context): + if isinstance(tp, model.BasePrimitiveType): + if tp.is_integer_type() and tp.name != '_Bool': + return '_cffi_from_c_int(%s, %s)' % (var, tp.name) + elif isinstance(tp, model.UnknownFloatType): + return '_cffi_from_c_double(%s)' % (var,) + elif tp.name != 'long double' and not tp.is_complex_type(): + cname = tp.name.replace(' ', '_') + if cname in ('char16_t', 'char32_t'): + self.needs_version(VERSION_CHAR16CHAR32) + return '_cffi_from_c_%s(%s)' % (cname, var) + else: + return '_cffi_from_c_deref((char *)&%s, _cffi_type(%d))' % ( + var, self._gettypenum(tp)) + elif isinstance(tp, (model.PointerType, model.FunctionPtrType)): + return '_cffi_from_c_pointer((char *)%s, _cffi_type(%d))' % ( + var, self._gettypenum(tp)) + elif isinstance(tp, model.ArrayType): + return '_cffi_from_c_pointer((char *)%s, _cffi_type(%d))' % ( + var, self._gettypenum(model.PointerType(tp.item))) + elif isinstance(tp, model.StructOrUnion): + if tp.fldnames is None: + raise TypeError("'%s' is used as %s, but is opaque" % ( + tp._get_c_name(), context)) + return '_cffi_from_c_struct((char *)&%s, _cffi_type(%d))' % ( + var, self._gettypenum(tp)) + elif isinstance(tp, model.EnumType): + return '_cffi_from_c_deref((char *)&%s, _cffi_type(%d))' % ( + var, self._gettypenum(tp)) + else: + raise NotImplementedError(tp) + + # ---------- + # typedefs + + def _typedef_type(self, tp, name): + return self._global_type(tp, "(*(%s *)0)" % (name,)) + + def _generate_cpy_typedef_collecttype(self, tp, name): + self._do_collect_type(self._typedef_type(tp, name)) + + def _generate_cpy_typedef_decl(self, tp, name): + pass + + def _typedef_ctx(self, tp, name): + type_index = self._typesdict[tp] + self._lsts["typename"].append(TypenameExpr(name, type_index)) + + def _generate_cpy_typedef_ctx(self, tp, name): + tp = self._typedef_type(tp, name) + self._typedef_ctx(tp, name) + if getattr(tp, "origin", None) == "unknown_type": + self._struct_ctx(tp, tp.name, approxname=None) + elif isinstance(tp, model.NamedPointerType): + self._struct_ctx(tp.totype, tp.totype.name, approxname=tp.name, + named_ptr=tp) + + # ---------- + # function declarations + + def _generate_cpy_function_collecttype(self, tp, name): + self._do_collect_type(tp.as_raw_function()) + if tp.ellipsis and not self.target_is_python: + self._do_collect_type(tp) + + def _generate_cpy_function_decl(self, tp, name): + assert not self.target_is_python + assert isinstance(tp, model.FunctionPtrType) + if tp.ellipsis: + # cannot support vararg functions better than this: check for its + # exact type (including the fixed arguments), and build it as a + # constant function pointer (no CPython wrapper) + self._generate_cpy_constant_decl(tp, name) + return + prnt = self._prnt + numargs = len(tp.args) + if numargs == 0: + argname = 'noarg' + elif numargs == 1: + argname = 'arg0' + else: + argname = 'args' + # + # ------------------------------ + # the 'd' version of the function, only for addressof(lib, 'func') + arguments = [] + call_arguments = [] + context = 'argument of %s' % name + for i, type in enumerate(tp.args): + arguments.append(type.get_c_name(' x%d' % i, context)) + call_arguments.append('x%d' % i) + repr_arguments = ', '.join(arguments) + repr_arguments = repr_arguments or 'void' + if tp.abi: + abi = tp.abi + ' ' + else: + abi = '' + name_and_arguments = '%s_cffi_d_%s(%s)' % (abi, name, repr_arguments) + prnt('static %s' % (tp.result.get_c_name(name_and_arguments),)) + prnt('{') + call_arguments = ', '.join(call_arguments) + result_code = 'return ' + if isinstance(tp.result, model.VoidType): + result_code = '' + prnt(' %s%s(%s);' % (result_code, name, call_arguments)) + prnt('}') + # + prnt('#ifndef PYPY_VERSION') # ------------------------------ + # + prnt('static PyObject *') + prnt('_cffi_f_%s(PyObject *self, PyObject *%s)' % (name, argname)) + prnt('{') + # + context = 'argument of %s' % name + for i, type in enumerate(tp.args): + arg = type.get_c_name(' x%d' % i, context) + prnt(' %s;' % arg) + # + localvars = set() + freelines = set() + for type in tp.args: + self._extra_local_variables(type, localvars, freelines) + for decl in sorted(localvars): + prnt(' %s;' % (decl,)) + # + if not isinstance(tp.result, model.VoidType): + result_code = 'result = ' + context = 'result of %s' % name + result_decl = ' %s;' % tp.result.get_c_name(' result', context) + prnt(result_decl) + prnt(' PyObject *pyresult;') + else: + result_decl = None + result_code = '' + # + if len(tp.args) > 1: + rng = range(len(tp.args)) + for i in rng: + prnt(' PyObject *arg%d;' % i) + prnt() + prnt(' if (!PyArg_UnpackTuple(args, "%s", %d, %d, %s))' % ( + name, len(rng), len(rng), + ', '.join(['&arg%d' % i for i in rng]))) + prnt(' return NULL;') + prnt() + # + for i, type in enumerate(tp.args): + self._convert_funcarg_to_c(type, 'arg%d' % i, 'x%d' % i, + 'return NULL') + prnt() + # + prnt(' Py_BEGIN_ALLOW_THREADS') + prnt(' _cffi_restore_errno();') + call_arguments = ['x%d' % i for i in range(len(tp.args))] + call_arguments = ', '.join(call_arguments) + prnt(' { %s%s(%s); }' % (result_code, name, call_arguments)) + prnt(' _cffi_save_errno();') + prnt(' Py_END_ALLOW_THREADS') + prnt() + # + prnt(' (void)self; /* unused */') + if numargs == 0: + prnt(' (void)noarg; /* unused */') + if result_code: + prnt(' pyresult = %s;' % + self._convert_expr_from_c(tp.result, 'result', 'result type')) + for freeline in freelines: + prnt(' ' + freeline) + prnt(' return pyresult;') + else: + for freeline in freelines: + prnt(' ' + freeline) + prnt(' Py_INCREF(Py_None);') + prnt(' return Py_None;') + prnt('}') + # + prnt('#else') # ------------------------------ + # + # the PyPy version: need to replace struct/union arguments with + # pointers, and if the result is a struct/union, insert a first + # arg that is a pointer to the result. We also do that for + # complex args and return type. + def need_indirection(type): + return (isinstance(type, model.StructOrUnion) or + (isinstance(type, model.PrimitiveType) and + type.is_complex_type())) + difference = False + arguments = [] + call_arguments = [] + context = 'argument of %s' % name + for i, type in enumerate(tp.args): + indirection = '' + if need_indirection(type): + indirection = '*' + difference = True + arg = type.get_c_name(' %sx%d' % (indirection, i), context) + arguments.append(arg) + call_arguments.append('%sx%d' % (indirection, i)) + tp_result = tp.result + if need_indirection(tp_result): + context = 'result of %s' % name + arg = tp_result.get_c_name(' *result', context) + arguments.insert(0, arg) + tp_result = model.void_type + result_decl = None + result_code = '*result = ' + difference = True + if difference: + repr_arguments = ', '.join(arguments) + repr_arguments = repr_arguments or 'void' + name_and_arguments = '%s_cffi_f_%s(%s)' % (abi, name, + repr_arguments) + prnt('static %s' % (tp_result.get_c_name(name_and_arguments),)) + prnt('{') + if result_decl: + prnt(result_decl) + call_arguments = ', '.join(call_arguments) + prnt(' { %s%s(%s); }' % (result_code, name, call_arguments)) + if result_decl: + prnt(' return result;') + prnt('}') + else: + prnt('# define _cffi_f_%s _cffi_d_%s' % (name, name)) + # + prnt('#endif') # ------------------------------ + prnt() + + def _generate_cpy_function_ctx(self, tp, name): + if tp.ellipsis and not self.target_is_python: + self._generate_cpy_constant_ctx(tp, name) + return + type_index = self._typesdict[tp.as_raw_function()] + numargs = len(tp.args) + if self.target_is_python: + meth_kind = OP_DLOPEN_FUNC + elif numargs == 0: + meth_kind = OP_CPYTHON_BLTN_N # 'METH_NOARGS' + elif numargs == 1: + meth_kind = OP_CPYTHON_BLTN_O # 'METH_O' + else: + meth_kind = OP_CPYTHON_BLTN_V # 'METH_VARARGS' + self._lsts["global"].append( + GlobalExpr(name, '_cffi_f_%s' % name, + CffiOp(meth_kind, type_index), + size='_cffi_d_%s' % name)) + + # ---------- + # named structs or unions + + def _field_type(self, tp_struct, field_name, tp_field): + if isinstance(tp_field, model.ArrayType): + actual_length = tp_field.length + if actual_length == '...': + ptr_struct_name = tp_struct.get_c_name('*') + actual_length = '_cffi_array_len(((%s)0)->%s)' % ( + ptr_struct_name, field_name) + tp_item = self._field_type(tp_struct, '%s[0]' % field_name, + tp_field.item) + tp_field = model.ArrayType(tp_item, actual_length) + return tp_field + + def _struct_collecttype(self, tp): + self._do_collect_type(tp) + if self.target_is_python: + # also requires nested anon struct/unions in ABI mode, recursively + for fldtype in tp.anonymous_struct_fields(): + self._struct_collecttype(fldtype) + + def _struct_decl(self, tp, cname, approxname): + if tp.fldtypes is None: + return + prnt = self._prnt + checkfuncname = '_cffi_checkfld_%s' % (approxname,) + prnt('_CFFI_UNUSED_FN') + prnt('static void %s(%s *p)' % (checkfuncname, cname)) + prnt('{') + prnt(' /* only to generate compile-time warnings or errors */') + prnt(' (void)p;') + for fname, ftype, fbitsize, fqual in self._enum_fields(tp): + try: + if ftype.is_integer_type() or fbitsize >= 0: + # accept all integers, but complain on float or double + if fname != '': + prnt(" (void)((p->%s) | 0); /* check that '%s.%s' is " + "an integer */" % (fname, cname, fname)) + continue + # only accept exactly the type declared, except that '[]' + # is interpreted as a '*' and so will match any array length. + # (It would also match '*', but that's harder to detect...) + while (isinstance(ftype, model.ArrayType) + and (ftype.length is None or ftype.length == '...')): + ftype = ftype.item + fname = fname + '[0]' + prnt(' { %s = &p->%s; (void)tmp; }' % ( + ftype.get_c_name('*tmp', 'field %r'%fname, quals=fqual), + fname)) + except VerificationError as e: + prnt(' /* %s */' % str(e)) # cannot verify it, ignore + prnt('}') + prnt('struct _cffi_align_%s { char x; %s y; };' % (approxname, cname)) + prnt() + + def _struct_ctx(self, tp, cname, approxname, named_ptr=None): + type_index = self._typesdict[tp] + reason_for_not_expanding = None + flags = [] + if isinstance(tp, model.UnionType): + flags.append("_CFFI_F_UNION") + if tp.fldtypes is None: + flags.append("_CFFI_F_OPAQUE") + reason_for_not_expanding = "opaque" + if (tp not in self.ffi._parser._included_declarations and + (named_ptr is None or + named_ptr not in self.ffi._parser._included_declarations)): + if tp.fldtypes is None: + pass # opaque + elif tp.partial or any(tp.anonymous_struct_fields()): + pass # field layout obtained silently from the C compiler + else: + flags.append("_CFFI_F_CHECK_FIELDS") + if tp.packed: + if tp.packed > 1: + raise NotImplementedError( + "%r is declared with 'pack=%r'; only 0 or 1 are " + "supported in API mode (try to use \"...;\", which " + "does not require a 'pack' declaration)" % + (tp, tp.packed)) + flags.append("_CFFI_F_PACKED") + else: + flags.append("_CFFI_F_EXTERNAL") + reason_for_not_expanding = "external" + flags = '|'.join(flags) or '0' + c_fields = [] + if reason_for_not_expanding is None: + enumfields = list(self._enum_fields(tp)) + for fldname, fldtype, fbitsize, fqual in enumfields: + fldtype = self._field_type(tp, fldname, fldtype) + self._check_not_opaque(fldtype, + "field '%s.%s'" % (tp.name, fldname)) + # cname is None for _add_missing_struct_unions() only + op = OP_NOOP + if fbitsize >= 0: + op = OP_BITFIELD + size = '%d /* bits */' % fbitsize + elif cname is None or ( + isinstance(fldtype, model.ArrayType) and + fldtype.length is None): + size = '(size_t)-1' + else: + size = 'sizeof(((%s)0)->%s)' % ( + tp.get_c_name('*') if named_ptr is None + else named_ptr.name, + fldname) + if cname is None or fbitsize >= 0: + offset = '(size_t)-1' + elif named_ptr is not None: + offset = '(size_t)(((char *)&((%s)4096)->%s) - (char *)4096)' % ( + named_ptr.name, fldname) + else: + offset = 'offsetof(%s, %s)' % (tp.get_c_name(''), fldname) + c_fields.append( + FieldExpr(fldname, offset, size, fbitsize, + CffiOp(op, self._typesdict[fldtype]))) + first_field_index = len(self._lsts["field"]) + self._lsts["field"].extend(c_fields) + # + if cname is None: # unknown name, for _add_missing_struct_unions + size = '(size_t)-2' + align = -2 + comment = "unnamed" + else: + if named_ptr is not None: + size = 'sizeof(*(%s)0)' % (named_ptr.name,) + align = '-1 /* unknown alignment */' + else: + size = 'sizeof(%s)' % (cname,) + align = 'offsetof(struct _cffi_align_%s, y)' % (approxname,) + comment = None + else: + size = '(size_t)-1' + align = -1 + first_field_index = -1 + comment = reason_for_not_expanding + self._lsts["struct_union"].append( + StructUnionExpr(tp.name, type_index, flags, size, align, comment, + first_field_index, c_fields)) + self._seen_struct_unions.add(tp) + + def _check_not_opaque(self, tp, location): + while isinstance(tp, model.ArrayType): + tp = tp.item + if isinstance(tp, model.StructOrUnion) and tp.fldtypes is None: + raise TypeError( + "%s is of an opaque type (not declared in cdef())" % location) + + def _add_missing_struct_unions(self): + # not very nice, but some struct declarations might be missing + # because they don't have any known C name. Check that they are + # not partial (we can't complete or verify them!) and emit them + # anonymously. + lst = list(self._struct_unions.items()) + lst.sort(key=lambda tp_order: tp_order[1]) + for tp, order in lst: + if tp not in self._seen_struct_unions: + if tp.partial: + raise NotImplementedError("internal inconsistency: %r is " + "partial but was not seen at " + "this point" % (tp,)) + if tp.name.startswith('$') and tp.name[1:].isdigit(): + approxname = tp.name[1:] + elif tp.name == '_IO_FILE' and tp.forcename == 'FILE': + approxname = 'FILE' + self._typedef_ctx(tp, 'FILE') + else: + raise NotImplementedError("internal inconsistency: %r" % + (tp,)) + self._struct_ctx(tp, None, approxname) + + def _generate_cpy_struct_collecttype(self, tp, name): + self._struct_collecttype(tp) + _generate_cpy_union_collecttype = _generate_cpy_struct_collecttype + + def _struct_names(self, tp): + cname = tp.get_c_name('') + if ' ' in cname: + return cname, cname.replace(' ', '_') + else: + return cname, '_' + cname + + def _generate_cpy_struct_decl(self, tp, name): + self._struct_decl(tp, *self._struct_names(tp)) + _generate_cpy_union_decl = _generate_cpy_struct_decl + + def _generate_cpy_struct_ctx(self, tp, name): + self._struct_ctx(tp, *self._struct_names(tp)) + _generate_cpy_union_ctx = _generate_cpy_struct_ctx + + # ---------- + # 'anonymous' declarations. These are produced for anonymous structs + # or unions; the 'name' is obtained by a typedef. + + def _generate_cpy_anonymous_collecttype(self, tp, name): + if isinstance(tp, model.EnumType): + self._generate_cpy_enum_collecttype(tp, name) + else: + self._struct_collecttype(tp) + + def _generate_cpy_anonymous_decl(self, tp, name): + if isinstance(tp, model.EnumType): + self._generate_cpy_enum_decl(tp) + else: + self._struct_decl(tp, name, 'typedef_' + name) + + def _generate_cpy_anonymous_ctx(self, tp, name): + if isinstance(tp, model.EnumType): + self._enum_ctx(tp, name) + else: + self._struct_ctx(tp, name, 'typedef_' + name) + + # ---------- + # constants, declared with "static const ..." + + def _generate_cpy_const(self, is_int, name, tp=None, category='const', + check_value=None): + if (category, name) in self._seen_constants: + raise VerificationError( + "duplicate declaration of %s '%s'" % (category, name)) + self._seen_constants.add((category, name)) + # + prnt = self._prnt + funcname = '_cffi_%s_%s' % (category, name) + if is_int: + prnt('static int %s(unsigned long long *o)' % funcname) + prnt('{') + prnt(' int n = (%s) <= 0;' % (name,)) + prnt(' *o = (unsigned long long)((%s) | 0);' + ' /* check that %s is an integer */' % (name, name)) + if check_value is not None: + if check_value > 0: + check_value = '%dU' % (check_value,) + prnt(' if (!_cffi_check_int(*o, n, %s))' % (check_value,)) + prnt(' n |= 2;') + prnt(' return n;') + prnt('}') + else: + assert check_value is None + prnt('static void %s(char *o)' % funcname) + prnt('{') + prnt(' *(%s)o = %s;' % (tp.get_c_name('*'), name)) + prnt('}') + prnt() + + def _generate_cpy_constant_collecttype(self, tp, name): + is_int = tp.is_integer_type() + if not is_int or self.target_is_python: + self._do_collect_type(tp) + + def _generate_cpy_constant_decl(self, tp, name): + is_int = tp.is_integer_type() + self._generate_cpy_const(is_int, name, tp) + + def _generate_cpy_constant_ctx(self, tp, name): + if not self.target_is_python and tp.is_integer_type(): + type_op = CffiOp(OP_CONSTANT_INT, -1) + else: + if self.target_is_python: + const_kind = OP_DLOPEN_CONST + else: + const_kind = OP_CONSTANT + type_index = self._typesdict[tp] + type_op = CffiOp(const_kind, type_index) + self._lsts["global"].append( + GlobalExpr(name, '_cffi_const_%s' % name, type_op)) + + # ---------- + # enums + + def _generate_cpy_enum_collecttype(self, tp, name): + self._do_collect_type(tp) + + def _generate_cpy_enum_decl(self, tp, name=None): + for enumerator in tp.enumerators: + self._generate_cpy_const(True, enumerator) + + def _enum_ctx(self, tp, cname): + type_index = self._typesdict[tp] + type_op = CffiOp(OP_ENUM, -1) + if self.target_is_python: + tp.check_not_partial() + for enumerator, enumvalue in zip(tp.enumerators, tp.enumvalues): + self._lsts["global"].append( + GlobalExpr(enumerator, '_cffi_const_%s' % enumerator, type_op, + check_value=enumvalue)) + # + if cname is not None and '$' not in cname and not self.target_is_python: + size = "sizeof(%s)" % cname + signed = "((%s)-1) <= 0" % cname + else: + basetp = tp.build_baseinttype(self.ffi, []) + size = self.ffi.sizeof(basetp) + signed = int(int(self.ffi.cast(basetp, -1)) < 0) + allenums = ",".join(tp.enumerators) + self._lsts["enum"].append( + EnumExpr(tp.name, type_index, size, signed, allenums)) + + def _generate_cpy_enum_ctx(self, tp, name): + self._enum_ctx(tp, tp._get_c_name()) + + # ---------- + # macros: for now only for integers + + def _generate_cpy_macro_collecttype(self, tp, name): + pass + + def _generate_cpy_macro_decl(self, tp, name): + if tp == '...': + check_value = None + else: + check_value = tp # an integer + self._generate_cpy_const(True, name, check_value=check_value) + + def _generate_cpy_macro_ctx(self, tp, name): + if tp == '...': + if self.target_is_python: + raise VerificationError( + "cannot use the syntax '...' in '#define %s ...' when " + "using the ABI mode" % (name,)) + check_value = None + else: + check_value = tp # an integer + type_op = CffiOp(OP_CONSTANT_INT, -1) + self._lsts["global"].append( + GlobalExpr(name, '_cffi_const_%s' % name, type_op, + check_value=check_value)) + + # ---------- + # global variables + + def _global_type(self, tp, global_name): + if isinstance(tp, model.ArrayType): + actual_length = tp.length + if actual_length == '...': + actual_length = '_cffi_array_len(%s)' % (global_name,) + tp_item = self._global_type(tp.item, '%s[0]' % global_name) + tp = model.ArrayType(tp_item, actual_length) + return tp + + def _generate_cpy_variable_collecttype(self, tp, name): + self._do_collect_type(self._global_type(tp, name)) + + def _generate_cpy_variable_decl(self, tp, name): + prnt = self._prnt + tp = self._global_type(tp, name) + if isinstance(tp, model.ArrayType) and tp.length is None: + tp = tp.item + ampersand = '' + else: + ampersand = '&' + # This code assumes that casts from "tp *" to "void *" is a + # no-op, i.e. a function that returns a "tp *" can be called + # as if it returned a "void *". This should be generally true + # on any modern machine. The only exception to that rule (on + # uncommon architectures, and as far as I can tell) might be + # if 'tp' were a function type, but that is not possible here. + # (If 'tp' is a function _pointer_ type, then casts from "fn_t + # **" to "void *" are again no-ops, as far as I can tell.) + decl = '*_cffi_var_%s(void)' % (name,) + prnt('static ' + tp.get_c_name(decl, quals=self._current_quals)) + prnt('{') + prnt(' return %s(%s);' % (ampersand, name)) + prnt('}') + prnt() + + def _generate_cpy_variable_ctx(self, tp, name): + tp = self._global_type(tp, name) + type_index = self._typesdict[tp] + if self.target_is_python: + op = OP_GLOBAL_VAR + else: + op = OP_GLOBAL_VAR_F + self._lsts["global"].append( + GlobalExpr(name, '_cffi_var_%s' % name, CffiOp(op, type_index))) + + # ---------- + # extern "Python" + + def _generate_cpy_extern_python_collecttype(self, tp, name): + assert isinstance(tp, model.FunctionPtrType) + self._do_collect_type(tp) + _generate_cpy_dllexport_python_collecttype = \ + _generate_cpy_extern_python_plus_c_collecttype = \ + _generate_cpy_extern_python_collecttype + + def _extern_python_decl(self, tp, name, tag_and_space): + prnt = self._prnt + if isinstance(tp.result, model.VoidType): + size_of_result = '0' + else: + context = 'result of %s' % name + size_of_result = '(int)sizeof(%s)' % ( + tp.result.get_c_name('', context),) + prnt('static struct _cffi_externpy_s _cffi_externpy__%s =' % name) + prnt(' { "%s.%s", %s, 0, 0 };' % ( + self.module_name, name, size_of_result)) + prnt() + # + arguments = [] + context = 'argument of %s' % name + for i, type in enumerate(tp.args): + arg = type.get_c_name(' a%d' % i, context) + arguments.append(arg) + # + repr_arguments = ', '.join(arguments) + repr_arguments = repr_arguments or 'void' + name_and_arguments = '%s(%s)' % (name, repr_arguments) + if tp.abi == "__stdcall": + name_and_arguments = '_cffi_stdcall ' + name_and_arguments + # + def may_need_128_bits(tp): + return (isinstance(tp, model.PrimitiveType) and + tp.name == 'long double') + # + size_of_a = max(len(tp.args)*8, 8) + if may_need_128_bits(tp.result): + size_of_a = max(size_of_a, 16) + if isinstance(tp.result, model.StructOrUnion): + size_of_a = 'sizeof(%s) > %d ? sizeof(%s) : %d' % ( + tp.result.get_c_name(''), size_of_a, + tp.result.get_c_name(''), size_of_a) + prnt('%s%s' % (tag_and_space, tp.result.get_c_name(name_and_arguments))) + prnt('{') + prnt(' char a[%s];' % size_of_a) + prnt(' char *p = a;') + for i, type in enumerate(tp.args): + arg = 'a%d' % i + if (isinstance(type, model.StructOrUnion) or + may_need_128_bits(type)): + arg = '&' + arg + type = model.PointerType(type) + prnt(' *(%s)(p + %d) = %s;' % (type.get_c_name('*'), i*8, arg)) + prnt(' _cffi_call_python(&_cffi_externpy__%s, p);' % name) + if not isinstance(tp.result, model.VoidType): + prnt(' return *(%s)p;' % (tp.result.get_c_name('*'),)) + prnt('}') + prnt() + self._num_externpy += 1 + + def _generate_cpy_extern_python_decl(self, tp, name): + self._extern_python_decl(tp, name, 'static ') + + def _generate_cpy_dllexport_python_decl(self, tp, name): + self._extern_python_decl(tp, name, 'CFFI_DLLEXPORT ') + + def _generate_cpy_extern_python_plus_c_decl(self, tp, name): + self._extern_python_decl(tp, name, '') + + def _generate_cpy_extern_python_ctx(self, tp, name): + if self.target_is_python: + raise VerificationError( + "cannot use 'extern \"Python\"' in the ABI mode") + if tp.ellipsis: + raise NotImplementedError("a vararg function is extern \"Python\"") + type_index = self._typesdict[tp] + type_op = CffiOp(OP_EXTERN_PYTHON, type_index) + self._lsts["global"].append( + GlobalExpr(name, '&_cffi_externpy__%s' % name, type_op, name)) + + _generate_cpy_dllexport_python_ctx = \ + _generate_cpy_extern_python_plus_c_ctx = \ + _generate_cpy_extern_python_ctx + + def _print_string_literal_in_array(self, s): + prnt = self._prnt + prnt('// # NB. this is not a string because of a size limit in MSVC') + if not isinstance(s, bytes): # unicode + s = s.encode('utf-8') # -> bytes + else: + s.decode('utf-8') # got bytes, check for valid utf-8 + try: + s.decode('ascii') + except UnicodeDecodeError: + s = b'# -*- encoding: utf8 -*-\n' + s + for line in s.splitlines(True): + comment = line + if type('//') is bytes: # python2 + line = map(ord, line) # make a list of integers + else: # python3 + # type(line) is bytes, which enumerates like a list of integers + comment = ascii(comment)[1:-1] + prnt(('// ' + comment).rstrip()) + printed_line = '' + for c in line: + if len(printed_line) >= 76: + prnt(printed_line) + printed_line = '' + printed_line += '%d,' % (c,) + prnt(printed_line) + + # ---------- + # emitting the opcodes for individual types + + def _emit_bytecode_VoidType(self, tp, index): + self.cffi_types[index] = CffiOp(OP_PRIMITIVE, PRIM_VOID) + + def _emit_bytecode_PrimitiveType(self, tp, index): + prim_index = PRIMITIVE_TO_INDEX[tp.name] + self.cffi_types[index] = CffiOp(OP_PRIMITIVE, prim_index) + + def _emit_bytecode_UnknownIntegerType(self, tp, index): + s = ('_cffi_prim_int(sizeof(%s), (\n' + ' ((%s)-1) | 0 /* check that %s is an integer type */\n' + ' ) <= 0)' % (tp.name, tp.name, tp.name)) + self.cffi_types[index] = CffiOp(OP_PRIMITIVE, s) + + def _emit_bytecode_UnknownFloatType(self, tp, index): + s = ('_cffi_prim_float(sizeof(%s) *\n' + ' (((%s)1) / 2) * 2 /* integer => 0, float => 1 */\n' + ' )' % (tp.name, tp.name)) + self.cffi_types[index] = CffiOp(OP_PRIMITIVE, s) + + def _emit_bytecode_RawFunctionType(self, tp, index): + self.cffi_types[index] = CffiOp(OP_FUNCTION, self._typesdict[tp.result]) + index += 1 + for tp1 in tp.args: + realindex = self._typesdict[tp1] + if index != realindex: + if isinstance(tp1, model.PrimitiveType): + self._emit_bytecode_PrimitiveType(tp1, index) + else: + self.cffi_types[index] = CffiOp(OP_NOOP, realindex) + index += 1 + flags = int(tp.ellipsis) + if tp.abi is not None: + if tp.abi == '__stdcall': + flags |= 2 + else: + raise NotImplementedError("abi=%r" % (tp.abi,)) + self.cffi_types[index] = CffiOp(OP_FUNCTION_END, flags) + + def _emit_bytecode_PointerType(self, tp, index): + self.cffi_types[index] = CffiOp(OP_POINTER, self._typesdict[tp.totype]) + + _emit_bytecode_ConstPointerType = _emit_bytecode_PointerType + _emit_bytecode_NamedPointerType = _emit_bytecode_PointerType + + def _emit_bytecode_FunctionPtrType(self, tp, index): + raw = tp.as_raw_function() + self.cffi_types[index] = CffiOp(OP_POINTER, self._typesdict[raw]) + + def _emit_bytecode_ArrayType(self, tp, index): + item_index = self._typesdict[tp.item] + if tp.length is None: + self.cffi_types[index] = CffiOp(OP_OPEN_ARRAY, item_index) + elif tp.length == '...': + raise VerificationError( + "type %s badly placed: the '...' array length can only be " + "used on global arrays or on fields of structures" % ( + str(tp).replace('/*...*/', '...'),)) + else: + assert self.cffi_types[index + 1] == 'LEN' + self.cffi_types[index] = CffiOp(OP_ARRAY, item_index) + self.cffi_types[index + 1] = CffiOp(None, str(tp.length)) + + def _emit_bytecode_StructType(self, tp, index): + struct_index = self._struct_unions[tp] + self.cffi_types[index] = CffiOp(OP_STRUCT_UNION, struct_index) + _emit_bytecode_UnionType = _emit_bytecode_StructType + + def _emit_bytecode_EnumType(self, tp, index): + enum_index = self._enums[tp] + self.cffi_types[index] = CffiOp(OP_ENUM, enum_index) + + +if sys.version_info >= (3,): + NativeIO = io.StringIO +else: + class NativeIO(io.BytesIO): + def write(self, s): + if isinstance(s, unicode): + s = s.encode('ascii') + super(NativeIO, self).write(s) + +def _is_file_like(maybefile): + # compare to xml.etree.ElementTree._get_writer + return hasattr(maybefile, 'write') + +def _make_c_or_py_source(ffi, module_name, preamble, target_file, verbose): + if verbose: + print("generating %s" % (target_file,)) + recompiler = Recompiler(ffi, module_name, + target_is_python=(preamble is None)) + recompiler.collect_type_table() + recompiler.collect_step_tables() + if _is_file_like(target_file): + recompiler.write_source_to_f(target_file, preamble) + return True + f = NativeIO() + recompiler.write_source_to_f(f, preamble) + output = f.getvalue() + try: + with open(target_file, 'r') as f1: + if f1.read(len(output) + 1) != output: + raise IOError + if verbose: + print("(already up-to-date)") + return False # already up-to-date + except IOError: + tmp_file = '%s.~%d' % (target_file, os.getpid()) + with open(tmp_file, 'w') as f1: + f1.write(output) + try: + os.rename(tmp_file, target_file) + except OSError: + os.unlink(target_file) + os.rename(tmp_file, target_file) + return True + +def make_c_source(ffi, module_name, preamble, target_c_file, verbose=False): + assert preamble is not None + return _make_c_or_py_source(ffi, module_name, preamble, target_c_file, + verbose) + +def make_py_source(ffi, module_name, target_py_file, verbose=False): + return _make_c_or_py_source(ffi, module_name, None, target_py_file, + verbose) + +def _modname_to_file(outputdir, modname, extension): + parts = modname.split('.') + try: + os.makedirs(os.path.join(outputdir, *parts[:-1])) + except OSError: + pass + parts[-1] += extension + return os.path.join(outputdir, *parts), parts + + +# Aaargh. Distutils is not tested at all for the purpose of compiling +# DLLs that are not extension modules. Here are some hacks to work +# around that, in the _patch_for_*() functions... + +def _patch_meth(patchlist, cls, name, new_meth): + old = getattr(cls, name) + patchlist.append((cls, name, old)) + setattr(cls, name, new_meth) + return old + +def _unpatch_meths(patchlist): + for cls, name, old_meth in reversed(patchlist): + setattr(cls, name, old_meth) + +def _patch_for_embedding(patchlist): + if sys.platform == 'win32': + # we must not remove the manifest when building for embedding! + # FUTURE: this module was removed in setuptools 74; this is likely dead code and should be removed, + # since the toolchain it supports (VS2005-2008) is also long dead. + from cffi._shimmed_dist_utils import MSVCCompiler + if MSVCCompiler is not None: + _patch_meth(patchlist, MSVCCompiler, '_remove_visual_c_ref', + lambda self, manifest_file: manifest_file) + + if sys.platform == 'darwin': + # we must not make a '-bundle', but a '-dynamiclib' instead + from cffi._shimmed_dist_utils import CCompiler + def my_link_shared_object(self, *args, **kwds): + if '-bundle' in self.linker_so: + self.linker_so = list(self.linker_so) + i = self.linker_so.index('-bundle') + self.linker_so[i] = '-dynamiclib' + return old_link_shared_object(self, *args, **kwds) + old_link_shared_object = _patch_meth(patchlist, CCompiler, + 'link_shared_object', + my_link_shared_object) + +def _patch_for_target(patchlist, target): + from cffi._shimmed_dist_utils import build_ext + # if 'target' is different from '*', we need to patch some internal + # method to just return this 'target' value, instead of having it + # built from module_name + if target.endswith('.*'): + target = target[:-2] + if sys.platform == 'win32': + target += '.dll' + elif sys.platform == 'darwin': + target += '.dylib' + else: + target += '.so' + _patch_meth(patchlist, build_ext, 'get_ext_filename', + lambda self, ext_name: target) + + +def recompile(ffi, module_name, preamble, tmpdir='.', call_c_compiler=True, + c_file=None, source_extension='.c', extradir=None, + compiler_verbose=1, target=None, debug=None, + uses_ffiplatform=True, **kwds): + if not isinstance(module_name, str): + module_name = module_name.encode('ascii') + if ffi._windows_unicode: + ffi._apply_windows_unicode(kwds) + if preamble is not None: + if call_c_compiler and _is_file_like(c_file): + raise TypeError("Writing to file-like objects is not supported " + "with call_c_compiler=True") + embedding = (ffi._embedding is not None) + if embedding: + ffi._apply_embedding_fix(kwds) + if c_file is None: + c_file, parts = _modname_to_file(tmpdir, module_name, + source_extension) + if extradir: + parts = [extradir] + parts + ext_c_file = os.path.join(*parts) + else: + ext_c_file = c_file + # + if target is None: + if embedding: + target = '%s.*' % module_name + else: + target = '*' + # + if uses_ffiplatform: + ext = ffiplatform.get_extension(ext_c_file, module_name, **kwds) + else: + ext = None + updated = make_c_source(ffi, module_name, preamble, c_file, + verbose=compiler_verbose) + if call_c_compiler: + patchlist = [] + cwd = os.getcwd() + try: + if embedding: + _patch_for_embedding(patchlist) + if target != '*': + _patch_for_target(patchlist, target) + if compiler_verbose: + if tmpdir == '.': + msg = 'the current directory is' + else: + msg = 'setting the current directory to' + print('%s %r' % (msg, os.path.abspath(tmpdir))) + os.chdir(tmpdir) + outputfilename = ffiplatform.compile('.', ext, + compiler_verbose, debug) + finally: + os.chdir(cwd) + _unpatch_meths(patchlist) + return outputfilename + else: + return ext, updated + else: + if c_file is None: + c_file, _ = _modname_to_file(tmpdir, module_name, '.py') + updated = make_py_source(ffi, module_name, c_file, + verbose=compiler_verbose) + if call_c_compiler: + return c_file + else: + return None, updated + diff --git a/venv/lib/python3.10/site-packages/cffi/setuptools_ext.py b/venv/lib/python3.10/site-packages/cffi/setuptools_ext.py new file mode 100644 index 0000000000000000000000000000000000000000..5cdd246fb4dfb808dc8b09df5724a68386fa4bc3 --- /dev/null +++ b/venv/lib/python3.10/site-packages/cffi/setuptools_ext.py @@ -0,0 +1,229 @@ +import os +import sys +import sysconfig + +try: + basestring +except NameError: + # Python 3.x + basestring = str + +def error(msg): + from cffi._shimmed_dist_utils import DistutilsSetupError + raise DistutilsSetupError(msg) + + +def execfile(filename, glob): + # We use execfile() (here rewritten for Python 3) instead of + # __import__() to load the build script. The problem with + # a normal import is that in some packages, the intermediate + # __init__.py files may already try to import the file that + # we are generating. + with open(filename) as f: + src = f.read() + src += '\n' # Python 2.6 compatibility + code = compile(src, filename, 'exec') + exec(code, glob, glob) + + +def add_cffi_module(dist, mod_spec): + from cffi.api import FFI + + if not isinstance(mod_spec, basestring): + error("argument to 'cffi_modules=...' must be a str or a list of str," + " not %r" % (type(mod_spec).__name__,)) + mod_spec = str(mod_spec) + try: + build_file_name, ffi_var_name = mod_spec.split(':') + except ValueError: + error("%r must be of the form 'path/build.py:ffi_variable'" % + (mod_spec,)) + if not os.path.exists(build_file_name): + ext = '' + rewritten = build_file_name.replace('.', '/') + '.py' + if os.path.exists(rewritten): + ext = ' (rewrite cffi_modules to [%r])' % ( + rewritten + ':' + ffi_var_name,) + error("%r does not name an existing file%s" % (build_file_name, ext)) + + mod_vars = {'__name__': '__cffi__', '__file__': build_file_name} + execfile(build_file_name, mod_vars) + + try: + ffi = mod_vars[ffi_var_name] + except KeyError: + error("%r: object %r not found in module" % (mod_spec, + ffi_var_name)) + if not isinstance(ffi, FFI): + ffi = ffi() # maybe it's a function instead of directly an ffi + if not isinstance(ffi, FFI): + error("%r is not an FFI instance (got %r)" % (mod_spec, + type(ffi).__name__)) + if not hasattr(ffi, '_assigned_source'): + error("%r: the set_source() method was not called" % (mod_spec,)) + module_name, source, source_extension, kwds = ffi._assigned_source + if ffi._windows_unicode: + kwds = kwds.copy() + ffi._apply_windows_unicode(kwds) + + if source is None: + _add_py_module(dist, ffi, module_name) + else: + _add_c_module(dist, ffi, module_name, source, source_extension, kwds) + +def _set_py_limited_api(Extension, kwds): + """ + Add py_limited_api to kwds if setuptools >= 26 is in use. + Do not alter the setting if it already exists. + Setuptools takes care of ignoring the flag on Python 2 and PyPy. + + CPython itself should ignore the flag in a debugging version + (by not listing .abi3.so in the extensions it supports), but + it doesn't so far, creating troubles. That's why we check + for "not hasattr(sys, 'gettotalrefcount')" (the 2.7 compatible equivalent + of 'd' not in sys.abiflags). (http://bugs.python.org/issue28401) + + On Windows, with CPython <= 3.4, it's better not to use py_limited_api + because virtualenv *still* doesn't copy PYTHON3.DLL on these versions. + Recently (2020) we started shipping only >= 3.5 wheels, though. So + we'll give it another try and set py_limited_api on Windows >= 3.5. + """ + from cffi._shimmed_dist_utils import log + from cffi import recompiler + + if ('py_limited_api' not in kwds and not hasattr(sys, 'gettotalrefcount') + and recompiler.USE_LIMITED_API): + import setuptools + try: + setuptools_major_version = int(setuptools.__version__.partition('.')[0]) + if setuptools_major_version >= 26: + kwds['py_limited_api'] = True + except ValueError: # certain development versions of setuptools + # If we don't know the version number of setuptools, we + # try to set 'py_limited_api' anyway. At worst, we get a + # warning. + kwds['py_limited_api'] = True + + if sysconfig.get_config_var("Py_GIL_DISABLED"): + if kwds.get('py_limited_api'): + log.info("Ignoring py_limited_api=True for free-threaded build.") + + kwds['py_limited_api'] = False + + if kwds.get('py_limited_api') is False: + # avoid setting Py_LIMITED_API if py_limited_api=False + # which _cffi_include.h does unless _CFFI_NO_LIMITED_API is defined + kwds.setdefault("define_macros", []).append(("_CFFI_NO_LIMITED_API", None)) + return kwds + +def _add_c_module(dist, ffi, module_name, source, source_extension, kwds): + # We are a setuptools extension. Need this build_ext for py_limited_api. + from setuptools.command.build_ext import build_ext + from cffi._shimmed_dist_utils import Extension, log, mkpath + from cffi import recompiler + + allsources = ['$PLACEHOLDER'] + allsources.extend(kwds.pop('sources', [])) + kwds = _set_py_limited_api(Extension, kwds) + ext = Extension(name=module_name, sources=allsources, **kwds) + + def make_mod(tmpdir, pre_run=None): + c_file = os.path.join(tmpdir, module_name + source_extension) + log.info("generating cffi module %r" % c_file) + mkpath(tmpdir) + # a setuptools-only, API-only hook: called with the "ext" and "ffi" + # arguments just before we turn the ffi into C code. To use it, + # subclass the 'distutils.command.build_ext.build_ext' class and + # add a method 'def pre_run(self, ext, ffi)'. + if pre_run is not None: + pre_run(ext, ffi) + updated = recompiler.make_c_source(ffi, module_name, source, c_file) + if not updated: + log.info("already up-to-date") + return c_file + + if dist.ext_modules is None: + dist.ext_modules = [] + dist.ext_modules.append(ext) + + base_class = dist.cmdclass.get('build_ext', build_ext) + class build_ext_make_mod(base_class): + def run(self): + if ext.sources[0] == '$PLACEHOLDER': + pre_run = getattr(self, 'pre_run', None) + ext.sources[0] = make_mod(self.build_temp, pre_run) + base_class.run(self) + dist.cmdclass['build_ext'] = build_ext_make_mod + # NB. multiple runs here will create multiple 'build_ext_make_mod' + # classes. Even in this case the 'build_ext' command should be + # run once; but just in case, the logic above does nothing if + # called again. + + +def _add_py_module(dist, ffi, module_name): + from setuptools.command.build_py import build_py + from setuptools.command.build_ext import build_ext + from cffi._shimmed_dist_utils import log, mkpath + from cffi import recompiler + + def generate_mod(py_file): + log.info("generating cffi module %r" % py_file) + mkpath(os.path.dirname(py_file)) + updated = recompiler.make_py_source(ffi, module_name, py_file) + if not updated: + log.info("already up-to-date") + + base_class = dist.cmdclass.get('build_py', build_py) + class build_py_make_mod(base_class): + def run(self): + base_class.run(self) + module_path = module_name.split('.') + module_path[-1] += '.py' + generate_mod(os.path.join(self.build_lib, *module_path)) + def get_source_files(self): + # This is called from 'setup.py sdist' only. Exclude + # the generate .py module in this case. + saved_py_modules = self.py_modules + try: + if saved_py_modules: + self.py_modules = [m for m in saved_py_modules + if m != module_name] + return base_class.get_source_files(self) + finally: + self.py_modules = saved_py_modules + dist.cmdclass['build_py'] = build_py_make_mod + + # distutils and setuptools have no notion I could find of a + # generated python module. If we don't add module_name to + # dist.py_modules, then things mostly work but there are some + # combination of options (--root and --record) that will miss + # the module. So we add it here, which gives a few apparently + # harmless warnings about not finding the file outside the + # build directory. + # Then we need to hack more in get_source_files(); see above. + if dist.py_modules is None: + dist.py_modules = [] + dist.py_modules.append(module_name) + + # the following is only for "build_ext -i" + base_class_2 = dist.cmdclass.get('build_ext', build_ext) + class build_ext_make_mod(base_class_2): + def run(self): + base_class_2.run(self) + if self.inplace: + # from get_ext_fullpath() in distutils/command/build_ext.py + module_path = module_name.split('.') + package = '.'.join(module_path[:-1]) + build_py = self.get_finalized_command('build_py') + package_dir = build_py.get_package_dir(package) + file_name = module_path[-1] + '.py' + generate_mod(os.path.join(package_dir, file_name)) + dist.cmdclass['build_ext'] = build_ext_make_mod + +def cffi_modules(dist, attr, value): + assert attr == 'cffi_modules' + if isinstance(value, basestring): + value = [value] + + for cffi_module in value: + add_cffi_module(dist, cffi_module) diff --git a/venv/lib/python3.10/site-packages/cffi/vengine_cpy.py b/venv/lib/python3.10/site-packages/cffi/vengine_cpy.py new file mode 100644 index 0000000000000000000000000000000000000000..02e6a471d04e4cbf45eb7698aecd3355ecd32546 --- /dev/null +++ b/venv/lib/python3.10/site-packages/cffi/vengine_cpy.py @@ -0,0 +1,1087 @@ +# +# DEPRECATED: implementation for ffi.verify() +# +import sys +from . import model +from .error import VerificationError +from . import _imp_emulation as imp + + +class VCPythonEngine(object): + _class_key = 'x' + _gen_python_module = True + + def __init__(self, verifier): + self.verifier = verifier + self.ffi = verifier.ffi + self._struct_pending_verification = {} + self._types_of_builtin_functions = {} + + def patch_extension_kwds(self, kwds): + pass + + def find_module(self, module_name, path, so_suffixes): + try: + f, filename, descr = imp.find_module(module_name, path) + except ImportError: + return None + if f is not None: + f.close() + # Note that after a setuptools installation, there are both .py + # and .so files with the same basename. The code here relies on + # imp.find_module() locating the .so in priority. + if descr[0] not in so_suffixes: + return None + return filename + + def collect_types(self): + self._typesdict = {} + self._generate("collecttype") + + def _prnt(self, what=''): + self._f.write(what + '\n') + + def _gettypenum(self, type): + # a KeyError here is a bug. please report it! :-) + return self._typesdict[type] + + def _do_collect_type(self, tp): + if ((not isinstance(tp, model.PrimitiveType) + or tp.name == 'long double') + and tp not in self._typesdict): + num = len(self._typesdict) + self._typesdict[tp] = num + + def write_source_to_f(self): + self.collect_types() + # + # The new module will have a _cffi_setup() function that receives + # objects from the ffi world, and that calls some setup code in + # the module. This setup code is split in several independent + # functions, e.g. one per constant. The functions are "chained" + # by ending in a tail call to each other. + # + # This is further split in two chained lists, depending on if we + # can do it at import-time or if we must wait for _cffi_setup() to + # provide us with the objects. This is needed because we + # need the values of the enum constants in order to build the + # that we may have to pass to _cffi_setup(). + # + # The following two 'chained_list_constants' items contains + # the head of these two chained lists, as a string that gives the + # call to do, if any. + self._chained_list_constants = ['((void)lib,0)', '((void)lib,0)'] + # + prnt = self._prnt + # first paste some standard set of lines that are mostly '#define' + prnt(cffimod_header) + prnt() + # then paste the C source given by the user, verbatim. + prnt(self.verifier.preamble) + prnt() + # + # call generate_cpy_xxx_decl(), for every xxx found from + # ffi._parser._declarations. This generates all the functions. + self._generate("decl") + # + # implement the function _cffi_setup_custom() as calling the + # head of the chained list. + self._generate_setup_custom() + prnt() + # + # produce the method table, including the entries for the + # generated Python->C function wrappers, which are done + # by generate_cpy_function_method(). + prnt('static PyMethodDef _cffi_methods[] = {') + self._generate("method") + prnt(' {"_cffi_setup", _cffi_setup, METH_VARARGS, NULL},') + prnt(' {NULL, NULL, 0, NULL} /* Sentinel */') + prnt('};') + prnt() + # + # standard init. + modname = self.verifier.get_module_name() + constants = self._chained_list_constants[False] + prnt('#if PY_MAJOR_VERSION >= 3') + prnt() + prnt('static struct PyModuleDef _cffi_module_def = {') + prnt(' PyModuleDef_HEAD_INIT,') + prnt(' "%s",' % modname) + prnt(' NULL,') + prnt(' -1,') + prnt(' _cffi_methods,') + prnt(' NULL, NULL, NULL, NULL') + prnt('};') + prnt() + prnt('PyMODINIT_FUNC') + prnt('PyInit_%s(void)' % modname) + prnt('{') + prnt(' PyObject *lib;') + prnt(' lib = PyModule_Create(&_cffi_module_def);') + prnt(' if (lib == NULL)') + prnt(' return NULL;') + prnt(' if (%s < 0 || _cffi_init() < 0) {' % (constants,)) + prnt(' Py_DECREF(lib);') + prnt(' return NULL;') + prnt(' }') + prnt('#if Py_GIL_DISABLED') + prnt(' PyUnstable_Module_SetGIL(lib, Py_MOD_GIL_NOT_USED);') + prnt('#endif') + prnt(' return lib;') + prnt('}') + prnt() + prnt('#else') + prnt() + prnt('PyMODINIT_FUNC') + prnt('init%s(void)' % modname) + prnt('{') + prnt(' PyObject *lib;') + prnt(' lib = Py_InitModule("%s", _cffi_methods);' % modname) + prnt(' if (lib == NULL)') + prnt(' return;') + prnt(' if (%s < 0 || _cffi_init() < 0)' % (constants,)) + prnt(' return;') + prnt(' return;') + prnt('}') + prnt() + prnt('#endif') + + def load_library(self, flags=None): + # XXX review all usages of 'self' here! + # import it as a new extension module + imp.acquire_lock() + try: + if hasattr(sys, "getdlopenflags"): + previous_flags = sys.getdlopenflags() + try: + if hasattr(sys, "setdlopenflags") and flags is not None: + sys.setdlopenflags(flags) + module = imp.load_dynamic(self.verifier.get_module_name(), + self.verifier.modulefilename) + except ImportError as e: + error = "importing %r: %s" % (self.verifier.modulefilename, e) + raise VerificationError(error) + finally: + if hasattr(sys, "setdlopenflags"): + sys.setdlopenflags(previous_flags) + finally: + imp.release_lock() + # + # call loading_cpy_struct() to get the struct layout inferred by + # the C compiler + self._load(module, 'loading') + # + # the C code will need the objects. Collect them in + # order in a list. + revmapping = dict([(value, key) + for (key, value) in self._typesdict.items()]) + lst = [revmapping[i] for i in range(len(revmapping))] + lst = list(map(self.ffi._get_cached_btype, lst)) + # + # build the FFILibrary class and instance and call _cffi_setup(). + # this will set up some fields like '_cffi_types', and only then + # it will invoke the chained list of functions that will really + # build (notably) the constant objects, as if they are + # pointers, and store them as attributes on the 'library' object. + class FFILibrary(object): + _cffi_python_module = module + _cffi_ffi = self.ffi + _cffi_dir = [] + def __dir__(self): + return FFILibrary._cffi_dir + list(self.__dict__) + library = FFILibrary() + if module._cffi_setup(lst, VerificationError, library): + import warnings + warnings.warn("reimporting %r might overwrite older definitions" + % (self.verifier.get_module_name())) + # + # finally, call the loaded_cpy_xxx() functions. This will perform + # the final adjustments, like copying the Python->C wrapper + # functions from the module to the 'library' object, and setting + # up the FFILibrary class with properties for the global C variables. + self._load(module, 'loaded', library=library) + module._cffi_original_ffi = self.ffi + module._cffi_types_of_builtin_funcs = self._types_of_builtin_functions + return library + + def _get_declarations(self): + lst = [(key, tp) for (key, (tp, qual)) in + self.ffi._parser._declarations.items()] + lst.sort() + return lst + + def _generate(self, step_name): + for name, tp in self._get_declarations(): + kind, realname = name.split(' ', 1) + try: + method = getattr(self, '_generate_cpy_%s_%s' % (kind, + step_name)) + except AttributeError: + raise VerificationError( + "not implemented in verify(): %r" % name) + try: + method(tp, realname) + except Exception as e: + model.attach_exception_info(e, name) + raise + + def _load(self, module, step_name, **kwds): + for name, tp in self._get_declarations(): + kind, realname = name.split(' ', 1) + method = getattr(self, '_%s_cpy_%s' % (step_name, kind)) + try: + method(tp, realname, module, **kwds) + except Exception as e: + model.attach_exception_info(e, name) + raise + + def _generate_nothing(self, tp, name): + pass + + def _loaded_noop(self, tp, name, module, **kwds): + pass + + # ---------- + + def _convert_funcarg_to_c(self, tp, fromvar, tovar, errcode): + extraarg = '' + if isinstance(tp, model.PrimitiveType): + if tp.is_integer_type() and tp.name != '_Bool': + converter = '_cffi_to_c_int' + extraarg = ', %s' % tp.name + elif tp.is_complex_type(): + raise VerificationError( + "not implemented in verify(): complex types") + else: + converter = '(%s)_cffi_to_c_%s' % (tp.get_c_name(''), + tp.name.replace(' ', '_')) + errvalue = '-1' + # + elif isinstance(tp, model.PointerType): + self._convert_funcarg_to_c_ptr_or_array(tp, fromvar, + tovar, errcode) + return + # + elif isinstance(tp, (model.StructOrUnion, model.EnumType)): + # a struct (not a struct pointer) as a function argument + self._prnt(' if (_cffi_to_c((char *)&%s, _cffi_type(%d), %s) < 0)' + % (tovar, self._gettypenum(tp), fromvar)) + self._prnt(' %s;' % errcode) + return + # + elif isinstance(tp, model.FunctionPtrType): + converter = '(%s)_cffi_to_c_pointer' % tp.get_c_name('') + extraarg = ', _cffi_type(%d)' % self._gettypenum(tp) + errvalue = 'NULL' + # + else: + raise NotImplementedError(tp) + # + self._prnt(' %s = %s(%s%s);' % (tovar, converter, fromvar, extraarg)) + self._prnt(' if (%s == (%s)%s && PyErr_Occurred())' % ( + tovar, tp.get_c_name(''), errvalue)) + self._prnt(' %s;' % errcode) + + def _extra_local_variables(self, tp, localvars, freelines): + if isinstance(tp, model.PointerType): + localvars.add('Py_ssize_t datasize') + localvars.add('struct _cffi_freeme_s *large_args_free = NULL') + freelines.add('if (large_args_free != NULL)' + ' _cffi_free_array_arguments(large_args_free);') + + def _convert_funcarg_to_c_ptr_or_array(self, tp, fromvar, tovar, errcode): + self._prnt(' datasize = _cffi_prepare_pointer_call_argument(') + self._prnt(' _cffi_type(%d), %s, (char **)&%s);' % ( + self._gettypenum(tp), fromvar, tovar)) + self._prnt(' if (datasize != 0) {') + self._prnt(' %s = ((size_t)datasize) <= 640 ? ' + 'alloca((size_t)datasize) : NULL;' % (tovar,)) + self._prnt(' if (_cffi_convert_array_argument(_cffi_type(%d), %s, ' + '(char **)&%s,' % (self._gettypenum(tp), fromvar, tovar)) + self._prnt(' datasize, &large_args_free) < 0)') + self._prnt(' %s;' % errcode) + self._prnt(' }') + + def _convert_expr_from_c(self, tp, var, context): + if isinstance(tp, model.PrimitiveType): + if tp.is_integer_type() and tp.name != '_Bool': + return '_cffi_from_c_int(%s, %s)' % (var, tp.name) + elif tp.name != 'long double': + return '_cffi_from_c_%s(%s)' % (tp.name.replace(' ', '_'), var) + else: + return '_cffi_from_c_deref((char *)&%s, _cffi_type(%d))' % ( + var, self._gettypenum(tp)) + elif isinstance(tp, (model.PointerType, model.FunctionPtrType)): + return '_cffi_from_c_pointer((char *)%s, _cffi_type(%d))' % ( + var, self._gettypenum(tp)) + elif isinstance(tp, model.ArrayType): + return '_cffi_from_c_pointer((char *)%s, _cffi_type(%d))' % ( + var, self._gettypenum(model.PointerType(tp.item))) + elif isinstance(tp, model.StructOrUnion): + if tp.fldnames is None: + raise TypeError("'%s' is used as %s, but is opaque" % ( + tp._get_c_name(), context)) + return '_cffi_from_c_struct((char *)&%s, _cffi_type(%d))' % ( + var, self._gettypenum(tp)) + elif isinstance(tp, model.EnumType): + return '_cffi_from_c_deref((char *)&%s, _cffi_type(%d))' % ( + var, self._gettypenum(tp)) + else: + raise NotImplementedError(tp) + + # ---------- + # typedefs: generates no code so far + + _generate_cpy_typedef_collecttype = _generate_nothing + _generate_cpy_typedef_decl = _generate_nothing + _generate_cpy_typedef_method = _generate_nothing + _loading_cpy_typedef = _loaded_noop + _loaded_cpy_typedef = _loaded_noop + + # ---------- + # function declarations + + def _generate_cpy_function_collecttype(self, tp, name): + assert isinstance(tp, model.FunctionPtrType) + if tp.ellipsis: + self._do_collect_type(tp) + else: + # don't call _do_collect_type(tp) in this common case, + # otherwise test_autofilled_struct_as_argument fails + for type in tp.args: + self._do_collect_type(type) + self._do_collect_type(tp.result) + + def _generate_cpy_function_decl(self, tp, name): + assert isinstance(tp, model.FunctionPtrType) + if tp.ellipsis: + # cannot support vararg functions better than this: check for its + # exact type (including the fixed arguments), and build it as a + # constant function pointer (no CPython wrapper) + self._generate_cpy_const(False, name, tp) + return + prnt = self._prnt + numargs = len(tp.args) + if numargs == 0: + argname = 'noarg' + elif numargs == 1: + argname = 'arg0' + else: + argname = 'args' + prnt('static PyObject *') + prnt('_cffi_f_%s(PyObject *self, PyObject *%s)' % (name, argname)) + prnt('{') + # + context = 'argument of %s' % name + for i, type in enumerate(tp.args): + prnt(' %s;' % type.get_c_name(' x%d' % i, context)) + # + localvars = set() + freelines = set() + for type in tp.args: + self._extra_local_variables(type, localvars, freelines) + for decl in sorted(localvars): + prnt(' %s;' % (decl,)) + # + if not isinstance(tp.result, model.VoidType): + result_code = 'result = ' + context = 'result of %s' % name + prnt(' %s;' % tp.result.get_c_name(' result', context)) + prnt(' PyObject *pyresult;') + else: + result_code = '' + # + if len(tp.args) > 1: + rng = range(len(tp.args)) + for i in rng: + prnt(' PyObject *arg%d;' % i) + prnt() + prnt(' if (!PyArg_ParseTuple(args, "%s:%s", %s))' % ( + 'O' * numargs, name, ', '.join(['&arg%d' % i for i in rng]))) + prnt(' return NULL;') + prnt() + # + for i, type in enumerate(tp.args): + self._convert_funcarg_to_c(type, 'arg%d' % i, 'x%d' % i, + 'return NULL') + prnt() + # + prnt(' Py_BEGIN_ALLOW_THREADS') + prnt(' _cffi_restore_errno();') + prnt(' { %s%s(%s); }' % ( + result_code, name, + ', '.join(['x%d' % i for i in range(len(tp.args))]))) + prnt(' _cffi_save_errno();') + prnt(' Py_END_ALLOW_THREADS') + prnt() + # + prnt(' (void)self; /* unused */') + if numargs == 0: + prnt(' (void)noarg; /* unused */') + if result_code: + prnt(' pyresult = %s;' % + self._convert_expr_from_c(tp.result, 'result', 'result type')) + for freeline in freelines: + prnt(' ' + freeline) + prnt(' return pyresult;') + else: + for freeline in freelines: + prnt(' ' + freeline) + prnt(' Py_INCREF(Py_None);') + prnt(' return Py_None;') + prnt('}') + prnt() + + def _generate_cpy_function_method(self, tp, name): + if tp.ellipsis: + return + numargs = len(tp.args) + if numargs == 0: + meth = 'METH_NOARGS' + elif numargs == 1: + meth = 'METH_O' + else: + meth = 'METH_VARARGS' + self._prnt(' {"%s", _cffi_f_%s, %s, NULL},' % (name, name, meth)) + + _loading_cpy_function = _loaded_noop + + def _loaded_cpy_function(self, tp, name, module, library): + if tp.ellipsis: + return + func = getattr(module, name) + setattr(library, name, func) + self._types_of_builtin_functions[func] = tp + + # ---------- + # named structs + + _generate_cpy_struct_collecttype = _generate_nothing + def _generate_cpy_struct_decl(self, tp, name): + assert name == tp.name + self._generate_struct_or_union_decl(tp, 'struct', name) + def _generate_cpy_struct_method(self, tp, name): + self._generate_struct_or_union_method(tp, 'struct', name) + def _loading_cpy_struct(self, tp, name, module): + self._loading_struct_or_union(tp, 'struct', name, module) + def _loaded_cpy_struct(self, tp, name, module, **kwds): + self._loaded_struct_or_union(tp) + + _generate_cpy_union_collecttype = _generate_nothing + def _generate_cpy_union_decl(self, tp, name): + assert name == tp.name + self._generate_struct_or_union_decl(tp, 'union', name) + def _generate_cpy_union_method(self, tp, name): + self._generate_struct_or_union_method(tp, 'union', name) + def _loading_cpy_union(self, tp, name, module): + self._loading_struct_or_union(tp, 'union', name, module) + def _loaded_cpy_union(self, tp, name, module, **kwds): + self._loaded_struct_or_union(tp) + + def _generate_struct_or_union_decl(self, tp, prefix, name): + if tp.fldnames is None: + return # nothing to do with opaque structs + checkfuncname = '_cffi_check_%s_%s' % (prefix, name) + layoutfuncname = '_cffi_layout_%s_%s' % (prefix, name) + cname = ('%s %s' % (prefix, name)).strip() + # + prnt = self._prnt + prnt('static void %s(%s *p)' % (checkfuncname, cname)) + prnt('{') + prnt(' /* only to generate compile-time warnings or errors */') + prnt(' (void)p;') + for fname, ftype, fbitsize, fqual in tp.enumfields(): + if (isinstance(ftype, model.PrimitiveType) + and ftype.is_integer_type()) or fbitsize >= 0: + # accept all integers, but complain on float or double + prnt(' (void)((p->%s) << 1);' % fname) + else: + # only accept exactly the type declared. + try: + prnt(' { %s = &p->%s; (void)tmp; }' % ( + ftype.get_c_name('*tmp', 'field %r'%fname, quals=fqual), + fname)) + except VerificationError as e: + prnt(' /* %s */' % str(e)) # cannot verify it, ignore + prnt('}') + prnt('static PyObject *') + prnt('%s(PyObject *self, PyObject *noarg)' % (layoutfuncname,)) + prnt('{') + prnt(' struct _cffi_aligncheck { char x; %s y; };' % cname) + prnt(' static Py_ssize_t nums[] = {') + prnt(' sizeof(%s),' % cname) + prnt(' offsetof(struct _cffi_aligncheck, y),') + for fname, ftype, fbitsize, fqual in tp.enumfields(): + if fbitsize >= 0: + continue # xxx ignore fbitsize for now + prnt(' offsetof(%s, %s),' % (cname, fname)) + if isinstance(ftype, model.ArrayType) and ftype.length is None: + prnt(' 0, /* %s */' % ftype._get_c_name()) + else: + prnt(' sizeof(((%s *)0)->%s),' % (cname, fname)) + prnt(' -1') + prnt(' };') + prnt(' (void)self; /* unused */') + prnt(' (void)noarg; /* unused */') + prnt(' return _cffi_get_struct_layout(nums);') + prnt(' /* the next line is not executed, but compiled */') + prnt(' %s(0);' % (checkfuncname,)) + prnt('}') + prnt() + + def _generate_struct_or_union_method(self, tp, prefix, name): + if tp.fldnames is None: + return # nothing to do with opaque structs + layoutfuncname = '_cffi_layout_%s_%s' % (prefix, name) + self._prnt(' {"%s", %s, METH_NOARGS, NULL},' % (layoutfuncname, + layoutfuncname)) + + def _loading_struct_or_union(self, tp, prefix, name, module): + if tp.fldnames is None: + return # nothing to do with opaque structs + layoutfuncname = '_cffi_layout_%s_%s' % (prefix, name) + # + function = getattr(module, layoutfuncname) + layout = function() + if isinstance(tp, model.StructOrUnion) and tp.partial: + # use the function()'s sizes and offsets to guide the + # layout of the struct + totalsize = layout[0] + totalalignment = layout[1] + fieldofs = layout[2::2] + fieldsize = layout[3::2] + tp.force_flatten() + assert len(fieldofs) == len(fieldsize) == len(tp.fldnames) + tp.fixedlayout = fieldofs, fieldsize, totalsize, totalalignment + else: + cname = ('%s %s' % (prefix, name)).strip() + self._struct_pending_verification[tp] = layout, cname + + def _loaded_struct_or_union(self, tp): + if tp.fldnames is None: + return # nothing to do with opaque structs + self.ffi._get_cached_btype(tp) # force 'fixedlayout' to be considered + + if tp in self._struct_pending_verification: + # check that the layout sizes and offsets match the real ones + def check(realvalue, expectedvalue, msg): + if realvalue != expectedvalue: + raise VerificationError( + "%s (we have %d, but C compiler says %d)" + % (msg, expectedvalue, realvalue)) + ffi = self.ffi + BStruct = ffi._get_cached_btype(tp) + layout, cname = self._struct_pending_verification.pop(tp) + check(layout[0], ffi.sizeof(BStruct), "wrong total size") + check(layout[1], ffi.alignof(BStruct), "wrong total alignment") + i = 2 + for fname, ftype, fbitsize, fqual in tp.enumfields(): + if fbitsize >= 0: + continue # xxx ignore fbitsize for now + check(layout[i], ffi.offsetof(BStruct, fname), + "wrong offset for field %r" % (fname,)) + if layout[i+1] != 0: + BField = ffi._get_cached_btype(ftype) + check(layout[i+1], ffi.sizeof(BField), + "wrong size for field %r" % (fname,)) + i += 2 + assert i == len(layout) + + # ---------- + # 'anonymous' declarations. These are produced for anonymous structs + # or unions; the 'name' is obtained by a typedef. + + _generate_cpy_anonymous_collecttype = _generate_nothing + + def _generate_cpy_anonymous_decl(self, tp, name): + if isinstance(tp, model.EnumType): + self._generate_cpy_enum_decl(tp, name, '') + else: + self._generate_struct_or_union_decl(tp, '', name) + + def _generate_cpy_anonymous_method(self, tp, name): + if not isinstance(tp, model.EnumType): + self._generate_struct_or_union_method(tp, '', name) + + def _loading_cpy_anonymous(self, tp, name, module): + if isinstance(tp, model.EnumType): + self._loading_cpy_enum(tp, name, module) + else: + self._loading_struct_or_union(tp, '', name, module) + + def _loaded_cpy_anonymous(self, tp, name, module, **kwds): + if isinstance(tp, model.EnumType): + self._loaded_cpy_enum(tp, name, module, **kwds) + else: + self._loaded_struct_or_union(tp) + + # ---------- + # constants, likely declared with '#define' + + def _generate_cpy_const(self, is_int, name, tp=None, category='const', + vartp=None, delayed=True, size_too=False, + check_value=None): + prnt = self._prnt + funcname = '_cffi_%s_%s' % (category, name) + prnt('static int %s(PyObject *lib)' % funcname) + prnt('{') + prnt(' PyObject *o;') + prnt(' int res;') + if not is_int: + prnt(' %s;' % (vartp or tp).get_c_name(' i', name)) + else: + assert category == 'const' + # + if check_value is not None: + self._check_int_constant_value(name, check_value) + # + if not is_int: + if category == 'var': + realexpr = '&' + name + else: + realexpr = name + prnt(' i = (%s);' % (realexpr,)) + prnt(' o = %s;' % (self._convert_expr_from_c(tp, 'i', + 'variable type'),)) + assert delayed + else: + prnt(' o = _cffi_from_c_int_const(%s);' % name) + prnt(' if (o == NULL)') + prnt(' return -1;') + if size_too: + prnt(' {') + prnt(' PyObject *o1 = o;') + prnt(' o = Py_BuildValue("On", o1, (Py_ssize_t)sizeof(%s));' + % (name,)) + prnt(' Py_DECREF(o1);') + prnt(' if (o == NULL)') + prnt(' return -1;') + prnt(' }') + prnt(' res = PyObject_SetAttrString(lib, "%s", o);' % name) + prnt(' Py_DECREF(o);') + prnt(' if (res < 0)') + prnt(' return -1;') + prnt(' return %s;' % self._chained_list_constants[delayed]) + self._chained_list_constants[delayed] = funcname + '(lib)' + prnt('}') + prnt() + + def _generate_cpy_constant_collecttype(self, tp, name): + is_int = isinstance(tp, model.PrimitiveType) and tp.is_integer_type() + if not is_int: + self._do_collect_type(tp) + + def _generate_cpy_constant_decl(self, tp, name): + is_int = isinstance(tp, model.PrimitiveType) and tp.is_integer_type() + self._generate_cpy_const(is_int, name, tp) + + _generate_cpy_constant_method = _generate_nothing + _loading_cpy_constant = _loaded_noop + _loaded_cpy_constant = _loaded_noop + + # ---------- + # enums + + def _check_int_constant_value(self, name, value, err_prefix=''): + prnt = self._prnt + if value <= 0: + prnt(' if ((%s) > 0 || (long)(%s) != %dL) {' % ( + name, name, value)) + else: + prnt(' if ((%s) <= 0 || (unsigned long)(%s) != %dUL) {' % ( + name, name, value)) + prnt(' char buf[64];') + prnt(' if ((%s) <= 0)' % name) + prnt(' snprintf(buf, 63, "%%ld", (long)(%s));' % name) + prnt(' else') + prnt(' snprintf(buf, 63, "%%lu", (unsigned long)(%s));' % + name) + prnt(' PyErr_Format(_cffi_VerificationError,') + prnt(' "%s%s has the real value %s, not %s",') + prnt(' "%s", "%s", buf, "%d");' % ( + err_prefix, name, value)) + prnt(' return -1;') + prnt(' }') + + def _enum_funcname(self, prefix, name): + # "$enum_$1" => "___D_enum____D_1" + name = name.replace('$', '___D_') + return '_cffi_e_%s_%s' % (prefix, name) + + def _generate_cpy_enum_decl(self, tp, name, prefix='enum'): + if tp.partial: + for enumerator in tp.enumerators: + self._generate_cpy_const(True, enumerator, delayed=False) + return + # + funcname = self._enum_funcname(prefix, name) + prnt = self._prnt + prnt('static int %s(PyObject *lib)' % funcname) + prnt('{') + for enumerator, enumvalue in zip(tp.enumerators, tp.enumvalues): + self._check_int_constant_value(enumerator, enumvalue, + "enum %s: " % name) + prnt(' return %s;' % self._chained_list_constants[True]) + self._chained_list_constants[True] = funcname + '(lib)' + prnt('}') + prnt() + + _generate_cpy_enum_collecttype = _generate_nothing + _generate_cpy_enum_method = _generate_nothing + + def _loading_cpy_enum(self, tp, name, module): + if tp.partial: + enumvalues = [getattr(module, enumerator) + for enumerator in tp.enumerators] + tp.enumvalues = tuple(enumvalues) + tp.partial_resolved = True + + def _loaded_cpy_enum(self, tp, name, module, library): + for enumerator, enumvalue in zip(tp.enumerators, tp.enumvalues): + setattr(library, enumerator, enumvalue) + + # ---------- + # macros: for now only for integers + + def _generate_cpy_macro_decl(self, tp, name): + if tp == '...': + check_value = None + else: + check_value = tp # an integer + self._generate_cpy_const(True, name, check_value=check_value) + + _generate_cpy_macro_collecttype = _generate_nothing + _generate_cpy_macro_method = _generate_nothing + _loading_cpy_macro = _loaded_noop + _loaded_cpy_macro = _loaded_noop + + # ---------- + # global variables + + def _generate_cpy_variable_collecttype(self, tp, name): + if isinstance(tp, model.ArrayType): + tp_ptr = model.PointerType(tp.item) + else: + tp_ptr = model.PointerType(tp) + self._do_collect_type(tp_ptr) + + def _generate_cpy_variable_decl(self, tp, name): + if isinstance(tp, model.ArrayType): + tp_ptr = model.PointerType(tp.item) + self._generate_cpy_const(False, name, tp, vartp=tp_ptr, + size_too = tp.length_is_unknown()) + else: + tp_ptr = model.PointerType(tp) + self._generate_cpy_const(False, name, tp_ptr, category='var') + + _generate_cpy_variable_method = _generate_nothing + _loading_cpy_variable = _loaded_noop + + def _loaded_cpy_variable(self, tp, name, module, library): + value = getattr(library, name) + if isinstance(tp, model.ArrayType): # int a[5] is "constant" in the + # sense that "a=..." is forbidden + if tp.length_is_unknown(): + assert isinstance(value, tuple) + (value, size) = value + BItemType = self.ffi._get_cached_btype(tp.item) + length, rest = divmod(size, self.ffi.sizeof(BItemType)) + if rest != 0: + raise VerificationError( + "bad size: %r does not seem to be an array of %s" % + (name, tp.item)) + tp = tp.resolve_length(length) + # 'value' is a which we have to replace with + # a if the N is actually known + if tp.length is not None: + BArray = self.ffi._get_cached_btype(tp) + value = self.ffi.cast(BArray, value) + setattr(library, name, value) + return + # remove ptr= from the library instance, and replace + # it by a property on the class, which reads/writes into ptr[0]. + ptr = value + delattr(library, name) + def getter(library): + return ptr[0] + def setter(library, value): + ptr[0] = value + setattr(type(library), name, property(getter, setter)) + type(library)._cffi_dir.append(name) + + # ---------- + + def _generate_setup_custom(self): + prnt = self._prnt + prnt('static int _cffi_setup_custom(PyObject *lib)') + prnt('{') + prnt(' return %s;' % self._chained_list_constants[True]) + prnt('}') + +cffimod_header = r''' +#include +#include + +/* this block of #ifs should be kept exactly identical between + c/_cffi_backend.c, cffi/vengine_cpy.py, cffi/vengine_gen.py + and cffi/_cffi_include.h */ +#if defined(_MSC_VER) +# include /* for alloca() */ +# if _MSC_VER < 1600 /* MSVC < 2010 */ + typedef __int8 int8_t; + typedef __int16 int16_t; + typedef __int32 int32_t; + typedef __int64 int64_t; + typedef unsigned __int8 uint8_t; + typedef unsigned __int16 uint16_t; + typedef unsigned __int32 uint32_t; + typedef unsigned __int64 uint64_t; + typedef __int8 int_least8_t; + typedef __int16 int_least16_t; + typedef __int32 int_least32_t; + typedef __int64 int_least64_t; + typedef unsigned __int8 uint_least8_t; + typedef unsigned __int16 uint_least16_t; + typedef unsigned __int32 uint_least32_t; + typedef unsigned __int64 uint_least64_t; + typedef __int8 int_fast8_t; + typedef __int16 int_fast16_t; + typedef __int32 int_fast32_t; + typedef __int64 int_fast64_t; + typedef unsigned __int8 uint_fast8_t; + typedef unsigned __int16 uint_fast16_t; + typedef unsigned __int32 uint_fast32_t; + typedef unsigned __int64 uint_fast64_t; + typedef __int64 intmax_t; + typedef unsigned __int64 uintmax_t; +# else +# include +# endif +# if _MSC_VER < 1800 /* MSVC < 2013 */ +# ifndef __cplusplus + typedef unsigned char _Bool; +# endif +# endif +# define _cffi_float_complex_t _Fcomplex /* include for it */ +# define _cffi_double_complex_t _Dcomplex /* include for it */ +#else +# include +# if (defined (__SVR4) && defined (__sun)) || defined(_AIX) || defined(__hpux) +# include +# endif +# define _cffi_float_complex_t float _Complex +# define _cffi_double_complex_t double _Complex +#endif + +#if PY_MAJOR_VERSION < 3 +# undef PyCapsule_CheckExact +# undef PyCapsule_GetPointer +# define PyCapsule_CheckExact(capsule) (PyCObject_Check(capsule)) +# define PyCapsule_GetPointer(capsule, name) \ + (PyCObject_AsVoidPtr(capsule)) +#endif + +#if PY_MAJOR_VERSION >= 3 +# define PyInt_FromLong PyLong_FromLong +#endif + +#define _cffi_from_c_double PyFloat_FromDouble +#define _cffi_from_c_float PyFloat_FromDouble +#define _cffi_from_c_long PyInt_FromLong +#define _cffi_from_c_ulong PyLong_FromUnsignedLong +#define _cffi_from_c_longlong PyLong_FromLongLong +#define _cffi_from_c_ulonglong PyLong_FromUnsignedLongLong +#define _cffi_from_c__Bool PyBool_FromLong + +#define _cffi_to_c_double PyFloat_AsDouble +#define _cffi_to_c_float PyFloat_AsDouble + +#define _cffi_from_c_int_const(x) \ + (((x) > 0) ? \ + ((unsigned long long)(x) <= (unsigned long long)LONG_MAX) ? \ + PyInt_FromLong((long)(x)) : \ + PyLong_FromUnsignedLongLong((unsigned long long)(x)) : \ + ((long long)(x) >= (long long)LONG_MIN) ? \ + PyInt_FromLong((long)(x)) : \ + PyLong_FromLongLong((long long)(x))) + +#define _cffi_from_c_int(x, type) \ + (((type)-1) > 0 ? /* unsigned */ \ + (sizeof(type) < sizeof(long) ? \ + PyInt_FromLong((long)x) : \ + sizeof(type) == sizeof(long) ? \ + PyLong_FromUnsignedLong((unsigned long)x) : \ + PyLong_FromUnsignedLongLong((unsigned long long)x)) : \ + (sizeof(type) <= sizeof(long) ? \ + PyInt_FromLong((long)x) : \ + PyLong_FromLongLong((long long)x))) + +#define _cffi_to_c_int(o, type) \ + ((type)( \ + sizeof(type) == 1 ? (((type)-1) > 0 ? (type)_cffi_to_c_u8(o) \ + : (type)_cffi_to_c_i8(o)) : \ + sizeof(type) == 2 ? (((type)-1) > 0 ? (type)_cffi_to_c_u16(o) \ + : (type)_cffi_to_c_i16(o)) : \ + sizeof(type) == 4 ? (((type)-1) > 0 ? (type)_cffi_to_c_u32(o) \ + : (type)_cffi_to_c_i32(o)) : \ + sizeof(type) == 8 ? (((type)-1) > 0 ? (type)_cffi_to_c_u64(o) \ + : (type)_cffi_to_c_i64(o)) : \ + (Py_FatalError("unsupported size for type " #type), (type)0))) + +#define _cffi_to_c_i8 \ + ((int(*)(PyObject *))_cffi_exports[1]) +#define _cffi_to_c_u8 \ + ((int(*)(PyObject *))_cffi_exports[2]) +#define _cffi_to_c_i16 \ + ((int(*)(PyObject *))_cffi_exports[3]) +#define _cffi_to_c_u16 \ + ((int(*)(PyObject *))_cffi_exports[4]) +#define _cffi_to_c_i32 \ + ((int(*)(PyObject *))_cffi_exports[5]) +#define _cffi_to_c_u32 \ + ((unsigned int(*)(PyObject *))_cffi_exports[6]) +#define _cffi_to_c_i64 \ + ((long long(*)(PyObject *))_cffi_exports[7]) +#define _cffi_to_c_u64 \ + ((unsigned long long(*)(PyObject *))_cffi_exports[8]) +#define _cffi_to_c_char \ + ((int(*)(PyObject *))_cffi_exports[9]) +#define _cffi_from_c_pointer \ + ((PyObject *(*)(char *, CTypeDescrObject *))_cffi_exports[10]) +#define _cffi_to_c_pointer \ + ((char *(*)(PyObject *, CTypeDescrObject *))_cffi_exports[11]) +#define _cffi_get_struct_layout \ + ((PyObject *(*)(Py_ssize_t[]))_cffi_exports[12]) +#define _cffi_restore_errno \ + ((void(*)(void))_cffi_exports[13]) +#define _cffi_save_errno \ + ((void(*)(void))_cffi_exports[14]) +#define _cffi_from_c_char \ + ((PyObject *(*)(char))_cffi_exports[15]) +#define _cffi_from_c_deref \ + ((PyObject *(*)(char *, CTypeDescrObject *))_cffi_exports[16]) +#define _cffi_to_c \ + ((int(*)(char *, CTypeDescrObject *, PyObject *))_cffi_exports[17]) +#define _cffi_from_c_struct \ + ((PyObject *(*)(char *, CTypeDescrObject *))_cffi_exports[18]) +#define _cffi_to_c_wchar_t \ + ((wchar_t(*)(PyObject *))_cffi_exports[19]) +#define _cffi_from_c_wchar_t \ + ((PyObject *(*)(wchar_t))_cffi_exports[20]) +#define _cffi_to_c_long_double \ + ((long double(*)(PyObject *))_cffi_exports[21]) +#define _cffi_to_c__Bool \ + ((_Bool(*)(PyObject *))_cffi_exports[22]) +#define _cffi_prepare_pointer_call_argument \ + ((Py_ssize_t(*)(CTypeDescrObject *, PyObject *, char **))_cffi_exports[23]) +#define _cffi_convert_array_from_object \ + ((int(*)(char *, CTypeDescrObject *, PyObject *))_cffi_exports[24]) +#define _CFFI_NUM_EXPORTS 25 + +typedef struct _ctypedescr CTypeDescrObject; + +static void *_cffi_exports[_CFFI_NUM_EXPORTS]; +static PyObject *_cffi_types, *_cffi_VerificationError; + +static int _cffi_setup_custom(PyObject *lib); /* forward */ + +static PyObject *_cffi_setup(PyObject *self, PyObject *args) +{ + PyObject *library; + int was_alive = (_cffi_types != NULL); + (void)self; /* unused */ + if (!PyArg_ParseTuple(args, "OOO", &_cffi_types, &_cffi_VerificationError, + &library)) + return NULL; + Py_INCREF(_cffi_types); + Py_INCREF(_cffi_VerificationError); + if (_cffi_setup_custom(library) < 0) + return NULL; + return PyBool_FromLong(was_alive); +} + +union _cffi_union_alignment_u { + unsigned char m_char; + unsigned short m_short; + unsigned int m_int; + unsigned long m_long; + unsigned long long m_longlong; + float m_float; + double m_double; + long double m_longdouble; +}; + +struct _cffi_freeme_s { + struct _cffi_freeme_s *next; + union _cffi_union_alignment_u alignment; +}; + +#ifdef __GNUC__ + __attribute__((unused)) +#endif +static int _cffi_convert_array_argument(CTypeDescrObject *ctptr, PyObject *arg, + char **output_data, Py_ssize_t datasize, + struct _cffi_freeme_s **freeme) +{ + char *p; + if (datasize < 0) + return -1; + + p = *output_data; + if (p == NULL) { + struct _cffi_freeme_s *fp = (struct _cffi_freeme_s *)PyObject_Malloc( + offsetof(struct _cffi_freeme_s, alignment) + (size_t)datasize); + if (fp == NULL) + return -1; + fp->next = *freeme; + *freeme = fp; + p = *output_data = (char *)&fp->alignment; + } + memset((void *)p, 0, (size_t)datasize); + return _cffi_convert_array_from_object(p, ctptr, arg); +} + +#ifdef __GNUC__ + __attribute__((unused)) +#endif +static void _cffi_free_array_arguments(struct _cffi_freeme_s *freeme) +{ + do { + void *p = (void *)freeme; + freeme = freeme->next; + PyObject_Free(p); + } while (freeme != NULL); +} + +static int _cffi_init(void) +{ + PyObject *module, *c_api_object = NULL; + + module = PyImport_ImportModule("_cffi_backend"); + if (module == NULL) + goto failure; + + c_api_object = PyObject_GetAttrString(module, "_C_API"); + if (c_api_object == NULL) + goto failure; + if (!PyCapsule_CheckExact(c_api_object)) { + PyErr_SetNone(PyExc_ImportError); + goto failure; + } + memcpy(_cffi_exports, PyCapsule_GetPointer(c_api_object, "cffi"), + _CFFI_NUM_EXPORTS * sizeof(void *)); + + Py_DECREF(module); + Py_DECREF(c_api_object); + return 0; + + failure: + Py_XDECREF(module); + Py_XDECREF(c_api_object); + return -1; +} + +#define _cffi_type(num) ((CTypeDescrObject *)PyList_GET_ITEM(_cffi_types, num)) + +/**********/ +''' diff --git a/venv/lib/python3.10/site-packages/cffi/vengine_gen.py b/venv/lib/python3.10/site-packages/cffi/vengine_gen.py new file mode 100644 index 0000000000000000000000000000000000000000..bffc82122c353fbd15a395d77e829a95bf8546b0 --- /dev/null +++ b/venv/lib/python3.10/site-packages/cffi/vengine_gen.py @@ -0,0 +1,679 @@ +# +# DEPRECATED: implementation for ffi.verify() +# +import sys, os +import types + +from . import model +from .error import VerificationError + + +class VGenericEngine(object): + _class_key = 'g' + _gen_python_module = False + + def __init__(self, verifier): + self.verifier = verifier + self.ffi = verifier.ffi + self.export_symbols = [] + self._struct_pending_verification = {} + + def patch_extension_kwds(self, kwds): + # add 'export_symbols' to the dictionary. Note that we add the + # list before filling it. When we fill it, it will thus also show + # up in kwds['export_symbols']. + kwds.setdefault('export_symbols', self.export_symbols) + + def find_module(self, module_name, path, so_suffixes): + for so_suffix in so_suffixes: + basename = module_name + so_suffix + if path is None: + path = sys.path + for dirname in path: + filename = os.path.join(dirname, basename) + if os.path.isfile(filename): + return filename + + def collect_types(self): + pass # not needed in the generic engine + + def _prnt(self, what=''): + self._f.write(what + '\n') + + def write_source_to_f(self): + prnt = self._prnt + # first paste some standard set of lines that are mostly '#include' + prnt(cffimod_header) + # then paste the C source given by the user, verbatim. + prnt(self.verifier.preamble) + # + # call generate_gen_xxx_decl(), for every xxx found from + # ffi._parser._declarations. This generates all the functions. + self._generate('decl') + # + # on Windows, distutils insists on putting init_cffi_xyz in + # 'export_symbols', so instead of fighting it, just give up and + # give it one + if sys.platform == 'win32': + if sys.version_info >= (3,): + prefix = 'PyInit_' + else: + prefix = 'init' + modname = self.verifier.get_module_name() + prnt("void %s%s(void) { }\n" % (prefix, modname)) + + def load_library(self, flags=0): + # import it with the CFFI backend + backend = self.ffi._backend + # needs to make a path that contains '/', on Posix + filename = os.path.join(os.curdir, self.verifier.modulefilename) + module = backend.load_library(filename, flags) + # + # call loading_gen_struct() to get the struct layout inferred by + # the C compiler + self._load(module, 'loading') + + # build the FFILibrary class and instance, this is a module subclass + # because modules are expected to have usually-constant-attributes and + # in PyPy this means the JIT is able to treat attributes as constant, + # which we want. + class FFILibrary(types.ModuleType): + _cffi_generic_module = module + _cffi_ffi = self.ffi + _cffi_dir = [] + def __dir__(self): + return FFILibrary._cffi_dir + library = FFILibrary("") + # + # finally, call the loaded_gen_xxx() functions. This will set + # up the 'library' object. + self._load(module, 'loaded', library=library) + return library + + def _get_declarations(self): + lst = [(key, tp) for (key, (tp, qual)) in + self.ffi._parser._declarations.items()] + lst.sort() + return lst + + def _generate(self, step_name): + for name, tp in self._get_declarations(): + kind, realname = name.split(' ', 1) + try: + method = getattr(self, '_generate_gen_%s_%s' % (kind, + step_name)) + except AttributeError: + raise VerificationError( + "not implemented in verify(): %r" % name) + try: + method(tp, realname) + except Exception as e: + model.attach_exception_info(e, name) + raise + + def _load(self, module, step_name, **kwds): + for name, tp in self._get_declarations(): + kind, realname = name.split(' ', 1) + method = getattr(self, '_%s_gen_%s' % (step_name, kind)) + try: + method(tp, realname, module, **kwds) + except Exception as e: + model.attach_exception_info(e, name) + raise + + def _generate_nothing(self, tp, name): + pass + + def _loaded_noop(self, tp, name, module, **kwds): + pass + + # ---------- + # typedefs: generates no code so far + + _generate_gen_typedef_decl = _generate_nothing + _loading_gen_typedef = _loaded_noop + _loaded_gen_typedef = _loaded_noop + + # ---------- + # function declarations + + def _generate_gen_function_decl(self, tp, name): + assert isinstance(tp, model.FunctionPtrType) + if tp.ellipsis: + # cannot support vararg functions better than this: check for its + # exact type (including the fixed arguments), and build it as a + # constant function pointer (no _cffi_f_%s wrapper) + self._generate_gen_const(False, name, tp) + return + prnt = self._prnt + numargs = len(tp.args) + argnames = [] + for i, type in enumerate(tp.args): + indirection = '' + if isinstance(type, model.StructOrUnion): + indirection = '*' + argnames.append('%sx%d' % (indirection, i)) + context = 'argument of %s' % name + arglist = [type.get_c_name(' %s' % arg, context) + for type, arg in zip(tp.args, argnames)] + tpresult = tp.result + if isinstance(tpresult, model.StructOrUnion): + arglist.insert(0, tpresult.get_c_name(' *r', context)) + tpresult = model.void_type + arglist = ', '.join(arglist) or 'void' + wrappername = '_cffi_f_%s' % name + self.export_symbols.append(wrappername) + if tp.abi: + abi = tp.abi + ' ' + else: + abi = '' + funcdecl = ' %s%s(%s)' % (abi, wrappername, arglist) + context = 'result of %s' % name + prnt(tpresult.get_c_name(funcdecl, context)) + prnt('{') + # + if isinstance(tp.result, model.StructOrUnion): + result_code = '*r = ' + elif not isinstance(tp.result, model.VoidType): + result_code = 'return ' + else: + result_code = '' + prnt(' %s%s(%s);' % (result_code, name, ', '.join(argnames))) + prnt('}') + prnt() + + _loading_gen_function = _loaded_noop + + def _loaded_gen_function(self, tp, name, module, library): + assert isinstance(tp, model.FunctionPtrType) + if tp.ellipsis: + newfunction = self._load_constant(False, tp, name, module) + else: + indirections = [] + base_tp = tp + if (any(isinstance(typ, model.StructOrUnion) for typ in tp.args) + or isinstance(tp.result, model.StructOrUnion)): + indirect_args = [] + for i, typ in enumerate(tp.args): + if isinstance(typ, model.StructOrUnion): + typ = model.PointerType(typ) + indirections.append((i, typ)) + indirect_args.append(typ) + indirect_result = tp.result + if isinstance(indirect_result, model.StructOrUnion): + if indirect_result.fldtypes is None: + raise TypeError("'%s' is used as result type, " + "but is opaque" % ( + indirect_result._get_c_name(),)) + indirect_result = model.PointerType(indirect_result) + indirect_args.insert(0, indirect_result) + indirections.insert(0, ("result", indirect_result)) + indirect_result = model.void_type + tp = model.FunctionPtrType(tuple(indirect_args), + indirect_result, tp.ellipsis) + BFunc = self.ffi._get_cached_btype(tp) + wrappername = '_cffi_f_%s' % name + newfunction = module.load_function(BFunc, wrappername) + for i, typ in indirections: + newfunction = self._make_struct_wrapper(newfunction, i, typ, + base_tp) + setattr(library, name, newfunction) + type(library)._cffi_dir.append(name) + + def _make_struct_wrapper(self, oldfunc, i, tp, base_tp): + backend = self.ffi._backend + BType = self.ffi._get_cached_btype(tp) + if i == "result": + ffi = self.ffi + def newfunc(*args): + res = ffi.new(BType) + oldfunc(res, *args) + return res[0] + else: + def newfunc(*args): + args = args[:i] + (backend.newp(BType, args[i]),) + args[i+1:] + return oldfunc(*args) + newfunc._cffi_base_type = base_tp + return newfunc + + # ---------- + # named structs + + def _generate_gen_struct_decl(self, tp, name): + assert name == tp.name + self._generate_struct_or_union_decl(tp, 'struct', name) + + def _loading_gen_struct(self, tp, name, module): + self._loading_struct_or_union(tp, 'struct', name, module) + + def _loaded_gen_struct(self, tp, name, module, **kwds): + self._loaded_struct_or_union(tp) + + def _generate_gen_union_decl(self, tp, name): + assert name == tp.name + self._generate_struct_or_union_decl(tp, 'union', name) + + def _loading_gen_union(self, tp, name, module): + self._loading_struct_or_union(tp, 'union', name, module) + + def _loaded_gen_union(self, tp, name, module, **kwds): + self._loaded_struct_or_union(tp) + + def _generate_struct_or_union_decl(self, tp, prefix, name): + if tp.fldnames is None: + return # nothing to do with opaque structs + checkfuncname = '_cffi_check_%s_%s' % (prefix, name) + layoutfuncname = '_cffi_layout_%s_%s' % (prefix, name) + cname = ('%s %s' % (prefix, name)).strip() + # + prnt = self._prnt + prnt('static void %s(%s *p)' % (checkfuncname, cname)) + prnt('{') + prnt(' /* only to generate compile-time warnings or errors */') + prnt(' (void)p;') + for fname, ftype, fbitsize, fqual in tp.enumfields(): + if (isinstance(ftype, model.PrimitiveType) + and ftype.is_integer_type()) or fbitsize >= 0: + # accept all integers, but complain on float or double + prnt(' (void)((p->%s) << 1);' % fname) + else: + # only accept exactly the type declared. + try: + prnt(' { %s = &p->%s; (void)tmp; }' % ( + ftype.get_c_name('*tmp', 'field %r'%fname, quals=fqual), + fname)) + except VerificationError as e: + prnt(' /* %s */' % str(e)) # cannot verify it, ignore + prnt('}') + self.export_symbols.append(layoutfuncname) + prnt('intptr_t %s(intptr_t i)' % (layoutfuncname,)) + prnt('{') + prnt(' struct _cffi_aligncheck { char x; %s y; };' % cname) + prnt(' static intptr_t nums[] = {') + prnt(' sizeof(%s),' % cname) + prnt(' offsetof(struct _cffi_aligncheck, y),') + for fname, ftype, fbitsize, fqual in tp.enumfields(): + if fbitsize >= 0: + continue # xxx ignore fbitsize for now + prnt(' offsetof(%s, %s),' % (cname, fname)) + if isinstance(ftype, model.ArrayType) and ftype.length is None: + prnt(' 0, /* %s */' % ftype._get_c_name()) + else: + prnt(' sizeof(((%s *)0)->%s),' % (cname, fname)) + prnt(' -1') + prnt(' };') + prnt(' return nums[i];') + prnt(' /* the next line is not executed, but compiled */') + prnt(' %s(0);' % (checkfuncname,)) + prnt('}') + prnt() + + def _loading_struct_or_union(self, tp, prefix, name, module): + if tp.fldnames is None: + return # nothing to do with opaque structs + layoutfuncname = '_cffi_layout_%s_%s' % (prefix, name) + # + BFunc = self.ffi._typeof_locked("intptr_t(*)(intptr_t)")[0] + function = module.load_function(BFunc, layoutfuncname) + layout = [] + num = 0 + while True: + x = function(num) + if x < 0: break + layout.append(x) + num += 1 + if isinstance(tp, model.StructOrUnion) and tp.partial: + # use the function()'s sizes and offsets to guide the + # layout of the struct + totalsize = layout[0] + totalalignment = layout[1] + fieldofs = layout[2::2] + fieldsize = layout[3::2] + tp.force_flatten() + assert len(fieldofs) == len(fieldsize) == len(tp.fldnames) + tp.fixedlayout = fieldofs, fieldsize, totalsize, totalalignment + else: + cname = ('%s %s' % (prefix, name)).strip() + self._struct_pending_verification[tp] = layout, cname + + def _loaded_struct_or_union(self, tp): + if tp.fldnames is None: + return # nothing to do with opaque structs + self.ffi._get_cached_btype(tp) # force 'fixedlayout' to be considered + + if tp in self._struct_pending_verification: + # check that the layout sizes and offsets match the real ones + def check(realvalue, expectedvalue, msg): + if realvalue != expectedvalue: + raise VerificationError( + "%s (we have %d, but C compiler says %d)" + % (msg, expectedvalue, realvalue)) + ffi = self.ffi + BStruct = ffi._get_cached_btype(tp) + layout, cname = self._struct_pending_verification.pop(tp) + check(layout[0], ffi.sizeof(BStruct), "wrong total size") + check(layout[1], ffi.alignof(BStruct), "wrong total alignment") + i = 2 + for fname, ftype, fbitsize, fqual in tp.enumfields(): + if fbitsize >= 0: + continue # xxx ignore fbitsize for now + check(layout[i], ffi.offsetof(BStruct, fname), + "wrong offset for field %r" % (fname,)) + if layout[i+1] != 0: + BField = ffi._get_cached_btype(ftype) + check(layout[i+1], ffi.sizeof(BField), + "wrong size for field %r" % (fname,)) + i += 2 + assert i == len(layout) + + # ---------- + # 'anonymous' declarations. These are produced for anonymous structs + # or unions; the 'name' is obtained by a typedef. + + def _generate_gen_anonymous_decl(self, tp, name): + if isinstance(tp, model.EnumType): + self._generate_gen_enum_decl(tp, name, '') + else: + self._generate_struct_or_union_decl(tp, '', name) + + def _loading_gen_anonymous(self, tp, name, module): + if isinstance(tp, model.EnumType): + self._loading_gen_enum(tp, name, module, '') + else: + self._loading_struct_or_union(tp, '', name, module) + + def _loaded_gen_anonymous(self, tp, name, module, **kwds): + if isinstance(tp, model.EnumType): + self._loaded_gen_enum(tp, name, module, **kwds) + else: + self._loaded_struct_or_union(tp) + + # ---------- + # constants, likely declared with '#define' + + def _generate_gen_const(self, is_int, name, tp=None, category='const', + check_value=None): + prnt = self._prnt + funcname = '_cffi_%s_%s' % (category, name) + self.export_symbols.append(funcname) + if check_value is not None: + assert is_int + assert category == 'const' + prnt('int %s(char *out_error)' % funcname) + prnt('{') + self._check_int_constant_value(name, check_value) + prnt(' return 0;') + prnt('}') + elif is_int: + assert category == 'const' + prnt('int %s(long long *out_value)' % funcname) + prnt('{') + prnt(' *out_value = (long long)(%s);' % (name,)) + prnt(' return (%s) <= 0;' % (name,)) + prnt('}') + else: + assert tp is not None + assert check_value is None + if category == 'var': + ampersand = '&' + else: + ampersand = '' + extra = '' + if category == 'const' and isinstance(tp, model.StructOrUnion): + extra = 'const *' + ampersand = '&' + prnt(tp.get_c_name(' %s%s(void)' % (extra, funcname), name)) + prnt('{') + prnt(' return (%s%s);' % (ampersand, name)) + prnt('}') + prnt() + + def _generate_gen_constant_decl(self, tp, name): + is_int = isinstance(tp, model.PrimitiveType) and tp.is_integer_type() + self._generate_gen_const(is_int, name, tp) + + _loading_gen_constant = _loaded_noop + + def _load_constant(self, is_int, tp, name, module, check_value=None): + funcname = '_cffi_const_%s' % name + if check_value is not None: + assert is_int + self._load_known_int_constant(module, funcname) + value = check_value + elif is_int: + BType = self.ffi._typeof_locked("long long*")[0] + BFunc = self.ffi._typeof_locked("int(*)(long long*)")[0] + function = module.load_function(BFunc, funcname) + p = self.ffi.new(BType) + negative = function(p) + value = int(p[0]) + if value < 0 and not negative: + BLongLong = self.ffi._typeof_locked("long long")[0] + value += (1 << (8*self.ffi.sizeof(BLongLong))) + else: + assert check_value is None + fntypeextra = '(*)(void)' + if isinstance(tp, model.StructOrUnion): + fntypeextra = '*' + fntypeextra + BFunc = self.ffi._typeof_locked(tp.get_c_name(fntypeextra, name))[0] + function = module.load_function(BFunc, funcname) + value = function() + if isinstance(tp, model.StructOrUnion): + value = value[0] + return value + + def _loaded_gen_constant(self, tp, name, module, library): + is_int = isinstance(tp, model.PrimitiveType) and tp.is_integer_type() + value = self._load_constant(is_int, tp, name, module) + setattr(library, name, value) + type(library)._cffi_dir.append(name) + + # ---------- + # enums + + def _check_int_constant_value(self, name, value): + prnt = self._prnt + if value <= 0: + prnt(' if ((%s) > 0 || (long)(%s) != %dL) {' % ( + name, name, value)) + else: + prnt(' if ((%s) <= 0 || (unsigned long)(%s) != %dUL) {' % ( + name, name, value)) + prnt(' char buf[64];') + prnt(' if ((%s) <= 0)' % name) + prnt(' sprintf(buf, "%%ld", (long)(%s));' % name) + prnt(' else') + prnt(' sprintf(buf, "%%lu", (unsigned long)(%s));' % + name) + prnt(' sprintf(out_error, "%s has the real value %s, not %s",') + prnt(' "%s", buf, "%d");' % (name[:100], value)) + prnt(' return -1;') + prnt(' }') + + def _load_known_int_constant(self, module, funcname): + BType = self.ffi._typeof_locked("char[]")[0] + BFunc = self.ffi._typeof_locked("int(*)(char*)")[0] + function = module.load_function(BFunc, funcname) + p = self.ffi.new(BType, 256) + if function(p) < 0: + error = self.ffi.string(p) + if sys.version_info >= (3,): + error = str(error, 'utf-8') + raise VerificationError(error) + + def _enum_funcname(self, prefix, name): + # "$enum_$1" => "___D_enum____D_1" + name = name.replace('$', '___D_') + return '_cffi_e_%s_%s' % (prefix, name) + + def _generate_gen_enum_decl(self, tp, name, prefix='enum'): + if tp.partial: + for enumerator in tp.enumerators: + self._generate_gen_const(True, enumerator) + return + # + funcname = self._enum_funcname(prefix, name) + self.export_symbols.append(funcname) + prnt = self._prnt + prnt('int %s(char *out_error)' % funcname) + prnt('{') + for enumerator, enumvalue in zip(tp.enumerators, tp.enumvalues): + self._check_int_constant_value(enumerator, enumvalue) + prnt(' return 0;') + prnt('}') + prnt() + + def _loading_gen_enum(self, tp, name, module, prefix='enum'): + if tp.partial: + enumvalues = [self._load_constant(True, tp, enumerator, module) + for enumerator in tp.enumerators] + tp.enumvalues = tuple(enumvalues) + tp.partial_resolved = True + else: + funcname = self._enum_funcname(prefix, name) + self._load_known_int_constant(module, funcname) + + def _loaded_gen_enum(self, tp, name, module, library): + for enumerator, enumvalue in zip(tp.enumerators, tp.enumvalues): + setattr(library, enumerator, enumvalue) + type(library)._cffi_dir.append(enumerator) + + # ---------- + # macros: for now only for integers + + def _generate_gen_macro_decl(self, tp, name): + if tp == '...': + check_value = None + else: + check_value = tp # an integer + self._generate_gen_const(True, name, check_value=check_value) + + _loading_gen_macro = _loaded_noop + + def _loaded_gen_macro(self, tp, name, module, library): + if tp == '...': + check_value = None + else: + check_value = tp # an integer + value = self._load_constant(True, tp, name, module, + check_value=check_value) + setattr(library, name, value) + type(library)._cffi_dir.append(name) + + # ---------- + # global variables + + def _generate_gen_variable_decl(self, tp, name): + if isinstance(tp, model.ArrayType): + if tp.length_is_unknown(): + prnt = self._prnt + funcname = '_cffi_sizeof_%s' % (name,) + self.export_symbols.append(funcname) + prnt("size_t %s(void)" % funcname) + prnt("{") + prnt(" return sizeof(%s);" % (name,)) + prnt("}") + tp_ptr = model.PointerType(tp.item) + self._generate_gen_const(False, name, tp_ptr) + else: + tp_ptr = model.PointerType(tp) + self._generate_gen_const(False, name, tp_ptr, category='var') + + _loading_gen_variable = _loaded_noop + + def _loaded_gen_variable(self, tp, name, module, library): + if isinstance(tp, model.ArrayType): # int a[5] is "constant" in the + # sense that "a=..." is forbidden + if tp.length_is_unknown(): + funcname = '_cffi_sizeof_%s' % (name,) + BFunc = self.ffi._typeof_locked('size_t(*)(void)')[0] + function = module.load_function(BFunc, funcname) + size = function() + BItemType = self.ffi._get_cached_btype(tp.item) + length, rest = divmod(size, self.ffi.sizeof(BItemType)) + if rest != 0: + raise VerificationError( + "bad size: %r does not seem to be an array of %s" % + (name, tp.item)) + tp = tp.resolve_length(length) + tp_ptr = model.PointerType(tp.item) + value = self._load_constant(False, tp_ptr, name, module) + # 'value' is a which we have to replace with + # a if the N is actually known + if tp.length is not None: + BArray = self.ffi._get_cached_btype(tp) + value = self.ffi.cast(BArray, value) + setattr(library, name, value) + type(library)._cffi_dir.append(name) + return + # remove ptr= from the library instance, and replace + # it by a property on the class, which reads/writes into ptr[0]. + funcname = '_cffi_var_%s' % name + BFunc = self.ffi._typeof_locked(tp.get_c_name('*(*)(void)', name))[0] + function = module.load_function(BFunc, funcname) + ptr = function() + def getter(library): + return ptr[0] + def setter(library, value): + ptr[0] = value + setattr(type(library), name, property(getter, setter)) + type(library)._cffi_dir.append(name) + +cffimod_header = r''' +#include +#include +#include +#include +#include /* XXX for ssize_t on some platforms */ + +/* this block of #ifs should be kept exactly identical between + c/_cffi_backend.c, cffi/vengine_cpy.py, cffi/vengine_gen.py + and cffi/_cffi_include.h */ +#if defined(_MSC_VER) +# include /* for alloca() */ +# if _MSC_VER < 1600 /* MSVC < 2010 */ + typedef __int8 int8_t; + typedef __int16 int16_t; + typedef __int32 int32_t; + typedef __int64 int64_t; + typedef unsigned __int8 uint8_t; + typedef unsigned __int16 uint16_t; + typedef unsigned __int32 uint32_t; + typedef unsigned __int64 uint64_t; + typedef __int8 int_least8_t; + typedef __int16 int_least16_t; + typedef __int32 int_least32_t; + typedef __int64 int_least64_t; + typedef unsigned __int8 uint_least8_t; + typedef unsigned __int16 uint_least16_t; + typedef unsigned __int32 uint_least32_t; + typedef unsigned __int64 uint_least64_t; + typedef __int8 int_fast8_t; + typedef __int16 int_fast16_t; + typedef __int32 int_fast32_t; + typedef __int64 int_fast64_t; + typedef unsigned __int8 uint_fast8_t; + typedef unsigned __int16 uint_fast16_t; + typedef unsigned __int32 uint_fast32_t; + typedef unsigned __int64 uint_fast64_t; + typedef __int64 intmax_t; + typedef unsigned __int64 uintmax_t; +# else +# include +# endif +# if _MSC_VER < 1800 /* MSVC < 2013 */ +# ifndef __cplusplus + typedef unsigned char _Bool; +# endif +# endif +# define _cffi_float_complex_t _Fcomplex /* include for it */ +# define _cffi_double_complex_t _Dcomplex /* include for it */ +#else +# include +# if (defined (__SVR4) && defined (__sun)) || defined(_AIX) || defined(__hpux) +# include +# endif +# define _cffi_float_complex_t float _Complex +# define _cffi_double_complex_t double _Complex +#endif +''' diff --git a/venv/lib/python3.10/site-packages/cffi/verifier.py b/venv/lib/python3.10/site-packages/cffi/verifier.py new file mode 100644 index 0000000000000000000000000000000000000000..e392a2b7fdab66662f5a32885cbe865d6c538ebe --- /dev/null +++ b/venv/lib/python3.10/site-packages/cffi/verifier.py @@ -0,0 +1,306 @@ +# +# DEPRECATED: implementation for ffi.verify() +# +import sys, os, binascii, shutil, io +from . import __version_verifier_modules__ +from . import ffiplatform +from .error import VerificationError + +if sys.version_info >= (3, 3): + import importlib.machinery + def _extension_suffixes(): + return importlib.machinery.EXTENSION_SUFFIXES[:] +else: + import imp + def _extension_suffixes(): + return [suffix for suffix, _, type in imp.get_suffixes() + if type == imp.C_EXTENSION] + + +if sys.version_info >= (3,): + NativeIO = io.StringIO +else: + class NativeIO(io.BytesIO): + def write(self, s): + if isinstance(s, unicode): + s = s.encode('ascii') + super(NativeIO, self).write(s) + + +class Verifier(object): + + def __init__(self, ffi, preamble, tmpdir=None, modulename=None, + ext_package=None, tag='', force_generic_engine=False, + source_extension='.c', flags=None, relative_to=None, **kwds): + if ffi._parser._uses_new_feature: + raise VerificationError( + "feature not supported with ffi.verify(), but only " + "with ffi.set_source(): %s" % (ffi._parser._uses_new_feature,)) + self.ffi = ffi + self.preamble = preamble + if not modulename: + flattened_kwds = ffiplatform.flatten(kwds) + vengine_class = _locate_engine_class(ffi, force_generic_engine) + self._vengine = vengine_class(self) + self._vengine.patch_extension_kwds(kwds) + self.flags = flags + self.kwds = self.make_relative_to(kwds, relative_to) + # + if modulename: + if tag: + raise TypeError("can't specify both 'modulename' and 'tag'") + else: + key = '\x00'.join(['%d.%d' % sys.version_info[:2], + __version_verifier_modules__, + preamble, flattened_kwds] + + ffi._cdefsources) + if sys.version_info >= (3,): + key = key.encode('utf-8') + k1 = hex(binascii.crc32(key[0::2]) & 0xffffffff) + k1 = k1.lstrip('0x').rstrip('L') + k2 = hex(binascii.crc32(key[1::2]) & 0xffffffff) + k2 = k2.lstrip('0').rstrip('L') + modulename = '_cffi_%s_%s%s%s' % (tag, self._vengine._class_key, + k1, k2) + suffix = _get_so_suffixes()[0] + self.tmpdir = tmpdir or _caller_dir_pycache() + self.sourcefilename = os.path.join(self.tmpdir, modulename + source_extension) + self.modulefilename = os.path.join(self.tmpdir, modulename + suffix) + self.ext_package = ext_package + self._has_source = False + self._has_module = False + + def write_source(self, file=None): + """Write the C source code. It is produced in 'self.sourcefilename', + which can be tweaked beforehand.""" + with self.ffi._lock: + if self._has_source and file is None: + raise VerificationError( + "source code already written") + self._write_source(file) + + def compile_module(self): + """Write the C source code (if not done already) and compile it. + This produces a dynamic link library in 'self.modulefilename'.""" + with self.ffi._lock: + if self._has_module: + raise VerificationError("module already compiled") + if not self._has_source: + self._write_source() + self._compile_module() + + def load_library(self): + """Get a C module from this Verifier instance. + Returns an instance of a FFILibrary class that behaves like the + objects returned by ffi.dlopen(), but that delegates all + operations to the C module. If necessary, the C code is written + and compiled first. + """ + with self.ffi._lock: + if not self._has_module: + self._locate_module() + if not self._has_module: + if not self._has_source: + self._write_source() + self._compile_module() + return self._load_library() + + def get_module_name(self): + basename = os.path.basename(self.modulefilename) + # kill both the .so extension and the other .'s, as introduced + # by Python 3: 'basename.cpython-33m.so' + basename = basename.split('.', 1)[0] + # and the _d added in Python 2 debug builds --- but try to be + # conservative and not kill a legitimate _d + if basename.endswith('_d') and hasattr(sys, 'gettotalrefcount'): + basename = basename[:-2] + return basename + + def get_extension(self): + if not self._has_source: + with self.ffi._lock: + if not self._has_source: + self._write_source() + sourcename = ffiplatform.maybe_relative_path(self.sourcefilename) + modname = self.get_module_name() + return ffiplatform.get_extension(sourcename, modname, **self.kwds) + + def generates_python_module(self): + return self._vengine._gen_python_module + + def make_relative_to(self, kwds, relative_to): + if relative_to and os.path.dirname(relative_to): + dirname = os.path.dirname(relative_to) + kwds = kwds.copy() + for key in ffiplatform.LIST_OF_FILE_NAMES: + if key in kwds: + lst = kwds[key] + if not isinstance(lst, (list, tuple)): + raise TypeError("keyword '%s' should be a list or tuple" + % (key,)) + lst = [os.path.join(dirname, fn) for fn in lst] + kwds[key] = lst + return kwds + + # ---------- + + def _locate_module(self): + if not os.path.isfile(self.modulefilename): + if self.ext_package: + try: + pkg = __import__(self.ext_package, None, None, ['__doc__']) + except ImportError: + return # cannot import the package itself, give up + # (e.g. it might be called differently before installation) + path = pkg.__path__ + else: + path = None + filename = self._vengine.find_module(self.get_module_name(), path, + _get_so_suffixes()) + if filename is None: + return + self.modulefilename = filename + self._vengine.collect_types() + self._has_module = True + + def _write_source_to(self, file): + self._vengine._f = file + try: + self._vengine.write_source_to_f() + finally: + del self._vengine._f + + def _write_source(self, file=None): + if file is not None: + self._write_source_to(file) + else: + # Write our source file to an in memory file. + f = NativeIO() + self._write_source_to(f) + source_data = f.getvalue() + + # Determine if this matches the current file + if os.path.exists(self.sourcefilename): + with open(self.sourcefilename, "r") as fp: + needs_written = not (fp.read() == source_data) + else: + needs_written = True + + # Actually write the file out if it doesn't match + if needs_written: + _ensure_dir(self.sourcefilename) + with open(self.sourcefilename, "w") as fp: + fp.write(source_data) + + # Set this flag + self._has_source = True + + def _compile_module(self): + # compile this C source + tmpdir = os.path.dirname(self.sourcefilename) + outputfilename = ffiplatform.compile(tmpdir, self.get_extension()) + try: + same = ffiplatform.samefile(outputfilename, self.modulefilename) + except OSError: + same = False + if not same: + _ensure_dir(self.modulefilename) + shutil.move(outputfilename, self.modulefilename) + self._has_module = True + + def _load_library(self): + assert self._has_module + if self.flags is not None: + return self._vengine.load_library(self.flags) + else: + return self._vengine.load_library() + +# ____________________________________________________________ + +_FORCE_GENERIC_ENGINE = False # for tests + +def _locate_engine_class(ffi, force_generic_engine): + if _FORCE_GENERIC_ENGINE: + force_generic_engine = True + if not force_generic_engine: + if '__pypy__' in sys.builtin_module_names: + force_generic_engine = True + else: + try: + import _cffi_backend + except ImportError: + _cffi_backend = '?' + if ffi._backend is not _cffi_backend: + force_generic_engine = True + if force_generic_engine: + from . import vengine_gen + return vengine_gen.VGenericEngine + else: + from . import vengine_cpy + return vengine_cpy.VCPythonEngine + +# ____________________________________________________________ + +_TMPDIR = None + +def _caller_dir_pycache(): + if _TMPDIR: + return _TMPDIR + result = os.environ.get('CFFI_TMPDIR') + if result: + return result + filename = sys._getframe(2).f_code.co_filename + return os.path.abspath(os.path.join(os.path.dirname(filename), + '__pycache__')) + +def set_tmpdir(dirname): + """Set the temporary directory to use instead of __pycache__.""" + global _TMPDIR + _TMPDIR = dirname + +def cleanup_tmpdir(tmpdir=None, keep_so=False): + """Clean up the temporary directory by removing all files in it + called `_cffi_*.{c,so}` as well as the `build` subdirectory.""" + tmpdir = tmpdir or _caller_dir_pycache() + try: + filelist = os.listdir(tmpdir) + except OSError: + return + if keep_so: + suffix = '.c' # only remove .c files + else: + suffix = _get_so_suffixes()[0].lower() + for fn in filelist: + if fn.lower().startswith('_cffi_') and ( + fn.lower().endswith(suffix) or fn.lower().endswith('.c')): + try: + os.unlink(os.path.join(tmpdir, fn)) + except OSError: + pass + clean_dir = [os.path.join(tmpdir, 'build')] + for dir in clean_dir: + try: + for fn in os.listdir(dir): + fn = os.path.join(dir, fn) + if os.path.isdir(fn): + clean_dir.append(fn) + else: + os.unlink(fn) + except OSError: + pass + +def _get_so_suffixes(): + suffixes = _extension_suffixes() + if not suffixes: + # bah, no C_EXTENSION available. Occurs on pypy without cpyext + if sys.platform == 'win32': + suffixes = [".pyd"] + else: + suffixes = [".so"] + + return suffixes + +def _ensure_dir(filename): + dirname = os.path.dirname(filename) + if dirname and not os.path.isdir(dirname): + os.makedirs(dirname) diff --git a/venv/lib/python3.10/site-packages/click_help_colors-0.9.4.dist-info/INSTALLER b/venv/lib/python3.10/site-packages/click_help_colors-0.9.4.dist-info/INSTALLER new file mode 100644 index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68 --- /dev/null +++ b/venv/lib/python3.10/site-packages/click_help_colors-0.9.4.dist-info/INSTALLER @@ -0,0 +1 @@ +pip diff --git a/venv/lib/python3.10/site-packages/click_help_colors-0.9.4.dist-info/LICENSE.txt b/venv/lib/python3.10/site-packages/click_help_colors-0.9.4.dist-info/LICENSE.txt new file mode 100644 index 0000000000000000000000000000000000000000..6ba615365be44c7413ebd4adf9b72808d09a101b --- /dev/null +++ b/venv/lib/python3.10/site-packages/click_help_colors-0.9.4.dist-info/LICENSE.txt @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2016 Roman Tonkonozhko + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/venv/lib/python3.10/site-packages/click_help_colors-0.9.4.dist-info/METADATA b/venv/lib/python3.10/site-packages/click_help_colors-0.9.4.dist-info/METADATA new file mode 100644 index 0000000000000000000000000000000000000000..2aa560aae88b678d970b1d5688633f39397eb5c4 --- /dev/null +++ b/venv/lib/python3.10/site-packages/click_help_colors-0.9.4.dist-info/METADATA @@ -0,0 +1,176 @@ +Metadata-Version: 2.1 +Name: click-help-colors +Version: 0.9.4 +Summary: Colorization of help messages in Click +Home-page: https://github.com/click-contrib/click-help-colors +License: MIT +Keywords: click +License-File: LICENSE.txt +Requires-Dist: click <9,>=7.0 +Provides-Extra: dev +Requires-Dist: mypy ; extra == 'dev' +Requires-Dist: pytest ; extra == 'dev' + +================= +click-help-colors +================= + +|pypi| |downloads| + +Colorization of help messages in Click_. + +Usage +----- + +.. code:: python + + import click + from click_help_colors import HelpColorsGroup, HelpColorsCommand + + @click.group( + cls=HelpColorsGroup, + help_headers_color='yellow', + help_options_color='green' + ) + def cli(): + pass + + @cli.command() + @click.option('--count', default=1, help='Some number.') + def command1(count): + click.echo('command 1') + + @cli.command( + cls=HelpColorsCommand, + help_options_color='blue' + ) + @click.option('--name', help='Some string.') + def command2(name): + click.echo('command 2') + +.. code-block:: console + + $ python example.py --help + +.. image:: https://raw.githubusercontent.com/click-contrib/click-help-colors/master/examples/screenshots/1.png + +.. code-block:: console + + $ python example.py command1 --help + +.. image:: https://raw.githubusercontent.com/click-contrib/click-help-colors/master/examples/screenshots/2.png + +.. code-block:: console + + $ python example.py command2 --help + +.. image:: https://raw.githubusercontent.com/click-contrib/click-help-colors/master/examples/screenshots/3.png + +.. code:: python + + import click + from click_help_colors import HelpColorsGroup, HelpColorsCommand + + @click.group( + cls=HelpColorsGroup, + help_headers_color='yellow', + help_options_color='green', + help_options_custom_colors={'command3': 'red', 'command4': 'cyan'} + ) + def cli(): + pass + + + @cli.command( + cls=HelpColorsCommand, + help_headers_color=None, + help_options_color=None, + help_options_custom_colors={'--count': 'red', '--subtract': 'green'} + ) + @click.option('--count', default=1, help='Count help text.') + @click.option('--add', default=1, help='Add help text.') + @click.option('--subtract', default=1, help='Subtract help text.') + def command1(count, add, subtract): + """A command""" + click.echo('command 1') + + ... + +.. code-block:: console + + $ python example_with_custom_colors.py --help + +.. image:: https://raw.githubusercontent.com/click-contrib/click-help-colors/master/examples/screenshots/4.png + +.. code-block:: console + + $ python example_with_custom_colors.py command1 --help + +.. image:: https://raw.githubusercontent.com/click-contrib/click-help-colors/master/examples/screenshots/5.png + +.. code:: python + + from click_help_colors import version_option + + @click.group() + def cli(): + pass + + @cli.command() + @version_option( + version='1.0', + prog_name='example', + message_color='green' + ) + def cmd1(): + pass + + @cli.command() + @version_option( + version='1.0', + prog_name='example', + version_color='green', + prog_name_color='yellow' + ) + def cmd2(): + pass + + @cli.command() + @version_option( + version='1.0', + prog_name='example', + version_color='green', + prog_name_color='white', + message='%(prog)s %(version)s\n python=3.7', + message_color='bright_black' + ) + def cmd3(): + pass + +.. image:: https://raw.githubusercontent.com/click-contrib/click-help-colors/master/examples/screenshots/6.png + +Installation +------------ + +With ``pip``: + +.. code-block:: console + + $ pip install click-help-colors + +From source: + +.. code-block:: console + + $ git clone https://github.com/click-contrib/click-help-colors.git + $ cd click-help-colors + $ python setup.py install + +.. _Click: http://click.pocoo.org/ + + +.. |pypi| image:: https://img.shields.io/pypi/v/click-help-colors + :alt: PyPI + +.. |downloads| image:: https://img.shields.io/pypi/dm/click-help-colors + :alt: PyPI - Downloads diff --git a/venv/lib/python3.10/site-packages/click_help_colors-0.9.4.dist-info/RECORD b/venv/lib/python3.10/site-packages/click_help_colors-0.9.4.dist-info/RECORD new file mode 100644 index 0000000000000000000000000000000000000000..c5c26140a88d608c6f6dc63ebc3802d84d514f18 --- /dev/null +++ b/venv/lib/python3.10/site-packages/click_help_colors-0.9.4.dist-info/RECORD @@ -0,0 +1,15 @@ +click_help_colors-0.9.4.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +click_help_colors-0.9.4.dist-info/LICENSE.txt,sha256=xZVqh6UiPnJIt80GHCc0jj0Djp3eQlsL4_sRHHlMdyE,1074 +click_help_colors-0.9.4.dist-info/METADATA,sha256=aXlwsa6VBT9arq0zvZZ6mmlouZEp4EWOvqPkise_UNY,4088 +click_help_colors-0.9.4.dist-info/RECORD,, +click_help_colors-0.9.4.dist-info/WHEEL,sha256=Xo9-1PvkuimrydujYJAjF7pCkriuXBpUPEjma1nZyJ0,92 +click_help_colors-0.9.4.dist-info/top_level.txt,sha256=sFMdBAKEvuiXxkAbjKRY3TwapVWePqzb7RDb6RGGW7o,18 +click_help_colors/__init__.py,sha256=hoVucFL2C6xRWLJss5e-O33RO0KOmdtqzGv1S0HguOo,431 +click_help_colors/__pycache__/__init__.cpython-310.pyc,, +click_help_colors/__pycache__/core.cpython-310.pyc,, +click_help_colors/__pycache__/decorators.cpython-310.pyc,, +click_help_colors/__pycache__/utils.cpython-310.pyc,, +click_help_colors/core.py,sha256=EM3oUzXD7QvRKnpKXh0dyqwpLrXLaEo8hatOwxlyL3E,7244 +click_help_colors/decorators.py,sha256=jC2VYHFS_d4u231tf2tbtiut0KpCJxVy0ZcQNW7Lu94,2358 +click_help_colors/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +click_help_colors/utils.py,sha256=XmATpdkBD0gETNjFktFGAvbtS9pCQ12N0IZRFQNg6OQ,752 diff --git a/venv/lib/python3.10/site-packages/click_help_colors-0.9.4.dist-info/WHEEL b/venv/lib/python3.10/site-packages/click_help_colors-0.9.4.dist-info/WHEEL new file mode 100644 index 0000000000000000000000000000000000000000..ba48cbcf9275ac6d88fe25821695e14d0a822e79 --- /dev/null +++ b/venv/lib/python3.10/site-packages/click_help_colors-0.9.4.dist-info/WHEEL @@ -0,0 +1,5 @@ +Wheel-Version: 1.0 +Generator: bdist_wheel (0.41.3) +Root-Is-Purelib: true +Tag: py3-none-any + diff --git a/venv/lib/python3.10/site-packages/click_help_colors-0.9.4.dist-info/top_level.txt b/venv/lib/python3.10/site-packages/click_help_colors-0.9.4.dist-info/top_level.txt new file mode 100644 index 0000000000000000000000000000000000000000..e8745a07080bad4f288632f4a1e357d1de23567a --- /dev/null +++ b/venv/lib/python3.10/site-packages/click_help_colors-0.9.4.dist-info/top_level.txt @@ -0,0 +1 @@ +click_help_colors diff --git a/venv/lib/python3.10/site-packages/cupy_backends/__init__.py b/venv/lib/python3.10/site-packages/cupy_backends/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/venv/lib/python3.10/site-packages/cupy_backends/__pycache__/__init__.cpython-310.pyc b/venv/lib/python3.10/site-packages/cupy_backends/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7439af64cf6a39fe26252696985c6c1a71c7087a Binary files /dev/null and b/venv/lib/python3.10/site-packages/cupy_backends/__pycache__/__init__.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/cupy_backends/cuda/__init__.py b/venv/lib/python3.10/site-packages/cupy_backends/cuda/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/venv/lib/python3.10/site-packages/cupy_backends/cuda/__pycache__/__init__.cpython-310.pyc b/venv/lib/python3.10/site-packages/cupy_backends/cuda/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..79d51b82ddbc7dc0ad722871d7052390d5242b48 Binary files /dev/null and b/venv/lib/python3.10/site-packages/cupy_backends/cuda/__pycache__/__init__.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/cupy_backends/cuda/api/__init__.py b/venv/lib/python3.10/site-packages/cupy_backends/cuda/api/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/venv/lib/python3.10/site-packages/cupy_backends/cuda/api/__pycache__/__init__.cpython-310.pyc b/venv/lib/python3.10/site-packages/cupy_backends/cuda/api/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..47ced31a973058c7d340e81f469fdd18ebf0c54c Binary files /dev/null and b/venv/lib/python3.10/site-packages/cupy_backends/cuda/api/__pycache__/__init__.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/cupy_backends/cuda/libs/__init__.py b/venv/lib/python3.10/site-packages/cupy_backends/cuda/libs/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/venv/lib/python3.10/site-packages/cupy_backends/cuda/libs/__pycache__/__init__.cpython-310.pyc b/venv/lib/python3.10/site-packages/cupy_backends/cuda/libs/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7a2a0289d21c6d10bf5564ed62b0075df6c3cfbc Binary files /dev/null and b/venv/lib/python3.10/site-packages/cupy_backends/cuda/libs/__pycache__/__init__.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/datasets-4.0.0.dist-info/AUTHORS b/venv/lib/python3.10/site-packages/datasets-4.0.0.dist-info/AUTHORS new file mode 100644 index 0000000000000000000000000000000000000000..7092efd949bb407beb485f25d6c1847804a79170 --- /dev/null +++ b/venv/lib/python3.10/site-packages/datasets-4.0.0.dist-info/AUTHORS @@ -0,0 +1,8 @@ +# This is the list of HuggingFace Datasets authors for copyright purposes. +# +# This does not necessarily list everyone who has contributed code, since in +# some cases, their employer may be the copyright holder. To see the full list +# of contributors, see the revision history in source control. + +Google Inc. +HuggingFace Inc. diff --git a/venv/lib/python3.10/site-packages/datasets-4.0.0.dist-info/INSTALLER b/venv/lib/python3.10/site-packages/datasets-4.0.0.dist-info/INSTALLER new file mode 100644 index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68 --- /dev/null +++ b/venv/lib/python3.10/site-packages/datasets-4.0.0.dist-info/INSTALLER @@ -0,0 +1 @@ +pip diff --git a/venv/lib/python3.10/site-packages/datasets-4.0.0.dist-info/LICENSE b/venv/lib/python3.10/site-packages/datasets-4.0.0.dist-info/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..d645695673349e3947e8e5ae42332d0ac3164cd7 --- /dev/null +++ b/venv/lib/python3.10/site-packages/datasets-4.0.0.dist-info/LICENSE @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/venv/lib/python3.10/site-packages/datasets-4.0.0.dist-info/METADATA b/venv/lib/python3.10/site-packages/datasets-4.0.0.dist-info/METADATA new file mode 100644 index 0000000000000000000000000000000000000000..6a8766b7cd8d365dd52377d3f8f60669cfeea1d4 --- /dev/null +++ b/venv/lib/python3.10/site-packages/datasets-4.0.0.dist-info/METADATA @@ -0,0 +1,370 @@ +Metadata-Version: 2.2 +Name: datasets +Version: 4.0.0 +Summary: HuggingFace community-driven open-source library of datasets +Home-page: https://github.com/huggingface/datasets +Download-URL: https://github.com/huggingface/datasets/tags +Author: HuggingFace Inc. +Author-email: thomas@huggingface.co +License: Apache 2.0 +Keywords: datasets machine learning datasets +Classifier: Development Status :: 5 - Production/Stable +Classifier: Intended Audience :: Developers +Classifier: Intended Audience :: Education +Classifier: Intended Audience :: Science/Research +Classifier: License :: OSI Approved :: Apache Software License +Classifier: Operating System :: OS Independent +Classifier: Programming Language :: Python :: 3 +Classifier: Programming Language :: Python :: 3.9 +Classifier: Programming Language :: Python :: 3.10 +Classifier: Programming Language :: Python :: 3.11 +Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence +Requires-Python: >=3.9.0 +Description-Content-Type: text/markdown +License-File: LICENSE +License-File: AUTHORS +Requires-Dist: filelock +Requires-Dist: numpy>=1.17 +Requires-Dist: pyarrow>=15.0.0 +Requires-Dist: dill<0.3.9,>=0.3.0 +Requires-Dist: pandas +Requires-Dist: requests>=2.32.2 +Requires-Dist: tqdm>=4.66.3 +Requires-Dist: xxhash +Requires-Dist: multiprocess<0.70.17 +Requires-Dist: fsspec[http]<=2025.3.0,>=2023.1.0 +Requires-Dist: huggingface-hub>=0.24.0 +Requires-Dist: packaging +Requires-Dist: pyyaml>=5.1 +Provides-Extra: audio +Requires-Dist: soundfile>=0.12.1; extra == "audio" +Requires-Dist: torchcodec>=0.4.0; extra == "audio" +Requires-Dist: torch>=2.7.0; extra == "audio" +Provides-Extra: vision +Requires-Dist: Pillow>=9.4.0; extra == "vision" +Provides-Extra: tensorflow +Requires-Dist: tensorflow>=2.6.0; extra == "tensorflow" +Provides-Extra: tensorflow-gpu +Requires-Dist: tensorflow>=2.6.0; extra == "tensorflow-gpu" +Provides-Extra: torch +Requires-Dist: torch; extra == "torch" +Provides-Extra: jax +Requires-Dist: jax>=0.3.14; extra == "jax" +Requires-Dist: jaxlib>=0.3.14; extra == "jax" +Provides-Extra: streaming +Provides-Extra: dev +Requires-Dist: numba>=0.56.4; extra == "dev" +Requires-Dist: absl-py; extra == "dev" +Requires-Dist: decorator; extra == "dev" +Requires-Dist: joblib<1.3.0; extra == "dev" +Requires-Dist: joblibspark; extra == "dev" +Requires-Dist: pytest; extra == "dev" +Requires-Dist: pytest-datadir; extra == "dev" +Requires-Dist: pytest-xdist; extra == "dev" +Requires-Dist: aiohttp; extra == "dev" +Requires-Dist: elasticsearch<8.0.0,>=7.17.12; extra == "dev" +Requires-Dist: faiss-cpu>=1.8.0.post1; extra == "dev" +Requires-Dist: jax>=0.3.14; sys_platform != "win32" and extra == "dev" +Requires-Dist: jaxlib>=0.3.14; sys_platform != "win32" and extra == "dev" +Requires-Dist: lz4; extra == "dev" +Requires-Dist: moto[server]; extra == "dev" +Requires-Dist: pyspark>=3.4; extra == "dev" +Requires-Dist: py7zr; extra == "dev" +Requires-Dist: rarfile>=4.0; extra == "dev" +Requires-Dist: sqlalchemy; extra == "dev" +Requires-Dist: protobuf<4.0.0; extra == "dev" +Requires-Dist: tensorflow>=2.6.0; (python_version < "3.10" and sys_platform != "win32") and extra == "dev" +Requires-Dist: tensorflow>=2.16.0; (python_version >= "3.10" and sys_platform != "win32") and extra == "dev" +Requires-Dist: tiktoken; extra == "dev" +Requires-Dist: torch>=2.0.0; extra == "dev" +Requires-Dist: torchdata; extra == "dev" +Requires-Dist: soundfile>=0.12.1; extra == "dev" +Requires-Dist: transformers>=4.42.0; extra == "dev" +Requires-Dist: zstandard; extra == "dev" +Requires-Dist: polars[timezone]>=0.20.0; extra == "dev" +Requires-Dist: Pillow>=9.4.0; extra == "dev" +Requires-Dist: soundfile>=0.12.1; extra == "dev" +Requires-Dist: torchcodec>=0.4.0; sys_platform != "win32" and extra == "dev" +Requires-Dist: ruff>=0.3.0; extra == "dev" +Requires-Dist: transformers; extra == "dev" +Requires-Dist: torch; extra == "dev" +Requires-Dist: tensorflow>=2.6.0; extra == "dev" +Provides-Extra: tests +Requires-Dist: numba>=0.56.4; extra == "tests" +Requires-Dist: absl-py; extra == "tests" +Requires-Dist: decorator; extra == "tests" +Requires-Dist: joblib<1.3.0; extra == "tests" +Requires-Dist: joblibspark; extra == "tests" +Requires-Dist: pytest; extra == "tests" +Requires-Dist: pytest-datadir; extra == "tests" +Requires-Dist: pytest-xdist; extra == "tests" +Requires-Dist: aiohttp; extra == "tests" +Requires-Dist: elasticsearch<8.0.0,>=7.17.12; extra == "tests" +Requires-Dist: faiss-cpu>=1.8.0.post1; extra == "tests" +Requires-Dist: jax>=0.3.14; sys_platform != "win32" and extra == "tests" +Requires-Dist: jaxlib>=0.3.14; sys_platform != "win32" and extra == "tests" +Requires-Dist: lz4; extra == "tests" +Requires-Dist: moto[server]; extra == "tests" +Requires-Dist: pyspark>=3.4; extra == "tests" +Requires-Dist: py7zr; extra == "tests" +Requires-Dist: rarfile>=4.0; extra == "tests" +Requires-Dist: sqlalchemy; extra == "tests" +Requires-Dist: protobuf<4.0.0; extra == "tests" +Requires-Dist: tensorflow>=2.6.0; (python_version < "3.10" and sys_platform != "win32") and extra == "tests" +Requires-Dist: tensorflow>=2.16.0; (python_version >= "3.10" and sys_platform != "win32") and extra == "tests" +Requires-Dist: tiktoken; extra == "tests" +Requires-Dist: torch>=2.0.0; extra == "tests" +Requires-Dist: torchdata; extra == "tests" +Requires-Dist: soundfile>=0.12.1; extra == "tests" +Requires-Dist: transformers>=4.42.0; extra == "tests" +Requires-Dist: zstandard; extra == "tests" +Requires-Dist: polars[timezone]>=0.20.0; extra == "tests" +Requires-Dist: Pillow>=9.4.0; extra == "tests" +Requires-Dist: soundfile>=0.12.1; extra == "tests" +Requires-Dist: torchcodec>=0.4.0; sys_platform != "win32" and extra == "tests" +Provides-Extra: tests-numpy2 +Requires-Dist: numba>=0.56.4; extra == "tests-numpy2" +Requires-Dist: absl-py; extra == "tests-numpy2" +Requires-Dist: decorator; extra == "tests-numpy2" +Requires-Dist: joblib<1.3.0; extra == "tests-numpy2" +Requires-Dist: joblibspark; extra == "tests-numpy2" +Requires-Dist: pytest; extra == "tests-numpy2" +Requires-Dist: pytest-datadir; extra == "tests-numpy2" +Requires-Dist: pytest-xdist; extra == "tests-numpy2" +Requires-Dist: aiohttp; extra == "tests-numpy2" +Requires-Dist: elasticsearch<8.0.0,>=7.17.12; extra == "tests-numpy2" +Requires-Dist: jax>=0.3.14; sys_platform != "win32" and extra == "tests-numpy2" +Requires-Dist: jaxlib>=0.3.14; sys_platform != "win32" and extra == "tests-numpy2" +Requires-Dist: lz4; extra == "tests-numpy2" +Requires-Dist: moto[server]; extra == "tests-numpy2" +Requires-Dist: pyspark>=3.4; extra == "tests-numpy2" +Requires-Dist: py7zr; extra == "tests-numpy2" +Requires-Dist: rarfile>=4.0; extra == "tests-numpy2" +Requires-Dist: sqlalchemy; extra == "tests-numpy2" +Requires-Dist: protobuf<4.0.0; extra == "tests-numpy2" +Requires-Dist: tiktoken; extra == "tests-numpy2" +Requires-Dist: torch>=2.0.0; extra == "tests-numpy2" +Requires-Dist: torchdata; extra == "tests-numpy2" +Requires-Dist: soundfile>=0.12.1; extra == "tests-numpy2" +Requires-Dist: transformers>=4.42.0; extra == "tests-numpy2" +Requires-Dist: zstandard; extra == "tests-numpy2" +Requires-Dist: polars[timezone]>=0.20.0; extra == "tests-numpy2" +Requires-Dist: Pillow>=9.4.0; extra == "tests-numpy2" +Requires-Dist: soundfile>=0.12.1; extra == "tests-numpy2" +Requires-Dist: torchcodec>=0.4.0; sys_platform != "win32" and extra == "tests-numpy2" +Provides-Extra: quality +Requires-Dist: ruff>=0.3.0; extra == "quality" +Provides-Extra: benchmarks +Requires-Dist: tensorflow==2.12.0; extra == "benchmarks" +Requires-Dist: torch==2.0.1; extra == "benchmarks" +Requires-Dist: transformers==4.30.1; extra == "benchmarks" +Provides-Extra: docs +Requires-Dist: transformers; extra == "docs" +Requires-Dist: torch; extra == "docs" +Requires-Dist: tensorflow>=2.6.0; extra == "docs" +Provides-Extra: pdfs +Requires-Dist: pdfplumber>=0.11.4; extra == "pdfs" +Dynamic: author +Dynamic: author-email +Dynamic: classifier +Dynamic: description +Dynamic: description-content-type +Dynamic: download-url +Dynamic: home-page +Dynamic: keywords +Dynamic: license +Dynamic: provides-extra +Dynamic: requires-dist +Dynamic: requires-python +Dynamic: summary + +

+ + + + Hugging Face Datasets Library + +
+
+

+ +

+ Build + GitHub + Documentation + GitHub release + Number of datasets + Contributor Covenant + DOI +

+ +🤗 Datasets is a lightweight library providing **two** main features: + +- **one-line dataloaders for many public datasets**: one-liners to download and pre-process any of the ![number of datasets](https://img.shields.io/endpoint?url=https://huggingface.co/api/shields/datasets&color=brightgreen) major public datasets (image datasets, audio datasets, text datasets in 467 languages and dialects, etc.) provided on the [HuggingFace Datasets Hub](https://huggingface.co/datasets). With a simple command like `squad_dataset = load_dataset("rajpurkar/squad")`, get any of these datasets ready to use in a dataloader for training/evaluating a ML model (Numpy/Pandas/PyTorch/TensorFlow/JAX), +- **efficient data pre-processing**: simple, fast and reproducible data pre-processing for the public datasets as well as your own local datasets in CSV, JSON, text, PNG, JPEG, WAV, MP3, Parquet, etc. With simple commands like `processed_dataset = dataset.map(process_example)`, efficiently prepare the dataset for inspection and ML model evaluation and training. + +[🎓 **Documentation**](https://huggingface.co/docs/datasets/) [🔎 **Find a dataset in the Hub**](https://huggingface.co/datasets) [🌟 **Share a dataset on the Hub**](https://huggingface.co/docs/datasets/share) + +

+ +

+ +🤗 Datasets is designed to let the community easily add and share new datasets. + +🤗 Datasets has many additional interesting features: + +- Thrive on large datasets: 🤗 Datasets naturally frees the user from RAM memory limitation, all datasets are memory-mapped using an efficient zero-serialization cost backend (Apache Arrow). +- Smart caching: never wait for your data to process several times. +- Lightweight and fast with a transparent and pythonic API (multi-processing/caching/memory-mapping). +- Built-in interoperability with NumPy, PyTorch, TensorFlow 2, JAX, Pandas, Polars and more. +- Native support for audio, image and video data. +- Enable streaming mode to save disk space and start iterating over the dataset immediately. + +🤗 Datasets originated from a fork of the awesome [TensorFlow Datasets](https://github.com/tensorflow/datasets) and the HuggingFace team want to deeply thank the TensorFlow Datasets team for building this amazing library. + +# Installation + +## With pip + +🤗 Datasets can be installed from PyPi and has to be installed in a virtual environment (venv or conda for instance) + +```bash +pip install datasets +``` + +## With conda + +🤗 Datasets can be installed using conda as follows: + +```bash +conda install -c huggingface -c conda-forge datasets +``` + +Follow the installation pages of TensorFlow and PyTorch to see how to install them with conda. + +For more details on installation, check the installation page in the documentation: https://huggingface.co/docs/datasets/installation + +## Installation to use with Machine Learning & Data frameworks frameworks + +If you plan to use 🤗 Datasets with PyTorch (2.0+), TensorFlow (2.6+) or JAX (3.14+) you should also install PyTorch, TensorFlow or JAX. +🤗 Datasets is also well integrated with data frameworks like PyArrow, Pandas, Polars and Spark, which should be installed separately. + +For more details on using the library with these frameworks, check the quick start page in the documentation: https://huggingface.co/docs/datasets/quickstart + +# Usage + +🤗 Datasets is made to be very simple to use - the API is centered around a single function, `datasets.load_dataset(dataset_name, **kwargs)`, that instantiates a dataset. + +This library can be used for text/image/audio/etc. datasets. Here is an example to load a text dataset: + +Here is a quick example: + +```python +from datasets import load_dataset + +# Print all the available datasets +from huggingface_hub import list_datasets +print([dataset.id for dataset in list_datasets()]) + +# Load a dataset and print the first example in the training set +squad_dataset = load_dataset('rajpurkar/squad') +print(squad_dataset['train'][0]) + +# Process the dataset - add a column with the length of the context texts +dataset_with_length = squad_dataset.map(lambda x: {"length": len(x["context"])}) + +# Process the dataset - tokenize the context texts (using a tokenizer from the 🤗 Transformers library) +from transformers import AutoTokenizer +tokenizer = AutoTokenizer.from_pretrained('bert-base-cased') + +tokenized_dataset = squad_dataset.map(lambda x: tokenizer(x['context']), batched=True) +``` + +If your dataset is bigger than your disk or if you don't want to wait to download the data, you can use streaming: + +```python +# If you want to use the dataset immediately and efficiently stream the data as you iterate over the dataset +image_dataset = load_dataset('timm/imagenet-1k-wds', streaming=True) +for example in image_dataset["train"]: + break +``` + +For more details on using the library, check the quick start page in the documentation: https://huggingface.co/docs/datasets/quickstart and the specific pages on: + +- Loading a dataset: https://huggingface.co/docs/datasets/loading +- What's in a Dataset: https://huggingface.co/docs/datasets/access +- Processing data with 🤗 Datasets: https://huggingface.co/docs/datasets/process + - Processing audio data: https://huggingface.co/docs/datasets/audio_process + - Processing image data: https://huggingface.co/docs/datasets/image_process + - Processing text data: https://huggingface.co/docs/datasets/nlp_process +- Streaming a dataset: https://huggingface.co/docs/datasets/stream +- etc. + +# Add a new dataset to the Hub + +We have a very detailed step-by-step guide to add a new dataset to the ![number of datasets](https://img.shields.io/endpoint?url=https://huggingface.co/api/shields/datasets&color=brightgreen) datasets already provided on the [HuggingFace Datasets Hub](https://huggingface.co/datasets). + +You can find: +- [how to upload a dataset to the Hub using your web browser or Python](https://huggingface.co/docs/datasets/upload_dataset) and also +- [how to upload it using Git](https://huggingface.co/docs/datasets/share). + +# Disclaimers + +You can use 🤗 Datasets to load datasets based on versioned git repositories maintained by the dataset authors. For reproducibility reasons, we ask users to pin the `revision` of the repositories they use. + +If you're a dataset owner and wish to update any part of it (description, citation, license, etc.), or do not want your dataset to be included in the Hugging Face Hub, please get in touch by opening a discussion or a pull request in the Community tab of the dataset page. Thanks for your contribution to the ML community! + +## BibTeX + +If you want to cite our 🤗 Datasets library, you can use our [paper](https://arxiv.org/abs/2109.02846): + +```bibtex +@inproceedings{lhoest-etal-2021-datasets, + title = "Datasets: A Community Library for Natural Language Processing", + author = "Lhoest, Quentin and + Villanova del Moral, Albert and + Jernite, Yacine and + Thakur, Abhishek and + von Platen, Patrick and + Patil, Suraj and + Chaumond, Julien and + Drame, Mariama and + Plu, Julien and + Tunstall, Lewis and + Davison, Joe and + {\v{S}}a{\v{s}}ko, Mario and + Chhablani, Gunjan and + Malik, Bhavitvya and + Brandeis, Simon and + Le Scao, Teven and + Sanh, Victor and + Xu, Canwen and + Patry, Nicolas and + McMillan-Major, Angelina and + Schmid, Philipp and + Gugger, Sylvain and + Delangue, Cl{\'e}ment and + Matussi{\`e}re, Th{\'e}o and + Debut, Lysandre and + Bekman, Stas and + Cistac, Pierric and + Goehringer, Thibault and + Mustar, Victor and + Lagunas, Fran{\c{c}}ois and + Rush, Alexander and + Wolf, Thomas", + booktitle = "Proceedings of the 2021 Conference on Empirical Methods in Natural Language Processing: System Demonstrations", + month = nov, + year = "2021", + address = "Online and Punta Cana, Dominican Republic", + publisher = "Association for Computational Linguistics", + url = "https://aclanthology.org/2021.emnlp-demo.21", + pages = "175--184", + abstract = "The scale, variety, and quantity of publicly-available NLP datasets has grown rapidly as researchers propose new tasks, larger models, and novel benchmarks. Datasets is a community library for contemporary NLP designed to support this ecosystem. Datasets aims to standardize end-user interfaces, versioning, and documentation, while providing a lightweight front-end that behaves similarly for small datasets as for internet-scale corpora. The design of the library incorporates a distributed, community-driven approach to adding datasets and documenting usage. After a year of development, the library now includes more than 650 unique datasets, has more than 250 contributors, and has helped support a variety of novel cross-dataset research projects and shared tasks. The library is available at https://github.com/huggingface/datasets.", + eprint={2109.02846}, + archivePrefix={arXiv}, + primaryClass={cs.CL}, +} +``` + +If you need to cite a specific version of our 🤗 Datasets library for reproducibility, you can use the corresponding version Zenodo DOI from this [list](https://zenodo.org/search?q=conceptrecid:%224817768%22&sort=-version&all_versions=True). diff --git a/venv/lib/python3.10/site-packages/datasets-4.0.0.dist-info/RECORD b/venv/lib/python3.10/site-packages/datasets-4.0.0.dist-info/RECORD new file mode 100644 index 0000000000000000000000000000000000000000..4bef17735361d69a83eea561f2dd417614872b50 --- /dev/null +++ b/venv/lib/python3.10/site-packages/datasets-4.0.0.dist-info/RECORD @@ -0,0 +1,254 @@ +../../../bin/datasets-cli,sha256=s4w0Pjk1H01g9YsLQSgHoEpqy2n_j3WhshJoZV1klB0,299 +datasets-4.0.0.dist-info/AUTHORS,sha256=L0FBY23tCNHLmvsOKAbumHn8WZZIK98sH53JYxhAchU,327 +datasets-4.0.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +datasets-4.0.0.dist-info/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358 +datasets-4.0.0.dist-info/METADATA,sha256=mthpmfRtfgoxdjCH0FHz5r0IC4zu63VL0dKFos07p1w,19289 +datasets-4.0.0.dist-info/RECORD,, +datasets-4.0.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91 +datasets-4.0.0.dist-info/entry_points.txt,sha256=iM-h4A7OQCrZqr3L2mwiyMtPeFj8w4HAHzmI45y3tg0,69 +datasets-4.0.0.dist-info/top_level.txt,sha256=9A857YvCQm_Dg3UjeKkWPz9sDBos0t3zN2pf5krTemQ,9 +datasets/__init__.py,sha256=YNBFgXn--2FOXIjy9DUAcX-lzsUFf8LBWz4K8dnuE-Q,1630 +datasets/__pycache__/__init__.cpython-310.pyc,, +datasets/__pycache__/arrow_dataset.cpython-310.pyc,, +datasets/__pycache__/arrow_reader.cpython-310.pyc,, +datasets/__pycache__/arrow_writer.cpython-310.pyc,, +datasets/__pycache__/builder.cpython-310.pyc,, +datasets/__pycache__/combine.cpython-310.pyc,, +datasets/__pycache__/config.cpython-310.pyc,, +datasets/__pycache__/data_files.cpython-310.pyc,, +datasets/__pycache__/dataset_dict.cpython-310.pyc,, +datasets/__pycache__/distributed.cpython-310.pyc,, +datasets/__pycache__/exceptions.cpython-310.pyc,, +datasets/__pycache__/fingerprint.cpython-310.pyc,, +datasets/__pycache__/hub.cpython-310.pyc,, +datasets/__pycache__/info.cpython-310.pyc,, +datasets/__pycache__/inspect.cpython-310.pyc,, +datasets/__pycache__/iterable_dataset.cpython-310.pyc,, +datasets/__pycache__/keyhash.cpython-310.pyc,, +datasets/__pycache__/load.cpython-310.pyc,, +datasets/__pycache__/naming.cpython-310.pyc,, +datasets/__pycache__/search.cpython-310.pyc,, +datasets/__pycache__/splits.cpython-310.pyc,, +datasets/__pycache__/streaming.cpython-310.pyc,, +datasets/__pycache__/table.cpython-310.pyc,, +datasets/arrow_dataset.py,sha256=UTAII1m0vmopyMMJtLEp46MxIrTE0oVdtMb5EyrgyLk,310125 +datasets/arrow_reader.py,sha256=byEDpH_SwzjbnVqW0pXjBaE1NoXFE4Cmwoz7zTB_IvA,25131 +datasets/arrow_writer.py,sha256=K3xaG5PGMGhYDzp3XP4dOpbHBFdKwSr42fcxRjCZ-8w,30663 +datasets/builder.py,sha256=UCG7L_bwZI8zpL5gOCqMZE11U3F52bkB_vNMfvImnQU,87686 +datasets/combine.py,sha256=iylOVTWReGk_9x1HYFEMkRvB8kLlQq6E0zEHdawp3ds,10892 +datasets/commands/__init__.py,sha256=rujbQtxJbwHhF9WQqp2DD9tfVTghDMJdl0v6H551Pcs,312 +datasets/commands/__pycache__/__init__.cpython-310.pyc,, +datasets/commands/__pycache__/datasets_cli.cpython-310.pyc,, +datasets/commands/__pycache__/delete_from_hub.cpython-310.pyc,, +datasets/commands/__pycache__/env.cpython-310.pyc,, +datasets/commands/__pycache__/test.cpython-310.pyc,, +datasets/commands/datasets_cli.py,sha256=CRy2H60h2sxJDpfa4LZ4dxipdGIZlTL47pEXLV6tfwQ,1175 +datasets/commands/delete_from_hub.py,sha256=o0wdolb1r1Jnl6F0KdqKn3u0l8VR2od6KzbRoqrSNPM,1396 +datasets/commands/env.py,sha256=8qg-hpXSXXsHvtYFvJkn5rn9IncqPsjjx3nR8no4a2I,1239 +datasets/commands/test.py,sha256=LEcbsx_zEl15679i2BPXFuvfdPsFGOogVR0rjBkf3_k,7820 +datasets/config.py,sha256=Q8XWJR16FWGRnpxhr3XE4p-Hi5Nv130yN1rpuZ33lag,10011 +datasets/data_files.py,sha256=tH5DC2Mu5hP9CkiW_q0pruH5CxARxc8iLXz6WPDH7eo,31525 +datasets/dataset_dict.py,sha256=cX0uWekrBV04TTMe6E9pOvZxjPvqRXvnYP5xZXLUcDw,127475 +datasets/distributed.py,sha256=pulXFluRCmo69KeDqblPz32avS6LCHTGycS77XgI2mY,1562 +datasets/download/__init__.py,sha256=lbFOtITDaR7PHrhzJ8VfRnpaOT6NYozSxUcLv_GVfTg,281 +datasets/download/__pycache__/__init__.cpython-310.pyc,, +datasets/download/__pycache__/download_config.cpython-310.pyc,, +datasets/download/__pycache__/download_manager.cpython-310.pyc,, +datasets/download/__pycache__/streaming_download_manager.cpython-310.pyc,, +datasets/download/download_config.py,sha256=t5qA5qgy2Q1QJiDnpS8CqxO0XxNQ0ftAvOji99-l-Sk,3796 +datasets/download/download_manager.py,sha256=44VSuSzIMJoZ-bDa3uF494jio5JmZFMeGAPzuXYRA7Q,12762 +datasets/download/streaming_download_manager.py,sha256=qvcoVsXnAGNi2lzKRktck_DJrIx1fQ7xedm881s0IQw,7537 +datasets/exceptions.py,sha256=B93GwElhEvlhHPU9GBSY8if27jhRwu875-gL6B2CL6c,4185 +datasets/features/__init__.py,sha256=0YpObHj_6rGhfwvDvhzrhdCnhoK3RBwwn7bNZ9T5ZM8,547 +datasets/features/__pycache__/__init__.cpython-310.pyc,, +datasets/features/__pycache__/_torchcodec.cpython-310.pyc,, +datasets/features/__pycache__/audio.cpython-310.pyc,, +datasets/features/__pycache__/features.cpython-310.pyc,, +datasets/features/__pycache__/image.cpython-310.pyc,, +datasets/features/__pycache__/pdf.cpython-310.pyc,, +datasets/features/__pycache__/translation.cpython-310.pyc,, +datasets/features/__pycache__/video.cpython-310.pyc,, +datasets/features/_torchcodec.py,sha256=Ws7JMYlUlPa7NHh1ZgxWQNrJV0c14kfYYCdrLjCkmjA,627 +datasets/features/audio.py,sha256=c6J546eLGFkN53IP_cbYS7bpRTfop4Qd_UpPrS1r7fk,13393 +datasets/features/features.py,sha256=-_FZ0AWOnxLUs3lvtkCoaef1YU234rX-MGhPGo4JyB8,93445 +datasets/features/image.py,sha256=H-kRiivtTtFBbRq_R9ijN2EWA3vrnhUQcsr1K5FQ4xQ,16217 +datasets/features/pdf.py,sha256=rh6qNNJuOa9dekb1GIa3hLBM9afAU8hRHQTpyKkJH80,11059 +datasets/features/translation.py,sha256=aIJfNMXTTQLamEk4L8mfTDDdyzscZUnhSPAor8RjE_8,4490 +datasets/features/video.py,sha256=4305NoaCpQLsUzw8t89Aa49nd7TMiQFqQ4jdct2iUnM,13973 +datasets/filesystems/__init__.py,sha256=jBDUQosQqEFIXUDLZwRWaTgNomwL6Fq2qiYPvvxuae0,1523 +datasets/filesystems/__pycache__/__init__.cpython-310.pyc,, +datasets/filesystems/__pycache__/compression.cpython-310.pyc,, +datasets/filesystems/compression.py,sha256=2NnuTGzqmH5wk_Vmp9nhuQCAAZ6bzBpCErvrHVOLR4c,4488 +datasets/fingerprint.py,sha256=9nIrIMTcsDdvMvhH56Ml_Zv0uXXR1dFvrolZkWxE-Ik,20333 +datasets/formatting/__init__.py,sha256=-pM10fSzw4MVj_L3NFWEv2sUyBh4mbnvCkfXgfS6WII,5412 +datasets/formatting/__pycache__/__init__.cpython-310.pyc,, +datasets/formatting/__pycache__/formatting.cpython-310.pyc,, +datasets/formatting/__pycache__/jax_formatter.cpython-310.pyc,, +datasets/formatting/__pycache__/np_formatter.cpython-310.pyc,, +datasets/formatting/__pycache__/polars_formatter.cpython-310.pyc,, +datasets/formatting/__pycache__/tf_formatter.cpython-310.pyc,, +datasets/formatting/__pycache__/torch_formatter.cpython-310.pyc,, +datasets/formatting/formatting.py,sha256=rCu4pZ7q-TXrc3tjKzNwHHTzt1r-icqg_bACrs6a36U,26598 +datasets/formatting/jax_formatter.py,sha256=uwckTeHc5DMt8CuqieBzSrfWQuhqaW3X076HaPxxKoY,7412 +datasets/formatting/np_formatter.py,sha256=gmp76JnzjCaIZTvcZUzsGp-vvIjFMqXEUArMU-JisCw,5102 +datasets/formatting/polars_formatter.py,sha256=oTm4l30SgGha-Oku42C0dA91Y8f2oifF9aWvi3QITDk,4744 +datasets/formatting/tf_formatter.py,sha256=_wnRRFH1Q5uzCK8mG8qAfdAVybGGuljbGUe46hmMTrU,5236 +datasets/formatting/torch_formatter.py,sha256=Ff7CtXY60Q7oIzvpNb8InQpjk8oEApAFXGj43ez5gFI,5311 +datasets/hub.py,sha256=6qnJVVTdEIShaUGlHrRjFJwvnJiNQuzsU01C8ID-8lA,4822 +datasets/info.py,sha256=AdNB1CcWOag6SfoR0IM7-grZbIYNPG_N1msl5ccJnq8,19642 +datasets/inspect.py,sha256=nC0X--w_RXZflkhhr729MJoP_4i929ith9QwfoaDF4M,15647 +datasets/io/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +datasets/io/__pycache__/__init__.cpython-310.pyc,, +datasets/io/__pycache__/abc.cpython-310.pyc,, +datasets/io/__pycache__/csv.cpython-310.pyc,, +datasets/io/__pycache__/generator.cpython-310.pyc,, +datasets/io/__pycache__/json.cpython-310.pyc,, +datasets/io/__pycache__/parquet.cpython-310.pyc,, +datasets/io/__pycache__/spark.cpython-310.pyc,, +datasets/io/__pycache__/sql.cpython-310.pyc,, +datasets/io/__pycache__/text.cpython-310.pyc,, +datasets/io/abc.py,sha256=LwDMXYs6YkhZuz1JiMK4PDIqgNjv7I8xH3UMUELW2ys,1672 +datasets/io/csv.py,sha256=v4zaWehHb9U3njbdhy7wQnb8qO_c_58XOUC9JgBBVwI,5265 +datasets/io/generator.py,sha256=sP_5GNozcxXIgDsPVMW_riqCZdInZ0_iFzcY_X1F-Mo,1909 +datasets/io/json.py,sha256=vQZT9vhTbKX5Nyob4zQZR1NXWCft7bT5_6_8DD4XZyo,6697 +datasets/io/parquet.py,sha256=IxotIfpNHXvJgFzsbT3-CjB1_FfvKpYhNNU1Akxe9bs,4354 +datasets/io/spark.py,sha256=VUIODLHgIbiK0CI0UvthQ_gUO0MQDtHUozvw7Dfs8FI,1797 +datasets/io/sql.py,sha256=4Zjw7peVEhhzoDtz2VTCFPqt2Tpy4zMB7T7ajb2GVTY,4234 +datasets/io/text.py,sha256=bebEzXBSGC40_Gy94j9ZTJ7Hg0IfrV_4pnIUEhQZVig,1975 +datasets/iterable_dataset.py,sha256=De3k3ybdHFDpewWjuZsyWE5WLyeoB6vnCenG88jQ9VI,199655 +datasets/keyhash.py,sha256=4bqtuEHHlof2BBJIydN2s6N7--wJg54DXgsgzbtbNzA,3896 +datasets/load.py,sha256=CyNX0AIVqvIsodwOkfd0UEK4hQpRNvbOp7Ygx_YP-DY,66768 +datasets/naming.py,sha256=aqQqYG4QR8YoxJJMAUyVv_oQyudm4WAApsEHvcozpNg,3001 +datasets/packaged_modules/__init__.py,sha256=mzJ6XaAZEzcCAIYNyUEBrf52xOwfs9qFljUNbJbhkw8,5212 +datasets/packaged_modules/__pycache__/__init__.cpython-310.pyc,, +datasets/packaged_modules/arrow/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +datasets/packaged_modules/arrow/__pycache__/__init__.cpython-310.pyc,, +datasets/packaged_modules/arrow/__pycache__/arrow.cpython-310.pyc,, +datasets/packaged_modules/arrow/arrow.py,sha256=lkadNXfBbJMQNDw-tK4B4Y1KJR5G-J6aAn9I9jHiLWY,3494 +datasets/packaged_modules/audiofolder/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +datasets/packaged_modules/audiofolder/__pycache__/__init__.cpython-310.pyc,, +datasets/packaged_modules/audiofolder/__pycache__/audiofolder.cpython-310.pyc,, +datasets/packaged_modules/audiofolder/audiofolder.py,sha256=SHS3Obbbr_KKBlg58yHIUmGFWUrC77JpgkEBlO-FNxc,1685 +datasets/packaged_modules/cache/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +datasets/packaged_modules/cache/__pycache__/__init__.cpython-310.pyc,, +datasets/packaged_modules/cache/__pycache__/cache.cpython-310.pyc,, +datasets/packaged_modules/cache/cache.py,sha256=sjQDBHJUeLU1U9PUK179BHfn8dHNA2RoudCWeIAv8p8,8196 +datasets/packaged_modules/csv/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +datasets/packaged_modules/csv/__pycache__/__init__.cpython-310.pyc,, +datasets/packaged_modules/csv/__pycache__/csv.cpython-310.pyc,, +datasets/packaged_modules/csv/csv.py,sha256=4LShCsr9o4YY0C-n4V37L01u2_2qithYrswSp1WMsRU,8568 +datasets/packaged_modules/folder_based_builder/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +datasets/packaged_modules/folder_based_builder/__pycache__/__init__.cpython-310.pyc,, +datasets/packaged_modules/folder_based_builder/__pycache__/folder_based_builder.cpython-310.pyc,, +datasets/packaged_modules/folder_based_builder/folder_based_builder.py,sha256=ryTimqZbh9_reC9sjR0Hl6Ww6AbJy9RrX1ijB-qPnGU,21509 +datasets/packaged_modules/generator/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +datasets/packaged_modules/generator/__pycache__/__init__.cpython-310.pyc,, +datasets/packaged_modules/generator/__pycache__/generator.cpython-310.pyc,, +datasets/packaged_modules/generator/generator.py,sha256=Oke-26QOyDRkGfmIARqSXDqOJW0sIDjboYCwWSHsbdQ,1002 +datasets/packaged_modules/imagefolder/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +datasets/packaged_modules/imagefolder/__pycache__/__init__.cpython-310.pyc,, +datasets/packaged_modules/imagefolder/__pycache__/imagefolder.cpython-310.pyc,, +datasets/packaged_modules/imagefolder/imagefolder.py,sha256=UpMVe8TUyayzHsVSfKN5wiXcc94QdamMvxauI4oFdw4,1956 +datasets/packaged_modules/json/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +datasets/packaged_modules/json/__pycache__/__init__.cpython-310.pyc,, +datasets/packaged_modules/json/__pycache__/json.cpython-310.pyc,, +datasets/packaged_modules/json/json.py,sha256=ipf8GieLlsGt5x1rJKr4ViJWg9oTHNp85OKYyPSW2R0,8698 +datasets/packaged_modules/pandas/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +datasets/packaged_modules/pandas/__pycache__/__init__.cpython-310.pyc,, +datasets/packaged_modules/pandas/__pycache__/pandas.cpython-310.pyc,, +datasets/packaged_modules/pandas/pandas.py,sha256=eR0B5iGOHZ1owzezYmlvx5U_rWblmlpCt_PdC5Ax59E,2547 +datasets/packaged_modules/parquet/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +datasets/packaged_modules/parquet/__pycache__/__init__.cpython-310.pyc,, +datasets/packaged_modules/parquet/__pycache__/parquet.cpython-310.pyc,, +datasets/packaged_modules/parquet/parquet.py,sha256=4P1SU_5Pqxp-nH2Jm_T8YDMof7YU-x6cUklFOl19wpc,5099 +datasets/packaged_modules/pdffolder/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +datasets/packaged_modules/pdffolder/__pycache__/__init__.cpython-310.pyc,, +datasets/packaged_modules/pdffolder/__pycache__/pdffolder.cpython-310.pyc,, +datasets/packaged_modules/pdffolder/pdffolder.py,sha256=bPYBh9-XOr2C-gg_Fl8h-UKhsVQ7VXjBL2FfW8abiGU,565 +datasets/packaged_modules/spark/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +datasets/packaged_modules/spark/__pycache__/__init__.cpython-310.pyc,, +datasets/packaged_modules/spark/__pycache__/spark.cpython-310.pyc,, +datasets/packaged_modules/spark/spark.py,sha256=UKu4mRB3k0EFb-Ij83eXpzr7VjCYn_TohQconF8Npag,14689 +datasets/packaged_modules/sql/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +datasets/packaged_modules/sql/__pycache__/__init__.cpython-310.pyc,, +datasets/packaged_modules/sql/__pycache__/sql.cpython-310.pyc,, +datasets/packaged_modules/sql/sql.py,sha256=0WWm-Xfputk2_QRCVrbKDbZAqZNHxOGdUwfX__4F5E0,4495 +datasets/packaged_modules/text/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +datasets/packaged_modules/text/__pycache__/__init__.cpython-310.pyc,, +datasets/packaged_modules/text/__pycache__/text.cpython-310.pyc,, +datasets/packaged_modules/text/text.py,sha256=VOJVHkmy4Vm53nspW7QboCkPxd1S0M0uEzun5v8rzUE,5516 +datasets/packaged_modules/videofolder/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +datasets/packaged_modules/videofolder/__pycache__/__init__.cpython-310.pyc,, +datasets/packaged_modules/videofolder/__pycache__/videofolder.cpython-310.pyc,, +datasets/packaged_modules/videofolder/videofolder.py,sha256=HLTMldDZ3WfK8OAbI2wssBuNCP6ucRBpNLpCoJVDL10,807 +datasets/packaged_modules/webdataset/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +datasets/packaged_modules/webdataset/__pycache__/__init__.cpython-310.pyc,, +datasets/packaged_modules/webdataset/__pycache__/_tenbin.cpython-310.pyc,, +datasets/packaged_modules/webdataset/__pycache__/webdataset.cpython-310.pyc,, +datasets/packaged_modules/webdataset/_tenbin.py,sha256=oovYsgR2R3eXSn1xSCLG3oTly1szKDP4UOiRp4ORdIk,8533 +datasets/packaged_modules/webdataset/webdataset.py,sha256=nqZQeeYiFM2nc7zEGrUmBcn7I8xBiXJLby2dG9hSOKo,10599 +datasets/packaged_modules/xml/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +datasets/packaged_modules/xml/__pycache__/__init__.cpython-310.pyc,, +datasets/packaged_modules/xml/__pycache__/xml.cpython-310.pyc,, +datasets/packaged_modules/xml/xml.py,sha256=av0HcLQnKl5d1yM0jfBqVhw9EbzqmO_RsHDfa5pkvx4,2822 +datasets/parallel/__init__.py,sha256=wiRFK4x67ez2vvmjwM2Sb9R1yFdf38laSarU9y0Bido,76 +datasets/parallel/__pycache__/__init__.cpython-310.pyc,, +datasets/parallel/__pycache__/parallel.cpython-310.pyc,, +datasets/parallel/parallel.py,sha256=E-oOQ6zwKrkLFPwZ-3EOcr_aANJDhE-d6QTq7Mp7WvA,4738 +datasets/search.py,sha256=PxveDc1hy2Yux7Gtvat1_Qe_0D6aIKQBWI5KbV0gS6I,35592 +datasets/splits.py,sha256=zZO9vPnbfzfxXQG8LSAQkajXV7TGB2kEwOWrQxPFQbI,23430 +datasets/streaming.py,sha256=7MIamZ2NmReUmJ_2pxgdSopIf7Oh5nFFAbb7WHLuW7E,5772 +datasets/table.py,sha256=8EpNo6Q6HMp2kkKITHUobwaZIJTfXZ4o4e47fzHXij0,93972 +datasets/utils/__init__.py,sha256=PuZtB9YTbRyvdwubnsx-JGdHuMA7p0I0Rmh0E_uxYF0,999 +datasets/utils/__pycache__/__init__.cpython-310.pyc,, +datasets/utils/__pycache__/_dataset_viewer.cpython-310.pyc,, +datasets/utils/__pycache__/_dill.cpython-310.pyc,, +datasets/utils/__pycache__/_filelock.cpython-310.pyc,, +datasets/utils/__pycache__/deprecation_utils.cpython-310.pyc,, +datasets/utils/__pycache__/doc_utils.cpython-310.pyc,, +datasets/utils/__pycache__/experimental.cpython-310.pyc,, +datasets/utils/__pycache__/extract.cpython-310.pyc,, +datasets/utils/__pycache__/file_utils.cpython-310.pyc,, +datasets/utils/__pycache__/filelock.cpython-310.pyc,, +datasets/utils/__pycache__/hub.cpython-310.pyc,, +datasets/utils/__pycache__/info_utils.cpython-310.pyc,, +datasets/utils/__pycache__/logging.cpython-310.pyc,, +datasets/utils/__pycache__/metadata.cpython-310.pyc,, +datasets/utils/__pycache__/patching.cpython-310.pyc,, +datasets/utils/__pycache__/py_utils.cpython-310.pyc,, +datasets/utils/__pycache__/sharding.cpython-310.pyc,, +datasets/utils/__pycache__/stratify.cpython-310.pyc,, +datasets/utils/__pycache__/tf_utils.cpython-310.pyc,, +datasets/utils/__pycache__/tqdm.cpython-310.pyc,, +datasets/utils/__pycache__/track.cpython-310.pyc,, +datasets/utils/__pycache__/typing.cpython-310.pyc,, +datasets/utils/__pycache__/version.cpython-310.pyc,, +datasets/utils/_dataset_viewer.py,sha256=SrE1N18S5yCoCx0rAhwaHNDVS9uhxjspA84iNT4TFRw,4397 +datasets/utils/_dill.py,sha256=g-KfsEBJltB2kOieJ35lF94iAFX4IYFWPvLQeL16gr8,17491 +datasets/utils/_filelock.py,sha256=iXW3bxsIr5JWNemhKtF_-q_0ysajkUTItzMm8LY9LBY,2355 +datasets/utils/deprecation_utils.py,sha256=hTHwlzRs92NfNVudH71LMpW70sjbsP5amebrIgi3A-U,3452 +datasets/utils/doc_utils.py,sha256=HoSm0TFaQaCYGfDgNhpBJ4Xc2WQZuOD6dTxLd9D87fs,407 +datasets/utils/experimental.py,sha256=JgOjaEY3RWZ--3u0-ry82gLCDUpudfBfl-hWZ46SyS4,1097 +datasets/utils/extract.py,sha256=kKMAujtg5FOK91MBXyWl6FFHZStEPn8WkOE7Jmo2Iq4,13021 +datasets/utils/file_utils.py,sha256=jA7m0-OKo0hABlhjDsYwWXqT5wo2RV4srs28zJNaCKk,53453 +datasets/utils/filelock.py,sha256=H6C5dQGFCzVKyeDRRY8fZ4YGTEvvNd-MTjpL_sWYb5k,352 +datasets/utils/hub.py,sha256=sD9VpJENA3M9_rWFGavUaVV_GsrOBLEKCZjcqtRdJ_s,438 +datasets/utils/info_utils.py,sha256=gAzubjnQbE0YTzB3hf3Cipmx5wCBtOje3fPwjYdzVBE,4330 +datasets/utils/logging.py,sha256=4mB8XLlFSHcDuGxkEss91sl0pfX3rIYjUiRa-6HX3Io,5383 +datasets/utils/metadata.py,sha256=Hrmn8xUoEzwpJKG3Y6tfJt5t7nW1OCxNjfLTlEaxsrI,9367 +datasets/utils/patching.py,sha256=iTeb7XG4faLJKNylq55EcZyCndUXU_XBDvOOkuDz_sc,4955 +datasets/utils/py_utils.py,sha256=v-nq7bKydxCDPiDiaRq1ssEF3pkRTpQn4NV4BxmO-2s,23375 +datasets/utils/resources/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +datasets/utils/resources/__pycache__/__init__.cpython-310.pyc,, +datasets/utils/resources/creators.json,sha256=XtIpMZefgBOdTevRrQTkFiufbgCbp_iyxseyphYQkn0,257 +datasets/utils/resources/languages.json,sha256=Z0rQNPsfje8zMi8KdvvwxF4APwwqcskJFUvhNiLAgPM,199138 +datasets/utils/resources/multilingualities.json,sha256=02Uc8RtRzfl13l98Y_alZm5HuMYwPzL78B0S5a1X-8c,205 +datasets/utils/resources/readme_structure.yaml,sha256=hNf9msoBZw5jfakQrDb0Af8T325TXdcaHsAO2MUcZvY,3877 +datasets/utils/resources/size_categories.json,sha256=_5nAP7z8R6t7_GfER81QudFO6Y1tqYu4AWrr4Aot8S8,171 +datasets/utils/sharding.py,sha256=VBQ4bRJQijMNDQTgFb1_ddlQ28wAcA0aQp4e-1jFIAk,4215 +datasets/utils/stratify.py,sha256=-MVaLmijYhGyKDpnZS9A8SiHekaIyVm84HVyIIQOmfg,4085 +datasets/utils/tf_utils.py,sha256=T3OysLGbkO7y-J-o9OVGyn9l-l-A3ruj-24JM_UULm8,24448 +datasets/utils/tqdm.py,sha256=44F0g2fBpJwShh1l88PP7Z8kBihFWA_Yee4sjiQSxes,4303 +datasets/utils/track.py,sha256=M81CGLn3MyJzHm98CQkbF3_1DG7evQsw-V52_Bp2paI,1838 +datasets/utils/typing.py,sha256=G11ytWmwjqVia2IdziRDIWvQ4mLJee-sKzgJfHqU16E,205 +datasets/utils/version.py,sha256=Z82cHpjTbQVJyWgnwSU8DsW2G0y-sSbSoOVeQrAds9k,3281 diff --git a/venv/lib/python3.10/site-packages/datasets-4.0.0.dist-info/WHEEL b/venv/lib/python3.10/site-packages/datasets-4.0.0.dist-info/WHEEL new file mode 100644 index 0000000000000000000000000000000000000000..505164bc02d63fe6b0b3299f849a77c5f1beeb41 --- /dev/null +++ b/venv/lib/python3.10/site-packages/datasets-4.0.0.dist-info/WHEEL @@ -0,0 +1,5 @@ +Wheel-Version: 1.0 +Generator: setuptools (75.8.0) +Root-Is-Purelib: true +Tag: py3-none-any + diff --git a/venv/lib/python3.10/site-packages/datasets-4.0.0.dist-info/entry_points.txt b/venv/lib/python3.10/site-packages/datasets-4.0.0.dist-info/entry_points.txt new file mode 100644 index 0000000000000000000000000000000000000000..a93c17922e3b5496fe8e1a43f3defa58727f5220 --- /dev/null +++ b/venv/lib/python3.10/site-packages/datasets-4.0.0.dist-info/entry_points.txt @@ -0,0 +1,2 @@ +[console_scripts] +datasets-cli = datasets.commands.datasets_cli:main diff --git a/venv/lib/python3.10/site-packages/datasets-4.0.0.dist-info/top_level.txt b/venv/lib/python3.10/site-packages/datasets-4.0.0.dist-info/top_level.txt new file mode 100644 index 0000000000000000000000000000000000000000..aee11b288aa3e6803c53bde002f7594c44497f5b --- /dev/null +++ b/venv/lib/python3.10/site-packages/datasets-4.0.0.dist-info/top_level.txt @@ -0,0 +1 @@ +datasets diff --git a/venv/lib/python3.10/site-packages/depyf/VERSION.txt b/venv/lib/python3.10/site-packages/depyf/VERSION.txt new file mode 100644 index 0000000000000000000000000000000000000000..47d04a528837ea50434734bd7cca947d47c4e012 --- /dev/null +++ b/venv/lib/python3.10/site-packages/depyf/VERSION.txt @@ -0,0 +1 @@ +0.18.0 \ No newline at end of file diff --git a/venv/lib/python3.10/site-packages/depyf/__init__.py b/venv/lib/python3.10/site-packages/depyf/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e06eda61bfccfdcd99446384589d52c848fb0702 --- /dev/null +++ b/venv/lib/python3.10/site-packages/depyf/__init__.py @@ -0,0 +1,24 @@ +from types import CodeType +import warnings + +from .decompiler import Decompiler, decompile + +try: + import torch + torch_version = torch.__version__ + valid = ("dev" not in torch_version and torch_version >= "2.2") or ( + "dev" in torch_version and torch_version.split("dev")[-1] >= "20231020") + if not valid: + warnings.warn( + ("Please use the nightly version of PyTorch to enable bytecode hooks.\n" + "PyTorch nightly can be installed by: `conda install pytorch-nightly::pytorch torchvision torchaudio -c pytorch-nightly`")) + + from depyf.explain.enhance_logging import install, uninstall + from depyf.explain.enable_debugging import prepare_debug, debug +except ImportError as e: + # print(e) + pass + +import os + +__version__ = open(f"{os.path.dirname(__file__)}/VERSION.txt").read().strip() diff --git a/venv/lib/python3.10/site-packages/depyf/__pycache__/code_transform.cpython-310.pyc b/venv/lib/python3.10/site-packages/depyf/__pycache__/code_transform.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..971acdaed894347c224c79c56cf75059681f98bc Binary files /dev/null and b/venv/lib/python3.10/site-packages/depyf/__pycache__/code_transform.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/depyf/code_transform.py b/venv/lib/python3.10/site-packages/depyf/code_transform.py new file mode 100644 index 0000000000000000000000000000000000000000..20985aec798686b54b0e7ab281e69a87da2273d8 --- /dev/null +++ b/venv/lib/python3.10/site-packages/depyf/code_transform.py @@ -0,0 +1,475 @@ +import dis +from typing import List, Tuple, Union, Optional, Callable, Any, Dict, Set +from types import CodeType +import ast +import astor +from collections import defaultdict +import dataclasses +import sys +import hashlib + +py311 = sys.version_info >= (3, 11) +all_jump_opcode_set = set(dis.hasjabs) | set(dis.hasjrel) + + +@dataclasses.dataclass +class Instruction: + """A mutable version of dis.Instruction""" + + opcode: int + opname: str + arg: Optional[int] + argval: Any + argrepr: str + offset: Optional[int] = None + starts_line: Optional[int] = None + is_jump_target: bool = False + + def __hash__(self): + return id(self) + + def __eq__(self, other): + return id(self) == id(other) + + def short_inst_repr(self): + return f"Instruction(opname={self.opname}, offset={self.offset})" + + def is_jump(self): + return self.opcode in all_jump_opcode_set + + def get_jump_target(self: "Instruction"): + if self.is_jump() and "to " in self.argrepr: + return int(self.argrepr.replace("to ", "").strip()) + # seems like a bug, "FOR_ITER" is in `dis.hasjrel`, but its `argval` is + # an absolute offset + if self.opcode in dis.hasjabs: + return self.argval + elif self.opcode in dis.hasjrel: + return self.offset + self.argval if not py311 else self.argval + else: + raise ValueError( + f"Instruction {self.opname} does not have jump target") + + +def convert_instruction(i: dis.Instruction) -> Instruction: + return Instruction( + i.opcode, + i.opname, + i.arg, + i.argval, + i.argrepr, + i.offset, + i.starts_line, + i.is_jump_target, + ) + + +def nop_instruction(inst: Instruction): + """Inplace modify an instruction as nop.""" + inst.opname = "NOP" + inst.opcode = dis.opmap["NOP"] + inst.arg = 0 + inst.argval = 0 + inst.argrepr = "" + inst.offset + inst.starts_line + inst.is_jump_target = False + return inst + + +def propagate_line_nums(instructions: List[Instruction]): + """Ensure every instruction has line number set in case some are removed""" + cur_line_no = None + + def populate_line_num(inst): + nonlocal cur_line_no + if inst.starts_line: + cur_line_no = inst.starts_line + + inst.starts_line = cur_line_no + + for inst in instructions: + populate_line_num(inst) + + +# ======= begin code borrowed from pytorch/torch/_dynamo/bytecode_transformation.py =========== +@dataclasses.dataclass +class ExceptionTableEntry: + start: int + end: int + target: int + depth: int + lasti: bool + +def decode_exception_table_varint(bytes_iter) -> int: + """ + Inverse of `encode_exception_table_varint`. + """ + b = next(bytes_iter) + val = b & 63 + while b & 64: + val <<= 6 + b = next(bytes_iter) + val |= b & 63 + return val + +def check_exception_table(tab: List[ExceptionTableEntry]) -> None: + """ + Verifies that a list of ExceptionTableEntries will make a well-formed + jump table: entries are non-empty, sorted, and do not overlap. + """ + for i in range(len(tab) - 1): + assert ( + tab[i].start <= tab[i].end + and tab[i].end < tab[i + 1].start + and tab[i + 1].start <= tab[i + 1].end + ) + +def parse_exception_table(exntab) -> List[ExceptionTableEntry]: + """ + Parse the exception table according to + https://github.com/python/cpython/blob/3.11/Objects/exception_handling_notes.txt + """ + exntab_iter = iter(exntab) + tab = [] + try: + while True: + start = decode_exception_table_varint(exntab_iter) * 2 + length = decode_exception_table_varint(exntab_iter) * 2 + end = start + length - 2 + target = decode_exception_table_varint(exntab_iter) * 2 + dl = decode_exception_table_varint(exntab_iter) + depth = dl >> 1 + lasti = bool(dl & 1) + tab.append(ExceptionTableEntry(start, end, target, depth, lasti)) + except StopIteration: + check_exception_table(tab) + return tab +# ======= end code borrowed from pytorch/torch/_dynamo/bytecode_transformation.py =========== + +def simplify_finally_statement(instructions: List[Instruction]): + """Simplify finally statement. + 3.10 finally statement: + SETUP_FINALLY + body + POP_BLOCK + finally code + Exception code + RERAISE + """ + for i, inst in enumerate(instructions): + if inst.opname == "SETUP_FINALLY": + finally_target = inst.get_jump_target() + reraise_idx = [j for j, _inst in enumerate( + instructions) if _inst.offset >= finally_target and _inst.opname == "RERAISE"] + if reraise_idx: + reraise_index = reraise_idx[0] + for j, _inst in enumerate(instructions): + if _inst.offset >= finally_target and j <= reraise_index: + nop_instruction(_inst) + + +def nop_unreachable_bytecode(code, + instructions: List[dis.Instruction]) -> List[dis.Instruction]: + """Mark unreachable bytecode as NOP.""" + jumps = set(dis.hasjabs) | set(dis.hasjrel) + + exception_targets = {} + if py311: + tab = parse_exception_table(code.co_exceptiontable) + exception_targets = {entry.target: entry for entry in tab} + + # difference bwteween `i in deadcode_positions` and `reachable[i] == False`: + # `i in deadcode_positions` means that the instruction is not reachable, defnitely a NOP + # `reachable[i] == False` means that the instruction is not reachable currently, but it might be reachable later when we iterate through the instructions + reachable = [False for x in instructions] + deadcode_positions = set() + reachable[0] = True + # each instruction marks the instruction after it + for i, inst in enumerate(instructions): + if inst.is_jump_target or inst.offset in exception_targets: + # the instruction is the target of a jump + reachable[i] = True + # the last instruction does not need to mark any following instructions + if i == len(instructions) - 1: + break + # this instruction is not reachable, nothing to do + if not reachable[i]: + continue + # this instruction is reachable + # the following instruction is reachable if it is sequential op or + # conditional jump + if inst.opname in ["RETURN_VALUE", "BREAK_LOOP"]: + # the instruction after the return is unreachable + pass + elif inst.opcode in jumps: + if inst.opcode in dis.hasjrel and inst.get_jump_target() == inst.offset: + # this is a jump to itself, it is regarded as a NOP, per the documentation at + # https://devguide.python.org/internals/interpreter/#jumps + reachable[i] = False + reachable[i + 1] = True + continue + if "IF" in inst.opname or "FOR_ITER" in inst.opname or "SETUP_LOOP" in inst.opname: + # the fallback block is always reachable for conditional jumps + reachable[i + 1] = True + elif inst.opname in ["SETUP_FINALLY", "SETUP_WITH", "BEFORE_WITH"]: + # the with/finally block is always reachable + reachable[i + 1] = True + else: + # this is a direct jump, the target is reachable + # we further check if any outside instructions jump into in-between instructions + # if not, we can mark this instruction as unreachable, too + # later, in-between instructions will be marked as unreachable (NOP) + # and the interpreter will slide through all the NOP directly + # to the target + jump_forwards = [j for j, instruct in enumerate( + instructions) if instruct.offset >= inst.get_jump_target()] + if len(jump_forwards): + j = jump_forwards[0] + if j > i: + smallest_jump_in = j + has_jump_in = False + + for ii, inst_ii in enumerate(instructions[i: j]): + # in python 3.11 exception table + # exception target indicates a jump target from many instructions + # and therefore it is treated as a jump-in + if inst_ii.offset in exception_targets: + has_jump_in = True + smallest_jump_in = min( + smallest_jump_in, ii) + + for ii, inst_ii in enumerate(instructions): + try: + jump_location = inst_ii.get_jump_target() + if (ii < i or ii > j) and (jump_location >= inst.offset and jump_location < instructions[j].offset): + has_jump_in = True + smallest_jump_in = min( + smallest_jump_in, ii) + except Exception: + pass + if not has_jump_in: + reachable[i] = False + for _ in range(i, smallest_jump_in): + deadcode_positions.add(_) + else: + reachable[i + 1] = True + + for i in deadcode_positions: + reachable[i] = False + + # mark unreachable instructions as NOP + for inst, flag in zip(instructions, reachable): + if not flag: + nop_instruction(inst) + + +def add_indentation(code: str, indentation: int = 4) -> str: + """Add indentation to code.""" + return "".join( + " " * + indentation + + line + + "\n" for line in code.splitlines()) + + +def remove_indentation(code: str, indentation: int = 4) -> str: + """Remove indentation from code.""" + return "".join(line[indentation:] + "\n" for line in code.splitlines()) + + +class RemoveAssignmentTransformer(ast.NodeTransformer): + def __init__(self, + temp_name: str, + temp_occurrences: Dict[str, + List[ast.Name]]): + # optimize one temp_name at a time + self.temp_name = temp_name + self.temp_occurrences = temp_occurrences + + def visit_Assign(self, node): + # single assimngment like `temp = xxx` + if len(node.targets) == 1 and isinstance(node.targets[0], ast.Name): + name = node.targets[0].id + # the assignment is like `temp = xxx` + if name == self.temp_name: + if len(self.temp_occurrences[name]) == 1: + return ast.Expr(value=node.value) + elif len(self.temp_occurrences[name]) == 3 and isinstance(self.temp_occurrences[name][-1], bool): + # we save the `xxx` here + self.temp_occurrences[name].append(node.value) + if self.temp_occurrences[name][-2]: + return None + return node + + +class RemoveAssignment2Transformer(ast.NodeTransformer): + def __init__(self, + temp_name: str, + temp_occurrences: Dict[str, + List[ast.Name]]): + # optimize one temp_name at a time + self.temp_name = temp_name + self.temp_occurrences = temp_occurrences + + def visit_Name(self, node): + name = node.id + if name == self.temp_name and len(self.temp_occurrences[name]) == 4 and isinstance( + self.temp_occurrences[name][-2], bool): + if self.temp_occurrences[name][-2]: + return self.temp_occurrences[name][-1] + return node + + +def get_parents(node): + """Collect all parent nodes of a given node.""" + parents = [] + while node: + parents.append(node) + node = getattr(node, "parent", None) + return parents + + +def set_parents(node, parent=None): + """Recursively set the parent attribute for each node.""" + for child in ast.iter_child_nodes(node): + child.parent = parent + set_parents(child, child) + + +def lowest_common_parent(node1, node2): + """Get the lowest common parent for two nodes.""" + parents1 = get_parents(node1) + parents2 = get_parents(node2) + + # Reverse the parents list to start comparing from the root. + parents1.reverse() + parents2.reverse() + + last_common = None + for p1, p2 in zip(parents1, parents2): + if p1 is p2: + last_common = p1 + else: + break + return last_common, p1, p2 + + +def remove_some_temp( + source_code: str, + temp_prefix: str, + indentation: int = 4) -> str: + tree = ast.parse(source_code) + set_parents(tree) + + temp_occurrences = defaultdict(list) + for node in ast.walk(tree): + if isinstance(node, ast.Name) and node.id.startswith(temp_prefix): + temp_occurrences[node.id].append(node) + + for key in temp_occurrences: + if len(temp_occurrences[key]) == 2: + node1 = temp_occurrences[key][0] + node2 = temp_occurrences[key][1] + parent, parent1, parent2 = lowest_common_parent(node1, node2) + assignment_node = node1 if isinstance( + node1.parent, ast.Assign) else node2 + assignment_parent = parent1 if isinstance( + node1.parent, ast.Assign) else parent2 + indentation_nodes = ( + ast.FunctionDef, + ast.AsyncFunctionDef, + ast.For, + ast.AsyncFor, + ast.While, + ast.If, + ast.Try, + ast.With, + ast.AsyncWith, + ast.ClassDef) + # we cannot remove the assignment if the assignment `temp=xxx` is + # in an indentation block while the usage of `temp` is not + can_merge = not isinstance(assignment_parent, indentation_nodes) + temp_occurrences[key].append(can_merge) + tree = RemoveAssignmentTransformer(key, temp_occurrences).visit(tree) + tree = RemoveAssignment2Transformer(key, temp_occurrences).visit(tree) + + reconstructed_code = astor.to_source(tree, indent_with=" " * indentation) + return reconstructed_code + + +class IdentifierReplacer(ast.NodeTransformer): + + # def visit_Name(self, node): + # return ast.copy_location(ast.Name(id='PLACEHOLDER', ctx=node.ctx), node) + + def visit_FunctionDef(self, node): + node.name = 'PLACEHOLDER' + return self.generic_visit(node) + + # def visit_AsyncFunctionDef(self, node): + # node.name = 'PLACEHOLDER' + # return self.generic_visit(node) + + # def visit_ClassDef(self, node): + # node.name = 'PLACEHOLDER' + # return self.generic_visit(node) + + # def visit_Attribute(self, node): + # node.attr = 'PLACEHOLDER' + # return self.generic_visit(node) + + +def fix_irregular_code( + old_bytecode: CodeType, + src_code: str, + add_local_variables: Optional[List[str]]=None, + add_cellvars: Optional[List[str]]=None, + ) -> str: + function_name = src_code.split("(")[0].split()[-1] + new_code = src_code + if add_local_variables is not None or add_cellvars is not None: + lines = src_code.splitlines() + header = lines[0] + body = lines[1:] + headers = [header] + if add_local_variables: + added_line = "; ".join(f"{x} = None" for x in add_local_variables) + added_line = " " + added_line + " # this line helps Python to generate bytecode with at least the same number of local variables as the original function\n" + headers.append(added_line) + if add_cellvars: + added_line = "return " + ", ".join(x for x in add_cellvars) + added_line = ( + " def __helper_for_cellvars():\n" + " # this function helps Python to generate bytecode with at least the same number of cellvars as the original function\n" + ) + " " + added_line + headers.append(added_line) + new_code = "".join([x + "\n" for x in headers + body]) + + freevars = old_bytecode.co_freevars + if freevars: + tmp_code = ( + "def __helper_outer_function():\n" + " # this is a helper function to help compilers generate bytecode to read capture variables from closures, rather than reading values from global scope. The value of these variables does not matter, and will be determined in runtime.\n" + ) + for freevar in freevars: + tmp_code += f" {freevar} = None\n" + tmp_code += add_indentation(new_code, 4) + new_code = tmp_code + + # make sure the new bytecode has at least the same number of local variables as the original bytecode + # this seems to fix the test failure in https://github.com/thuml/depyf/actions/runs/7004325219/job/19051829613 , and might be related with the discussion in https://github.com/pytorch/pytorch/pull/111883 + compiled_code = compile(new_code, "noname", "exec") + from .utils import collect_all_code_objects + code_objects = collect_all_code_objects(compiled_code) + target_code = [x for x in code_objects if x.co_name == function_name][0] + + missing_local_variables = set(old_bytecode.co_varnames) - set(target_code.co_varnames) + missing_cellvars = set(old_bytecode.co_cellvars) - set(target_code.co_cellvars) + + if missing_local_variables or missing_cellvars: + return fix_irregular_code( + old_bytecode, src_code, + add_local_variables=sorted(list(missing_local_variables)), + add_cellvars=sorted(list(missing_cellvars))) + return new_code diff --git a/venv/lib/python3.10/site-packages/depyf/decompiler.py b/venv/lib/python3.10/site-packages/depyf/decompiler.py new file mode 100644 index 0000000000000000000000000000000000000000..6caf20b0c7bab0e109a5fc17c5c0bde11c7b7ff4 --- /dev/null +++ b/venv/lib/python3.10/site-packages/depyf/decompiler.py @@ -0,0 +1,1312 @@ +"""A simple program to transform bytecode into more readable source code.""" + +import sys +import os +import dis +from types import CodeType +from typing import List, Tuple, Dict, Union, Callable, Optional +import dataclasses +import inspect +import functools +from collections import defaultdict +import contextlib + +from .code_transform import ( + nop_unreachable_bytecode, + nop_instruction, + add_indentation, + remove_indentation, + remove_some_temp, + propagate_line_nums, + convert_instruction, + simplify_finally_statement, + Instruction, +) +from .utils import ( + get_function_signature, +) + + +class DecompilationError(Exception): + """Custom exception class for decompilation.""" + + def __init__(self, message=""): + self.message = message + super().__init__(self.message) + + def __str__(self): + return f'DecompilationError: {self.message}' + + +@dataclasses.dataclass +class DecompilerState: + """State of decompiler, keep track of the evaluation stack, as well as the decompiled source code.""" + source_code: str + stack: list + inside_loop: bool = False + loop_start_index: int = -1 # inclusive + loop_end_index: int = -1 # exclusive + + +@dataclasses.dataclass +class Decompiler: + """A decompiler for a code object.""" + code: CodeType + temp_count: int = 0 + temp_prefix: str = "__temp_" + state: DecompilerState = dataclasses.field( + default_factory=lambda: DecompilerState( + source_code="", stack=[])) + indentation: int = 4 + + @contextlib.contextmanager + def new_state(self, stack, inside_loop=False, loop_start_index=-1, loop_end_index=-1): + """Create a new state for decompiler.""" + state = DecompilerState(source_code="", stack=stack, inside_loop=inside_loop, loop_start_index=loop_start_index, loop_end_index=loop_end_index) + old_state = self.state + if old_state.inside_loop and not state.inside_loop: + # inherit the loop state from the old state + state.inside_loop = old_state.inside_loop + state.loop_start_index = old_state.loop_start_index + state.loop_end_index = old_state.loop_end_index + self.state = state + yield + self.state = old_state + + +# ==================== Unsupported Instructions ============================= + def unimplemented_instruction(self, inst: Instruction): + raise NotImplementedError(f"Unsupported instruction: {inst.opname}") + + GET_YIELD_FROM_ITER = unimplemented_instruction + + # we don't support try-except/try-finally + POP_EXCEPT = WITH_EXCEPT_START = JUMP_IF_NOT_EXC_MATCH = CHECK_EG_MATCH = PUSH_EXC_INFO = PREP_RERAISE_STAR = WITH_CLEANUP_FINISH = CALL_FINALLY = POP_FINALLY = WITH_CLEANUP_START = SETUP_EXCEPT = CHECK_EXC_MATCH = CLEANUP_THROW = unimplemented_instruction + + # we don't support async/await + GET_AWAITABLE = GET_AITER = GET_ANEXT = END_ASYNC_FOR = BEFORE_ASYNC_WITH = SETUP_ASYNC_WITH = SEND = ASYNC_GEN_WRAP = unimplemented_instruction + + CACHE = unimplemented_instruction + + # we don't know these instructions + PRINT_EXPR = COPY_DICT_WITHOUT_KEYS = unimplemented_instruction + + # we only support bytecode for functions + IMPORT_STAR = unimplemented_instruction + + YIELD_FROM = SETUP_ANNOTATIONS = LOAD_BUILD_CLASS = MATCH_MAPPING = MATCH_SEQUENCE = MATCH_KEYS = MATCH_CLASS = unimplemented_instruction + + # don't find any interesting use case for these instructions + CALL_INTRINSIC_2 = unimplemented_instruction + + +# ==================== NOP Instructions ============================= + + def generic_nop(self, inst: Instruction): + pass + + # "EXTENDED_ARG" is treated as NOP here, because it has been handled by `dis.get_instructions`. + # The extended args are already merged into the following instruction's + # `inst.argval`. + EXTENDED_ARG = generic_nop + + NOP = RESUME = SETUP_LOOP = POP_BLOCK = PRECALL = BEGIN_FINALLY = END_FINALLY = generic_nop + + MAKE_CELL = generic_nop + + RERAISE = generic_nop + + # our FOR_ITER is different from CPython's FOR_ITER (as it does not need + # to explicitly consider the case of exhausted iterator), so we don't need + # to do anything here + END_FOR = generic_nop + + +# ==================== Load Instructions ============================= + + def LOAD_CONST(self, inst: Instruction): + """Push a constant onto the stack. + `inst.argval` is the constant value, we have to use `repr` to get the source code + """ + can_repr = False + try: + can_repr = eval(repr(inst.argval)) == inst.argval + except BaseException: + pass + if can_repr: + self.state.stack.append(repr(inst.argval)) + else: + if isinstance(inst.argval, type): + # Don't know why a class type get here, support this corner + # case anyway. + module = inst.argval.__module__ + name = inst.argval.__name__ + self.state.source_code += "import importlib\n" + temp_name = self.get_temp_name() + self.state.source_code += f'{temp_name} = importlib.import_module("{module}").{name}\n' + self.state.stack.append(temp_name) + elif inst.argrepr.startswith("torch."): + # Don't know why torch.xxx get here, support this corner case + # anyway. This deals with something like `torch.float`. + self.state.source_code += "import torch\n" + temp_name = self.get_temp_name() + self.state.source_code += f'{temp_name} = {inst.argval}\n' + self.state.stack.append(temp_name) + elif isinstance(inst.argval, CodeType): + # used in MAKE_FUNCTION + self.state.stack.append(inst.argval) + else: + self.state.stack.append(f"'__co_consts[{inst.arg}]'") + + def generic_load(self, inst: Instruction): + """`inst.argval` is the variable name, in string""" + if "NULL + " in inst.argrepr: + # Python 3.11 support + self.state.stack.append(None) + if inst.argrepr.startswith("."): + # list/set/tuple comprehension. + self.state.stack.append(inst.argval.replace(".", "comp_arg_")) + else: + self.state.stack.append(inst.argval) + + LOAD_FAST = LOAD_FAST_AND_CLEAR = LOAD_FAST_CHECK = LOAD_GLOBAL = LOAD_DEREF = LOAD_NAME = LOAD_CLASSDEREF = LOAD_CLOSURE = generic_load + + def LOAD_LOCALS(self, inst: Instruction): + self.state.stack.append("locals()") + self.replace_mutable_tos_with_temp() + + def LOAD_FROM_DICT_OR_GLOBALS(self, inst: Instruction): + tos = self.state.stack.pop() + self.state.stack.append( + f"{tos}[{inst.argval}] if '{inst.argval}' in {tos} else {inst.argval}") + self.replace_mutable_tos_with_temp() + + LOAD_FROM_DICT_OR_DEREF = LOAD_FROM_DICT_OR_GLOBALS + + def MAKE_FUNCTION(self, inst: Instruction): + if sys.version_info < (3, 11): + qual_name = self.state.stack.pop() + try: + qual_name = eval(qual_name) + except Exception: + pass + # qual_name for inner function is something like `LongformerEncoder.forward..create_custom_forward` + # get the last part of the name, which is the function name + func_name = qual_name.split(".")[-1] + if "<" in func_name: + self.state.source_code += f'"original function name {func_name} is illegal, use a temp name."\n' + func_name = self.get_temp_name() + else: + # Python 3.11 support, see + # https://docs.python.org/3.11/library/dis.html#opcode-MAKE_FUNCTION + func_name = self.get_temp_name() + code = self.state.stack.pop() + if inst.argval & 0x08: + # has closure + self.state.stack.pop() + if inst.argval & 0x04: + # has annotations + self.state.stack.pop() + kw_defaults = self.state.stack.pop() if inst.argval & 0x02 else {} + defaults = self.state.stack.pop() if inst.argval & 0x01 else () + if len(kw_defaults) or len(defaults): + print( + "Function with default arguments is not supported, ignore the default arguments") + this_index = self.index_of(inst.offset) + immediately_used = False + if self.instructions[this_index + 1].opname == "STORE_FAST": + # the function is immediately stored in a variable, use that + # variable name + func_name = self.instructions[this_index + 1].argval + immediately_used = True + inner_func = Decompiler(code).decompile(overwite_fn_name=func_name) + self.state.source_code += inner_func + if not immediately_used: + self.state.stack.append(func_name) + else: + # skip one instruction + return this_index + 2 + + def COPY_FREE_VARS(self, inst: Instruction): + # this opcode is used to copy free variables from the outer scope to the closure + # it affects the frame, but not the stack or the source code + pass + + def LOAD_ATTR(self, inst: Instruction): + lhs = str(self.state.stack.pop()) + rhs = inst.argval + if rhs.isidentifier(): + self.state.stack.append(f"{lhs}.{rhs}") + else: + self.state.stack.append(f"getattr({lhs}, {repr(rhs)})") + + def LOAD_SUPER_ATTR(self, inst: Instruction): + # not tested + self_obj = self.state.stack.pop() + cls_obj = self.state.stack.pop() + super_obj = self.state.stack.pop() + self.state.stack.append( + f"{super_obj}({cls_obj}, {self_obj}).{inst.argval}") + self.replace_mutable_tos_with_temp() + + def LOAD_METHOD(self, inst: Instruction): + self.state.stack.append(f"{self.state.stack.pop()}.{inst.argval}") + + def LOAD_ASSERTION_ERROR(self, inst: Instruction): + self.state.stack.append("AssertionError") + + def PUSH_NULL(self, inst: Instruction): + # the `None` object is used to represent `NULL` in python bytecode + self.state.stack.append(None) + + def GET_ITER(self, inst: Instruction): + tos = self.state.stack.pop() + self.state.stack.append(f"iter({tos})") + +# ==================== Store Instructions ============================= + + def generic_store(self, inst: Instruction): + left = inst.argval + right = self.state.stack.pop() + if left != right: + # Inplace operations like `+=` will pop the variable name from the stack, and push the result back to the stack + # leading to a source code like `x = x`. We need to avoid this. + self.state.source_code += f"{left} = {right}\n" + + STORE_FAST = STORE_GLOBAL = STORE_DEREF = STORE_NAME = generic_store + + def STORE_SUBSCR(self, inst: Instruction): + index = self.state.stack.pop() + x = self.state.stack.pop() + value = self.state.stack.pop() + self.state.source_code += f"{x}[{index}] = {value}\n" + + def STORE_SLICE(self, inst: Instruction): + # not tested, code according to + # https://docs.python.org/3.12/library/dis.html#opcode-STORE_SLICE + end = self.state.stack.pop() + start = self.state.stack.pop() + container = self.state.stack.pop() + value = self.state.stack.pop() + self.state.source_code += f"{container}[{start}:{end}] = {value}\n" + + def STORE_ATTR(self, inst: Instruction): + x = self.state.stack.pop() + value = self.state.stack.pop() + self.state.source_code += f"{x}.{inst.argval} = {value}\n" + +# ==================== Del Instructions ============================= + + def DELETE_SUBSCR(self, inst: Instruction): + index = self.state.stack.pop() + x = self.state.stack.pop() + self.state.source_code += f"del {x}[{index}]\n" + + def generic_delete(self, inst: Instruction): + self.state.source_code += f"del {inst.argval}\n" + + DELETE_NAME = DELETE_GLOBAL = DELETE_DEREF = generic_delete + # `DELETE_FAST` just reduces the ref count by one + # it does not occur as code `del x` in the source code + DELETE_FAST = generic_nop + + def DELETE_ATTR(self, inst: Instruction): + x = self.state.stack.pop() + self.state.source_code += f"del {x}.{inst.argval}\n" + +# ==================== Import Instructions ============================= + def IMPORT_NAME(self, inst: Instruction): + # TODO: check multi-level import, e.g. `import a.b.c` + name = inst.argval.split(".")[0] + fromlist = self.state.stack.pop() + level = self.state.stack.pop() + self.state.source_code += f"{name} = __import__({repr(inst.argval)}, fromlist={fromlist}, level={level})\n" + self.state.stack.append(name) + + def IMPORT_FROM(self, inst: Instruction): + name = inst.argval + module = self.state.stack[-1] + self.state.source_code += f"{name} = {module}.{name}\n" + self.state.stack.append(name) + +# ==================== Unary Instructions ============================= + + def generic_unary(self, inst: Instruction): + op = { + "UNARY_NEGATIVE": "-", + "UNARY_POSITIVE": "+", + "UNARY_INVERT": "~", + "UNARY_NOT": "not", + }[inst.opname] + self.state.stack.append(f"({op} {self.state.stack.pop()})") + + UNARY_NEGATIVE = UNARY_POSITIVE = UNARY_INVERT = UNARY_NOT = generic_unary + + def GET_LEN(self, inst: Instruction): + self.state.stack.append(f"len({self.state.stack[-1]})") + +# ==================== Binary Instructions ============================= + def generic_binary(self, inst: Instruction): + rhs = self.state.stack.pop() + lhs = self.state.stack.pop() + op = { + "BINARY_MULTIPLY": "*", + "BINARY_ADD": "+", + "BINARY_SUBTRACT": "-", + "BINARY_TRUE_DIVIDE": "/", + "BINARY_FLOOR_DIVIDE": "//", + "BINARY_MODULO": "%", + "BINARY_POWER": "**", + "BINARY_AND": "&", + "BINARY_OR": "|", + "BINARY_XOR": "^", + "BINARY_LSHIFT": "<<", + "BINARY_RSHIFT": ">>", + "BINARY_MATRIX_MULTIPLY": "@", + }[inst.opname] + self.state.stack.append(f"({lhs} {op} {rhs})") + + BINARY_MULTIPLY = BINARY_ADD = BINARY_SUBTRACT = BINARY_TRUE_DIVIDE = BINARY_FLOOR_DIVIDE = BINARY_MODULO = BINARY_POWER = BINARY_AND = BINARY_OR = BINARY_XOR = BINARY_LSHIFT = BINARY_RSHIFT = BINARY_MATRIX_MULTIPLY = generic_binary + + def BINARY_SUBSCR(self, inst: Instruction): + rhs = self.state.stack.pop() + lhs = self.state.stack.pop() + self.state.stack.append(f"{lhs}[{rhs}]") + + def BINARY_SLICE(self, inst: Instruction): + end = self.state.stack.pop() + start = self.state.stack.pop() + container = self.state.stack.pop() + self.state.stack.append(f"{container}[{start}:{end}]") + +# ==================== Binary Inplace Instructions ======================= + def generic_inplace_binary(self, inst: Instruction): + rhs = self.state.stack.pop() + lhs = self.state.stack.pop() + op = { + "INPLACE_MULTIPLY": "*", + "INPLACE_ADD": "+", + "INPLACE_SUBTRACT": "-", + "INPLACE_TRUE_DIVIDE": "/", + "INPLACE_FLOOR_DIVIDE": "//", + "INPLACE_MODULO": "%", + "INPLACE_POWER": "**", + "INPLACE_AND": "&", + "INPLACE_OR": "|", + "INPLACE_XOR": "^", + "INPLACE_LSHIFT": "<<", + "INPLACE_RSHIFT": ">>", + "INPLACE_MATRIX_MULTIPLY": "@", + }[inst.opname] + self.state.source_code += f"{lhs} {op}= {rhs}\n" + self.state.stack.append(lhs) + + INPLACE_MULTIPLY = INPLACE_ADD = INPLACE_SUBTRACT = INPLACE_TRUE_DIVIDE = INPLACE_FLOOR_DIVIDE = INPLACE_MODULO = INPLACE_POWER = INPLACE_AND = INPLACE_OR = INPLACE_XOR = INPLACE_LSHIFT = INPLACE_RSHIFT = INPLACE_MATRIX_MULTIPLY = generic_inplace_binary + + def BINARY_OP(self, inst: Instruction): + rhs = self.state.stack.pop() + lhs = self.state.stack.pop() + if "=" in inst.argrepr: + self.state.source_code += f"{lhs} {inst.argrepr} {rhs}\n" + self.state.stack.append(lhs) + else: + self.state.stack.append(f"({lhs} {inst.argrepr} {rhs})") + +# ==================== Conditional Test Instructions ===================== + def COMPARE_OP(self, inst: Instruction): + rhs = self.state.stack.pop() + lhs = self.state.stack.pop() + self.state.stack.append(f"({lhs} {inst.argval} {rhs})") + + def IS_OP(self, inst: Instruction): + rhs = self.state.stack.pop() + lhs = self.state.stack.pop() + op = "is" if inst.argval == 0 else "is not" + self.state.stack.append(f"({lhs} {op} {rhs})") + + def CONTAINS_OP(self, inst: Instruction): + rhs = self.state.stack.pop() + lhs = self.state.stack.pop() + op = "in" if inst.argval == 0 else "not in" + self.state.stack.append(f"({lhs} {op} {rhs})") + +# ==================== Control Flow Instructions ============================= + + def BREAK_LOOP(self, inst: Instruction): + self.state.source_code += "break\n" + + def generic_abs_jump(self, inst: Instruction): + jump_offset = inst.get_jump_target() + jump_index = self.index_of(jump_offset) + if self.state.inside_loop: + if jump_index >= self.state.loop_end_index: + self.state.source_code += "break\n" + elif jump_index <= self.state.loop_start_index: + self.state.source_code += "continue\n" + else: + return jump_index + else: + return jump_index + + JUMP_ABSOLUTE = JUMP_FORWARD = JUMP_BACKWARD = JUMP_BACKWARD_NO_INTERRUPT = generic_abs_jump + + def RETURN_VALUE(self, inst: Instruction): + self.state.source_code += f"return {self.state.stack[-1]}\n" + self.state.stack.pop() + + def RETURN_CONST(self, inst: Instruction): + self.state.source_code += f"return {inst.argval}\n" + + def YIELD_VALUE(self, inst: Instruction): + if sys.version_info >= (3, 12): + raise NotImplementedError( + "YIELD_VALUE is not supported in Python 3.12") + self.state.source_code += f"yield {self.state.stack[-1]}\n" + + def RETURN_GENERATOR(self, inst: Instruction): + # we don't handle generator/coroutine, add this to support simple yield + self.state.stack.append(None) + + def GEN_START(self, inst: Instruction): + # self.state.stack.pop() + assert inst.argval == 0, "Only generator expression is supported" + + def generic_jump_if(self, inst: Instruction): + """How we support if-else: + + Failed idea: try to paritition the block of instructions into if and else. + This is not possible, as the if-else block might have overlapping instructions. + Take this function as an example: + + def f(a): + b = 1 if a else 2 + print(b) + + The bytecode is: + 2 0 LOAD_FAST 0 (a) + 2 POP_JUMP_IF_FALSE 4 (to 8) + 4 LOAD_CONST 1 (1) + 6 JUMP_FORWARD 1 (to 10) + >> 8 LOAD_CONST 2 (2) + >> 10 STORE_FAST 1 (b) + + 3 12 LOAD_GLOBAL 0 (print) + 14 LOAD_FAST 1 (b) + 16 CALL_FUNCTION 1 + 18 POP_TOP + 20 LOAD_CONST 0 (None) + 22 RETURN_VALUE + + The instructions for if branch: 2, 4, 6, 10 + The instructions for else branch: 8, 10 + They share the same instruction 10, so we cannot partition the block into if and else. + + Another example: + + def f(): + g(arg1=a if a is not None else b, arg2=2) + print(1) + + The bytecode is: + + 2 0 LOAD_GLOBAL 0 (g) + 2 LOAD_GLOBAL 1 (a) + 4 LOAD_CONST 0 (None) + 6 IS_OP 1 + 8 POP_JUMP_IF_FALSE 7 (to 14) + 10 LOAD_GLOBAL 1 (a) + 12 JUMP_FORWARD 1 (to 16) + >> 14 LOAD_GLOBAL 2 (b) + >> 16 LOAD_CONST 1 (2) + 18 LOAD_CONST 2 (('arg1', 'arg2')) + 20 CALL_FUNCTION_KW 2 + 22 POP_TOP + + 3 24 LOAD_GLOBAL 3 (print) + 26 LOAD_CONST 3 (1) + 28 CALL_FUNCTION 1 + 30 POP_TOP + 32 LOAD_CONST 0 (None) + 34 RETURN_VALUE + + The instructions for if branch: 8, 14, 16, 18, 20, 22 + The instructions for else branch: 10, 12, 16, 18, 20, 22 + They share the same instructions 16, 18, 20, 22, so we cannot partition the block into if and else. + + Current idea: + + We take advantage of the following fact: + + This code snippet: + + if cond: + if-body + else: + else-body + rest-body + + is equivalent to: + + if cond： + if-body + rest-body + else: + else-body + rest-body + + By duplicating the rest-body, we can decompile the if-else block separately. And they will have some duplicated code. + + Of course, we don't want to duplicate too long code, so we need to find the end of if-else block. + The current heuristic is to find the first store/return/jump/for-iter instruction after the if-else block (because they are indicators that we will generate meaningful source code). + """ + jump_offset = inst.get_jump_target() + jump_index = self.index_of(jump_offset) + this_index = self.index_of(inst.offset) + cond = self.state.stack[-1] + fallthrough_stack = self.state.stack.copy() + jump_stack = self.state.stack.copy() + + if "IF_NOT_NONE" in inst.opname: + cond = f"({cond} is None)" + elif "IF_NONE" in inst.opname: + cond = f"({cond} is not None)" + elif "IF_TRUE" in inst.opname: + cond = f"(not {cond})" + elif "IF_FALSE" in inst.opname: + cond = f"{cond}" + + # POP_AND_JUMP / JUMP_OR_POP + if "POP_JUMP" in inst.opname: + jump_stack.pop() + fallthrough_stack.pop() + elif "OR_POP" in inst.opname: + fallthrough_stack.pop() + + end_index_candidates = [len(self.instructions)] + if self.state.inside_loop: + end_index_candidates.append(self.state.loop_end_index) + + def qualified_jump(i: Instruction): + return i.is_jump() and i.get_jump_target() >= jump_offset + + jump_targets = [i.get_jump_target() for i in self.instructions[this_index: jump_index] if qualified_jump(i)] + + if not jump_targets: + # this is a jump back, we will generate a ``continue`` statement + # normally `if` condition is for the fallthrough code, but in this case + # we need to generate the `if` condition for the jump code + # therefore the condition is reversed + cond = self.state.stack[-1] + if "IF_NOT_NONE" in inst.opname: + cond = f"({cond} is not None)" + elif "IF_NONE" in inst.opname: + cond = f"({cond} is None)" + elif "IF_TRUE" in inst.opname: + cond = f"{cond}" + elif "IF_FALSE" in inst.opname: + cond = f"(not {cond})" + if_code = f"if {cond}:\n" + add_indentation("continue\n", self.indentation) + self.state.source_code += if_code + return + + max_jump = max(jump_targets) + max_jump_index = self.index_of(max_jump) + # else branch might have jumps, we need to find the end of the else + all_jump_targets = [i.get_jump_target() for i in self.instructions[this_index: max_jump_index] if qualified_jump(i)] + max_jump_index = self.index_of(max(all_jump_targets)) + last_inst = self.instructions[max_jump_index - 1] + if "RAISE" in last_inst.opname or "RETURN" in last_inst.opname or "STORE" in last_inst.opname: + # if-body instructions end with raise/return/store, it is very likely that if-body and else-body don't share any instructions + pass + else: + old_map_jump_index = max_jump_index + while max_jump_index < len(self.instructions): + opname = self.instructions[max_jump_index].opname + if "STORE" in opname or "RETURN" in opname: + # we want to include the store/return instruction in the if-else block + max_jump_index += 1 + break + elif ("JUMP" in opname and max_jump_index > old_map_jump_index) or "FOR_ITER" in opname: + # we don't want to include the jump instruction in the if-else block + break + max_jump_index += 1 + end_index_candidates.append(max_jump_index) + + end_index = min(end_index_candidates) + + with self.new_state(fallthrough_stack): + self.decompile_range(this_index + 1, end_index) + if_body = self.state.source_code + if_body = add_indentation(if_body, self.indentation) + if_end_stack = self.state.stack.copy() + if_code = f"if {cond}:\n{if_body}" + self.state.source_code += if_code + + with self.new_state(jump_stack): + self.decompile_range(jump_index, end_index) + else_body = self.state.source_code + if else_body: + else_body = add_indentation(else_body, self.indentation) + else_code = f"else:\n{else_body}" + self.state.source_code += else_code + + self.state.stack = if_end_stack + return end_index + + + POP_JUMP_IF_TRUE = POP_JUMP_IF_FALSE = generic_jump_if + POP_JUMP_FORWARD_IF_TRUE = POP_JUMP_FORWARD_IF_FALSE = generic_jump_if + POP_JUMP_BACKWARD_IF_TRUE = POP_JUMP_BACKWARD_IF_FALSE = generic_jump_if + POP_JUMP_FORWARD_IF_NONE = POP_JUMP_FORWARD_IF_NOT_NONE = generic_jump_if + POP_JUMP_BACKWARD_IF_NONE = POP_JUMP_BACKWARD_IF_NOT_NONE = generic_jump_if + JUMP_IF_TRUE_OR_POP = JUMP_IF_FALSE_OR_POP = generic_jump_if + POP_JUMP_IF_NOT_NONE = POP_JUMP_BACKWARD_IF_NOT_NONE + POP_JUMP_IF_NONE = POP_JUMP_BACKWARD_IF_NONE + + def SETUP_FINALLY(self, inst: Instruction): + start_index = self.index_of(inst.offset) + end_index = self.index_of(inst.get_jump_target()) + pop_block_index = [i for i, x in enumerate( + self.instructions) if x.opname == "POP_BLOCK" and start_index <= i < end_index][-1] + + try_code = "" + with self.new_state(self.state.stack): + self.decompile_range(start_index + 1, pop_block_index) + try_code = self.state.source_code + try_code = add_indentation(try_code, self.indentation) + try_code = "try:\n" + try_code + + finally_code = "" + with self.new_state(self.state.stack): + end_finally_index = [ + i for i, x in enumerate( + self.instructions) if x.opname == "END_FINALLY" and start_index <= i] + if end_finally_index: + end_index = end_finally_index[0] + finally_end_index = end_index + if self.instructions[finally_end_index - 1].is_jump(): + finally_end_index -= 1 + self.decompile_range(pop_block_index + 1, finally_end_index) + finally_code = self.state.source_code + finally_code = add_indentation(finally_code, self.indentation) + finally_code = "finally:\n" + finally_code + + self.state.source_code += try_code + finally_code + return end_index + + def SETUP_WITH(self, inst: Instruction): + """ + with expression as var: + body + + is equivalent to: + + var = expression + var.__enter__() + try: + body + finally: + var.__exit__() + + We find the start of `finally` by `WITH_EXCEPT_START`, and the end of `finally` by `POP_EXCEPT`. + In early python version, the start is `WITH_CLEANUP_START` and the end is `WITH_CLEANUP_FINISH`. + """ + start_index = self.index_of(inst.offset) + with_except_index = [i for i, x in enumerate( + self.instructions) if x.opname in ["WITH_EXCEPT_START", "WITH_CLEANUP_START"] and i > start_index][-1] + end_index = with_except_index + nop_instruction(self.instructions[end_index]) + + # NOP PUSH_EXC_INFO and JUMP_FORWARD + i = end_index - 1 + while end_index - i <= 2: + _inst = self.instructions[i] + if _inst.opname.startswith("JUMP") or _inst.opname == "PUSH_EXC_INFO": + nop_instruction(_inst) + i -= 1 + + pop_except_indices = [i for i, x in enumerate( + self.instructions) if x.opname in ["POP_EXCEPT", "WITH_CLEANUP_FINISH"] and i > end_index] + if sys.version_info >= (3, 11): + # Python 3.11 seems to have two `POP_EXCEPT` instructions, not sure why. + pop_except_index = pop_except_indices[1] + else: + pop_except_index = pop_except_indices[0] + for i in range(end_index, pop_except_index + 1): + nop_instruction(self.instructions[i]) + tos = self.state.stack[-1] + temp = self.get_temp_name() + self.state.stack.append(f"{temp}.__exit__") + self.state.stack.append(temp) + with_clause = f"with {tos} as {temp}:\n" + with_body = "" + with self.new_state(self.state.stack): + self.decompile_range(start_index + 1, end_index) + with_body = self.state.source_code + with_body = add_indentation(with_body, self.indentation) + lines = with_body.splitlines() + ans = [] + for line in lines: + if f"{temp}.__exit__" in line or "None(None, None)" in line.strip(): + # this is the line that calls __exit__, we need to remove it, as it is managed by `with` statement. + # `None(None, None)` is used for Python 3.11. Who knows why it loads three Nones but call with 2 args for the following simple code: + # def f(): + # with a: + # print(2) + continue + ans.append(line) + with_body = "".join([x + "\n" for x in ans]) + + self.state.source_code += with_clause + with_body + return pop_except_index + 1 + + BEFORE_WITH = SETUP_WITH + + def FOR_ITER(self, inst: Instruction): + start_index = self.index_of(inst.offset) + end_index = self.index_of(inst.get_jump_target()) + + temp_name = self.get_temp_name() + for_code = f"for {temp_name} in {self.state.stack.pop()}:\n" + self.state.stack.append(temp_name) + last_inst = self.instructions[end_index] + if last_inst.is_jump() and last_inst.get_jump_target() == inst.offset: + # if end_index is something like jumping back to for_iter, + # we should deal with it inside the loop + end_index += 1 + with self.new_state(self.state.stack, inside_loop=True, loop_start_index=start_index, loop_end_index=end_index): + self.decompile_range(start_index + 1, end_index) + code = self.state.source_code + for_code = for_code + add_indentation(code, self.indentation) + for_end_stack = self.state.stack.copy() + self.state.source_code += for_code + self.state.stack = for_end_stack + return end_index + +# ==================== Stack Manipulation Instructions =================== + def rot_n(self, inst: Instruction): + if inst.opname == "ROT_N": + n = inst.argval + else: + n = { + "ROT_TWO": 2, + "ROT_THREE": 3, + "ROT_FOUR": 4, + }[inst.opname] + values = self.state.stack[-n:] + values = [values[-1]] + values[:-1] + self.state.stack[-n:] = values + + ROT_N = ROT_TWO = ROT_THREE = ROT_FOUR = rot_n + + def SWAP(self, inst: Instruction): + n = inst.argval + tos = self.state.stack[-1] + value = self.state.stack[- n] + tos, value = value, tos + self.state.stack[-1] = tos + self.state.stack[- n] = value + + def COPY(self, inst: Instruction): + # not tested, don't know how to generate this instruction + n = inst.argval + value = self.state.stack[-1 - n] + self.state.stack.append(value) + + def POP_TOP(self, inst: Instruction): + self.state.stack.pop() + + def DUP_TOP(self, inst: Instruction): + # not tested + self.state.stack.append(self.state.stack[-1]) + + def DUP_TOP_TWO(self, inst: Instruction): + # not tested + tos = self.state.stack[-1] + tos1 = self.state.stack[-2] + self.state.stack.append(tos1) + self.state.stack.append(tos) + +# ==================== Function Call Instructions ============================= + def KW_NAMES(self, inst: Instruction): + names = self.code.co_consts[inst.arg] + self.state.stack.append(repr(names)) + + def CALL(self, inst: Instruction): + last_inst = [x for x in self.instructions if x.offset < inst.offset] + has_kw_names = False + if last_inst: + if last_inst[-1].opname == "KW_NAMES" or (len( + last_inst) > 1 and last_inst[-2].opname == "KW_NAMES" and last_inst[-1].opname == "PRECALL"): + has_kw_names = True + kw_names = tuple() + if has_kw_names: + kw_names = eval(self.state.stack.pop()) + args = [(self.state.stack.pop()) for _ in range(inst.argval)] + args = args[::-1] + pos_args = args[:len(args) - len(kw_names)] + kwargs = args[len(args) - len(kw_names):] + kwcalls = [] + for name, value in zip(kw_names, kwargs): + kwcalls.append(f"{name}={value}") + func = self.state.stack.pop() + if self.state.stack and self.state.stack[-1] is None: + self.state.stack.pop() + if "iter(" in func: + # Why do we need this? Don't know. But sometimes CPython generates + # CALL with argval=0, but the function actually needs an arg (for + # list/set/map comprehension). + pos_args = [func] + func = self.state.stack.pop() + self.state.stack.append(f"{func}({', '.join(pos_args + kwcalls)})") + self.replace_mutable_tos_with_temp() + + def generic_call(self, inst: Instruction): + args = [(self.state.stack.pop()) for _ in range(inst.argval)] + args = args[::-1] + func = self.state.stack.pop() + self.state.stack.append(f"{func}({', '.join(args)})") + self.replace_mutable_tos_with_temp() + + CALL_FUNCTION = CALL_METHOD = generic_call + + def CALL_FUNCTION_KW(self, inst: Instruction): + kw_args = eval(self.state.stack.pop()) + kw_vals = [(self.state.stack.pop()) for _ in range(len(kw_args))] + kw_vals.reverse() + kwcalls = [] + for name, val in zip(kw_args, kw_vals): + kwcalls.append(f"{name}={val}") + pos_args = [(self.state.stack.pop()) + for _ in range(inst.argval - len(kw_args))] + pos_args = pos_args[::-1] + func = self.state.stack.pop() + self.state.stack.append(f"{func}({', '.join(pos_args + kwcalls)})") + self.replace_mutable_tos_with_temp() + + def CALL_FUNCTION_EX(self, inst: Instruction): + if inst.argval == 0: + args = self.state.stack.pop() + func = self.state.stack.pop() + self.state.stack.append(f"{func}(*{args})") + elif inst.argval == 1: + kw_args = self.state.stack.pop() + args = self.state.stack.pop() + func = self.state.stack.pop() + self.state.stack.append(f"{func}(*{args}, **{kw_args})") + self.replace_mutable_tos_with_temp() + + def CALL_INTRINSIC_1(self, inst: Instruction): + if inst.argrepr in [ + "INTRINSIC_1_INVALID", + "INTRINSIC_IMPORT_STAR", + "INTRINSIC_STOPITERATION_ERROR", + "INTRINSIC_ASYNC_GEN_WRAP"]: + # invalid intrinsic, skip + pass + elif inst.argrepr in ["INTRINSIC_TYPEVAR", "INTRINSIC_PARAMSPEC", "INTRINSIC_TYPEVARTUPLE", "INTRINSIC_SUBSCRIPT_GENERIC", "INTRINSIC_TYPEALIAS"]: + # not tested, skip + pass + elif inst.argrepr == "INTRINSIC_PRINT": + self.state.source_code += f"print({self.state.stack.pop()})\n" + self.state.stack.append("None") + elif inst.argrepr == "INTRINSIC_UNARY_POSITIVE": + self.state.stack[-1] = f"+{self.state.stack[-1]}" + elif inst.argrepr == "INTRINSIC_LIST_TO_TUPLE": + return self.LIST_TO_TUPLE(inst) + + +# ==================== Container Related Instructions (tuple, list, set, d + + def UNPACK_SEQUENCE(self, inst: Instruction): + # sequence can be tuple, list, or even generator + # we cannot directly use indexing to get the elements + # because the sequence might be a generator (not subscriptable) + # instead, we use a temporary variable to store the unpacked elements + + # e.g. `a, b = (None for _ in (1, 2))` + # will be transformed into: + # __temp_1 = (None for _ in (1, 2)) + # __temp_2, __temp_3 = __temp_1 + # a = __temp_2 + # b = __temp_3 + varname = self.state.stack.pop() + tmp_names = [] + for i in range(inst.argval): + tmp_names.append(self.get_temp_name()) + # NOTE: even if there is only one element, we still need to unpack it + # a = b is different from a, = b + lhs = "".join([f"{x}, " for x in tmp_names]) + self.state.source_code += lhs + f"= {varname}\n" + for name in tmp_names[::-1]: + self.state.stack.append(name) + + def UNPACK_EX(self, inst: Instruction): + varname = self.state.stack.pop() + tmp_names = [] + for i in range(inst.argval): + tmp_names.append(self.get_temp_name()) + star_name = self.get_temp_name() + self.state.source_code += ", ".join(tmp_names) + f", *{star_name}" + f" = {varname}\n" + self.state.stack.append(star_name) + for name in tmp_names[::-1]: + self.state.stack.append(name) + + def BUILD_SLICE(self, inst: Instruction): + tos = self.state.stack.pop() + tos1 = self.state.stack.pop() + if inst.argval == 2: + self.state.stack.append(f"slice({tos1}, {tos})") + elif inst.argval == 3: + tos2 = self.state.stack.pop() + self.state.stack.append(f"slice({tos2}, {tos1}, {tos})") + + def build_tuple(self, inst: Instruction): + args = [self.state.stack.pop() for _ in range(inst.argval)] + args = args[::-1] + if "UNPACK" in inst.opname: + args = [f"*{arg}" for arg in args] + if inst.argval == 1: + self.state.stack.append(f"({args[0]},)") + else: + self.state.stack.append(f"({', '.join(args)})") + + BUILD_TUPLE = BUILD_TUPLE_UNPACK = BUILD_TUPLE_UNPACK_WITH_CALL = build_tuple + + def build_list(self, inst: Instruction): + args = [self.state.stack.pop() for _ in range(inst.argval)] + args = args[::-1] + if "UNPACK" in inst.opname: + args = [f"*{arg}" for arg in args] + self.state.stack.append(f"[{', '.join(args)}]") + self.replace_mutable_tos_with_temp() + + BUILD_LIST = BUILD_LIST_UNPACK = build_list + + def build_set(self, inst: Instruction): + ans = "" + if inst.argval == 0: + ans = "set()" + else: + args = [self.state.stack.pop() for _ in range(inst.argval)] + args = args[::-1] + if "UNPACK" in inst.opname: + args = [f"*{arg}" for arg in args] + ans = f"{{{', '.join(args)}}}" + self.state.stack.append(ans) + self.replace_mutable_tos_with_temp() + + BUILD_SET = BUILD_SET_UNPACK = build_set + + def build_map_unpack(self, inst: Instruction): + if inst.argval == 0: + self.state.stack.append("dict()") + else: + args = [self.state.stack.pop() for _ in range(inst.argval)] + args = args[::-1] + args = [f"**{arg}" for arg in args] + self.state.stack.append(f"{{{', '.join(args)}}}") + self.replace_mutable_tos_with_temp() + + BUILD_MAP_UNPACK = BUILD_MAP_UNPACK_WITH_CALL = build_map_unpack + + def BUILD_MAP(self, inst: Instruction): + args = [self.state.stack.pop() for _ in range(inst.argval * 2)] + args = args[::-1] + keys = args[::2] + values = args[1::2] + self.state.stack.append( + f"{{{', '.join([f'{k}: {v}' for k, v in zip(keys, values)])}}}") + self.replace_mutable_tos_with_temp() + + def BUILD_CONST_KEY_MAP(self, inst: Instruction): + keys = eval(self.state.stack.pop()) + args = [self.state.stack.pop() for _ in range(inst.argval)] + values = args[::-1] + self.state.stack.append( + f"{{{', '.join([f'{k}: {v}' for k, v in zip(keys, values)])}}}") + self.replace_mutable_tos_with_temp() + + def BUILD_STRING(self, inst: Instruction): + args = [self.state.stack.pop() for _ in range(inst.argval)] + args = args[::-1] + values = " + ".join(args) + self.state.stack.append(values) + + def LIST_TO_TUPLE(self, inst: Instruction): + item = self.state.stack.pop() + self.state.stack.append(f"tuple({item})") + + def LIST_EXTEND(self, inst: Instruction): + assert inst.argval == 1, "Only tested for argval==1" + values = self.state.stack.pop() + temp = self.replace_mutable_tos_with_temp() + self.state.source_code += f"{temp}.extend({values})\n" + + def LIST_APPEND(self, inst: Instruction): + if inst.argval == 1: + # it should be a bug, the tos should be the value. fix it anyway. + inst.argval += 1 + container = self.state.stack[-inst.argval] + value = self.state.stack.pop() + self.state.source_code += f"{container}.append({value})\n" + + def generic_update(self, inst: Instruction): + assert inst.argval == 1, "Only tested for argval==1" + values = self.state.stack.pop() + temp = self.replace_mutable_tos_with_temp() + self.state.source_code += f"{temp}.update({values})\n" + + SET_UPDATE = DICT_UPDATE = DICT_MERGE = generic_update + + def SET_ADD(self, inst: Instruction): + if inst.argval == 1: + # it should be a bug, the tos should be the value. fix it anyway. + inst.argval += 1 + container = self.state.stack[-inst.argval] + value = self.state.stack.pop() + self.state.source_code += f"{container}.add({value})\n" + + def MAP_ADD(self, inst: Instruction): + container = self.state.stack[-inst.argval - 1] + # see https://docs.python.org/3.10/library/dis.html#opcode-MAP_ADD + if sys.version_info >= (3, 8): + value = self.state.stack.pop() + key = self.state.stack.pop() + else: + key = self.state.stack.pop() + value = self.state.stack.pop() + self.state.source_code += f"{container}.__setitem__({key}, {value})\n" + +# ==================== Misc Instructions ============================= + def RAISE_VARARGS(self, inst: Instruction): + if inst.argval == 0: + self.state.source_code += "raise\n" + elif inst.argval == 1: + self.state.source_code += f"raise {self.state.stack.pop()}\n" + elif inst.argval == 2: + tos = self.state.stack.pop() + tos1 = self.state.stack.pop() + self.state.source_code += f"raise {tos1} from {tos}\n" + + def FORMAT_VALUE(self, inst: Instruction): + func, spec = inst.argval + if spec: + form_spec = self.state.stack.pop() + value = self.state.stack.pop() + self.state.stack.append(f"format({value}, {form_spec})") + else: + value = self.state.stack.pop() + func = str if func is None else func + self.state.stack.append(f"{func.__name__}({value})") + + + def decompile_range(self, start: int, end: int): + try: + running_index = start + while running_index < end: + inst = self.instructions[running_index] + method = getattr( + Decompiler, + inst.opname, + Decompiler.unimplemented_instruction) + output = method(self, inst) + if output: + running_index = output + else: + running_index += 1 + except Exception as e: + raise DecompilationError( + f"Failed to decompile instruction {inst} in {self.code.co_name}") from e + + def index_of(self, offset: int): + for idx, inst in enumerate(self.instructions): + if inst.offset == offset: + return idx + raise ValueError(f"Cannot find instruction with offset {offset}") + + @staticmethod + def cleanup_instructions(code, instructions: List[Instruction]): + propagate_line_nums(instructions) + simplify_finally_statement(instructions) + nop_unreachable_bytecode(code, instructions) + + def __init__(self, code: Union[CodeType, Callable]): + if callable(code): + from depyf.utils import get_code_owner + code = get_code_owner(code).__code__ + self.code = code + instructions = list(convert_instruction(_) + for _ in dis.get_instructions(code)) + Decompiler.cleanup_instructions(code, instructions) + self.instructions = instructions + self.state = DecompilerState(source_code="", stack=[]) + + def get_temp_name(self): + Decompiler.temp_count += 1 + return f"{self.temp_prefix}{Decompiler.temp_count}" + + def replace_mutable_tos_with_temp(self): + ans = self.state.stack.pop() + temp_name = self.get_temp_name() + self.state.source_code += f"{temp_name} = {ans}\n" + self.state.stack.append(temp_name) + return temp_name + + @staticmethod + def supported_opnames(): + opnames = [] + for x in dis.opname: + if getattr( + Decompiler, + x, + Decompiler.unimplemented_instruction) is not Decompiler.unimplemented_instruction: + opnames.append(x) + return opnames + + @functools.lru_cache(maxsize=None) + def decompile( + self, + indentation=4, + temp_prefix: str = "__temp_", + overwite_fn_name: Optional[str] = None) -> str: + try: + self.indentation = indentation + self.temp_prefix = temp_prefix + self.decompile_range(0, len(self.instructions)) + source_code = self.state.source_code + # the header might have invalid function name in torchdynamo. only + # optimize the function body. + source_code = remove_some_temp( + source_code, self.temp_prefix, indentation) + header = get_function_signature(self.code, overwite_fn_name) + # we cannot rely on `co_names`. For example, `from math import sqrt` will make `math` and `sqrt` in `co_names`. + global_names = set(inst.argval for inst in dis.get_instructions(self.code) if inst.opname == "STORE_GLOBAL") + global_statements = "global " + ", ".join( + global_names) + "\n" if global_names else "" + nonlocal_statement = "nonlocal " + ", ".join( + self.code.co_freevars) + "\n" if self.code.co_freevars else "" + source_code = global_statements + nonlocal_statement + source_code + source_code = header + add_indentation(source_code, indentation) + return source_code + except DecompilationError: + raise + except Exception as e: + raise DecompilationError( + f"Failed to decompile {self.code.co_name}") from e + + @staticmethod + def decompile_and_compile_like( + code_to_decompile: CodeType, + reference_code: CodeType, + indentation=4, + temp_prefix: str = "__temp_", + filepath_template: Optional[str] = None) -> CodeType: + + # first, decompile the code into source code, with function name `__place_holder__` + src = Decompiler(code_to_decompile).decompile(indentation=indentation, temp_prefix=temp_prefix, overwite_fn_name="__place_holder__") + + # fix the freevars/cellvars in the source code + from depyf.code_transform import fix_irregular_code + # check https://dev-discuss.pytorch.org/t/what-is-the-relationship-requirement-among-original-bytecode-transformed-bytecode-and-bytecode-returned-by-hooks-in-dynamo/1693/4 for why we need to prepare freevars like `reference_code` rather than `code` + src = fix_irregular_code(reference_code, src) + + if filepath_template is None: + func_name = reference_code.co_name + src = src.replace("__place_holder__", func_name) + filename = "noname" + else: + src_body = src[src.find("("):] + if reference_code.co_freevars: + src_body = src_body[src_body.find("("):] + + count = 0 + while True: + filename = filepath_template % count + if os.path.exists(filename): + existing_code = open(filename, "r").read() + existing_code_body = existing_code[existing_code.find("("):] + if reference_code.co_freevars: + existing_code_body = existing_code_body[existing_code_body.find("("):] + if src_body == existing_code_body: + # the same code body is found, we do not need to dump the code again. + src = existing_code + break + else: + count += 1 + else: + func_name = filename.split(os.path.sep)[-1].split(".")[0] + src = src.replace("__place_holder__", func_name) + with open(filename, "w") as f: + f.write(src) + break + + func_name = filename.split(os.path.sep)[-1].split(".")[0] + + from depyf.utils import collect_all_code_objects + transformed_code = compile(src, filename=filename, mode="exec") + transformed_codes = collect_all_code_objects(transformed_code) + decompiled_and_compiled_back_code = [x for x in transformed_codes if x.co_name == func_name][0] + + # torch.compile might hold random non-constant values in `new_code.co_consts` that cannot + # be represented in source code. During decompliation, we treat them as `__co_consts[i]`, + # a string that represents the constant in the original code object. + # We need to replace them with the actual constant in the original code object, so that + # the decompiled and compiled back code object can be used for execution. + updated_consts = [] + for i, x in enumerate(decompiled_and_compiled_back_code.co_consts): + if isinstance(x, str) and x.startswith("__co_consts"): + index = int(x.split("[")[-1][:-1]) # __co_consts[0] -> 0 + updated_consts.append(code_to_decompile.co_consts[index]) + else: + updated_consts.append(x) + + decompiled_and_compiled_back_code = decompiled_and_compiled_back_code.replace(co_consts=tuple(updated_consts)) + + return decompiled_and_compiled_back_code + + def __hash__(self): + # see https://github.com/thuml/depyf/pull/21 + return id(self.code) + + def __eq__(self, other): + return hash(self) == hash(other) + +def decompile(code: Union[CodeType, Callable]) -> str: + """Decompile any callable or code object into Python source code. + It is especially useful for some dynamically generated code, like ``torch.compile``, + or ``dataclasses``. + + Example usage: + + .. code-block:: python + + from dataclasses import dataclass + @dataclass + class Data: + x: int + y: float + + import depyf + print(depyf.decompile(Data.__init__)) + print(depyf.decompile(Data.__eq__)) + + Output: + + .. code-block:: python + + def __init__(self, x, y): + self.x = x + self.y = y + return None + + def __eq__(self, other): + if other.__class__ is self.__class__: + return (self.x, self.y) == (other.x, other.y) + return NotImplemented + + The output source code is semantically equivalent to the function, but not syntactically the same. It verbosely adds many details that are hidden in the Python code. For example, the above output code of ``__init__`` explicitly returns ``None``, which is typically ignored. + + Another detail is that the output code of ``__eq__`` returns ``NotImplemented`` instead of raising ``NotImplemented`` exception when the types are different. At the first glance, it seems to be a bug. However, it is actually the correct behavior. The ``__eq__`` method should return ``NotImplemented`` when the types are different, so that the other object can try to compare with the current object. See `the Python documentation `_ for more details. + """ + return Decompiler(code).decompile() diff --git a/venv/lib/python3.10/site-packages/depyf/explain/__init__.py b/venv/lib/python3.10/site-packages/depyf/explain/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..31feb23a2b5235b1c86669dd716914578c778867 --- /dev/null +++ b/venv/lib/python3.10/site-packages/depyf/explain/__init__.py @@ -0,0 +1,17 @@ +from depyf.explain.utils import DynamoOptimizationResult + +from torch._dynamo.eval_frame import innermost_fn + +from typing import List, Callable, Dict, Union, Set +from types import CodeType + + +def _extract_artifacts(original_code: CodeType, module): + result = DynamoOptimizationResult(original_code, None, module) + return result + +def dump_src(original_code: CodeType, module): + from depyf.explain.global_variables import data + assert data["is_inside_prepare_debug"], "`dump_src` must be used inside `depyf.prepare_debug`." + artifacts = _extract_artifacts(original_code, module) + return artifacts.to_src() diff --git a/venv/lib/python3.10/site-packages/depyf/explain/__pycache__/__init__.cpython-310.pyc b/venv/lib/python3.10/site-packages/depyf/explain/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..90ca508f2221dd3b8943a1d5790b980e71bb4162 Binary files /dev/null and b/venv/lib/python3.10/site-packages/depyf/explain/__pycache__/__init__.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/depyf/explain/__pycache__/enable_debugging.cpython-310.pyc b/venv/lib/python3.10/site-packages/depyf/explain/__pycache__/enable_debugging.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..71736beac45d9af2ce59589a45b2e007a4d8e99f Binary files /dev/null and b/venv/lib/python3.10/site-packages/depyf/explain/__pycache__/enable_debugging.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/depyf/explain/enable_debugging.py b/venv/lib/python3.10/site-packages/depyf/explain/enable_debugging.py new file mode 100644 index 0000000000000000000000000000000000000000..61179dfecf87a63c13d101c9ab5d091c55050837 --- /dev/null +++ b/venv/lib/python3.10/site-packages/depyf/explain/enable_debugging.py @@ -0,0 +1,251 @@ +from .patched_boxed_run import patched_boxed_run +from .patched_lazy_format_graph_code import patched_lazy_format_graph_code +from .patched_load_by_key_path import patched_load_by_key_path +from .patched__exec_with_source import patched__exec_with_source +from typing import List, Tuple, Dict, Union, Callable, Optional, Any + +import contextlib +import warnings +import traceback + +import dataclasses +import itertools +import sys +import os +import inspect + + +@dataclasses.dataclass +class DebuggableHook(object): + dump_src_dir: str + log_bytecode: bool + optimized_code_and_module: List =dataclasses.field(default_factory=list, init=False) + + def __call__(self, code, new_code): + frame = sys._getframe() + import os + while True: + frame = frame.f_back + code_name = frame.f_code.co_name + file_name = frame.f_code.co_filename.split(os.path.sep)[-1] + if code_name == "_compile" and file_name == "convert_frame.py": + break + frame = frame.f_locals["frame"] + assert frame.f_code == code + self.optimized_code_and_module.append([code, frame.f_globals]) + from depyf.decompiler import DecompilationError + try: + import os + # replace " "/"<"/">"/"." with "_" + func_name = code.co_name.replace(".", "_").replace("<", "_").replace(">", "_").replace(" ", "_") + filepath_template = os.path.join( + self.dump_src_dir, + f"__transformed_code_%s_for_{func_name}.py") + + from depyf.explain.utils import lock_on_file + from depyf.decompiler import Decompiler + + # function name and file name are related. + with lock_on_file(filepath_template): + decompiled_and_compiled_back_code = Decompiler.decompile_and_compile_like(code_to_decompile=new_code, reference_code=code, filepath_template=filepath_template) + filename = decompiled_and_compiled_back_code.co_filename + if self.log_bytecode: + with lock_on_file(filename): + import dill + # code object, especially `new_code` constructed by Dynamo, may not be able to be dumped using `marshal`. + # see https://github.com/pytorch/pytorch/issues/116013 for more details. + with contextlib.suppress(Exception): + dill.dump(code, open(filename + ".original_bytecode", "wb")) + + with contextlib.suppress(Exception): + dill.dump(new_code, open(filename + ".transformed_bytecode", "wb")) + + with contextlib.suppress(Exception): + dill.dump(decompiled_and_compiled_back_code, open(filename + ".decompiled_and_compiled_back_bytecode", "wb")) + + # this fix is used for PyTorch prior to PR https://github.com/pytorch/pytorch/pull/114487 + from torch._dynamo.utils import orig_code_map + from torch._dynamo.convert_frame import output_codes + output_codes.add(decompiled_and_compiled_back_code) + orig_code_map[decompiled_and_compiled_back_code] = code + + return decompiled_and_compiled_back_code + except (DecompilationError, SyntaxError) as e: + from io import StringIO + string_io = StringIO() + import dis + print("There is a problem when decompiling and compiling the following code:", file=string_io) + dis.dis(new_code, file=string_io) + print("Please consider submitting an issue to https://github.com/thuml/depyf .", file=string_io) + # do not stop the program for decompilation error and compile error + warnings.warn(string_io.getvalue()) + traceback.print_exc() + +@contextlib.contextmanager +def patch(parent, name, value): + old_value = getattr(parent, name, None) + if old_value is not None: + setattr(parent, name, value) + try: + yield + finally: + if old_value is not None: + setattr(parent, name, old_value) + + +@contextlib.contextmanager +def enable_bytecode_hook(hook): + import torch + handle = torch._dynamo.convert_frame.register_bytecode_hook(hook) + try: + yield + finally: + handle.remove() + + +@contextlib.contextmanager +def prepare_debug(dump_src_dir, clean_wild_fx_code=True, log_bytecode=False): + """ + A context manager to dump debugging information for torch.compile. + It should wrap the code that actually triggers the compilation, rather than + the code that applies ``torch.compile``. + + Example: + + .. code-block:: python + + import torch + + @torch.compile + def toy_example(a, b): + x = a / (torch.abs(a) + 1) + if b.sum() < 0: + b = b * -1 + return x * b + + def main(): + for _ in range(100): + toy_example(torch.randn(10), torch.randn(10)) + + if __name__ == "__main__": + # main() + # surround the code you want to run inside `with depyf.prepare_debug` + import depyf + with depyf.prepare_debug("./dump_src_dir"): + main() + + After running the code, you will find the dumped information in the directory ``dump_src_dir``. The details are organized into the following: + + - ``full_code_for_xxx.py`` for each function using torch.compile + - ``__transformed_code_for_xxx.py`` for Python code associated with each graph. + - ``__transformed_code_for_xxx.py.xxx_bytecode`` for Python bytecode, dumped code object, can be loaded via ``dill.load(open("/path/to/file", "wb"))``. Note that the load function might import some modules like transformers. Make sure you have these modules installed. + - ``__compiled_fn_xxx.py`` for each computation graph and its optimization: + - ``Captured Graph``: a plain forward computation graph + - ``Joint Graph``: joint forward-backward graph from AOTAutograd + - ``Forward Graph``: forward graph from AOTAutograd + - ``Backward Graph``: backward graph from AOTAutograd + - ``kernel xxx``: compiled CPU/GPU kernel wrapper from Inductor. + + Arguments: + + - ``dump_src_dir``: the directory to dump the source code. + - ``clean_wild_fx_code``: whether to clean the wild fx code that are not recognized for parts of compiled functions. They are usually used by PyTorch internally. + - ``log_bytecode``: whether to log bytecode (original bytecode, transformed bytecode from Dynamo, and decompiled_and_compiled_back_code). + """ + + if not isinstance(dump_src_dir, str): + raise RuntimeError('''You are using an obsolete usage style`depyf.prepare_debug(func=function, dump_src_dir="/path")`. Please use `depyf.prepare_debug(dump_src_dir="/path")` instead, which will automatically capture all compiled functions.''') + + import os + import torch + + current_line_number = inspect.currentframe().f_lineno + 1 + warnings.warn_explicit(f"{__file__}:{current_line_number}: You are trying to debug `torch.compile`. Please make sure the code runs multiple times to cover all the possible branches.", UserWarning, "", 0) + + from depyf.utils import safe_create_directory + + if not os.path.exists(dump_src_dir): + safe_create_directory(dump_src_dir) + + dump_src_dir = os.path.abspath(dump_src_dir) + + from .global_variables import data + + data["dump_src_dir"] = dump_src_dir + data["unpatched__exec_with_source"] = torch.fx.graph_module._exec_with_source + data["unpatched_load_by_key_path"] = torch._inductor.codecache.PyCodeCache.load_by_key_path + data["unpatched___call__"] = torch._dynamo.eval_frame.OptimizeContext.__call__ + data["is_inside_prepare_debug"] = True + + bytecode_hook = DebuggableHook(dump_src_dir, log_bytecode) + + # patch some functions + with patch(torch.fx.graph_module, "_exec_with_source", patched__exec_with_source), \ + patch(torch._inductor.codecache.PyCodeCache, "load_by_key_path", patched_load_by_key_path), \ + patch(torch._dynamo.utils.lazy_format_graph_code, "__code__", patched_lazy_format_graph_code.__code__): + # we have to directly manipulate the code object, since the function has been imported in many places. + # simply replacing torch._dynamo.utils.lazy_format_graph_code does not work for those functions. + # Note: `unitest.mock.patch` does not work here, since it will not + # patch the code object. (it will try to delete the code object and + # then set a new code object. The `delattr` will raise an error.) + + # enable bytecode hook + with enable_bytecode_hook(bytecode_hook): + try: + yield + finally: + + code_names = {x[0].co_name for x in bytecode_hook.optimized_code_and_module} + for code, module in bytecode_hook.optimized_code_and_module: + if code.co_name.startswith("resume_in_") and any(f"resume_in_{name}" in code.co_name for name in code_names): + continue + # https://github.com/pytorch/pytorch/pull/118201 introduces `torch_dynamo_resume_in_` names. + if code.co_name.startswith("torch_dynamo_resume_in_") and any(f"torch_dynamo_resume_in_{name}" in code.co_name for name in code_names): + continue + from depyf.explain import dump_src + from depyf.explain.utils import write_code_to_file_template + from torch._dynamo.eval_frame import innermost_fn, _debug_get_cache_entry_list + entries = _debug_get_cache_entry_list(code) + if not entries: + current_line_number = inspect.currentframe().f_lineno + 1 + warnings.warn_explicit(f"{__file__}:{current_line_number}: Code object {code} is compiled but does not have any compiled cache entries. Probably some torch.nn.Module instances are destroyed too early. It is recommended to make sure the torch.nn.Module instances exist after `with depyf.prepare_debug`.", UserWarning, "", 0) + full_src = dump_src(code, module) + filepath_template = os.path.join(dump_src_dir, f"full_code_for_{code.co_name}_%s.py") + full_code_path = write_code_to_file_template(full_src, filepath_template) + + for file in os.listdir(dump_src_dir): + name = file.split(os.path.sep)[-1] + # remove *.lock file and possibly fx_graph_code* file + if (clean_wild_fx_code and name.startswith("fx_graph_code")) or name.endswith(".lock"): + try: + # multiple processes may try to remove the same file. + os.remove(os.path.join(dump_src_dir, file)) + except OSError: + pass + + data["is_inside_prepare_debug"] = False + +@contextlib.contextmanager +def debug(): + """ + A context manager to debug the compiled code. Essentially, it sets a breakpoint to pause the program and allows you to check the full source code in files with prefix ``full_code_for_`` in the ``dump_src_dir`` argument of :func:`depyf.prepare_debug`, and set breakpoints in their separate ``__transformed_code_`` files according to the function name. Then continue your debugging. + """ + from .global_variables import data + if data["is_inside_prepare_debug"]: + raise RuntimeError("You cannot use `depyf.debug` inside `depyf.prepare_debug`.") + dump_src_dir = data["dump_src_dir"] + import torch + # after https://github.com/pytorch/pytorch/pull/131258 + # torch._dynamo.eval_frame.set_eval_frame is not available in the module + # we need to directly access it from the `_C` extension. + callback = torch._C._dynamo.eval_frame.set_eval_frame(False) + # sometimes pytorch use Interpreter to run node by node. This cannot be debugged. + # we patch this function to run the graph function directly. + with patch(torch.fx.Interpreter.boxed_run, "__code__", patched_boxed_run.__code__): + try: + msg = f"`depyf` places a breakpoint here to pause the program. You can check the full source code in files with prefix `full_code_for_` in {dump_src_dir} first, and set breakpoints in their separate files according to the function name. Then continue your debugging." + print(msg) + breakpoint() + yield + finally: + torch._C._dynamo.eval_frame.set_eval_frame(callback) diff --git a/venv/lib/python3.10/site-packages/depyf/explain/enhance_logging.py b/venv/lib/python3.10/site-packages/depyf/explain/enhance_logging.py new file mode 100644 index 0000000000000000000000000000000000000000..2ad42c0613e62fc21ece1cf39bee120293683b78 --- /dev/null +++ b/venv/lib/python3.10/site-packages/depyf/explain/enhance_logging.py @@ -0,0 +1,94 @@ +import types +from depyf.decompiler import decompile, DecompilationError + + +def pytorch_bytecode_src_hook(code: types.CodeType, new_code: types.CodeType): + import torch + bytecode_log = torch._logging.getArtifactLogger( + "torch._dynamo.convert_frame", "bytecode" + ) + import logging + + if bytecode_log.isEnabledFor(logging.DEBUG): + try: + decompiled_src = decompile(new_code) + bytecode_log.debug("possible source code:") + bytecode_log.debug(decompiled_src) + except DecompilationError as e: + bytecode_log.debug("Decompilation fails due to: %s", str(e)) + finally: + bytecode_log.debug( + "If you find the decompiled code is wrong," + "please submit an issue at " + "https://github.com/thuml/depyf/issues." + ) + + +_handle = None + + +def install(): + """ + Install the bytecode hook for PyTorch, integrate into PyTorch's logging system. + + Example: + + .. code-block:: python + + import torch + import depyf + depyf.install() + # anything with torch.compile + @torch.compile + def f(a, b): + return a + b + f(torch.tensor(1), torch.tensor(2)) + + Turn on bytecode log by ``export TORCH_LOGS="+bytecode"``, and execute the script. + We will see the decompiled source code in the log: + + .. code-block:: text + + ORIGINAL BYTECODE f test.py line 5 + 7 0 LOAD_FAST 0 (a) + 2 LOAD_FAST 1 (b) + 4 BINARY_ADD + 6 RETURN_VALUE + + + MODIFIED BYTECODE f test.py line 5 + 5 0 LOAD_GLOBAL 0 (__compiled_fn_1) + 2 LOAD_FAST 0 (a) + 4 LOAD_FAST 1 (b) + 6 CALL_FUNCTION 2 + 8 UNPACK_SEQUENCE 1 + 10 RETURN_VALUE + + + possible source code: + def f(a, b): + __temp_2, = __compiled_fn_1(a, b) + return __temp_2 + + If you find the decompiled code is wrong,please submit an issue at https://github.com/thuml/depyf/issues. + + To uninstall the hook, use :func:`depyf.uninstall()`. + """ + import torch + global _handle + if _handle is not None: + return + _handle = torch._dynamo.convert_frame.register_bytecode_hook( + pytorch_bytecode_src_hook) + + +def uninstall(): + """ + Uninstall the bytecode hook for PyTorch. + Should be called after :func:`depyf.install()`. + """ + global _handle + if _handle is None: + return + _handle.remove() + _handle = None diff --git a/venv/lib/python3.10/site-packages/depyf/explain/global_variables.py b/venv/lib/python3.10/site-packages/depyf/explain/global_variables.py new file mode 100644 index 0000000000000000000000000000000000000000..884186c084d525c76914bf22b21c199a3db5ef2c --- /dev/null +++ b/venv/lib/python3.10/site-packages/depyf/explain/global_variables.py @@ -0,0 +1,14 @@ +import os + +import torch + +from torch._inductor.codecache import PyCodeCache + +data = { + "dump_src_dir": os.path.join(os.path.dirname(__file__), "dumped_src"), + "unpatched__exec_with_source": torch.fx.graph_module._exec_with_source, + "unpatched_load_by_key_path": PyCodeCache.load_by_key_path, + "unpatched___call__": torch._dynamo.eval_frame.OptimizeContext.__call__, + "optimized_functions": set(), + "is_inside_prepare_debug": False, +} diff --git a/venv/lib/python3.10/site-packages/depyf/explain/patched___call__.py b/venv/lib/python3.10/site-packages/depyf/explain/patched___call__.py new file mode 100644 index 0000000000000000000000000000000000000000..a5d033c774f8d8cb18e177ef07d4f965d097aa28 --- /dev/null +++ b/venv/lib/python3.10/site-packages/depyf/explain/patched___call__.py @@ -0,0 +1,9 @@ +def patched___call__(self, code, check_fn): + from depyf.explain.global_variables import data + from depyf.utils import get_code_owner + import torch + unpatched___call__ = data["unpatched___call__"] + optimized_functions = data["optimized_functions"] + optimized_functions.add(code) + + return unpatched___call__(self, code, check_fn) \ No newline at end of file diff --git a/venv/lib/python3.10/site-packages/depyf/explain/patched__exec_with_source.py b/venv/lib/python3.10/site-packages/depyf/explain/patched__exec_with_source.py new file mode 100644 index 0000000000000000000000000000000000000000..7982f802e4326db8345ccf25969d5b584afd8f1d --- /dev/null +++ b/venv/lib/python3.10/site-packages/depyf/explain/patched__exec_with_source.py @@ -0,0 +1,20 @@ +def patched__exec_with_source(src: str, globals, co_fields=None): + from depyf.explain.global_variables import data + from depyf.explain.utils import write_code_to_file_template + dump_src_dir = data["dump_src_dir"] + unpatched__exec_with_source = data["unpatched__exec_with_source"] + unpatched__exec_with_source(src, globals, co_fields) + import inspect + key = inspect.getsourcefile(globals["forward"]) + import hashlib + import os + hash_value = hashlib.md5(src.encode()).hexdigest() + src = "# " + key + src + filename = write_code_to_file_template( + src, + f"{dump_src_dir}/fx_graph_code_" + + hash_value + + "_" + + "%s" + + ".py") + exec(compile(src, filename, "exec"), globals) diff --git a/venv/lib/python3.10/site-packages/depyf/explain/patched_boxed_run.py b/venv/lib/python3.10/site-packages/depyf/explain/patched_boxed_run.py new file mode 100644 index 0000000000000000000000000000000000000000..0fcbafe4ffdc132d40d1a8aca4bd246ba5bac412 --- /dev/null +++ b/venv/lib/python3.10/site-packages/depyf/explain/patched_boxed_run.py @@ -0,0 +1,2 @@ +def patched_boxed_run(self, args_list): + return self.module.forward(*args_list) diff --git a/venv/lib/python3.10/site-packages/depyf/optimization.py b/venv/lib/python3.10/site-packages/depyf/optimization.py new file mode 100644 index 0000000000000000000000000000000000000000..c9bdaf18aeee255439d784ecaf56b5bc688e4293 --- /dev/null +++ b/venv/lib/python3.10/site-packages/depyf/optimization.py @@ -0,0 +1,74 @@ +import os +import sys +from abc import abstractmethod +from contextlib import contextmanager +from types import CodeType +from typing import Callable, List + +import torch + + +class TorchCompileWrapperWithCustomDispatcher: + """ + A wrapper class for torch.compile, with a custom dispatch logic. + Subclasses should: + 1. Implement the forward method + 2. Implement the dispatch logic in the __call__ method + It can use `self.compiled_codes` to access the compiled bytecode, + and `with self.dispatch_to_code(index):` to dispatch to + the compiled code. + 3. Implement the `__init__` method to determine how to call + `torch.compile` over the forward method. + """ + + def __init__(self, compiled_callable: Callable, use_custom_dispatcher: bool = True): + self.compiled_callable = compiled_callable + self.original_code_object = self.__class__.forward.__code__ + self.compiled_codes: List[CodeType] = [] + torch._dynamo.convert_frame.register_bytecode_hook(self.bytecode_hook) + + self.use_custom_dispatcher: bool = use_custom_dispatcher + + def __call__(self, *args, **kwargs): + """Implement the dispatch logic here, beyond the torch.compile level. + NOTE: this function can have additional arguments beyond the forward + method, for directly dispatching to the compiled code. + """ + return self.compiled_callable(*args, **kwargs) + + @abstractmethod + def forward(self, *args, **kwargs): + ... + + def bytecode_hook(self, old_code: CodeType, new_code: CodeType): + """Hook to save the compiled bytecode for direct execution.""" + if old_code is not self.original_code_object: + return + frame = sys._getframe() + while True: + frame = frame.f_back + code_name = frame.f_code.co_name + file_name = frame.f_code.co_filename.split(os.path.sep)[-1] + if code_name == "_compile" and file_name == "convert_frame.py": + break + frame = frame.f_locals["frame"] + assert frame.f_code == old_code + + if frame.f_locals["self"] is not self: + return + + self.compiled_codes.append(new_code) + + @contextmanager + def dispatch_to_code(self, index: int): + """Context manager to dispatch to the compiled code. + Why does this work? Because Dynamo guarantees that the compiled + bytecode has exactly the same arguments, cell variables, and free + variables as the original code. Therefore we can directly switch + the code object in the function and call it. + + See https://dev-discuss.pytorch.org/t/what-is-the-relationship-requirement-among-original-bytecode-transformed-bytecode-and-bytecode-returned-by-hooks-in-dynamo/1693/7 for more details. + """ # noqa + self.__class__.forward.__code__ = self.compiled_codes[index] + yield + self.__class__.forward.__code__ = self.original_code_object diff --git a/venv/lib/python3.10/site-packages/depyf/utils.py b/venv/lib/python3.10/site-packages/depyf/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..92a224f50dc458b7b1ecef7e978a670fd0e2cf07 --- /dev/null +++ b/venv/lib/python3.10/site-packages/depyf/utils.py @@ -0,0 +1,90 @@ +import dis +from typing import List, Tuple, Union, Optional, Callable, Any, Dict, Set +from types import CodeType + + +def get_function_signature(code_obj: CodeType, + overwite_fn_name: Optional[str] = None) -> str: + # Extract all required details from the code object + # Sometimes the code object does not have a name, e.g. when it is a lambda + # function, so we can overwrite it to be a valid name + normal_arg_count = code_obj.co_argcount + code_obj.co_kwonlyargcount + arg_names = code_obj.co_varnames[:normal_arg_count] + arg_names = [ + x if not x.startswith(".") else x.replace( + ".", "comp_arg_") for x in arg_names] + + import inspect + if code_obj.co_flags & inspect.CO_VARARGS: + arg_names.append('*' + code_obj.co_varnames[normal_arg_count]) + normal_arg_count += 1 + if code_obj.co_flags & inspect.CO_VARKEYWORDS: + arg_names.append('**' + code_obj.co_varnames[normal_arg_count]) + normal_arg_count += 1 + args_str = ', '.join(arg_names) + fn_name = overwite_fn_name if overwite_fn_name is not None else code_obj.co_name + header = f"def {fn_name}({args_str}):\n" + return header + + +def collect_all_code_objects(code: CodeType) -> List[CodeType]: + code_objects = [code] + for const in code.co_consts: + if isinstance(const, type(code)): + code_objects.extend(collect_all_code_objects(const)) + return code_objects + + +def safe_create_directory(path): + # allow multiple processes to create the same directory + import os + try: + os.makedirs(path, exist_ok=True) + except OSError as e: + if not os.path.isdir(path): + raise + + + +def get_code_owner(fn): + """A callable object `fn` might have a __code__ attribute, which is a code object. + However, `fn` might not be the owner of the code object. Only the code owner can change the code object. + This function returns the owner of the code object. + An example: + class A: + def func(self): + return 1 + a = A() + `a.func.__code__` is read-only. `A.func.__code__` is writable. + We can change the code object via `a.func.__func__.__code__`. + """ + import functools + while True: + if hasattr(fn, "__func__"): + # deal with bounded function + fn = fn.__func__ + elif hasattr(fn, "__wrapped__"): + # deal with lru_cache or other decorators + fn = fn.__wrapped__ + elif isinstance(fn, functools.partial): + # deal with partial function + fn = fn.func + elif hasattr(fn, "__call__") and hasattr(fn.__call__, "__func__"): + # deal with callable object + fn = fn.__call__.__func__ + else: + break + return fn + + + +def decompile_ensure(fn: CodeType, overwite_fn_name=None): + import depyf + from depyf.decompiler import DecompilationError + try: + decompiled_source_code = depyf.Decompiler( + fn).decompile(overwite_fn_name=overwite_fn_name) + except DecompilationError as e: + header = get_function_signature(fn, overwite_fn_name=overwite_fn_name) + decompiled_source_code = header + " 'Failed to decompile.'\n" + return decompiled_source_code diff --git a/venv/lib/python3.10/site-packages/dill-0.3.8.dist-info/INSTALLER b/venv/lib/python3.10/site-packages/dill-0.3.8.dist-info/INSTALLER new file mode 100644 index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68 --- /dev/null +++ b/venv/lib/python3.10/site-packages/dill-0.3.8.dist-info/INSTALLER @@ -0,0 +1 @@ +pip diff --git a/venv/lib/python3.10/site-packages/dill-0.3.8.dist-info/LICENSE b/venv/lib/python3.10/site-packages/dill-0.3.8.dist-info/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..1eb999e0babe28897c4544d034b36f5f0fe77ca6 --- /dev/null +++ b/venv/lib/python3.10/site-packages/dill-0.3.8.dist-info/LICENSE @@ -0,0 +1,35 @@ +Copyright (c) 2004-2016 California Institute of Technology. +Copyright (c) 2016-2024 The Uncertainty Quantification Foundation. +All rights reserved. + +This software is available subject to the conditions and terms laid +out below. By downloading and using this software you are agreeing +to the following conditions. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: + + - Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + - Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + + - Neither the names of the copyright holders nor the names of any of + the contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED +TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR +CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; +OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, +WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR +OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF +ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + diff --git a/venv/lib/python3.10/site-packages/dill-0.3.8.dist-info/METADATA b/venv/lib/python3.10/site-packages/dill-0.3.8.dist-info/METADATA new file mode 100644 index 0000000000000000000000000000000000000000..79509850401450817ad338cd856c35cf78c2b3e4 --- /dev/null +++ b/venv/lib/python3.10/site-packages/dill-0.3.8.dist-info/METADATA @@ -0,0 +1,280 @@ +Metadata-Version: 2.1 +Name: dill +Version: 0.3.8 +Summary: serialize all of Python +Home-page: https://github.com/uqfoundation/dill +Author: Mike McKerns +Author-email: mmckerns@uqfoundation.org +Maintainer: Mike McKerns +Maintainer-email: mmckerns@uqfoundation.org +License: BSD-3-Clause +Download-URL: https://pypi.org/project/dill/#files +Project-URL: Documentation, http://dill.rtfd.io +Project-URL: Source Code, https://github.com/uqfoundation/dill +Project-URL: Bug Tracker, https://github.com/uqfoundation/dill/issues +Platform: Linux +Platform: Windows +Platform: Mac +Classifier: Development Status :: 5 - Production/Stable +Classifier: Intended Audience :: Developers +Classifier: Intended Audience :: Science/Research +Classifier: License :: OSI Approved :: BSD License +Classifier: Programming Language :: Python :: 3 +Classifier: Programming Language :: Python :: 3.8 +Classifier: Programming Language :: Python :: 3.9 +Classifier: Programming Language :: Python :: 3.10 +Classifier: Programming Language :: Python :: 3.11 +Classifier: Programming Language :: Python :: 3.12 +Classifier: Programming Language :: Python :: Implementation :: CPython +Classifier: Programming Language :: Python :: Implementation :: PyPy +Classifier: Topic :: Scientific/Engineering +Classifier: Topic :: Software Development +Requires-Python: >=3.8 +Provides-Extra: graph +Requires-Dist: objgraph (>=1.7.2) ; extra == 'graph' +Provides-Extra: profile +Requires-Dist: gprof2dot (>=2022.7.29) ; extra == 'profile' +Provides-Extra: readline + +----------------------------- +dill: serialize all of Python +----------------------------- + +About Dill +========== + +``dill`` extends Python's ``pickle`` module for serializing and de-serializing +Python objects to the majority of the built-in Python types. Serialization +is the process of converting an object to a byte stream, and the inverse +of which is converting a byte stream back to a Python object hierarchy. + +``dill`` provides the user the same interface as the ``pickle`` module, and +also includes some additional features. In addition to pickling Python +objects, ``dill`` provides the ability to save the state of an interpreter +session in a single command. Hence, it would be feasible to save an +interpreter session, close the interpreter, ship the pickled file to +another computer, open a new interpreter, unpickle the session and +thus continue from the 'saved' state of the original interpreter +session. + +``dill`` can be used to store Python objects to a file, but the primary +usage is to send Python objects across the network as a byte stream. +``dill`` is quite flexible, and allows arbitrary user defined classes +and functions to be serialized. Thus ``dill`` is not intended to be +secure against erroneously or maliciously constructed data. It is +left to the user to decide whether the data they unpickle is from +a trustworthy source. + +``dill`` is part of ``pathos``, a Python framework for heterogeneous computing. +``dill`` is in active development, so any user feedback, bug reports, comments, +or suggestions are highly appreciated. A list of issues is located at +https://github.com/uqfoundation/dill/issues, with a legacy list maintained at +https://uqfoundation.github.io/project/pathos/query. + + +Major Features +============== + +``dill`` can pickle the following standard types: + + - none, type, bool, int, float, complex, bytes, str, + - tuple, list, dict, file, buffer, builtin, + - Python classes, namedtuples, dataclasses, metaclasses, + - instances of classes, + - set, frozenset, array, functions, exceptions + +``dill`` can also pickle more 'exotic' standard types: + + - functions with yields, nested functions, lambdas, + - cell, method, unboundmethod, module, code, methodwrapper, + - methoddescriptor, getsetdescriptor, memberdescriptor, wrapperdescriptor, + - dictproxy, slice, notimplemented, ellipsis, quit + +``dill`` cannot yet pickle these standard types: + + - frame, generator, traceback + +``dill`` also provides the capability to: + + - save and load Python interpreter sessions + - save and extract the source code from functions and classes + - interactively diagnose pickling errors + + +Current Release +=============== + +The latest released version of ``dill`` is available from: + + https://pypi.org/project/dill + +``dill`` is distributed under a 3-clause BSD license. + + +Development Version +=================== + +You can get the latest development version with all the shiny new features at: + + https://github.com/uqfoundation + +If you have a new contribution, please submit a pull request. + + +Installation +============ + +``dill`` can be installed with ``pip``:: + + $ pip install dill + +To optionally include the ``objgraph`` diagnostic tool in the install:: + + $ pip install dill[graph] + +To optionally include the ``gprof2dot`` diagnostic tool in the install:: + + $ pip install dill[profile] + +For windows users, to optionally install session history tools:: + + $ pip install dill[readline] + + +Requirements +============ + +``dill`` requires: + + - ``python`` (or ``pypy``), **>=3.8** + - ``setuptools``, **>=42** + +Optional requirements: + + - ``objgraph``, **>=1.7.2** + - ``gprof2dot``, **>=2022.7.29** + - ``pyreadline``, **>=1.7.1** (on windows) + + +Basic Usage +=========== + +``dill`` is a drop-in replacement for ``pickle``. Existing code can be +updated to allow complete pickling using:: + + >>> import dill as pickle + +or:: + + >>> from dill import dumps, loads + +``dumps`` converts the object to a unique byte string, and ``loads`` performs +the inverse operation:: + + >>> squared = lambda x: x**2 + >>> loads(dumps(squared))(3) + 9 + +There are a number of options to control serialization which are provided +as keyword arguments to several ``dill`` functions: + +* with *protocol*, the pickle protocol level can be set. This uses the + same value as the ``pickle`` module, *DEFAULT_PROTOCOL*. +* with *byref=True*, ``dill`` to behave a lot more like pickle with + certain objects (like modules) pickled by reference as opposed to + attempting to pickle the object itself. +* with *recurse=True*, objects referred to in the global dictionary are + recursively traced and pickled, instead of the default behavior of + attempting to store the entire global dictionary. +* with *fmode*, the contents of the file can be pickled along with the file + handle, which is useful if the object is being sent over the wire to a + remote system which does not have the original file on disk. Options are + *HANDLE_FMODE* for just the handle, *CONTENTS_FMODE* for the file content + and *FILE_FMODE* for content and handle. +* with *ignore=False*, objects reconstructed with types defined in the + top-level script environment use the existing type in the environment + rather than a possibly different reconstructed type. + +The default serialization can also be set globally in *dill.settings*. +Thus, we can modify how ``dill`` handles references to the global dictionary +locally or globally:: + + >>> import dill.settings + >>> dumps(absolute) == dumps(absolute, recurse=True) + False + >>> dill.settings['recurse'] = True + >>> dumps(absolute) == dumps(absolute, recurse=True) + True + +``dill`` also includes source code inspection, as an alternate to pickling:: + + >>> import dill.source + >>> print(dill.source.getsource(squared)) + squared = lambda x:x**2 + +To aid in debugging pickling issues, use *dill.detect* which provides +tools like pickle tracing:: + + >>> import dill.detect + >>> with dill.detect.trace(): + >>> dumps(squared) + ┬ F1: at 0x7fe074f8c280> + ├┬ F2: + │└ # F2 [34 B] + ├┬ Co: at 0x7fe07501eb30, file "", line 1> + │├┬ F2: + ││└ # F2 [19 B] + │└ # Co [87 B] + ├┬ D1: + │└ # D1 [22 B] + ├┬ D2: + │└ # D2 [2 B] + ├┬ D2: + │├┬ D2: + ││└ # D2 [2 B] + │└ # D2 [23 B] + └ # F1 [180 B] + +With trace, we see how ``dill`` stored the lambda (``F1``) by first storing +``_create_function``, the underlying code object (``Co``) and ``_create_code`` +(which is used to handle code objects), then we handle the reference to +the global dict (``D2``) plus other dictionaries (``D1`` and ``D2``) that +save the lambda object's state. A ``#`` marks when the object is actually stored. + + +More Information +================ + +Probably the best way to get started is to look at the documentation at +http://dill.rtfd.io. Also see ``dill.tests`` for a set of scripts that +demonstrate how ``dill`` can serialize different Python objects. You can +run the test suite with ``python -m dill.tests``. The contents of any +pickle file can be examined with ``undill``. As ``dill`` conforms to +the ``pickle`` interface, the examples and documentation found at +http://docs.python.org/library/pickle.html also apply to ``dill`` +if one will ``import dill as pickle``. The source code is also generally +well documented, so further questions may be resolved by inspecting the +code itself. Please feel free to submit a ticket on github, or ask a +question on stackoverflow (**@Mike McKerns**). +If you would like to share how you use ``dill`` in your work, please send +an email (to **mmckerns at uqfoundation dot org**). + + +Citation +======== + +If you use ``dill`` to do research that leads to publication, we ask that you +acknowledge use of ``dill`` by citing the following in your publication:: + + M.M. McKerns, L. Strand, T. Sullivan, A. Fang, M.A.G. Aivazis, + "Building a framework for predictive science", Proceedings of + the 10th Python in Science Conference, 2011; + http://arxiv.org/pdf/1202.1056 + + Michael McKerns and Michael Aivazis, + "pathos: a framework for heterogeneous computing", 2010- ; + https://uqfoundation.github.io/project/pathos + +Please see https://uqfoundation.github.io/project/pathos or +http://arxiv.org/pdf/1202.1056 for further information. + diff --git a/venv/lib/python3.10/site-packages/dill-0.3.8.dist-info/RECORD b/venv/lib/python3.10/site-packages/dill-0.3.8.dist-info/RECORD new file mode 100644 index 0000000000000000000000000000000000000000..de485563f6ac5b194a2d66df5e1b64e08e9953b9 --- /dev/null +++ b/venv/lib/python3.10/site-packages/dill-0.3.8.dist-info/RECORD @@ -0,0 +1,97 @@ +../../../bin/get_gprof,sha256=rzqgCSE1DnGG_RiegbWDEBJRDABJPjZN7McV3O9asUs,2554 +../../../bin/get_objgraph,sha256=M9zHZ1THx5CLU_o4UBDJO5DcI9C5t_FYlNOpGcPy5TU,1748 +../../../bin/undill,sha256=oXudWBaH_nmglJvk_ZDK7KgatpCtU8ndOusWXjLwipY,684 +dill-0.3.8.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +dill-0.3.8.dist-info/LICENSE,sha256=UeiKI-eId86r1yfCGcel4z9l2pugOsT9KFupBKoc4is,1790 +dill-0.3.8.dist-info/METADATA,sha256=UxkSs2cU8JyrJsV5kS0QR9crJ07hrUJS2RiIMQaC4ss,10106 +dill-0.3.8.dist-info/RECORD,, +dill-0.3.8.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92 +dill-0.3.8.dist-info/top_level.txt,sha256=HLSIyYIjQzJiBvs3_-16ntezE3j6mWGTW0DT1xDd7X0,5 +dill/__diff.py,sha256=kirMxzB7E8lfjo21M5oIf7if95ny0aWhYB790KMpN08,7143 +dill/__info__.py,sha256=Kmel_yLTyH-hwNC5cVfzN-LV08AbS_AvSa2uwMeIQdk,10756 +dill/__init__.py,sha256=j-Jxl3H6bxatS0h2f8ywWs7DChwk7B9ozuZQBVcjYGU,3798 +dill/__pycache__/__diff.cpython-310.pyc,, +dill/__pycache__/__info__.cpython-310.pyc,, +dill/__pycache__/__init__.cpython-310.pyc,, +dill/__pycache__/_dill.cpython-310.pyc,, +dill/__pycache__/_objects.cpython-310.pyc,, +dill/__pycache__/_shims.cpython-310.pyc,, +dill/__pycache__/detect.cpython-310.pyc,, +dill/__pycache__/logger.cpython-310.pyc,, +dill/__pycache__/objtypes.cpython-310.pyc,, +dill/__pycache__/pointers.cpython-310.pyc,, +dill/__pycache__/session.cpython-310.pyc,, +dill/__pycache__/settings.cpython-310.pyc,, +dill/__pycache__/source.cpython-310.pyc,, +dill/__pycache__/temp.cpython-310.pyc,, +dill/_dill.py,sha256=3Eo6gKj1sODJjgPgYNT8TU-YL6QNQ7rIeWPUVnRzyqQ,88548 +dill/_objects.py,sha256=dPlUXzQIh8CA0fMy9NMbwwLGUPmXe5H8MdQtRWB1b_M,19605 +dill/_shims.py,sha256=IuzQcyPET5VWmWMoSGStieoedvNXlb5suDpa4bykTbQ,6635 +dill/detect.py,sha256=Mb-PfCxn1mg0l3TmHXyPNVEc4n3fuxc_nue6eL3-q_o,11114 +dill/logger.py,sha256=YS5ZloAOKjJRZaOBRCaMUDWmWVQZcicvbXVSrz8L8XU,11134 +dill/objtypes.py,sha256=BamGH3BEM6lLlxisuvXcGjsCRLNeoLs4_rFZrM5r2yM,736 +dill/pointers.py,sha256=vnQzjwGtKMGnmbdYRXRWNLMyceNPSw4f7UpvwCXLYbE,4467 +dill/session.py,sha256=NvCWpoP9r_rGBL2pOwwxOri8mFly5KlIWG3GwkBFnc0,23525 +dill/settings.py,sha256=7I3yvSpPKstOqpoW2gv3X77kXK-hZlqCnF7nJUGhxTY,630 +dill/source.py,sha256=DWfIxcBjpjbbKYz2DstV9kRdjajBdZLOcLXfsZsPo9U,45121 +dill/temp.py,sha256=KJUry4t0UjQCh5t4LXcxNyMF_uOGHwcjTuNYTJD9qdA,8027 +dill/tests/__init__.py,sha256=Gx-chVB-l-e7ncsGp2zF4BimTjbUyO7BY7RkrO835vY,479 +dill/tests/__main__.py,sha256=fHhioQwcOvTPlf1RM_wVQ0Y3ndETWJOuXJQ2rVtqliA,899 +dill/tests/__pycache__/__init__.cpython-310.pyc,, +dill/tests/__pycache__/__main__.cpython-310.pyc,, +dill/tests/__pycache__/test_abc.cpython-310.pyc,, +dill/tests/__pycache__/test_check.cpython-310.pyc,, +dill/tests/__pycache__/test_classdef.cpython-310.pyc,, +dill/tests/__pycache__/test_dataclasses.cpython-310.pyc,, +dill/tests/__pycache__/test_detect.cpython-310.pyc,, +dill/tests/__pycache__/test_dictviews.cpython-310.pyc,, +dill/tests/__pycache__/test_diff.cpython-310.pyc,, +dill/tests/__pycache__/test_extendpickle.cpython-310.pyc,, +dill/tests/__pycache__/test_fglobals.cpython-310.pyc,, +dill/tests/__pycache__/test_file.cpython-310.pyc,, +dill/tests/__pycache__/test_functions.cpython-310.pyc,, +dill/tests/__pycache__/test_functors.cpython-310.pyc,, +dill/tests/__pycache__/test_logger.cpython-310.pyc,, +dill/tests/__pycache__/test_mixins.cpython-310.pyc,, +dill/tests/__pycache__/test_module.cpython-310.pyc,, +dill/tests/__pycache__/test_moduledict.cpython-310.pyc,, +dill/tests/__pycache__/test_nested.cpython-310.pyc,, +dill/tests/__pycache__/test_objects.cpython-310.pyc,, +dill/tests/__pycache__/test_properties.cpython-310.pyc,, +dill/tests/__pycache__/test_pycapsule.cpython-310.pyc,, +dill/tests/__pycache__/test_recursive.cpython-310.pyc,, +dill/tests/__pycache__/test_registered.cpython-310.pyc,, +dill/tests/__pycache__/test_restricted.cpython-310.pyc,, +dill/tests/__pycache__/test_selected.cpython-310.pyc,, +dill/tests/__pycache__/test_session.cpython-310.pyc,, +dill/tests/__pycache__/test_source.cpython-310.pyc,, +dill/tests/__pycache__/test_temp.cpython-310.pyc,, +dill/tests/__pycache__/test_weakref.cpython-310.pyc,, +dill/tests/test_abc.py,sha256=BSjSKKCQ5_iPfFxAd0yBq4KSAJxelrlC3IzoAhjd1C4,4227 +dill/tests/test_check.py,sha256=4F5gkX6zxY7C5sD2_0Tkqf3T3jmQl0K15FOxYUTZQl0,1396 +dill/tests/test_classdef.py,sha256=fI3fVk4SlsjNMMs5RfU6DUCaxpP7YYRjvLZ2nhXMHuc,8600 +dill/tests/test_dataclasses.py,sha256=yKjFuG24ymLtjk-sZZdhvNY7aDqerTDpMcfi_eV4ft0,890 +dill/tests/test_detect.py,sha256=sE9THufHXCDysBPQ4QkN5DHn6DaIldVRAEciseIRH08,4083 +dill/tests/test_dictviews.py,sha256=Jhol0cQWPwoQrp7OPxGhU8FNRX2GgfFp9fTahCvQEPA,1337 +dill/tests/test_diff.py,sha256=5VIWf2fpV6auLHNfzkHLTrgx6AJBlE2xe5Wanfmq8TM,2667 +dill/tests/test_extendpickle.py,sha256=gONrMBHO94Edhnqm1wo49hgzwmaxHs7L-86Hs-7albY,1315 +dill/tests/test_fglobals.py,sha256=DCvdojmKcLN_X9vX4Qe1FbsqjeoJK-wsY2uJwBfNFro,1676 +dill/tests/test_file.py,sha256=jUU2h8qaDOIe1mn_Ng7wqCZcd7Ucx3TAaI-K_90_Tbk,13578 +dill/tests/test_functions.py,sha256=-mqTpUbzRu8GynjBGD25dRDm8qInIe07sRZmCcA_iXY,4267 +dill/tests/test_functors.py,sha256=7rx9wLmrgFwF0gUm_-SGOISPYSok0XjmrQ-jFMRt6gs,930 +dill/tests/test_logger.py,sha256=D9zGRaA-CEadG13orPS_D4gPVZlkqXf9Zu8wn2oMiYc,2385 +dill/tests/test_mixins.py,sha256=YtB24BjodooLj85ijFbAxiM7LlFQZAUL8RQVx9vIAwY,4007 +dill/tests/test_module.py,sha256=KLl_gZJJqDY7S_bD5wCqKL8JQCS0MDMoipVQSDfASlo,1943 +dill/tests/test_moduledict.py,sha256=faXG6-5AcmCfP3xe2FYGOUdSosU-9TWnKU_ZVqPDaxY,1182 +dill/tests/test_nested.py,sha256=ViWiOrChLZktS0z6qyKqMxDdTuy9kAX4qMgH_OreMcc,3146 +dill/tests/test_objects.py,sha256=pPAth0toC_UWztuKHC7NZlsRBb0g_gSAt70UbUtXEXo,1931 +dill/tests/test_properties.py,sha256=h35c-lYir1JG6oLPtrA0eYE0xoSohIimsA3yIfRw6yA,1346 +dill/tests/test_pycapsule.py,sha256=EXFyB6g1Wx9O9LM6StIeUKhrhln4_hou1xrtGwkt4Cw,1417 +dill/tests/test_recursive.py,sha256=bfr-BsK1Xu0PU7l2srHsDXdY2l1LeM3L3w7NraXO0cc,4182 +dill/tests/test_registered.py,sha256=J3oku053VfdJgYh4Z5_kyFRf-C52JglIzjcyxEaYOhk,1573 +dill/tests/test_restricted.py,sha256=xLMIae8sYJksAj9hKKyHFHIL8vtbGpFeOULz59snYM4,783 +dill/tests/test_selected.py,sha256=Hp-AAd6Qp5FJZ-vY_Bbejo5Rg6xFstec5QkSg5D7Aac,3218 +dill/tests/test_session.py,sha256=KoSPvs4c4VJ8mFMF7EUlD_3GwcOhhipt9fqHr--Go-4,10161 +dill/tests/test_source.py,sha256=wZTYBbpzUwj3Mz5OjrHQKfskaVVwuy2UQDg5p2wLbT4,6036 +dill/tests/test_temp.py,sha256=F_7nJkSetLIBSAYMw1-hYh03iVrEYwGs-4GIUzoBOfY,2619 +dill/tests/test_weakref.py,sha256=mrjZP5aPtUP1wBD6ibPsDsfI9ffmq_Ykt7ltoodi5Lg,1602 diff --git a/venv/lib/python3.10/site-packages/dill-0.3.8.dist-info/WHEEL b/venv/lib/python3.10/site-packages/dill-0.3.8.dist-info/WHEEL new file mode 100644 index 0000000000000000000000000000000000000000..becc9a66ea739ba941d48a749e248761cc6e658a --- /dev/null +++ b/venv/lib/python3.10/site-packages/dill-0.3.8.dist-info/WHEEL @@ -0,0 +1,5 @@ +Wheel-Version: 1.0 +Generator: bdist_wheel (0.37.1) +Root-Is-Purelib: true +Tag: py3-none-any + diff --git a/venv/lib/python3.10/site-packages/dill-0.3.8.dist-info/top_level.txt b/venv/lib/python3.10/site-packages/dill-0.3.8.dist-info/top_level.txt new file mode 100644 index 0000000000000000000000000000000000000000..85eea7018a40c657c08ef73fcf3a39024b2df2cb --- /dev/null +++ b/venv/lib/python3.10/site-packages/dill-0.3.8.dist-info/top_level.txt @@ -0,0 +1 @@ +dill diff --git a/venv/lib/python3.10/site-packages/dtlib-0.0.0.dev2.dist-info/INSTALLER b/venv/lib/python3.10/site-packages/dtlib-0.0.0.dev2.dist-info/INSTALLER new file mode 100644 index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68 --- /dev/null +++ b/venv/lib/python3.10/site-packages/dtlib-0.0.0.dev2.dist-info/INSTALLER @@ -0,0 +1 @@ +pip diff --git a/venv/lib/python3.10/site-packages/dtlib-0.0.0.dev2.dist-info/LICENSE b/venv/lib/python3.10/site-packages/dtlib-0.0.0.dev2.dist-info/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..2531d6b8c95944b443bcf29f2af7bfb5f8e1ac43 --- /dev/null +++ b/venv/lib/python3.10/site-packages/dtlib-0.0.0.dev2.dist-info/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2022 Jeffrey Bonde + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/venv/lib/python3.10/site-packages/dtlib-0.0.0.dev2.dist-info/METADATA b/venv/lib/python3.10/site-packages/dtlib-0.0.0.dev2.dist-info/METADATA new file mode 100644 index 0000000000000000000000000000000000000000..5dcba6682b2cf689e2a9848ae6c1dadd44ad7199 --- /dev/null +++ b/venv/lib/python3.10/site-packages/dtlib-0.0.0.dev2.dist-info/METADATA @@ -0,0 +1,33 @@ +Metadata-Version: 2.1 +Name: dtlib +Version: 0.0.0.dev2 +Summary: A small package of basic data structures and algorithms +Author-email: Jeffrey Bonde +License: MIT License + Copyright (c) 2022 Jeffrey Bonde + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + The above copyright notice and this permission notice shall be included in all + copies or substantial portions of the Software. + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + SOFTWARE. +Project-URL: Homepage, https://github.com/bondeje/dtlib +Project-URL: Bug Tracker, https://github.com/bondeje/dtlib/issues +Classifier: Programming Language :: Python :: 3 +Classifier: License :: OSI Approved :: MIT License +Classifier: Operating System :: OS Independent +Requires-Python: >=3.7 +Description-Content-Type: text/markdown +License-File: LICENSE + +# dtlib +A small package of basic data structures and algorithms diff --git a/venv/lib/python3.10/site-packages/dtlib-0.0.0.dev2.dist-info/RECORD b/venv/lib/python3.10/site-packages/dtlib-0.0.0.dev2.dist-info/RECORD new file mode 100644 index 0000000000000000000000000000000000000000..30f02eb654bc54955d6e9a30619d9631209cf2eb --- /dev/null +++ b/venv/lib/python3.10/site-packages/dtlib-0.0.0.dev2.dist-info/RECORD @@ -0,0 +1,58 @@ +dtlib-0.0.0.dev2.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +dtlib-0.0.0.dev2.dist-info/LICENSE,sha256=Q2QU012tyedQCLbyuKf7syWl3YB_Hi9n_ASCedSNKpE,1091 +dtlib-0.0.0.dev2.dist-info/METADATA,sha256=RCgvO5EZJJQBPr-6FNCxRDPeC2u0nYaZrs7qgzcZW9s,1834 +dtlib-0.0.0.dev2.dist-info/RECORD,, +dtlib-0.0.0.dev2.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92 +dtlib-0.0.0.dev2.dist-info/top_level.txt,sha256=SOOj0N2NxEoGn-G93-wfDyU3_RRyP8WH2wbhntOVJ6o,6 +dtlib/__init__.py,sha256=uptOMogw9AYThYxyKCVj6NEm76_mKQjlR5g7iWZ2sGQ,72 +dtlib/__pycache__/__init__.cpython-310.pyc,, +dtlib/__pycache__/utils.cpython-310.pyc,, +dtlib/trees/BinarySearchTree.py,sha256=RUX5PCYcn10E3AWIPg16_K9u9UTmnxAfSe30HhbCoOE,6060 +dtlib/trees/BinaryTree.py,sha256=Ro7ybEcmE0PMouID5HebbN3nWhcbFygJ8FTEgpFkJBw,9484 +dtlib/trees/Heap.py,sha256=M5yeGXmanKimHz2o-h1C0hM2tQQ7GrfRQiyStc4APVM,5246 +dtlib/trees/OrderStatisticTree.py,sha256=F31lSC6m_JwfwIZtv5zpcnZzXgx3bfXeC87-c6aenpI,5721 +dtlib/trees/Tree.py,sha256=xKn0C4vFdigTKabVSpZlZfleSQZGM5cXJIB0jhtCt1c,1545 +dtlib/trees/WeightBalancedTree.py,sha256=wPijDBkDwXrMjz496xR9apbThFFvJIwG6d_qHgR5T8s,5059 +dtlib/trees/_ArrayBinarySearchTree.py,sha256=26uVc-bFCRZ2Xs8-kDrVKh1wz8F6K6R9CMTG9a7YcGA,13182 +dtlib/trees/_ArrayBinaryTree.py,sha256=7y4fxPnSqLfk6EGCWk7fAYU--m8u0kfhxNdtgsn5PUE,33014 +dtlib/trees/_ArrayHeap.py,sha256=4cldu0wRfUXlv2vt9gaoA8tN-EG-vJojtzooWb888t0,92 +dtlib/trees/_ArrayOrderStatisticTree.py,sha256=9iR7yTW0j0S2NjzqA89tCV4ePxE6-qxWVNNvcY-rE8M,14409 +dtlib/trees/_ArrayWeightBalancedTree.py,sha256=O6JDamLInF_VsUgh329uV3I_6exCWePJTpDkrw9mIVI,10549 +dtlib/trees/_LinkedBinarySearchTree.py,sha256=ID9xqHUbdzUP2WQq26K-jUo_asjuorkRYImMzWbBcQw,16671 +dtlib/trees/_LinkedBinaryTree.py,sha256=oqSpkS0BmyOvtaa_3NEgzs0Wo2B_QgklFD2eiPd6eLc,21132 +dtlib/trees/_LinkedHeap.py,sha256=TlsnKOAyc1KVgMFm1RYwY8c1ufEMyHS2b5rZFLxZ9Pg,92 +dtlib/trees/_LinkedOrderStatisticTree.py,sha256=oB6wjvC2pyWFgoOpSss5BKw2NusMeZ73hDDD53xBlb0,14375 +dtlib/trees/_LinkedWeightBalancedTree.py,sha256=RaACYRX3S0F3ob6N44uqe5lH7BLfRC7gN2Nd_liJLcI,10710 +dtlib/trees/_Node.py,sha256=SBqE-8Ou80HmuwQ6Kd33J2FomacO8CFAy3xN4bLJWE8,4763 +dtlib/trees/__init__.py,sha256=dbeDmoBuks-cKn24BtZFfc7-ZPu6F1j4USOc5FRJm1A,342 +dtlib/trees/__pycache__/BinarySearchTree.cpython-310.pyc,, +dtlib/trees/__pycache__/BinaryTree.cpython-310.pyc,, +dtlib/trees/__pycache__/Heap.cpython-310.pyc,, +dtlib/trees/__pycache__/OrderStatisticTree.cpython-310.pyc,, +dtlib/trees/__pycache__/Tree.cpython-310.pyc,, +dtlib/trees/__pycache__/WeightBalancedTree.cpython-310.pyc,, +dtlib/trees/__pycache__/_ArrayBinarySearchTree.cpython-310.pyc,, +dtlib/trees/__pycache__/_ArrayBinaryTree.cpython-310.pyc,, +dtlib/trees/__pycache__/_ArrayHeap.cpython-310.pyc,, +dtlib/trees/__pycache__/_ArrayOrderStatisticTree.cpython-310.pyc,, +dtlib/trees/__pycache__/_ArrayWeightBalancedTree.cpython-310.pyc,, +dtlib/trees/__pycache__/_LinkedBinarySearchTree.cpython-310.pyc,, +dtlib/trees/__pycache__/_LinkedBinaryTree.cpython-310.pyc,, +dtlib/trees/__pycache__/_LinkedHeap.cpython-310.pyc,, +dtlib/trees/__pycache__/_LinkedOrderStatisticTree.cpython-310.pyc,, +dtlib/trees/__pycache__/_LinkedWeightBalancedTree.cpython-310.pyc,, +dtlib/trees/__pycache__/_Node.cpython-310.pyc,, +dtlib/trees/__pycache__/__init__.cpython-310.pyc,, +dtlib/trees/__pycache__/_config.cpython-310.pyc,, +dtlib/trees/__pycache__/_constants.cpython-310.pyc,, +dtlib/trees/__pycache__/utils.cpython-310.pyc,, +dtlib/trees/_config.py,sha256=4B0lc7b_XQ1Coz15q3iJR7AyzCndKsRLqeqo9hWFUEI,257 +dtlib/trees/_constants.py,sha256=uNgnXvJI-gIrg21KIIoyy5MdUXDJOFR_WlozJZ6N0fo,1459 +dtlib/trees/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +dtlib/trees/tests/__pycache__/__init__.cpython-310.pyc,, +dtlib/trees/tests/__pycache__/test_ArrayBinaryTree.cpython-310.pyc,, +dtlib/trees/tests/__pycache__/test_Node.cpython-310.pyc,, +dtlib/trees/tests/test_ArrayBinaryTree.py,sha256=b1oScVK_VCyCDTrvBoTFmCn1wEDjvigUanTx6CWlVmM,18564 +dtlib/trees/tests/test_Node.py,sha256=xgoADq0Ov8EESPESVf86LbdPjaf2PzJcIqxJJ7e8Oxk,1883 +dtlib/trees/utils.py,sha256=xLQ3NdXzkVWnKBRMlU-09Jk34pwtLWOwZtnr379ZsZY,172 +dtlib/utils.py,sha256=1qUNwQrKyhnH6hj96oDn4qJXOCtwk3g8LGDmQExjhgs,592 diff --git a/venv/lib/python3.10/site-packages/dtlib-0.0.0.dev2.dist-info/WHEEL b/venv/lib/python3.10/site-packages/dtlib-0.0.0.dev2.dist-info/WHEEL new file mode 100644 index 0000000000000000000000000000000000000000..becc9a66ea739ba941d48a749e248761cc6e658a --- /dev/null +++ b/venv/lib/python3.10/site-packages/dtlib-0.0.0.dev2.dist-info/WHEEL @@ -0,0 +1,5 @@ +Wheel-Version: 1.0 +Generator: bdist_wheel (0.37.1) +Root-Is-Purelib: true +Tag: py3-none-any + diff --git a/venv/lib/python3.10/site-packages/dtlib-0.0.0.dev2.dist-info/top_level.txt b/venv/lib/python3.10/site-packages/dtlib-0.0.0.dev2.dist-info/top_level.txt new file mode 100644 index 0000000000000000000000000000000000000000..c093bc82aa697f8f07e7cd8fe362136ed67fd4e7 --- /dev/null +++ b/venv/lib/python3.10/site-packages/dtlib-0.0.0.dev2.dist-info/top_level.txt @@ -0,0 +1 @@ +dtlib diff --git a/venv/lib/python3.10/site-packages/filelock/__init__.py b/venv/lib/python3.10/site-packages/filelock/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..c9d8c5b8ebe565a652b3671b3dfa066f7346af45 --- /dev/null +++ b/venv/lib/python3.10/site-packages/filelock/__init__.py @@ -0,0 +1,70 @@ +""" +A platform independent file lock that supports the with-statement. + +.. autodata:: filelock.__version__ + :no-value: + +""" + +from __future__ import annotations + +import sys +import warnings +from typing import TYPE_CHECKING + +from ._api import AcquireReturnProxy, BaseFileLock +from ._error import Timeout +from ._soft import SoftFileLock +from ._unix import UnixFileLock, has_fcntl +from ._windows import WindowsFileLock +from .asyncio import ( + AsyncAcquireReturnProxy, + AsyncSoftFileLock, + AsyncUnixFileLock, + AsyncWindowsFileLock, + BaseAsyncFileLock, +) +from .version import version + +#: version of the project as a string +__version__: str = version + + +if sys.platform == "win32": # pragma: win32 cover + _FileLock: type[BaseFileLock] = WindowsFileLock + _AsyncFileLock: type[BaseAsyncFileLock] = AsyncWindowsFileLock +else: # pragma: win32 no cover # noqa: PLR5501 + if has_fcntl: + _FileLock: type[BaseFileLock] = UnixFileLock + _AsyncFileLock: type[BaseAsyncFileLock] = AsyncUnixFileLock + else: + _FileLock = SoftFileLock + _AsyncFileLock = AsyncSoftFileLock + if warnings is not None: + warnings.warn("only soft file lock is available", stacklevel=2) + +if TYPE_CHECKING: + FileLock = SoftFileLock + AsyncFileLock = AsyncSoftFileLock +else: + #: Alias for the lock, which should be used for the current platform. + FileLock = _FileLock + AsyncFileLock = _AsyncFileLock + + +__all__ = [ + "AcquireReturnProxy", + "AsyncAcquireReturnProxy", + "AsyncFileLock", + "AsyncSoftFileLock", + "AsyncUnixFileLock", + "AsyncWindowsFileLock", + "BaseAsyncFileLock", + "BaseFileLock", + "FileLock", + "SoftFileLock", + "Timeout", + "UnixFileLock", + "WindowsFileLock", + "__version__", +] diff --git a/venv/lib/python3.10/site-packages/filelock/__pycache__/__init__.cpython-310.pyc b/venv/lib/python3.10/site-packages/filelock/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b0ffc3e61b2709e28a165e2f79096c2201d52886 Binary files /dev/null and b/venv/lib/python3.10/site-packages/filelock/__pycache__/__init__.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/filelock/__pycache__/_api.cpython-310.pyc b/venv/lib/python3.10/site-packages/filelock/__pycache__/_api.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f67a2ada4e8c158e72a3496943e11f24b3d6033b Binary files /dev/null and b/venv/lib/python3.10/site-packages/filelock/__pycache__/_api.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/filelock/__pycache__/_error.cpython-310.pyc b/venv/lib/python3.10/site-packages/filelock/__pycache__/_error.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c781930747b0e878bac10baf0e4920961e09214b Binary files /dev/null and b/venv/lib/python3.10/site-packages/filelock/__pycache__/_error.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/filelock/__pycache__/_soft.cpython-310.pyc b/venv/lib/python3.10/site-packages/filelock/__pycache__/_soft.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..927e50a59c364bcd5fe519a96893d743d6c4345f Binary files /dev/null and b/venv/lib/python3.10/site-packages/filelock/__pycache__/_soft.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/filelock/__pycache__/_unix.cpython-310.pyc b/venv/lib/python3.10/site-packages/filelock/__pycache__/_unix.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ef5ea04c81697d13da915555e801fa9297d1d317 Binary files /dev/null and b/venv/lib/python3.10/site-packages/filelock/__pycache__/_unix.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/filelock/__pycache__/_util.cpython-310.pyc b/venv/lib/python3.10/site-packages/filelock/__pycache__/_util.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..09f95223bfd67d1c446f43ffe7f04ee8f790af56 Binary files /dev/null and b/venv/lib/python3.10/site-packages/filelock/__pycache__/_util.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/filelock/__pycache__/_windows.cpython-310.pyc b/venv/lib/python3.10/site-packages/filelock/__pycache__/_windows.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..84c97ddccbb286ad7f8c5e6dade89a5688bcb788 Binary files /dev/null and b/venv/lib/python3.10/site-packages/filelock/__pycache__/_windows.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/filelock/__pycache__/asyncio.cpython-310.pyc b/venv/lib/python3.10/site-packages/filelock/__pycache__/asyncio.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d92ead7bf61f8118cc886da6480002c6c166d97a Binary files /dev/null and b/venv/lib/python3.10/site-packages/filelock/__pycache__/asyncio.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/filelock/__pycache__/version.cpython-310.pyc b/venv/lib/python3.10/site-packages/filelock/__pycache__/version.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..97101dce4f0649907ae455713094bc95737d2f7b Binary files /dev/null and b/venv/lib/python3.10/site-packages/filelock/__pycache__/version.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/filelock/_api.py b/venv/lib/python3.10/site-packages/filelock/_api.py new file mode 100644 index 0000000000000000000000000000000000000000..8fde69a0fef7badcc123d17735cd784a99baed52 --- /dev/null +++ b/venv/lib/python3.10/site-packages/filelock/_api.py @@ -0,0 +1,403 @@ +from __future__ import annotations + +import contextlib +import inspect +import logging +import os +import time +import warnings +from abc import ABCMeta, abstractmethod +from dataclasses import dataclass +from threading import local +from typing import TYPE_CHECKING, Any, cast +from weakref import WeakValueDictionary + +from ._error import Timeout + +if TYPE_CHECKING: + import sys + from types import TracebackType + + if sys.version_info >= (3, 11): # pragma: no cover (py311+) + from typing import Self + else: # pragma: no cover ( None: + self.lock = lock + + def __enter__(self) -> BaseFileLock: + return self.lock + + def __exit__( + self, + exc_type: type[BaseException] | None, + exc_value: BaseException | None, + traceback: TracebackType | None, + ) -> None: + self.lock.release() + + +@dataclass +class FileLockContext: + """A dataclass which holds the context for a ``BaseFileLock`` object.""" + + # The context is held in a separate class to allow optional use of thread local storage via the + # ThreadLocalFileContext class. + + #: The path to the lock file. + lock_file: str + + #: The default timeout value. + timeout: float + + #: The mode for the lock files + mode: int + + #: Whether the lock should be blocking or not + blocking: bool + + #: The file descriptor for the *_lock_file* as it is returned by the os.open() function, not None when lock held + lock_file_fd: int | None = None + + #: The lock counter is used for implementing the nested locking mechanism. + lock_counter: int = 0 # When the lock is acquired is increased and the lock is only released, when this value is 0 + + +class ThreadLocalFileContext(FileLockContext, local): + """A thread local version of the ``FileLockContext`` class.""" + + +class FileLockMeta(ABCMeta): + def __call__( # noqa: PLR0913 + cls, + lock_file: str | os.PathLike[str], + timeout: float = -1, + mode: int = 0o644, + thread_local: bool = True, # noqa: FBT001, FBT002 + *, + blocking: bool = True, + is_singleton: bool = False, + **kwargs: Any, # capture remaining kwargs for subclasses # noqa: ANN401 + ) -> BaseFileLock: + if is_singleton: + instance = cls._instances.get(str(lock_file)) # type: ignore[attr-defined] + if instance: + params_to_check = { + "thread_local": (thread_local, instance.is_thread_local()), + "timeout": (timeout, instance.timeout), + "mode": (mode, instance.mode), + "blocking": (blocking, instance.blocking), + } + + non_matching_params = { + name: (passed_param, set_param) + for name, (passed_param, set_param) in params_to_check.items() + if passed_param != set_param + } + if not non_matching_params: + return cast("BaseFileLock", instance) + + # parameters do not match; raise error + msg = "Singleton lock instances cannot be initialized with differing arguments" + msg += "\nNon-matching arguments: " + for param_name, (passed_param, set_param) in non_matching_params.items(): + msg += f"\n\t{param_name} (existing lock has {set_param} but {passed_param} was passed)" + raise ValueError(msg) + + # Workaround to make `__init__`'s params optional in subclasses + # E.g. virtualenv changes the signature of the `__init__` method in the `BaseFileLock` class descendant + # (https://github.com/tox-dev/filelock/pull/340) + + all_params = { + "timeout": timeout, + "mode": mode, + "thread_local": thread_local, + "blocking": blocking, + "is_singleton": is_singleton, + **kwargs, + } + + present_params = inspect.signature(cls.__init__).parameters # type: ignore[misc] + init_params = {key: value for key, value in all_params.items() if key in present_params} + + instance = super().__call__(lock_file, **init_params) + + if is_singleton: + cls._instances[str(lock_file)] = instance # type: ignore[attr-defined] + + return cast("BaseFileLock", instance) + + +class BaseFileLock(contextlib.ContextDecorator, metaclass=FileLockMeta): + """Abstract base class for a file lock object.""" + + _instances: WeakValueDictionary[str, BaseFileLock] + + def __init_subclass__(cls, **kwargs: dict[str, Any]) -> None: + """Setup unique state for lock subclasses.""" + super().__init_subclass__(**kwargs) + cls._instances = WeakValueDictionary() + + def __init__( # noqa: PLR0913 + self, + lock_file: str | os.PathLike[str], + timeout: float = -1, + mode: int = 0o644, + thread_local: bool = True, # noqa: FBT001, FBT002 + *, + blocking: bool = True, + is_singleton: bool = False, + ) -> None: + """ + Create a new lock object. + + :param lock_file: path to the file + :param timeout: default timeout when acquiring the lock, in seconds. It will be used as fallback value in \ + the acquire method, if no timeout value (``None``) is given. If you want to disable the timeout, set it \ + to a negative value. A timeout of 0 means that there is exactly one attempt to acquire the file lock. + :param mode: file permissions for the lockfile + :param thread_local: Whether this object's internal context should be thread local or not. If this is set to \ + ``False`` then the lock will be reentrant across threads. + :param blocking: whether the lock should be blocking or not + :param is_singleton: If this is set to ``True`` then only one instance of this class will be created \ + per lock file. This is useful if you want to use the lock object for reentrant locking without needing \ + to pass the same object around. + + """ + self._is_thread_local = thread_local + self._is_singleton = is_singleton + + # Create the context. Note that external code should not work with the context directly and should instead use + # properties of this class. + kwargs: dict[str, Any] = { + "lock_file": os.fspath(lock_file), + "timeout": timeout, + "mode": mode, + "blocking": blocking, + } + self._context: FileLockContext = (ThreadLocalFileContext if thread_local else FileLockContext)(**kwargs) + + def is_thread_local(self) -> bool: + """:return: a flag indicating if this lock is thread local or not""" + return self._is_thread_local + + @property + def is_singleton(self) -> bool: + """:return: a flag indicating if this lock is singleton or not""" + return self._is_singleton + + @property + def lock_file(self) -> str: + """:return: path to the lock file""" + return self._context.lock_file + + @property + def timeout(self) -> float: + """ + :return: the default timeout value, in seconds + + .. versionadded:: 2.0.0 + """ + return self._context.timeout + + @timeout.setter + def timeout(self, value: float | str) -> None: + """ + Change the default timeout value. + + :param value: the new value, in seconds + + """ + self._context.timeout = float(value) + + @property + def blocking(self) -> bool: + """:return: whether the locking is blocking or not""" + return self._context.blocking + + @blocking.setter + def blocking(self, value: bool) -> None: + """ + Change the default blocking value. + + :param value: the new value as bool + + """ + self._context.blocking = value + + @property + def mode(self) -> int: + """:return: the file permissions for the lockfile""" + return self._context.mode + + @abstractmethod + def _acquire(self) -> None: + """If the file lock could be acquired, self._context.lock_file_fd holds the file descriptor of the lock file.""" + raise NotImplementedError + + @abstractmethod + def _release(self) -> None: + """Releases the lock and sets self._context.lock_file_fd to None.""" + raise NotImplementedError + + @property + def is_locked(self) -> bool: + """ + + :return: A boolean indicating if the lock file is holding the lock currently. + + .. versionchanged:: 2.0.0 + + This was previously a method and is now a property. + """ + return self._context.lock_file_fd is not None + + @property + def lock_counter(self) -> int: + """:return: The number of times this lock has been acquired (but not yet released).""" + return self._context.lock_counter + + def acquire( + self, + timeout: float | None = None, + poll_interval: float = 0.05, + *, + poll_intervall: float | None = None, + blocking: bool | None = None, + ) -> AcquireReturnProxy: + """ + Try to acquire the file lock. + + :param timeout: maximum wait time for acquiring the lock, ``None`` means use the default :attr:`~timeout` is and + if ``timeout < 0``, there is no timeout and this method will block until the lock could be acquired + :param poll_interval: interval of trying to acquire the lock file + :param poll_intervall: deprecated, kept for backwards compatibility, use ``poll_interval`` instead + :param blocking: defaults to True. If False, function will return immediately if it cannot obtain a lock on the + first attempt. Otherwise, this method will block until the timeout expires or the lock is acquired. + :raises Timeout: if fails to acquire lock within the timeout period + :return: a context object that will unlock the file when the context is exited + + .. code-block:: python + + # You can use this method in the context manager (recommended) + with lock.acquire(): + pass + + # Or use an equivalent try-finally construct: + lock.acquire() + try: + pass + finally: + lock.release() + + .. versionchanged:: 2.0.0 + + This method returns now a *proxy* object instead of *self*, + so that it can be used in a with statement without side effects. + + """ + # Use the default timeout, if no timeout is provided. + if timeout is None: + timeout = self._context.timeout + + if blocking is None: + blocking = self._context.blocking + + if poll_intervall is not None: + msg = "use poll_interval instead of poll_intervall" + warnings.warn(msg, DeprecationWarning, stacklevel=2) + poll_interval = poll_intervall + + # Increment the number right at the beginning. We can still undo it, if something fails. + self._context.lock_counter += 1 + + lock_id = id(self) + lock_filename = self.lock_file + start_time = time.perf_counter() + try: + while True: + if not self.is_locked: + _LOGGER.debug("Attempting to acquire lock %s on %s", lock_id, lock_filename) + self._acquire() + if self.is_locked: + _LOGGER.debug("Lock %s acquired on %s", lock_id, lock_filename) + break + if blocking is False: + _LOGGER.debug("Failed to immediately acquire lock %s on %s", lock_id, lock_filename) + raise Timeout(lock_filename) # noqa: TRY301 + if 0 <= timeout < time.perf_counter() - start_time: + _LOGGER.debug("Timeout on acquiring lock %s on %s", lock_id, lock_filename) + raise Timeout(lock_filename) # noqa: TRY301 + msg = "Lock %s not acquired on %s, waiting %s seconds ..." + _LOGGER.debug(msg, lock_id, lock_filename, poll_interval) + time.sleep(poll_interval) + except BaseException: # Something did go wrong, so decrement the counter. + self._context.lock_counter = max(0, self._context.lock_counter - 1) + raise + return AcquireReturnProxy(lock=self) + + def release(self, force: bool = False) -> None: # noqa: FBT001, FBT002 + """ + Releases the file lock. Please note, that the lock is only completely released, if the lock counter is 0. + Also note, that the lock file itself is not automatically deleted. + + :param force: If true, the lock counter is ignored and the lock is released in every case/ + + """ + if self.is_locked: + self._context.lock_counter -= 1 + + if self._context.lock_counter == 0 or force: + lock_id, lock_filename = id(self), self.lock_file + + _LOGGER.debug("Attempting to release lock %s on %s", lock_id, lock_filename) + self._release() + self._context.lock_counter = 0 + _LOGGER.debug("Lock %s released on %s", lock_id, lock_filename) + + def __enter__(self) -> Self: + """ + Acquire the lock. + + :return: the lock object + + """ + self.acquire() + return self + + def __exit__( + self, + exc_type: type[BaseException] | None, + exc_value: BaseException | None, + traceback: TracebackType | None, + ) -> None: + """ + Release the lock. + + :param exc_type: the exception type if raised + :param exc_value: the exception value if raised + :param traceback: the exception traceback if raised + + """ + self.release() + + def __del__(self) -> None: + """Called when the lock object is deleted.""" + self.release(force=True) + + +__all__ = [ + "AcquireReturnProxy", + "BaseFileLock", +] diff --git a/venv/lib/python3.10/site-packages/filelock/_error.py b/venv/lib/python3.10/site-packages/filelock/_error.py new file mode 100644 index 0000000000000000000000000000000000000000..f7ff08c0f508ad7077eb6ed1990898840c952b3a --- /dev/null +++ b/venv/lib/python3.10/site-packages/filelock/_error.py @@ -0,0 +1,30 @@ +from __future__ import annotations + +from typing import Any + + +class Timeout(TimeoutError): # noqa: N818 + """Raised when the lock could not be acquired in *timeout* seconds.""" + + def __init__(self, lock_file: str) -> None: + super().__init__() + self._lock_file = lock_file + + def __reduce__(self) -> str | tuple[Any, ...]: + return self.__class__, (self._lock_file,) # Properly pickle the exception + + def __str__(self) -> str: + return f"The file lock '{self._lock_file}' could not be acquired." + + def __repr__(self) -> str: + return f"{self.__class__.__name__}({self.lock_file!r})" + + @property + def lock_file(self) -> str: + """:return: The path of the file lock.""" + return self._lock_file + + +__all__ = [ + "Timeout", +] diff --git a/venv/lib/python3.10/site-packages/filelock/_soft.py b/venv/lib/python3.10/site-packages/filelock/_soft.py new file mode 100644 index 0000000000000000000000000000000000000000..28c67f74cc82b8f55e47afd6a71972cc1fb95eb6 --- /dev/null +++ b/venv/lib/python3.10/site-packages/filelock/_soft.py @@ -0,0 +1,47 @@ +from __future__ import annotations + +import os +import sys +from contextlib import suppress +from errno import EACCES, EEXIST +from pathlib import Path + +from ._api import BaseFileLock +from ._util import ensure_directory_exists, raise_on_not_writable_file + + +class SoftFileLock(BaseFileLock): + """Simply watches the existence of the lock file.""" + + def _acquire(self) -> None: + raise_on_not_writable_file(self.lock_file) + ensure_directory_exists(self.lock_file) + # first check for exists and read-only mode as the open will mask this case as EEXIST + flags = ( + os.O_WRONLY # open for writing only + | os.O_CREAT + | os.O_EXCL # together with above raise EEXIST if the file specified by filename exists + | os.O_TRUNC # truncate the file to zero byte + ) + try: + file_handler = os.open(self.lock_file, flags, self._context.mode) + except OSError as exception: # re-raise unless expected exception + if not ( + exception.errno == EEXIST # lock already exist + or (exception.errno == EACCES and sys.platform == "win32") # has no access to this lock + ): # pragma: win32 no cover + raise + else: + self._context.lock_file_fd = file_handler + + def _release(self) -> None: + assert self._context.lock_file_fd is not None # noqa: S101 + os.close(self._context.lock_file_fd) # the lock file is definitely not None + self._context.lock_file_fd = None + with suppress(OSError): # the file is already deleted and that's what we want + Path(self.lock_file).unlink() + + +__all__ = [ + "SoftFileLock", +] diff --git a/venv/lib/python3.10/site-packages/filelock/_unix.py b/venv/lib/python3.10/site-packages/filelock/_unix.py new file mode 100644 index 0000000000000000000000000000000000000000..b2fd0f33d25d2bdf4a2a883380154771b4a25f9b --- /dev/null +++ b/venv/lib/python3.10/site-packages/filelock/_unix.py @@ -0,0 +1,70 @@ +from __future__ import annotations + +import os +import sys +from contextlib import suppress +from errno import ENOSYS +from pathlib import Path +from typing import cast + +from ._api import BaseFileLock +from ._util import ensure_directory_exists + +#: a flag to indicate if the fcntl API is available +has_fcntl = False +if sys.platform == "win32": # pragma: win32 cover + + class UnixFileLock(BaseFileLock): + """Uses the :func:`fcntl.flock` to hard lock the lock file on unix systems.""" + + def _acquire(self) -> None: + raise NotImplementedError + + def _release(self) -> None: + raise NotImplementedError + +else: # pragma: win32 no cover + try: + import fcntl + + _ = (fcntl.flock, fcntl.LOCK_EX, fcntl.LOCK_NB, fcntl.LOCK_UN) + except (ImportError, AttributeError): + pass + else: + has_fcntl = True + + class UnixFileLock(BaseFileLock): + """Uses the :func:`fcntl.flock` to hard lock the lock file on unix systems.""" + + def _acquire(self) -> None: + ensure_directory_exists(self.lock_file) + open_flags = os.O_RDWR | os.O_TRUNC + if not Path(self.lock_file).exists(): + open_flags |= os.O_CREAT + fd = os.open(self.lock_file, open_flags, self._context.mode) + with suppress(PermissionError): # This locked is not owned by this UID + os.fchmod(fd, self._context.mode) + try: + fcntl.flock(fd, fcntl.LOCK_EX | fcntl.LOCK_NB) + except OSError as exception: + os.close(fd) + if exception.errno == ENOSYS: # NotImplemented error + msg = "FileSystem does not appear to support flock; use SoftFileLock instead" + raise NotImplementedError(msg) from exception + else: + self._context.lock_file_fd = fd + + def _release(self) -> None: + # Do not remove the lockfile: + # https://github.com/tox-dev/py-filelock/issues/31 + # https://stackoverflow.com/questions/17708885/flock-removing-locked-file-without-race-condition + fd = cast("int", self._context.lock_file_fd) + self._context.lock_file_fd = None + fcntl.flock(fd, fcntl.LOCK_UN) + os.close(fd) + + +__all__ = [ + "UnixFileLock", + "has_fcntl", +] diff --git a/venv/lib/python3.10/site-packages/filelock/_util.py b/venv/lib/python3.10/site-packages/filelock/_util.py new file mode 100644 index 0000000000000000000000000000000000000000..c671e8533873948f0e1b5575ff952c722019f067 --- /dev/null +++ b/venv/lib/python3.10/site-packages/filelock/_util.py @@ -0,0 +1,52 @@ +from __future__ import annotations + +import os +import stat +import sys +from errno import EACCES, EISDIR +from pathlib import Path + + +def raise_on_not_writable_file(filename: str) -> None: + """ + Raise an exception if attempting to open the file for writing would fail. + + This is done so files that will never be writable can be separated from files that are writable but currently + locked. + + :param filename: file to check + :raises OSError: as if the file was opened for writing. + + """ + try: # use stat to do exists + can write to check without race condition + file_stat = os.stat(filename) # noqa: PTH116 + except OSError: + return # swallow does not exist or other errors + + if file_stat.st_mtime != 0: # if os.stat returns but modification is zero that's an invalid os.stat - ignore it + if not (file_stat.st_mode & stat.S_IWUSR): + raise PermissionError(EACCES, "Permission denied", filename) + + if stat.S_ISDIR(file_stat.st_mode): + if sys.platform == "win32": # pragma: win32 cover + # On Windows, this is PermissionError + raise PermissionError(EACCES, "Permission denied", filename) + else: # pragma: win32 no cover # noqa: RET506 + # On linux / macOS, this is IsADirectoryError + raise IsADirectoryError(EISDIR, "Is a directory", filename) + + +def ensure_directory_exists(filename: Path | str) -> None: + """ + Ensure the directory containing the file exists (create it if necessary). + + :param filename: file. + + """ + Path(filename).parent.mkdir(parents=True, exist_ok=True) + + +__all__ = [ + "ensure_directory_exists", + "raise_on_not_writable_file", +] diff --git a/venv/lib/python3.10/site-packages/filelock/_windows.py b/venv/lib/python3.10/site-packages/filelock/_windows.py new file mode 100644 index 0000000000000000000000000000000000000000..348251d1067c28c55a6a267f8d11337abfae837f --- /dev/null +++ b/venv/lib/python3.10/site-packages/filelock/_windows.py @@ -0,0 +1,65 @@ +from __future__ import annotations + +import os +import sys +from contextlib import suppress +from errno import EACCES +from pathlib import Path +from typing import cast + +from ._api import BaseFileLock +from ._util import ensure_directory_exists, raise_on_not_writable_file + +if sys.platform == "win32": # pragma: win32 cover + import msvcrt + + class WindowsFileLock(BaseFileLock): + """Uses the :func:`msvcrt.locking` function to hard lock the lock file on Windows systems.""" + + def _acquire(self) -> None: + raise_on_not_writable_file(self.lock_file) + ensure_directory_exists(self.lock_file) + flags = ( + os.O_RDWR # open for read and write + | os.O_CREAT # create file if not exists + | os.O_TRUNC # truncate file if not empty + ) + try: + fd = os.open(self.lock_file, flags, self._context.mode) + except OSError as exception: + if exception.errno != EACCES: # has no access to this lock + raise + else: + try: + msvcrt.locking(fd, msvcrt.LK_NBLCK, 1) + except OSError as exception: + os.close(fd) # close file first + if exception.errno != EACCES: # file is already locked + raise + else: + self._context.lock_file_fd = fd + + def _release(self) -> None: + fd = cast("int", self._context.lock_file_fd) + self._context.lock_file_fd = None + msvcrt.locking(fd, msvcrt.LK_UNLCK, 1) + os.close(fd) + + with suppress(OSError): # Probably another instance of the application hat acquired the file lock. + Path(self.lock_file).unlink() + +else: # pragma: win32 no cover + + class WindowsFileLock(BaseFileLock): + """Uses the :func:`msvcrt.locking` function to hard lock the lock file on Windows systems.""" + + def _acquire(self) -> None: + raise NotImplementedError + + def _release(self) -> None: + raise NotImplementedError + + +__all__ = [ + "WindowsFileLock", +] diff --git a/venv/lib/python3.10/site-packages/filelock/asyncio.py b/venv/lib/python3.10/site-packages/filelock/asyncio.py new file mode 100644 index 0000000000000000000000000000000000000000..1c9c9f05bdbc41e13a2c4c3094d43acab8207089 --- /dev/null +++ b/venv/lib/python3.10/site-packages/filelock/asyncio.py @@ -0,0 +1,342 @@ +"""An asyncio-based implementation of the file lock.""" + +from __future__ import annotations + +import asyncio +import contextlib +import logging +import os +import time +from dataclasses import dataclass +from threading import local +from typing import TYPE_CHECKING, Any, Callable, NoReturn, cast + +from ._api import BaseFileLock, FileLockContext, FileLockMeta +from ._error import Timeout +from ._soft import SoftFileLock +from ._unix import UnixFileLock +from ._windows import WindowsFileLock + +if TYPE_CHECKING: + import sys + from concurrent import futures + from types import TracebackType + + if sys.version_info >= (3, 11): # pragma: no cover (py311+) + from typing import Self + else: # pragma: no cover ( None: # noqa: D107 + self.lock = lock + + async def __aenter__(self) -> BaseAsyncFileLock: # noqa: D105 + return self.lock + + async def __aexit__( # noqa: D105 + self, + exc_type: type[BaseException] | None, + exc_value: BaseException | None, + traceback: TracebackType | None, + ) -> None: + await self.lock.release() + + +class AsyncFileLockMeta(FileLockMeta): + def __call__( # type: ignore[override] # noqa: PLR0913 + cls, # noqa: N805 + lock_file: str | os.PathLike[str], + timeout: float = -1, + mode: int = 0o644, + thread_local: bool = False, # noqa: FBT001, FBT002 + *, + blocking: bool = True, + is_singleton: bool = False, + loop: asyncio.AbstractEventLoop | None = None, + run_in_executor: bool = True, + executor: futures.Executor | None = None, + ) -> BaseAsyncFileLock: + if thread_local and run_in_executor: + msg = "run_in_executor is not supported when thread_local is True" + raise ValueError(msg) + instance = super().__call__( + lock_file=lock_file, + timeout=timeout, + mode=mode, + thread_local=thread_local, + blocking=blocking, + is_singleton=is_singleton, + loop=loop, + run_in_executor=run_in_executor, + executor=executor, + ) + return cast("BaseAsyncFileLock", instance) + + +class BaseAsyncFileLock(BaseFileLock, metaclass=AsyncFileLockMeta): + """Base class for asynchronous file locks.""" + + def __init__( # noqa: PLR0913 + self, + lock_file: str | os.PathLike[str], + timeout: float = -1, + mode: int = 0o644, + thread_local: bool = False, # noqa: FBT001, FBT002 + *, + blocking: bool = True, + is_singleton: bool = False, + loop: asyncio.AbstractEventLoop | None = None, + run_in_executor: bool = True, + executor: futures.Executor | None = None, + ) -> None: + """ + Create a new lock object. + + :param lock_file: path to the file + :param timeout: default timeout when acquiring the lock, in seconds. It will be used as fallback value in \ + the acquire method, if no timeout value (``None``) is given. If you want to disable the timeout, set it \ + to a negative value. A timeout of 0 means that there is exactly one attempt to acquire the file lock. + :param mode: file permissions for the lockfile + :param thread_local: Whether this object's internal context should be thread local or not. If this is set to \ + ``False`` then the lock will be reentrant across threads. + :param blocking: whether the lock should be blocking or not + :param is_singleton: If this is set to ``True`` then only one instance of this class will be created \ + per lock file. This is useful if you want to use the lock object for reentrant locking without needing \ + to pass the same object around. + :param loop: The event loop to use. If not specified, the running event loop will be used. + :param run_in_executor: If this is set to ``True`` then the lock will be acquired in an executor. + :param executor: The executor to use. If not specified, the default executor will be used. + + """ + self._is_thread_local = thread_local + self._is_singleton = is_singleton + + # Create the context. Note that external code should not work with the context directly and should instead use + # properties of this class. + kwargs: dict[str, Any] = { + "lock_file": os.fspath(lock_file), + "timeout": timeout, + "mode": mode, + "blocking": blocking, + "loop": loop, + "run_in_executor": run_in_executor, + "executor": executor, + } + self._context: AsyncFileLockContext = (AsyncThreadLocalFileContext if thread_local else AsyncFileLockContext)( + **kwargs + ) + + @property + def run_in_executor(self) -> bool: + """::return: whether run in executor.""" + return self._context.run_in_executor + + @property + def executor(self) -> futures.Executor | None: + """::return: the executor.""" + return self._context.executor + + @executor.setter + def executor(self, value: futures.Executor | None) -> None: # pragma: no cover + """ + Change the executor. + + :param value: the new executor or ``None`` + :type value: futures.Executor | None + + """ + self._context.executor = value + + @property + def loop(self) -> asyncio.AbstractEventLoop | None: + """::return: the event loop.""" + return self._context.loop + + async def acquire( # type: ignore[override] + self, + timeout: float | None = None, + poll_interval: float = 0.05, + *, + blocking: bool | None = None, + ) -> AsyncAcquireReturnProxy: + """ + Try to acquire the file lock. + + :param timeout: maximum wait time for acquiring the lock, ``None`` means use the default + :attr:`~BaseFileLock.timeout` is and if ``timeout < 0``, there is no timeout and + this method will block until the lock could be acquired + :param poll_interval: interval of trying to acquire the lock file + :param blocking: defaults to True. If False, function will return immediately if it cannot obtain a lock on the + first attempt. Otherwise, this method will block until the timeout expires or the lock is acquired. + :raises Timeout: if fails to acquire lock within the timeout period + :return: a context object that will unlock the file when the context is exited + + .. code-block:: python + + # You can use this method in the context manager (recommended) + with lock.acquire(): + pass + + # Or use an equivalent try-finally construct: + lock.acquire() + try: + pass + finally: + lock.release() + + """ + # Use the default timeout, if no timeout is provided. + if timeout is None: + timeout = self._context.timeout + + if blocking is None: + blocking = self._context.blocking + + # Increment the number right at the beginning. We can still undo it, if something fails. + self._context.lock_counter += 1 + + lock_id = id(self) + lock_filename = self.lock_file + start_time = time.perf_counter() + try: + while True: + if not self.is_locked: + _LOGGER.debug("Attempting to acquire lock %s on %s", lock_id, lock_filename) + await self._run_internal_method(self._acquire) + if self.is_locked: + _LOGGER.debug("Lock %s acquired on %s", lock_id, lock_filename) + break + if blocking is False: + _LOGGER.debug("Failed to immediately acquire lock %s on %s", lock_id, lock_filename) + raise Timeout(lock_filename) # noqa: TRY301 + if 0 <= timeout < time.perf_counter() - start_time: + _LOGGER.debug("Timeout on acquiring lock %s on %s", lock_id, lock_filename) + raise Timeout(lock_filename) # noqa: TRY301 + msg = "Lock %s not acquired on %s, waiting %s seconds ..." + _LOGGER.debug(msg, lock_id, lock_filename, poll_interval) + await asyncio.sleep(poll_interval) + except BaseException: # Something did go wrong, so decrement the counter. + self._context.lock_counter = max(0, self._context.lock_counter - 1) + raise + return AsyncAcquireReturnProxy(lock=self) + + async def release(self, force: bool = False) -> None: # type: ignore[override] # noqa: FBT001, FBT002 + """ + Releases the file lock. Please note, that the lock is only completely released, if the lock counter is 0. + Also note, that the lock file itself is not automatically deleted. + + :param force: If true, the lock counter is ignored and the lock is released in every case/ + + """ + if self.is_locked: + self._context.lock_counter -= 1 + + if self._context.lock_counter == 0 or force: + lock_id, lock_filename = id(self), self.lock_file + + _LOGGER.debug("Attempting to release lock %s on %s", lock_id, lock_filename) + await self._run_internal_method(self._release) + self._context.lock_counter = 0 + _LOGGER.debug("Lock %s released on %s", lock_id, lock_filename) + + async def _run_internal_method(self, method: Callable[[], Any]) -> None: + if asyncio.iscoroutinefunction(method): + await method() + elif self.run_in_executor: + loop = self.loop or asyncio.get_running_loop() + await loop.run_in_executor(self.executor, method) + else: + method() + + def __enter__(self) -> NoReturn: + """ + Replace old __enter__ method to avoid using it. + + NOTE: DO NOT USE `with` FOR ASYNCIO LOCKS, USE `async with` INSTEAD. + + :return: none + :rtype: NoReturn + """ + msg = "Do not use `with` for asyncio locks, use `async with` instead." + raise NotImplementedError(msg) + + async def __aenter__(self) -> Self: + """ + Acquire the lock. + + :return: the lock object + + """ + await self.acquire() + return self + + async def __aexit__( + self, + exc_type: type[BaseException] | None, + exc_value: BaseException | None, + traceback: TracebackType | None, + ) -> None: + """ + Release the lock. + + :param exc_type: the exception type if raised + :param exc_value: the exception value if raised + :param traceback: the exception traceback if raised + + """ + await self.release() + + def __del__(self) -> None: + """Called when the lock object is deleted.""" + with contextlib.suppress(RuntimeError): + loop = self.loop or asyncio.get_running_loop() + if not loop.is_running(): # pragma: no cover + loop.run_until_complete(self.release(force=True)) + else: + loop.create_task(self.release(force=True)) + + +class AsyncSoftFileLock(SoftFileLock, BaseAsyncFileLock): + """Simply watches the existence of the lock file.""" + + +class AsyncUnixFileLock(UnixFileLock, BaseAsyncFileLock): + """Uses the :func:`fcntl.flock` to hard lock the lock file on unix systems.""" + + +class AsyncWindowsFileLock(WindowsFileLock, BaseAsyncFileLock): + """Uses the :func:`msvcrt.locking` to hard lock the lock file on windows systems.""" + + +__all__ = [ + "AsyncAcquireReturnProxy", + "AsyncSoftFileLock", + "AsyncUnixFileLock", + "AsyncWindowsFileLock", + "BaseAsyncFileLock", +] diff --git a/venv/lib/python3.10/site-packages/filelock/py.typed b/venv/lib/python3.10/site-packages/filelock/py.typed new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/venv/lib/python3.10/site-packages/filelock/version.py b/venv/lib/python3.10/site-packages/filelock/version.py new file mode 100644 index 0000000000000000000000000000000000000000..68cfbf97cf730dd2cd88931283036e275c15db4f --- /dev/null +++ b/venv/lib/python3.10/site-packages/filelock/version.py @@ -0,0 +1,21 @@ +# file generated by setuptools-scm +# don't change, don't track in version control + +__all__ = ["__version__", "__version_tuple__", "version", "version_tuple"] + +TYPE_CHECKING = False +if TYPE_CHECKING: + from typing import Tuple + from typing import Union + + VERSION_TUPLE = Tuple[Union[int, str], ...] +else: + VERSION_TUPLE = object + +version: str +__version__: str +__version_tuple__: VERSION_TUPLE +version_tuple: VERSION_TUPLE + +__version__ = version = '3.18.0' +__version_tuple__ = version_tuple = (3, 18, 0) diff --git a/venv/lib/python3.10/site-packages/functorch/__init__.py b/venv/lib/python3.10/site-packages/functorch/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..0aef38c8a9bb84a9833c4c2c9c34ad528d564b32 --- /dev/null +++ b/venv/lib/python3.10/site-packages/functorch/__init__.py @@ -0,0 +1,39 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# All rights reserved. +# +# This source code is licensed under the BSD-style license found in the +# LICENSE file in the root directory of this source tree. +import torch +from torch._functorch.deprecated import ( + combine_state_for_ensemble, + functionalize, + grad, + grad_and_value, + hessian, + jacfwd, + jacrev, + jvp, + make_functional, + make_functional_with_buffers, + vjp, + vmap, +) + +# utilities. Maybe these should go in their own namespace in the future? +from torch._functorch.make_functional import ( + FunctionalModule, + FunctionalModuleWithBuffers, +) + +# Was never documented +from torch._functorch.python_key import make_fx + + +# Top-level APIs. Please think carefully before adding something to the +# top-level namespace: +# - private helper functions should go into torch._functorch +# - very experimental things should go into functorch.experimental +# - compilation related things should go into functorch.compile + + +__version__ = torch.__version__ diff --git a/venv/lib/python3.10/site-packages/functorch/__pycache__/__init__.cpython-310.pyc b/venv/lib/python3.10/site-packages/functorch/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9f31589c7ebdd9ee814594d549d412a6e6d9f663 Binary files /dev/null and b/venv/lib/python3.10/site-packages/functorch/__pycache__/__init__.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/functorch/_src/__init__.py b/venv/lib/python3.10/site-packages/functorch/_src/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/venv/lib/python3.10/site-packages/functorch/_src/__pycache__/__init__.cpython-310.pyc b/venv/lib/python3.10/site-packages/functorch/_src/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7ff9a7ba59806bfae29934a992d09121ef85958a Binary files /dev/null and b/venv/lib/python3.10/site-packages/functorch/_src/__pycache__/__init__.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/functorch/_src/aot_autograd/__init__.py b/venv/lib/python3.10/site-packages/functorch/_src/aot_autograd/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..94f258df84ba8730208768fc44222bee4b3ebc33 --- /dev/null +++ b/venv/lib/python3.10/site-packages/functorch/_src/aot_autograd/__init__.py @@ -0,0 +1,8 @@ +# This file has moved to under torch/_functorch. It is not public API. +# If you are not a PyTorch developer and you are relying on the following +# imports, please file an issue. +from torch._functorch.aot_autograd import ( + aot_autograd_decompositions, + KNOWN_TYPES, + PytreeThunk, +) diff --git a/venv/lib/python3.10/site-packages/functorch/_src/aot_autograd/__pycache__/__init__.cpython-310.pyc b/venv/lib/python3.10/site-packages/functorch/_src/aot_autograd/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..51fb4d16017b58014744f416f2489aa301cb2c06 Binary files /dev/null and b/venv/lib/python3.10/site-packages/functorch/_src/aot_autograd/__pycache__/__init__.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/functorch/_src/eager_transforms/__init__.py b/venv/lib/python3.10/site-packages/functorch/_src/eager_transforms/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..6052b5548f4af3dbc6d9d45b0ffe72a8d5013d41 --- /dev/null +++ b/venv/lib/python3.10/site-packages/functorch/_src/eager_transforms/__init__.py @@ -0,0 +1,7 @@ +# This file has moved to under torch/_functorch. It is not public API. +# If you are not a PyTorch developer and you are relying on the following +# imports, please file an issue. +from torch._functorch.eager_transforms import ( + _assert_wrapped_functional, + _unwrap_functional_tensor, +) diff --git a/venv/lib/python3.10/site-packages/functorch/_src/eager_transforms/__pycache__/__init__.cpython-310.pyc b/venv/lib/python3.10/site-packages/functorch/_src/eager_transforms/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0f55c09a99aac55593da09d5c7939d5acdbe1a39 Binary files /dev/null and b/venv/lib/python3.10/site-packages/functorch/_src/eager_transforms/__pycache__/__init__.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/functorch/_src/make_functional/__init__.py b/venv/lib/python3.10/site-packages/functorch/_src/make_functional/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..3de7787df0c3304207b42b51e9fb62da9d33c7d0 --- /dev/null +++ b/venv/lib/python3.10/site-packages/functorch/_src/make_functional/__init__.py @@ -0,0 +1,4 @@ +# This file has moved to under torch/_functorch. It is not public API. +# If you are not a PyTorch developer and you are relying on the following +# imports, please file an issue. +from torch._functorch.make_functional import _swap_state diff --git a/venv/lib/python3.10/site-packages/functorch/_src/make_functional/__pycache__/__init__.cpython-310.pyc b/venv/lib/python3.10/site-packages/functorch/_src/make_functional/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..786969e4e6a2f3b80496cc234d7599ff6e311d9f Binary files /dev/null and b/venv/lib/python3.10/site-packages/functorch/_src/make_functional/__pycache__/__init__.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/functorch/_src/vmap/__init__.py b/venv/lib/python3.10/site-packages/functorch/_src/vmap/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..dc90517753e50f92362ba954248e31f69f7cfcd5 --- /dev/null +++ b/venv/lib/python3.10/site-packages/functorch/_src/vmap/__init__.py @@ -0,0 +1,16 @@ +# This file has moved to under torch/_functorch. It is not public API. +# If you are not a PyTorch developer and you are relying on the following +# imports, please file an issue. +from torch._functorch.vmap import ( + _add_batch_dim, + _broadcast_to_and_flatten, + _create_batched_inputs, + _get_name, + _process_batched_inputs, + _remove_batch_dim, + _unwrap_batched, + _validate_and_get_batch_size, + Tensor, + tree_flatten, + tree_unflatten, +) diff --git a/venv/lib/python3.10/site-packages/functorch/_src/vmap/__pycache__/__init__.cpython-310.pyc b/venv/lib/python3.10/site-packages/functorch/_src/vmap/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..658e04ac11bb8231edca163fdc42db036b7d8904 Binary files /dev/null and b/venv/lib/python3.10/site-packages/functorch/_src/vmap/__pycache__/__init__.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/functorch/compile/__init__.py b/venv/lib/python3.10/site-packages/functorch/compile/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e7548a5ff6b91bae4fa561f0de7ad5d3492eda05 --- /dev/null +++ b/venv/lib/python3.10/site-packages/functorch/compile/__init__.py @@ -0,0 +1,30 @@ +from torch._functorch import config +from torch._functorch.aot_autograd import ( + aot_function, + aot_module, + aot_module_simplified, + compiled_function, + compiled_module, + get_aot_compilation_context, + get_aot_graph_name, + get_graph_being_compiled, + make_boxed_compiler, + make_boxed_func, +) +from torch._functorch.compilers import ( + debug_compile, + default_decompositions, + draw_graph_compile, + memory_efficient_fusion, + nnc_jit, + nop, + print_compile, + ts_compile, +) +from torch._functorch.fx_minifier import minifier +from torch._functorch.partitioners import ( + default_partition, + draw_graph, + min_cut_rematerialization_partition, +) +from torch._functorch.python_key import pythonkey_decompose diff --git a/venv/lib/python3.10/site-packages/functorch/compile/__pycache__/__init__.cpython-310.pyc b/venv/lib/python3.10/site-packages/functorch/compile/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..119397f762de8b5fb5e1dd9601097f965e418655 Binary files /dev/null and b/venv/lib/python3.10/site-packages/functorch/compile/__pycache__/__init__.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/functorch/dim/__init__.py b/venv/lib/python3.10/site-packages/functorch/dim/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..a6de6ad59e9501b13cf5ba934c810e53ad61f6a3 --- /dev/null +++ b/venv/lib/python3.10/site-packages/functorch/dim/__init__.py @@ -0,0 +1,181 @@ +import dis +import inspect +from typing import Sequence, Union + +import functorch._C +import torch +from functorch._C import dim as _C + +from .tree_map import tree_flatten, tree_map +from .wrap_type import wrap_type + + +_C._patch_tensor_class() +dims, DimList, dimlists = _C.dims, _C.DimList, _C.dimlists + + +class DimensionMismatchError(Exception): + pass + + +class DimensionBindError(Exception): + pass + + +from . import op_properties + + +# use dict to avoid writing C++ bindings for set +pointwise = dict.fromkeys(op_properties.pointwise, True) + +use_c = True +if not use_c: + from . import reference + + +class _Tensor: + # fast path around slow wrapping/unwrapping logic for simply queries used + # by the implementation... + + @property + def dims(self): + return tuple(d for d in self._levels if isinstance(d, Dim)) + + def dim(self): + return self.ndim + + if use_c: + __torch_function__ = classmethod(_C.__torch_function__) + expand = _C._instancemethod(_C.expand) + else: + __torch_function__ = reference.__torch_function__ + expand = reference.expand + + index = _C._instancemethod(_C.index) + + def __repr__(self): + tensor, levels, ndim = self._tensor, self._levels, self.ndim + return f"{tensor}\nwith dims={tuple(l + ndim if isinstance(l, int) else l for l in levels)} sizes={tuple(tensor.size())}" + + +TensorLike = (_Tensor, torch.Tensor) + + +class Dim(_C.Dim, _Tensor): + # note that _C.Dim comes before tensor because we want the Dim API for things like size to take precendence. + # Tensor defines format, but we want to print Dims with special formatting + __format__ = object.__format__ + + +class Tensor(_Tensor, _C.Tensor): + if not use_c: + from_batched = staticmethod(_C.Tensor_from_batched) + from_positional = staticmethod(_C.Tensor_from_positional) + sum = _C._instancemethod(_C.Tensor_sum) + + +def cat(tensors, dim, new_dim): + n = dims() + return stack(tensors, n, dim).index([n, dim], new_dim) + + +if use_c: + _wrap = _C._wrap + + def _def(name, *args, **kwargs): + orig = getattr(torch.Tensor, name) + setattr(_Tensor, name, _C._instancemethod(_wrap(orig, *args, **kwargs))) + + t__getitem__ = _C._instancemethod(_C.__getitem__) + stack = _C.stack + split = _C._instancemethod(_C.split) +else: + _wrap, _def = reference._wrap, reference._def + t__getitem__ = reference.t__getitem__ + stack = reference.stack + split = reference.split + +# note: there is no python reference +t__setitem__ = _C._instancemethod(_C.__setitem__) +# this is patched in the C API because otherwise torch.Tensor will +# no longer be considered a sequence and things will break +# torch.Tensor.__getitem__ = t__getitem__ + +_Tensor.__getitem__ = t__getitem__ +# torch.Tensor.__setitem__ = t__setitem__ +_Tensor.__setitem__ = t__setitem__ + +torch.Tensor.split = split +_Tensor.split = split +torch.Tensor.expand = _C._instancemethod(_C.expand) +torch.Tensor.index = _C._instancemethod(_C.index) +wrap_type(use_c, _Tensor, torch.Tensor, _Tensor.__torch_function__) +del _Tensor.ndim + +if use_c: + _Tensor.order = _C._instancemethod(_C.order) +else: + _Tensor.order = reference.positional + +_def("mean") +_def("sum") +_def("all") +_def("amax") +_def("amin") +_def("aminmax") +_def("any") +_def("count_nonzero") +_def("logsumexp") +_def("nanmean") +_def("nansum") +_def("prod") +_def("std", keepdim_offset=2) +_def("var", keepdim_offset=2) +_def("max", single_dim=True) +_def("min", single_dim=True) +_def("argmax", single_dim=True) +_def("argmin", single_dim=True) +_def("kthvalue", single_dim=True) +_def("median", single_dim=True) +_def("nanmedian", single_dim=True) +_def("mode", single_dim=True) +_def("sort", reduce=False) +_def("argsort", reduce=False) +_def("unbind", single_dim=True) +_def("chunk", dim_offset=1, reduce=False) +_def("cummax", single_dim=True, reduce=False) +_def("cummin", single_dim=True, reduce=False) +_def("cumprod", single_dim=True, reduce=False) +_def("cumprod_", single_dim=True, reduce=False) +_def("cumsum", single_dim=True, reduce=False) +_def("cumsum_", single_dim=True, reduce=False) +_def("logcumsumexp", single_dim=True, reduce=False) +_def("renorm", dim_offset=1, single_dim=True, reduce=False) +_def("softmax", single_dim=True, reduce=False) +softmax = _wrap(torch.nn.functional.softmax, single_dim=True, reduce=False) + +# stuff to handle in the future, because they require special +# binding logic for dims +# cross +# diag_embed +# diagonal +# diagonal_scatter +# diff +# nanquantile +# quantile +# roll +# rot90 +# topk (new dimes on output) +# should these all be subsumed by inplace indexing? +# index_add_ +# index_add +# index_copy +# index_copy_ +# index_fill +# index_fill_ +# index_select +# scatter +# scatter_ +# scatter_add +# scatter_add_ +# scatter_reduce diff --git a/venv/lib/python3.10/site-packages/functorch/dim/__pycache__/__init__.cpython-310.pyc b/venv/lib/python3.10/site-packages/functorch/dim/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a311e2f7a0074eacccb3270ba65a210dfe364fb0 Binary files /dev/null and b/venv/lib/python3.10/site-packages/functorch/dim/__pycache__/__init__.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/functorch/dim/__pycache__/batch_tensor.cpython-310.pyc b/venv/lib/python3.10/site-packages/functorch/dim/__pycache__/batch_tensor.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5b3b997d269f3622795fcab6b2ac7be1e0add53f Binary files /dev/null and b/venv/lib/python3.10/site-packages/functorch/dim/__pycache__/batch_tensor.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/functorch/dim/__pycache__/delayed_mul_tensor.cpython-310.pyc b/venv/lib/python3.10/site-packages/functorch/dim/__pycache__/delayed_mul_tensor.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3b043e4a6a82864df1b2869af4303ad84e31c06e Binary files /dev/null and b/venv/lib/python3.10/site-packages/functorch/dim/__pycache__/delayed_mul_tensor.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/functorch/dim/__pycache__/dim.cpython-310.pyc b/venv/lib/python3.10/site-packages/functorch/dim/__pycache__/dim.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f433d8e0fd4bc0f42b0ad97a2de651a92fb4afa6 Binary files /dev/null and b/venv/lib/python3.10/site-packages/functorch/dim/__pycache__/dim.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/functorch/dim/__pycache__/magic_trace.cpython-310.pyc b/venv/lib/python3.10/site-packages/functorch/dim/__pycache__/magic_trace.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..bc2ed3bacf86ef17a2c7a45cfee5dbeedf328a2b Binary files /dev/null and b/venv/lib/python3.10/site-packages/functorch/dim/__pycache__/magic_trace.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/functorch/dim/__pycache__/op_properties.cpython-310.pyc b/venv/lib/python3.10/site-packages/functorch/dim/__pycache__/op_properties.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..22955e7a2010e498c6abb134bc1e014af3bd2cc8 Binary files /dev/null and b/venv/lib/python3.10/site-packages/functorch/dim/__pycache__/op_properties.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/functorch/dim/__pycache__/reference.cpython-310.pyc b/venv/lib/python3.10/site-packages/functorch/dim/__pycache__/reference.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..848d8857c1ab963348cdf630d23a2ed63bb41f5d Binary files /dev/null and b/venv/lib/python3.10/site-packages/functorch/dim/__pycache__/reference.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/functorch/dim/__pycache__/tree_map.cpython-310.pyc b/venv/lib/python3.10/site-packages/functorch/dim/__pycache__/tree_map.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c8026b84c1e6f516aba16dda2cf2cef165d78f15 Binary files /dev/null and b/venv/lib/python3.10/site-packages/functorch/dim/__pycache__/tree_map.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/functorch/dim/__pycache__/wrap_type.cpython-310.pyc b/venv/lib/python3.10/site-packages/functorch/dim/__pycache__/wrap_type.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ebc56fadd9256b578ce95a0e035fd2eb31afe5a1 Binary files /dev/null and b/venv/lib/python3.10/site-packages/functorch/dim/__pycache__/wrap_type.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/functorch/dim/batch_tensor.py b/venv/lib/python3.10/site-packages/functorch/dim/batch_tensor.py new file mode 100644 index 0000000000000000000000000000000000000000..dae9b270896e988151741409b666a82ba1aba5a4 --- /dev/null +++ b/venv/lib/python3.10/site-packages/functorch/dim/batch_tensor.py @@ -0,0 +1,26 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# All rights reserved. +# +# This source code is licensed under the BSD-style license found in the +# LICENSE file in the root directory of this source tree. +from contextlib import contextmanager + +from torch._C._functorch import _vmap_add_layers, _vmap_remove_layers + + +_enabled = False + + +@contextmanager +def _enable_layers(dims): + global _enabled + assert not _enabled + input = sorted((d._level, d.size) for d in dims if not isinstance(d, int)) + n = len(input) + try: + _vmap_add_layers(input) + _enabled = True + yield + finally: + _enabled = False + _vmap_remove_layers(n) diff --git a/venv/lib/python3.10/site-packages/functorch/dim/delayed_mul_tensor.py b/venv/lib/python3.10/site-packages/functorch/dim/delayed_mul_tensor.py new file mode 100644 index 0000000000000000000000000000000000000000..3c136cfe1247dbd7dcc38777e6326b360619941b --- /dev/null +++ b/venv/lib/python3.10/site-packages/functorch/dim/delayed_mul_tensor.py @@ -0,0 +1,76 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# All rights reserved. +# +# This source code is licensed under the BSD-style license found in the +# LICENSE file in the root directory of this source tree. +import torch + +from . import _Tensor, Tensor +from .reference import _dims, _enable_layers, llist, ltuple + + +class DelayedMulTensor(_Tensor): + def __init__(self, lhs, rhs): + self._lhs, self._rhs = lhs, rhs + self._data = None + self._levels_data = None + self._has_device = lhs._has_device or rhs._has_device + self._batchtensor_data = None + self._tensor_data = None + + @property + def _levels(self): + if self._levels_data is None: + levels = llist(self._lhs._levels) + for l in self._rhs._levels: + if l not in levels: + levels.append(l) + self._levels_data = ltuple(levels) + return self._levels_data + + @property + def _batchtensor(self): + if self._batchtensor_data is None: + with _enable_layers(self._levels): + print("bt multiply fallback") + self._batchtensor_data = self._lhs._batchtensor * self._rhs._batchtensor + return self._batchtensor_data + + @property + def _tensor(self): + if self._tensor_data is None: + self._tensor_data = Tensor.from_batched( + self._batchtensor, self._has_device + )._tensor + return self._tensor_data + + @property + def ndim(self): + return self._batchtensor.ndim + + @property + def dims(self): + return ltuple(super().dims) + + def sum(self, dim): + dims = _dims(dim, 0, False, False) + n = ord("a") + all_levels = self._levels + + def to_char(d): + return chr(n + all_levels.index(d)) + + plhs, levelslhs = self._lhs._tensor, self._lhs._levels + prhs, levelsrhs = self._rhs._tensor, self._rhs._levels + new_levels = [l for l in self._levels if l not in dims] + fmt = "".join( + [ + *(to_char(d) for d in levelslhs), + ",", + *(to_char(d) for d in levelsrhs), + "->", + *(to_char(d) for d in new_levels), + ] + ) + result_data = torch.einsum(fmt, (plhs, prhs)) + return Tensor.from_positional(result_data, new_levels, True) diff --git a/venv/lib/python3.10/site-packages/functorch/dim/dim.py b/venv/lib/python3.10/site-packages/functorch/dim/dim.py new file mode 100644 index 0000000000000000000000000000000000000000..9a4b56866484905cc0bd693c865d03c937aa1b75 --- /dev/null +++ b/venv/lib/python3.10/site-packages/functorch/dim/dim.py @@ -0,0 +1,120 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# All rights reserved. +# +# This source code is licensed under the BSD-style license found in the +# LICENSE file in the root directory of this source tree. +import dis +import inspect +from dataclasses import dataclass +from typing import Union + +from . import DimList + + +_vmap_levels = [] + + +@dataclass +class LevelInfo: + level: int + alive: bool = True + + +class Dim: + def __init__(self, name: str, size: Union[None, int] = None): + self.name = name + self._size = None + self._vmap_level = None + if size is not None: + self.size = size + + def __del__(self): + if self._vmap_level is not None: + _vmap_active_levels[self._vmap_stack].alive = False # noqa: F821 + while ( + not _vmap_levels[-1].alive and current_level() == _vmap_levels[-1].level # noqa: F821 + ): + _vmap_decrement_nesting() # noqa: F821 + _vmap_levels.pop() + + @property + def size(self): + assert self.is_bound + return self._size + + @size.setter + def size(self, size: int): + from . import DimensionBindError + + if self._size is None: + self._size = size + self._vmap_level = _vmap_increment_nesting(size, "same") # noqa: F821 + self._vmap_stack = len(_vmap_levels) + _vmap_levels.append(LevelInfo(self._vmap_level)) + + elif self._size != size: + raise DimensionBindError( + f"Dim '{self}' previously bound to a dimension of size {self._size} cannot bind to a dimension of size {size}" + ) + + @property + def is_bound(self): + return self._size is not None + + def __repr__(self): + return self.name + + +def extract_name(inst): + assert inst.opname == "STORE_FAST" or inst.opname == "STORE_NAME" + return inst.argval + + +_cache = {} + + +def dims(lists=0): + frame = inspect.currentframe() + assert frame is not None + calling_frame = frame.f_back + assert calling_frame is not None + code, lasti = calling_frame.f_code, calling_frame.f_lasti + key = (code, lasti) + if key not in _cache: + first = lasti // 2 + 1 + instructions = list(dis.get_instructions(calling_frame.f_code)) + unpack = instructions[first] + + if unpack.opname == "STORE_FAST" or unpack.opname == "STORE_NAME": + # just a single dim, not a list + name = unpack.argval + ctor = Dim if lists == 0 else DimList + _cache[key] = lambda: ctor(name=name) + else: + assert unpack.opname == "UNPACK_SEQUENCE" + ndims = unpack.argval + names = tuple( + extract_name(instructions[first + 1 + i]) for i in range(ndims) + ) + first_list = len(names) - lists + _cache[key] = lambda: tuple( + Dim(n) if i < first_list else DimList(name=n) + for i, n in enumerate(names) + ) + return _cache[key]() + + +def _dim_set(positional, arg): + def convert(a): + if isinstance(a, Dim): + return a + else: + assert isinstance(a, int) + return positional[a] + + if arg is None: + return positional + elif not isinstance(arg, (Dim, int)): + return tuple(convert(a) for a in arg) + else: + return (convert(arg),) diff --git a/venv/lib/python3.10/site-packages/functorch/dim/magic_trace.py b/venv/lib/python3.10/site-packages/functorch/dim/magic_trace.py new file mode 100644 index 0000000000000000000000000000000000000000..5c962a898ca79cfe3d8af7432aacc3802d4f4ade --- /dev/null +++ b/venv/lib/python3.10/site-packages/functorch/dim/magic_trace.py @@ -0,0 +1,42 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# All rights reserved. +# +# This source code is licensed under the BSD-style license found in the +# LICENSE file in the root directory of this source tree. +import os +import signal +import subprocess +from contextlib import contextmanager + + +@contextmanager +def magic_trace(output="trace.fxt", magic_trace_cache="/tmp/magic-trace"): + pid = os.getpid() + if not os.path.exists(magic_trace_cache): + print(f"Downloading magic_trace to: {magic_trace_cache}") + subprocess.run( + [ + "wget", + "-O", + magic_trace_cache, + "-q", + "https://github.com/janestreet/magic-trace/releases/download/v1.0.2/magic-trace", + ] + ) + subprocess.run(["chmod", "+x", magic_trace_cache]) + args = [magic_trace_cache, "attach", "-pid", str(pid), "-o", output] + p = subprocess.Popen(args, stderr=subprocess.PIPE, encoding="utf-8") + while True: + x = p.stderr.readline() + print(x) + if "Attached" in x: + break + try: + yield + finally: + p.send_signal(signal.SIGINT) + r = p.wait() + print(p.stderr.read()) + p.stderr.close() + if r != 0: + raise ValueError(f"magic_trace exited abnormally: {r}") diff --git a/venv/lib/python3.10/site-packages/functorch/dim/op_properties.py b/venv/lib/python3.10/site-packages/functorch/dim/op_properties.py new file mode 100644 index 0000000000000000000000000000000000000000..01313f71f030d58ce76c15c7f8516c4a0bdcf48a --- /dev/null +++ b/venv/lib/python3.10/site-packages/functorch/dim/op_properties.py @@ -0,0 +1,312 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# All rights reserved. +# +# This source code is licensed under the BSD-style license found in the +# LICENSE file in the root directory of this source tree. +import torch + + +# pointwise operators can go through a faster pathway + +tensor_magic_methods = ["add", ""] +pointwise_magic_methods_with_reverse = ( + "add", + "sub", + "mul", + "floordiv", + "div", + "truediv", + "mod", + "pow", + "lshift", + "rshift", + "and", + "or", + "xor", +) +pointwise_magic_methods = ( + *(x for m in pointwise_magic_methods_with_reverse for x in (m, "r" + m)), + "eq", + "gt", + "le", + "lt", + "ge", + "gt", + "ne", + "neg", + "pos", + "abs", + "invert", + "iadd", + "isub", + "imul", + "ifloordiv", + "idiv", + "itruediv", + "imod", + "ipow", + "ilshift", + "irshift", + "iand", + "ior", + "ixor", + "int", + "long", + "float", + "complex", +) + +pointwise_methods = (*(f"__{m}__" for m in pointwise_magic_methods),) + +pointwise = ( + *(getattr(torch.Tensor, m) for m in pointwise_methods), + torch.nn.functional.dropout, + torch.where, + torch.Tensor.abs, + torch.abs, + torch.Tensor.acos, + torch.acos, + torch.Tensor.acosh, + torch.acosh, + torch.Tensor.add, + torch.add, + torch.Tensor.addcdiv, + torch.addcdiv, + torch.Tensor.addcmul, + torch.addcmul, + torch.Tensor.addr, + torch.addr, + torch.Tensor.angle, + torch.angle, + torch.Tensor.asin, + torch.asin, + torch.Tensor.asinh, + torch.asinh, + torch.Tensor.atan, + torch.atan, + torch.Tensor.atan2, + torch.atan2, + torch.Tensor.atanh, + torch.atanh, + torch.Tensor.bitwise_and, + torch.bitwise_and, + torch.Tensor.bitwise_left_shift, + torch.bitwise_left_shift, + torch.Tensor.bitwise_not, + torch.bitwise_not, + torch.Tensor.bitwise_or, + torch.bitwise_or, + torch.Tensor.bitwise_right_shift, + torch.bitwise_right_shift, + torch.Tensor.bitwise_xor, + torch.bitwise_xor, + torch.Tensor.ceil, + torch.ceil, + torch.celu, + torch.nn.functional.celu, + torch.Tensor.clamp, + torch.clamp, + torch.Tensor.clamp_max, + torch.clamp_max, + torch.Tensor.clamp_min, + torch.clamp_min, + torch.Tensor.copysign, + torch.copysign, + torch.Tensor.cos, + torch.cos, + torch.Tensor.cosh, + torch.cosh, + torch.Tensor.deg2rad, + torch.deg2rad, + torch.Tensor.digamma, + torch.digamma, + torch.Tensor.div, + torch.div, + torch.dropout, + torch.nn.functional.dropout, + torch.nn.functional.elu, + torch.Tensor.eq, + torch.eq, + torch.Tensor.erf, + torch.erf, + torch.Tensor.erfc, + torch.erfc, + torch.Tensor.erfinv, + torch.erfinv, + torch.Tensor.exp, + torch.exp, + torch.Tensor.exp2, + torch.exp2, + torch.Tensor.expm1, + torch.expm1, + torch.feature_dropout, + torch.Tensor.float_power, + torch.float_power, + torch.Tensor.floor, + torch.floor, + torch.Tensor.floor_divide, + torch.floor_divide, + torch.Tensor.fmod, + torch.fmod, + torch.Tensor.frac, + torch.frac, + torch.Tensor.frexp, + torch.frexp, + torch.Tensor.gcd, + torch.gcd, + torch.Tensor.ge, + torch.ge, + torch.nn.functional.gelu, + torch.nn.functional.glu, + torch.Tensor.gt, + torch.gt, + torch.Tensor.hardshrink, + torch.hardshrink, + torch.nn.functional.hardshrink, + torch.nn.functional.hardsigmoid, + torch.nn.functional.hardswish, + torch.nn.functional.hardtanh, + torch.Tensor.heaviside, + torch.heaviside, + torch.Tensor.hypot, + torch.hypot, + torch.Tensor.i0, + torch.i0, + torch.Tensor.igamma, + torch.igamma, + torch.Tensor.igammac, + torch.igammac, + torch.Tensor.isclose, + torch.isclose, + torch.Tensor.isfinite, + torch.isfinite, + torch.Tensor.isinf, + torch.isinf, + torch.Tensor.isnan, + torch.isnan, + torch.Tensor.isneginf, + torch.isneginf, + torch.Tensor.isposinf, + torch.isposinf, + torch.Tensor.isreal, + torch.isreal, + torch.Tensor.kron, + torch.kron, + torch.Tensor.lcm, + torch.lcm, + torch.Tensor.ldexp, + torch.ldexp, + torch.Tensor.le, + torch.le, + torch.nn.functional.leaky_relu, + torch.Tensor.lerp, + torch.lerp, + torch.Tensor.lgamma, + torch.lgamma, + torch.Tensor.log, + torch.log, + torch.Tensor.log10, + torch.log10, + torch.Tensor.log1p, + torch.log1p, + torch.Tensor.log2, + torch.log2, + torch.nn.functional.logsigmoid, + torch.Tensor.logical_and, + torch.logical_and, + torch.Tensor.logical_not, + torch.logical_not, + torch.Tensor.logical_or, + torch.logical_or, + torch.Tensor.logical_xor, + torch.logical_xor, + torch.Tensor.logit, + torch.logit, + torch.Tensor.lt, + torch.lt, + torch.Tensor.maximum, + torch.maximum, + torch.Tensor.minimum, + torch.minimum, + torch.nn.functional.mish, + torch.Tensor.mvlgamma, + torch.mvlgamma, + torch.Tensor.nan_to_num, + torch.nan_to_num, + torch.Tensor.ne, + torch.ne, + torch.Tensor.neg, + torch.neg, + torch.Tensor.nextafter, + torch.nextafter, + torch.Tensor.outer, + torch.outer, + torch.polar, + torch.Tensor.polygamma, + torch.polygamma, + torch.Tensor.positive, + torch.positive, + torch.Tensor.pow, + torch.pow, + torch.Tensor.prelu, + torch.prelu, + torch.nn.functional.prelu, + torch.Tensor.rad2deg, + torch.rad2deg, + torch.Tensor.reciprocal, + torch.reciprocal, + torch.Tensor.relu, + torch.relu, + torch.nn.functional.relu, + torch.nn.functional.relu6, + torch.Tensor.remainder, + torch.remainder, + torch.Tensor.round, + torch.round, + torch.rrelu, + torch.nn.functional.rrelu, + torch.Tensor.rsqrt, + torch.rsqrt, + torch.rsub, + torch.selu, + torch.nn.functional.selu, + torch.Tensor.sgn, + torch.sgn, + torch.Tensor.sigmoid, + torch.sigmoid, + torch.nn.functional.sigmoid, + torch.Tensor.sign, + torch.sign, + torch.Tensor.signbit, + torch.signbit, + torch.nn.functional.silu, + torch.Tensor.sin, + torch.sin, + torch.Tensor.sinc, + torch.sinc, + torch.Tensor.sinh, + torch.sinh, + torch.nn.functional.softplus, + torch.nn.functional.softshrink, + torch.Tensor.sqrt, + torch.sqrt, + torch.Tensor.square, + torch.square, + torch.Tensor.sub, + torch.sub, + torch.Tensor.tan, + torch.tan, + torch.Tensor.tanh, + torch.tanh, + torch.nn.functional.tanh, + torch.threshold, + torch.nn.functional.threshold, + torch.trapz, + torch.Tensor.true_divide, + torch.true_divide, + torch.Tensor.trunc, + torch.trunc, + torch.Tensor.xlogy, + torch.xlogy, + torch.rand_like, +) diff --git a/venv/lib/python3.10/site-packages/functorch/dim/reference.py b/venv/lib/python3.10/site-packages/functorch/dim/reference.py new file mode 100644 index 0000000000000000000000000000000000000000..6453a441b9445b58a02e3f917ff0746790908eae --- /dev/null +++ b/venv/lib/python3.10/site-packages/functorch/dim/reference.py @@ -0,0 +1,643 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# All rights reserved. +# +# This source code is licensed under the BSD-style license found in the +# LICENSE file in the root directory of this source tree. + +# reference python implementations for C ops +import torch +from functorch._C import dim as _C + +from . import op_properties +from .batch_tensor import _enable_layers +from .tree_map import tree_flatten, tree_map + + +DimList = _C.DimList +import operator +from functools import reduce + + +# use dict to avoid writing C++ bindings for set +pointwise = set(op_properties.pointwise) + + +def prod(x): + return reduce(operator.mul, x, 1) + + +def _wrap_dim(d, N, keepdim): + from . import Dim + + if isinstance(d, Dim): + assert not keepdim, "cannot preserve first-class dimensions with keepdim=True" + return d + elif d >= 0: + return d - N + else: + return d + + +def _dims(d, N, keepdim, single_dim): + from . import Dim + + if isinstance(d, (Dim, int)): + return ltuple((_wrap_dim(d, N, keepdim),)) + assert not single_dim, f"expected a single dimension or int but found: {d}" + return ltuple(_wrap_dim(x, N, keepdim) for x in d) + + +def _bind_dims_to_size(lhs_size, rhs, lhs_debug): + from . import DimensionMismatchError + + not_bound = tuple((i, r) for i, r in enumerate(rhs) if not r.is_bound) + if len(not_bound) == 1: + idx, d = not_bound[0] + rhs_so_far = prod(r.size for r in rhs if r.is_bound) + if lhs_size % rhs_so_far != 0: + rhs_s = tuple("?" if not r.is_bound else str(r.size) for r in rhs) + raise DimensionMismatchError( + f"inferred dimension does not evenly fit into larger dimension: {lhs_size} vs {rhs_s}" + ) + new_size = lhs_size // rhs_so_far + d.size = new_size + elif len(not_bound) > 1: + rhs_s = tuple("?" if not r.is_bound else str(r.size) for r in rhs) + raise DimensionMismatchError( + f"cannot infer the size of two dimensions at once: {rhs} with sizes {rhs_s}" + ) + else: + rhs_size = prod(r.size for r in rhs) + if lhs_size != rhs_size: + raise DimensionMismatchError( + f"Dimension sizes to do not match ({lhs_size} != {rhs_size}) when matching {lhs_debug} to {rhs}" + ) + + +def _tensor_levels(inp): + from . import _Tensor + + if isinstance(inp, _Tensor): + return inp._tensor, llist(inp._levels), inp._has_device + else: + return inp, llist(range(-inp.ndim, 0)), True + + +def _match_levels(v, from_levels, to_levels): + view = [] + permute = [] + requires_view = False + size = v.size() + for t in to_levels: + try: + idx = from_levels.index(t) + permute.append(idx) + view.append(size[idx]) + except ValueError: + view.append(1) + requires_view = True + if permute != list(range(len(permute))): + v = v.permute(*permute) + if requires_view: + v = v.view(*view) + return v + + +# make a single dimension positional but do not permute it, +# used to do multi-tensor operators where the dim being acted on +# should not physically move if possible +def _positional_no_permute(self, dim, expand_dim=False): + from . import Tensor + + ptensor, levels = self._tensor, llist(self._levels) + try: + idx = levels.index(dim) + except ValueError: + if not expand_dim: + raise + idx = 0 + ptensor = ptensor.expand(dim.size, *ptensor.size()) + levels.insert(0, 0) + idx_batched = 0 + for i in range(idx): + if isinstance(levels[i], int): + levels[i] -= 1 + idx_batched += 1 + levels[idx] = -idx_batched - 1 + return Tensor.from_positional(ptensor, levels, self._has_device), idx_batched + + +def seq(a, b): + from . import Dim + + if isinstance(a, Dim) != isinstance(b, Dim): + return False + if isinstance(a, Dim): + return a is b + else: + return a == b + + +class isin: + def __contains__(self, item): + for x in self: + if seq(item, x): + return True + return False + + def index(self, item): + for i, x in enumerate(self): + if seq(item, x): + return i + raise ValueError + + +class llist(isin, list): + pass + + +class ltuple(isin, tuple): + pass + + +empty_dict = {} + + +@classmethod +def __torch_function__(self, orig, cls, args, kwargs=empty_dict): + from . import _Tensor, Tensor, TensorLike + from .delayed_mul_tensor import DelayedMulTensor + + if orig is torch.Tensor.__mul__: + lhs, rhs = args + if ( + isinstance(lhs, _Tensor) + and isinstance(rhs, _Tensor) + and lhs.ndim == 0 + and rhs.ndim == 0 + ): + return DelayedMulTensor(lhs, rhs) + all_dims = llist() + flat_args, unflatten = tree_flatten((args, kwargs)) + device_holding_tensor = None + for f in flat_args: + if isinstance(f, _Tensor): + if f._has_device: + device_holding_tensor = f._batchtensor + for d in f.dims: + if d not in all_dims: + all_dims.append(d) + + def unwrap(t): + if isinstance(t, _Tensor): + r = t._batchtensor + if device_holding_tensor is not None and not t._has_device: + r = r.to(device=device_holding_tensor.device) + return r + return t + + if orig in pointwise: + result_levels = llist() + to_expand = [] + for i, f in enumerate(flat_args): + if isinstance(f, TensorLike): + ptensor, levels, _ = _tensor_levels(f) + if ( + isinstance(f, _Tensor) + and not f._has_device + and device_holding_tensor is not None + ): + ptensor = ptensor.to(device=device_holding_tensor.device) + flat_args[i] = ptensor + for l in levels: + if l not in result_levels: + result_levels.append(l) + to_expand.append((i, levels)) + + for i, levels in to_expand: + flat_args[i] = _match_levels(flat_args[i], levels, result_levels) + args, kwargs = unflatten(flat_args) + result = orig(*args, **kwargs) + + def wrap(t): + if isinstance(t, TensorLike): + return Tensor.from_positional( + t, result_levels, device_holding_tensor is not None + ) + return t + + return tree_map(wrap, result) + else: + + def wrap(t): + if isinstance(t, TensorLike): + return Tensor.from_batched(t, device_holding_tensor is not None) + return t + + with _enable_layers(all_dims): + print(f"batch_tensor for {orig}") + args, kwargs = unflatten(unwrap(f) for f in flat_args) + result = orig(*args, **kwargs) + # print("END", orig) + return tree_map(wrap, result) + + +def positional(self, *dims): + from . import Dim, DimensionBindError, Tensor + + ptensor, levels = self._tensor, llist(self._levels) + flat_dims = llist() + view = [] + needs_view = False + ndim = self.ndim + for d in dims: + if isinstance(d, DimList): + flat_dims.extend(d) + view.extend(e.size for e in d) + elif isinstance(d, Dim): + flat_dims.append(d) + view.append(d.size) + elif isinstance(d, int): + d = _wrap_dim(d, ndim, False) + flat_dims.append(d) + view.append(ptensor.size(d)) + else: + flat_dims.extend(d) + view.append(prod(e.size for e in d)) + needs_view = True + + permute = list(range(len(levels))) + for i, d in enumerate(flat_dims): + try: + idx = levels.index(d) + except ValueError as e: + raise DimensionBindError( + f"tensor of dimensions {self.dims} does not contain dim {d}" + ) from e + p = permute[idx] + del levels[idx] + del permute[idx] + levels.insert(i, 0) + permute.insert(i, p) + ptensor = ptensor.permute(*permute) + seen = 0 + for i in range(len(levels) - 1, -1, -1): + if isinstance(levels[i], int): + seen += 1 + levels[i] = -seen + result = Tensor.from_positional(ptensor, levels, self._has_device) + if needs_view: + result = result.reshape(*view, *result.size()[len(flat_dims) :]) + return result + + +def _contains_dim(input): + from . import Dim + + for i in input: + if isinstance(i, Dim): + return True + + +def expand(self, *sizes): + if not _contains_dim(sizes): + return self.__torch_function__(torch.Tensor.expand, None, (self, *sizes)) + dims = sizes + sizes = [d.size for d in dims] + [-1] * self.ndim + self = self.expand(*sizes) + return self[dims] + + +_not_present = object() + + +def _getarg(name, offset, args, kwargs, default): + if len(args) > offset: + return args[offset] + return kwargs.get(name, default) + + +def _patcharg(name, offset, args, kwargs, value): + if len(args) > offset: + args[offset] = value + else: + kwargs[name] = value + + +def _wrap( + orig, dim_offset=0, keepdim_offset=1, dim_name="dim", single_dim=False, reduce=True +): + from . import Dim, Tensor, TensorLike + + def fn(self, *args, **kwargs): + dim = _getarg(dim_name, dim_offset, args, kwargs, _not_present) + if dim is _not_present or (single_dim and not isinstance(dim, Dim)): + with _enable_layers(self.dims): + print(f"dim fallback batch_tensor for {orig}") + return Tensor.from_batched( + orig(self._batchtensor, *args, **kwargs), self._has_device + ) + keepdim = ( + _getarg("keepdim", keepdim_offset, args, kwargs, False) if reduce else False + ) + t, levels = self._tensor, llist(self._levels) + dims = _dims(dim, self._batchtensor.ndim, keepdim, single_dim) + dim_indices = tuple(levels.index(d) for d in dims) + if reduce and not keepdim: + new_levels = [l for i, l in enumerate(levels) if i not in dim_indices] + else: + new_levels = levels + + if len(dim_indices) == 1: + dim_indices = dim_indices[ + 0 + ] # so that dims that really only take a single argument work... + args = list(args) + _patcharg(dim_name, dim_offset, args, kwargs, dim_indices) + + def wrap(t): + if isinstance(t, TensorLike): + return Tensor.from_positional(t, new_levels, self._has_device) + return t + + with _enable_layers(new_levels): + print(f"dim used batch_tensor for {orig}") + r = orig(t, *args, **kwargs) + return tree_map(wrap, r) + + return fn + + +def _def(name, *args, **kwargs): + from . import _Tensor + + orig = getattr(torch.Tensor, name) + setattr(_Tensor, name, _wrap(orig, *args, **kwargs)) + + +no_slice = slice(None) + +_orig_getitem = torch.Tensor.__getitem__ + + +class dim_tracker: + def __init__(self) -> None: + self.dims = llist() + self.count = [] + + def record(self, d): + if d not in self.dims: + self.dims.append(d) + self.count.append(1) + + def __getitem__(self, d): + return self.count[self.dims.index(d)] + + +def t__getitem__(self, input): + from . import _Tensor, Dim, DimensionBindError, DimList, Tensor, TensorLike + + # * bail to original example if we have a single non-Dim tensor, or a non-tensor + # * locate ... or an unbound tensor list, and determine its size, bind dim list + # (remember that None does not count to the total dim count) + # * bind simple dims and dim-packs to their sizes, count the number of uses of each dim, + # produce the re-view if needed + # * for each single-use dim index, replace with no_slice and mark that it will be added + # (keep track of whether we have to call super) + # * call super if needed + # * if we have dims to bind, bind them (it will help if we eliminated ... and None before) + # this handles bool indexing handling, as well as some other simple cases. + + is_simple = ( + not isinstance(input, Dim) + and not isinstance(input, (tuple, list)) + and + # WAR for functorch bug where zero time tensors in getitem are not handled correctly. + not (isinstance(input, TensorLike) and input.ndim == 0) + ) + + if is_simple: + if isinstance(self, _Tensor): + return _Tensor.__torch_function__(_orig_getitem, None, (self, input)) + else: + return _orig_getitem(self, input) + + # can further optimize this case + if not isinstance(input, tuple): + input = [input] + else: + input = list(input) + + dims_indexed = 0 + expanding_object = None + dimlists = [] + for i, s in enumerate(input): + if s is ... or isinstance(s, DimList) and not s.is_bound: + if expanding_object is not None: + msg = ( + "at most one ... or unbound dimension list can exist in indexing list but" + f" found 2 at offsets {i} and {expanding_object}" + ) + raise DimensionBindError(msg) + expanding_object = i + + if isinstance(s, DimList): + dims_indexed += len(s) if s.is_bound else 0 + dimlists.append(i) + elif s is not None and s is not ...: + dims_indexed += 1 + + ndim = self.ndim + if dims_indexed > ndim: + raise IndexError( + f"at least {dims_indexed} indices were supplied but the tensor only has {ndim} dimensions." + ) + if expanding_object is not None: + expanding_ndims = ndim - dims_indexed + obj = input[expanding_object] + if obj is ...: + input[expanding_object : expanding_object + 1] = [ + no_slice + ] * expanding_ndims + else: + obj.bind_len(expanding_ndims) + # flatten the dimslists into the indexing + for i in reversed(dimlists): + input[i : i + 1] = input[i] + dims_indexed = 0 + requires_view = False + size = self.size() + view_sizes = [] + dims_seen = dim_tracker() + + def add_dims(t): + if not isinstance(t, _Tensor): + return + for d in t.dims: + dims_seen.record(d) + + add_dims(self) + dim_packs = [] + for i, idx in enumerate(input): + if idx is None: + input[i] = no_slice + view_sizes.append(1) + requires_view = True + else: + sz = size[dims_indexed] + if isinstance(idx, Dim): + idx.size = sz + dims_seen.record(idx) + view_sizes.append(sz) + elif isinstance(idx, (tuple, list)) and idx and isinstance(idx[0], Dim): + for d in idx: + dims_seen.record(idx) + _bind_dims_to_size(sz, idx, f"offset {i}") + view_sizes.extend(d.size for d in idx) + requires_view = True + dim_packs.append(i) + else: + add_dims(idx) + view_sizes.append(sz) + dims_indexed += 1 + if requires_view: + self = self.view(*view_sizes) + for i in reversed(dim_packs): + input[i : i + 1] = input[i] + + # currenty: + # input is flat, containing either Dim, or Tensor, or something valid for standard indexing + # self may have first-class dims as well. + + # to index: + # drop the first class dims from self, they just become direct indices of their positions + + # figure out the dimensions of the indexing tensors: union of all the dims in the tensors in the index. + # these dimensions will appear and need to be bound at the first place tensor occures + + if isinstance(self, _Tensor): + ptensor_self, levels = self._tensor, list(self._levels) + # indices to ptensor rather than self which has first-class dimensions + input_it = iter(input) + flat_inputs = [next(input_it) if isinstance(l, int) else l for l in levels] + has_device = self._has_device + to_pad = 0 + else: + ptensor_self, flat_inputs = self, input + to_pad = ptensor_self.ndim - len(flat_inputs) + has_device = True + + result_levels = [] + index_levels = [] + tensor_insert_point = None + to_expand = {} + requires_getindex = False + for i, inp in enumerate(flat_inputs): + if isinstance(inp, Dim) and dims_seen[inp] == 1: + flat_inputs[i] = no_slice + result_levels.append(inp) + elif isinstance(inp, TensorLike): + requires_getindex = True + if tensor_insert_point is None: + tensor_insert_point = len(result_levels) + ptensor, levels, _ = _tensor_levels(inp) + to_expand[i] = levels + flat_inputs[i] = ptensor + for l in levels: + if l not in index_levels: + index_levels.append(l) + else: + requires_getindex = True + result_levels.append(0) + + if tensor_insert_point is not None: + result_levels[tensor_insert_point:tensor_insert_point] = index_levels + + for i, levels in to_expand.items(): + flat_inputs[i] = _match_levels(flat_inputs[i], levels, index_levels) + + if requires_getindex: + result = _orig_getitem(ptensor_self, flat_inputs) + else: + result = ptensor_self + + next_positional = -1 + if to_pad > 0: + result_levels.extend([0] * to_pad) + for i, r in enumerate(reversed(result_levels)): + if isinstance(r, int): + result_levels[-1 - i] = next_positional + next_positional -= 1 + + return Tensor.from_positional(result, result_levels, has_device) + + +# XXX - dim is optional and can be the outer-most dimension... +def stack(tensors, new_dim, dim=0, out=None): + if isinstance(dim, int): + return torch.stack(tensors, dim, out).index(dim, new_dim) + index = None + if out is not None: + out, index = _positional_no_permute(out, dim, expand_dim=True) + ptensors = [] + for t in tensors: + pt, pi = _positional_no_permute(t, dim, expand_dim=True) + if index is not None and pi != index: + pt = pt.move_dim(pi, index) + else: + index = pi + ptensors.append(pt) + pr = torch.stack(ptensors, index, out=out) + return pr.index((index, index + 1), (new_dim, dim)) + + +_orig_split = torch.Tensor.split + + +def split(self, split_size_or_sections, dim=0): + from . import _Tensor, Dim + + if isinstance(split_size_or_sections, int) or any( + isinstance(t, int) for t in split_size_or_sections + ): + if isinstance(dim, Dim): + raise ValueError( + "when dim is specified as a Dim object, split sizes must also be dimensions." + ) + return _orig_split(self, split_size_or_sections, dim=dim) + + if isinstance(dim, Dim): + assert isinstance(self, _Tensor), f"Tensor does not have dimension {dim}" + self, dim = _positional_no_permute(self, dim) + + size = self.size(dim) + total_bound_size = 0 + unbound = [] + sizes = [] + for i, d in enumerate(split_size_or_sections): + if d.is_bound: + sizes.append(d.size) + total_bound_size += d.size + else: + sizes.append(0) + unbound.append(i) + + if unbound: + assert ( + total_bound_size <= size + ), f"result dimensions are larger than original: {total_bound_size} vs {size} ({split_size_or_sections})" + remaining_size = size - total_bound_size + chunk_size = -(-remaining_size // len(unbound)) + for u in unbound: + sz = min(chunk_size, remaining_size) + split_size_or_sections[u].size = sz + sizes[u] = sz + remaining_size -= sz + else: + assert ( + total_bound_size == size + ), f"result dimensions do not match original: {total_bound_size} vs {size} ({split_size_or_sections})" + return tuple( + t.index(dim, d) + for d, t in zip(split_size_or_sections, _orig_split(self, sizes, dim=dim)) + ) diff --git a/venv/lib/python3.10/site-packages/functorch/dim/tree_map.py b/venv/lib/python3.10/site-packages/functorch/dim/tree_map.py new file mode 100644 index 0000000000000000000000000000000000000000..3d2eae0582c85619e0d28e648af58cbd847eee97 --- /dev/null +++ b/venv/lib/python3.10/site-packages/functorch/dim/tree_map.py @@ -0,0 +1,15 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# All rights reserved. +# +# This source code is licensed under the BSD-style license found in the +# LICENSE file in the root directory of this source tree. + +from functorch._C import dim + + +tree_flatten = dim.tree_flatten + + +def tree_map(fn, tree): + vs, unflatten = tree_flatten(tree) + return unflatten(fn(v) for v in vs) diff --git a/venv/lib/python3.10/site-packages/functorch/dim/wrap_type.py b/venv/lib/python3.10/site-packages/functorch/dim/wrap_type.py new file mode 100644 index 0000000000000000000000000000000000000000..aae543b91a896e2d5cef3b03d725c3d91ce1305d --- /dev/null +++ b/venv/lib/python3.10/site-packages/functorch/dim/wrap_type.py @@ -0,0 +1,72 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# All rights reserved. +# +# This source code is licensed under the BSD-style license found in the +# LICENSE file in the root directory of this source tree. + +from types import ( + BuiltinMethodType, + FunctionType, + GetSetDescriptorType, + MethodDescriptorType, + WrapperDescriptorType, +) + +from functorch._C import dim as _C + + +_wrap_method = _C._wrap_method + +FUNC_TYPES = ( + FunctionType, + MethodDescriptorType, + BuiltinMethodType, + WrapperDescriptorType, +) +PROPERTY_TYPES = (GetSetDescriptorType, property) + + +def _py_wrap_method(orig, __torch_function__): + def impl(*args, **kwargs): + return __torch_function__(orig, None, args, kwargs) + + return impl + + +def wrap_type(use_c, to_patch, pattern, __torch_function__): + if use_c: + wrap_method = _wrap_method + else: + wrap_method = _py_wrap_method + + all = {} + for t in reversed(pattern.mro()[:-1]): # skip object + all.update(t.__dict__) + + def wrap_attr(orig): + return property(wrap_method(orig.__get__, __torch_function__)) + + for name, obj in all.items(): + if name in ( + "__dict__", + "__new__", + "__init__", + "__repr__", + "__weakref__", + "__doc__", + "__module__", + "__dir__", + ): + continue + + # skip things that have been overloaded + # things that come from object like `__eq__` still need to be patched, however. + if hasattr(to_patch, name) and getattr(to_patch, name) is not getattr( + object, name, None + ): + continue + + if isinstance(obj, FUNC_TYPES): + setattr(to_patch, name, wrap_method(obj, __torch_function__)) + elif isinstance(obj, PROPERTY_TYPES): + setattr(to_patch, name, wrap_attr(obj)) diff --git a/venv/lib/python3.10/site-packages/functorch/einops/__init__.py b/venv/lib/python3.10/site-packages/functorch/einops/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d7ac34f7a3722010fc0fde97fd1cd72e76fa88b7 --- /dev/null +++ b/venv/lib/python3.10/site-packages/functorch/einops/__init__.py @@ -0,0 +1,4 @@ +from .rearrange import rearrange + + +__all__ = ["rearrange"] diff --git a/venv/lib/python3.10/site-packages/functorch/einops/__pycache__/__init__.cpython-310.pyc b/venv/lib/python3.10/site-packages/functorch/einops/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..156e07fe49c9db2580189f569e08994d093bd3a3 Binary files /dev/null and b/venv/lib/python3.10/site-packages/functorch/einops/__pycache__/__init__.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/functorch/einops/__pycache__/_parsing.cpython-310.pyc b/venv/lib/python3.10/site-packages/functorch/einops/__pycache__/_parsing.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..76d2c45333a316a8bf6cc4d4cf7cb1c47c2ddcc2 Binary files /dev/null and b/venv/lib/python3.10/site-packages/functorch/einops/__pycache__/_parsing.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/functorch/einops/__pycache__/rearrange.cpython-310.pyc b/venv/lib/python3.10/site-packages/functorch/einops/__pycache__/rearrange.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5647a88bb94ce060689e39a5a42e37b28917f4f9 Binary files /dev/null and b/venv/lib/python3.10/site-packages/functorch/einops/__pycache__/rearrange.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/functorch/einops/_parsing.py b/venv/lib/python3.10/site-packages/functorch/einops/_parsing.py new file mode 100644 index 0000000000000000000000000000000000000000..ee69aa60d1a58e44dcdf888d8c5e1a568f0151d6 --- /dev/null +++ b/venv/lib/python3.10/site-packages/functorch/einops/_parsing.py @@ -0,0 +1,304 @@ +"""Adapted from https://github.com/arogozhnikov/einops/blob/36c7bb16e57d6e57f8f3050f9e07abdf3f00469f/einops/parsing.py. + +MIT License + +Copyright (c) 2018 Alex Rogozhnikov + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +""" + +from __future__ import annotations + +import keyword +import warnings +from typing import Collection, List, Mapping, Optional, Set, Tuple, Union + + +_ellipsis: str = "\u2026" # NB, this is a single unicode symbol. String is used as it is not a list, but can be iterated + + +class AnonymousAxis: + """Used by `ParsedExpression` to represent an axis with a size (> 1), but no associated identifier. + + Note: Different instances of this class are not equal to each other, even if they have the same value. + """ + + def __init__(self, value: str) -> None: + self.value = int(value) + if self.value < 1: + raise ValueError( + f"Anonymous axis should have positive length, not {self.value}" + ) + + def __repr__(self) -> str: + return f"{self.value}-axis" + + +class ParsedExpression: + """Structure containing information about one side of an `einops`-style pattern (e.g. 'b c (h w)').""" + + def __init__( + self, + expression: str, + *, + allow_underscore: bool = False, + allow_duplicates: bool = False, + ) -> None: + """Parse the expression and store relevant metadata. + + Args: + expression (str): the `einops`-pattern to parse + allow_underscore (bool): whether to allow axis identifier names to begin with an underscore + allow_duplicates (bool): whether to allow an identifier to appear more than once in the expression + """ + self.has_ellipsis: bool = False + self.has_ellipsis_parenthesized: Optional[bool] = None + self.identifiers: Set[Union[str, AnonymousAxis]] = set() + # that's axes like 2, 3, 4 or 5. Axes with size 1 are exceptional and replaced with empty composition + self.has_non_unitary_anonymous_axes: bool = False + # composition keeps structure of composite axes, see how different corner cases are handled in tests + self.composition: List[Union[List[Union[str, AnonymousAxis]], str]] = [] + if "." in expression: + if "..." not in expression: + raise ValueError( + "Expression may contain dots only inside ellipsis (...)" + ) + if str.count(expression, "...") != 1 or str.count(expression, ".") != 3: + raise ValueError( + "Expression may contain dots only inside ellipsis (...); only one ellipsis for tensor " + ) + expression = expression.replace("...", _ellipsis) + self.has_ellipsis = True + + bracket_group: Optional[List[Union[str, AnonymousAxis]]] = None + + def add_axis_name(x: str) -> None: + if x in self.identifiers: + if not (allow_underscore and x == "_") and not allow_duplicates: + raise ValueError( + f"Indexing expression contains duplicate dimension '{x}'" + ) + if x == _ellipsis: + self.identifiers.add(_ellipsis) + if bracket_group is None: + self.composition.append(_ellipsis) + self.has_ellipsis_parenthesized = False + else: + bracket_group.append(_ellipsis) + self.has_ellipsis_parenthesized = True + else: + is_number = str.isdecimal(x) + if is_number and int(x) == 1: + # handling the case of anonymous axis of length 1 + if bracket_group is None: + self.composition.append([]) + else: + pass # no need to think about 1s inside parenthesis + return + is_axis_name, reason = self.check_axis_name_return_reason( + x, allow_underscore=allow_underscore + ) + if not (is_number or is_axis_name): + raise ValueError(f"Invalid axis identifier: {x}\n{reason}") + axis_name: Union[str, AnonymousAxis] = ( + AnonymousAxis(x) if is_number else x + ) + self.identifiers.add(axis_name) + if is_number: + self.has_non_unitary_anonymous_axes = True + if bracket_group is None: + self.composition.append([axis_name]) + else: + bracket_group.append(axis_name) + + current_identifier = None + for char in expression: + if char in "() ": + if current_identifier is not None: + add_axis_name(current_identifier) + current_identifier = None + if char == "(": + if bracket_group is not None: + raise ValueError( + "Axis composition is one-level (brackets inside brackets not allowed)" + ) + bracket_group = [] + elif char == ")": + if bracket_group is None: + raise ValueError("Brackets are not balanced") + self.composition.append(bracket_group) + bracket_group = None + elif str.isalnum(char) or char in ["_", _ellipsis]: + if current_identifier is None: + current_identifier = char + else: + current_identifier += char + else: + raise ValueError(f"Unknown character '{char}'") + + if bracket_group is not None: + raise ValueError(f"Imbalanced parentheses in expression: '{expression}'") + if current_identifier is not None: + add_axis_name(current_identifier) + + @staticmethod + def check_axis_name_return_reason( + name: str, allow_underscore: bool = False + ) -> Tuple[bool, str]: + """Check if the given axis name is valid, and a message explaining why if not. + + Valid axes names are python identifiers except keywords, and should not start or end with an underscore. + + Args: + name (str): the axis name to check + allow_underscore (bool): whether axis names are allowed to start with an underscore + + Returns: + Tuple[bool, str]: whether the axis name is valid, a message explaining why if not + """ + if not str.isidentifier(name): + return False, "not a valid python identifier" + elif name[0] == "_" or name[-1] == "_": + if name == "_" and allow_underscore: + return True, "" + return False, "axis name should should not start or end with underscore" + else: + if keyword.iskeyword(name): + warnings.warn( + f"It is discouraged to use axes names that are keywords: {name}", + RuntimeWarning, + ) + if name in ["axis"]: + warnings.warn( + "It is discouraged to use 'axis' as an axis name and will raise an error in future", + FutureWarning, + ) + return True, "" + + @staticmethod + def check_axis_name(name: str) -> bool: + """Check if the name is a valid axis name. + + Args: + name (str): the axis name to check + + Returns: + bool: whether the axis name is valid + """ + is_valid, _ = ParsedExpression.check_axis_name_return_reason(name) + return is_valid + + +def parse_pattern( + pattern: str, axes_lengths: Mapping[str, int] +) -> Tuple[ParsedExpression, ParsedExpression]: + """Parse an `einops`-style pattern into a left-hand side and right-hand side `ParsedExpression` object. + + Args: + pattern (str): the `einops`-style rearrangement pattern + axes_lengths (Mapping[str, int]): any additional length specifications for dimensions + + Returns: + Tuple[ParsedExpression, ParsedExpression]: a tuple containing the left-hand side and right-hand side expressions + """ + # adapted from einops.einops._prepare_transformation_recipe + # https://github.com/arogozhnikov/einops/blob/230ac1526c1f42c9e1f7373912c7f8047496df11/einops/einops.py + try: + left_str, right_str = pattern.split("->") + except ValueError: + raise ValueError("Pattern must contain a single '->' separator") from None + + if _ellipsis in axes_lengths: + raise ValueError(f"'{_ellipsis}' is not an allowed axis identifier") + + left = ParsedExpression(left_str) + right = ParsedExpression(right_str) + + if not left.has_ellipsis and right.has_ellipsis: + raise ValueError( + f"Ellipsis found in right side, but not left side of a pattern {pattern}" + ) + if left.has_ellipsis and left.has_ellipsis_parenthesized: + raise ValueError( + f"Ellipsis is parenthesis in the left side is not allowed: {pattern}" + ) + + return left, right + + +def validate_rearrange_expressions( + left: ParsedExpression, right: ParsedExpression, axes_lengths: Mapping[str, int] +) -> None: + """Perform expression validations that are specific to the `rearrange` operation. + + Args: + left (ParsedExpression): left-hand side expression + right (ParsedExpression): right-hand side expression + axes_lengths (Mapping[str, int]): any additional length specifications for dimensions + """ + for length in axes_lengths.values(): + if (length_type := type(length)) is not int: + raise TypeError( + f"rearrange axis lengths must be integers, got: {length_type}" + ) + + if left.has_non_unitary_anonymous_axes or right.has_non_unitary_anonymous_axes: + raise ValueError("rearrange only supports unnamed axes of size 1") + + difference = set.symmetric_difference(left.identifiers, right.identifiers) + if len(difference) > 0: + raise ValueError( + f"Identifiers only on one side of rearrange expression (should be on both): {difference}" + ) + + unmatched_axes = axes_lengths.keys() - left.identifiers + if len(unmatched_axes) > 0: + raise ValueError( + f"Identifiers not found in rearrange expression: {unmatched_axes}" + ) + + +def comma_separate(collection: Collection[Union[str, Collection[str]]]) -> str: + """Convert a collection of strings representing first class dims into a comma-separated string. + + Args: + collection (Collection[Union[str, Collection[str]]]): the collection of strings to convert + + Returns: + str: the comma-separated string + + Examples: + >>> comma_separate(("d0",)) + 'd0' + + >>> comma_separate(("d0", "d1", "d2", "d3")) + 'd0, d1, d2, d3' + + >>> comma_separate([("d1", "d4")]) + '(d1, d4)' + + >>> comma_separate([("d0",), (), ("d1",), ("d2",), ("d3", "d4")]) + '(d0,), (), (d1,), (d2,), (d3, d4)' + """ + return ", ".join( + item + if isinstance(item, str) + else f"({comma_separate(item)}{',' if len(item) == 1 else ''})" + for item in collection + ) diff --git a/venv/lib/python3.10/site-packages/functorch/einops/rearrange.py b/venv/lib/python3.10/site-packages/functorch/einops/rearrange.py new file mode 100644 index 0000000000000000000000000000000000000000..a0bceed7388347faefe35b14e1d31759fdb5fa5f --- /dev/null +++ b/venv/lib/python3.10/site-packages/functorch/einops/rearrange.py @@ -0,0 +1,208 @@ +from __future__ import annotations + +import functools +from typing import Callable, Dict, List, Sequence, Tuple, Union + +import torch +from functorch._C import dim as _C + +from ._parsing import ( + _ellipsis, + AnonymousAxis, + comma_separate, + parse_pattern, + validate_rearrange_expressions, +) + + +__all__ = ["rearrange"] + +dims = _C.dims + + +@functools.lru_cache(256) +def _create_rearrange_callable( + tensor_ndim: int, pattern: str, **axes_lengths: int +) -> Callable[[torch.Tensor], torch.Tensor]: + r"""Translate an `einops`-style pattern into a callable that performs the rearrange using first-class dimensions. + + Since the an equivalent result is computed for tensors with the same number of dimensions, with the same pattern and + specified axes lengths, this function can be memoized. + + Args: + tensor_ndim (int): the number of dimensions in the tensor to rearrange + pattern (str): the `einops`-style rearrangement pattern + axes_lengths (int): any additional length specifications for dimensions + + Returns: + Callable[[torch.Tensor], torch.Tensor]: a callable that performs the rearrangement + """ + left, right = parse_pattern(pattern, axes_lengths) + validate_rearrange_expressions(left, right, axes_lengths) + + n_anon_dims = sum(not dim for dim in left.composition) + if left.has_ellipsis: + n_ellipsis_dims = tensor_ndim - (len(left.composition) - 1) + n_named_dims = len(left.identifiers) - 1 + + if (pattern_ndim := n_anon_dims + n_named_dims) > tensor_ndim: + raise ValueError( + f"Number of dimensions in pattern ({pattern_ndim}) must be less than or equal to the number of " + f"dimensions in the tensor ({tensor_ndim})" + ) + else: + n_ellipsis_dims = 0 + n_named_dims = len(left.identifiers) + + if (pattern_ndim := len(left.composition)) != tensor_ndim: + raise ValueError( + f"Number of dimensions in pattern ({pattern_ndim}) must be equal to the number of dimensions in " + f"the tensor ({tensor_ndim})" + ) + n_dims = n_named_dims + n_ellipsis_dims + n_anon_dims + + if n_dims == 0: + # an identity rearrangement on a 0-dimension tensor + return lambda tensor: tensor + + first_class_dims: Tuple[str, ...] = tuple(f"d{i}" for i in range(n_dims)) + identifier_dim_map: Dict[Union[str, AnonymousAxis], Tuple[str, ...]] = {} + anon_axes: List[AnonymousAxis] = [] + + # map the left-hand side identifiers to strings representing first class dims + dims_i = 0 + for dimension in left.composition: + if isinstance(dimension, list): + for identifier in dimension: + # non-unitary anon axes are not allowed in rearrange & unitary anon axes are represented as empty lists + assert isinstance(identifier, str) + identifier_dim_map[identifier] = (first_class_dims[dims_i],) + dims_i += 1 + if not dimension: + # unitary anonymous axis + anon_axis = AnonymousAxis("1") + identifier_dim_map[anon_axis] = (first_class_dims[dims_i],) + anon_axes.append(anon_axis) + dimension.append(anon_axis) + dims_i += 1 + elif dimension == _ellipsis: + identifier = _ellipsis + identifier_dim_map[identifier] = tuple( + first_class_dims[dims_i + j] for j in range(n_ellipsis_dims) + ) + dims_i += n_ellipsis_dims + else: + raise ValueError(f"Unexpected dimension: {dimension}") + + def composition_to_dims( + composition: Sequence[Union[List[Union[str, AnonymousAxis]], str]], + ) -> List[Union[str, Tuple[str, ...]]]: + """Convert a `ParsedExpression.composition` into a `Tensor.__getitem__` index of strings representing first + class dims.""" + dim_composition: List[Union[str, Tuple[str, ...]]] = [] + for dimension in composition: + if isinstance(dimension, list): + dim_composition.append( + tuple( + dim + for identifier in dimension + for dim in identifier_dim_map[identifier] + ) + ) + elif dimension == _ellipsis: + dim_composition.extend(identifier_dim_map[_ellipsis]) + else: + raise ValueError(f"Unexpected dimension: {dimension}") + return dim_composition + + left_dims = composition_to_dims(left.composition) + right_dims = composition_to_dims(right.composition) + anon_dims = tuple(identifier_dim_map[axis][0] for axis in anon_axes) + specified_lengths = tuple( + (identifier_dim_map[axis][0], length) for axis, length in axes_lengths.items() + ) + + custom_rearrange_callable_name = "do_rearrange" + custom_rearrange_callable_code = ( + ( + f"def {custom_rearrange_callable_name}(tensor):\n" + f" {comma_separate(first_class_dims)} = dims({n_dims})\n" + ) + + ( + "".join( + f" {dim}.size = {length}\n" for (dim, length) in specified_lengths + ) + if specified_lengths + else "" + ) + + f" tensor = tensor[{comma_separate(left_dims)}].order({comma_separate(right_dims)})\n" + + ( + f" return tensor.sum({comma_separate([anon_dims])}, keepdim=False)\n" + if anon_dims + else " return tensor\n" + ) + ) + + exec(custom_rearrange_callable_code) + return locals()[custom_rearrange_callable_name] + + +def rearrange( + tensor: Union[torch.Tensor, List[torch.Tensor], Tuple[torch.Tensor, ...]], + pattern: str, + **axes_lengths: int, +) -> torch.Tensor: + r"""A native implementation of `einops.rearrange`, a reader-friendly smart element reordering for multidimensional + tensors. This operation includes functionality of transpose (axes permutation), reshape (view), squeeze, unsqueeze, + stack, concatenate and other operations. + + See: https://einops.rocks/api/rearrange/ + + Args: + tensor (Tensor or sequence of Tensor): the tensor(s) to rearrange + pattern (str): the rearrangement pattern + axes_lengths (int): any additional length specifications for dimensions + + Returns: + Tensor: the rearranged tensor + + Examples: + >>> # suppose we have a set of 32 images in "h w c" format (height-width-channel) + >>> images = torch.randn((32, 30, 40, 3)) + + >>> # stack along first (batch) axis, output is a single array + >>> rearrange(images, "b h w c -> b h w c").shape + torch.Size([32, 30, 40, 3]) + + >>> # concatenate images along height (vertical axis), 960 = 32 * 30 + >>> rearrange(images, "b h w c -> (b h) w c").shape + torch.Size([960, 40, 3]) + + >>> # concatenated images along horizontal axis, 1280 = 32 * 40 + >>> rearrange(images, "b h w c -> h (b w) c").shape + torch.Size([30, 1280, 3]) + + >>> # reordered axes to "b c h w" format for deep learning + >>> rearrange(images, "b h w c -> b c h w").shape + torch.Size([32, 3, 30, 40]) + + >>> # flattened each image into a vector, 3600 = 30 * 40 * 3 + >>> rearrange(images, "b h w c -> b (c h w)").shape + torch.Size([32, 3600]) + + >>> # split each image into 4 smaller (top-left, top-right, bottom-left, bottom-right), 128 = 32 * 2 * 2 + >>> rearrange(images, "b (h1 h) (w1 w) c -> (b h1 w1) h w c", h1=2, w1=2).shape + torch.Size([128, 15, 20, 3]) + + >>> # space-to-depth operation + >>> rearrange(images, "b (h h1) (w w1) c -> b h w (c h1 w1)", h1=2, w1=2).shape + torch.Size([32, 15, 20, 12]) + """ + if not isinstance(tensor, torch.Tensor): + tensor = torch.stack(tensor) + + rearrange_callable = _create_rearrange_callable( + tensor.ndim, pattern, **axes_lengths + ) + + return rearrange_callable(tensor) diff --git a/venv/lib/python3.10/site-packages/functorch/experimental/__init__.py b/venv/lib/python3.10/site-packages/functorch/experimental/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..3941f6d96e1f6df532966d06de4f72a952a58465 --- /dev/null +++ b/venv/lib/python3.10/site-packages/functorch/experimental/__init__.py @@ -0,0 +1,5 @@ +# PyTorch forward-mode is not mature yet +from functorch import functionalize +from torch._functorch.apis import chunk_vmap +from torch._functorch.batch_norm_replacement import replace_all_batch_norm_modules_ +from torch._functorch.eager_transforms import hessian, jacfwd, jvp diff --git a/venv/lib/python3.10/site-packages/functorch/experimental/__pycache__/__init__.cpython-310.pyc b/venv/lib/python3.10/site-packages/functorch/experimental/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0c2cdc0f08b6276b8a0f67487171aac0d75f87a4 Binary files /dev/null and b/venv/lib/python3.10/site-packages/functorch/experimental/__pycache__/__init__.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/functorch/experimental/__pycache__/control_flow.cpython-310.pyc b/venv/lib/python3.10/site-packages/functorch/experimental/__pycache__/control_flow.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c716719c954794d712cb7cd0947ead672e8a18bb Binary files /dev/null and b/venv/lib/python3.10/site-packages/functorch/experimental/__pycache__/control_flow.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/functorch/experimental/__pycache__/ops.cpython-310.pyc b/venv/lib/python3.10/site-packages/functorch/experimental/__pycache__/ops.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6b7891a18dc6ee93eb7f2d9203bf885c573b9d88 Binary files /dev/null and b/venv/lib/python3.10/site-packages/functorch/experimental/__pycache__/ops.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/functorch/experimental/control_flow.py b/venv/lib/python3.10/site-packages/functorch/experimental/control_flow.py new file mode 100644 index 0000000000000000000000000000000000000000..cbfd76d184cc224042a1ee19454d6957c2221b3b --- /dev/null +++ b/venv/lib/python3.10/site-packages/functorch/experimental/control_flow.py @@ -0,0 +1,7 @@ +from torch import cond # noqa: F401 +from torch._higher_order_ops.cond import UnsupportedAliasMutationException # noqa: F401 +from torch._higher_order_ops.map import ( # noqa: F401 + _stack_pytree, + _unstack_pytree, + map, +) diff --git a/venv/lib/python3.10/site-packages/functorch/experimental/ops.py b/venv/lib/python3.10/site-packages/functorch/experimental/ops.py new file mode 100644 index 0000000000000000000000000000000000000000..7a502ef2b002cd824e7b67d08fccac872b313110 --- /dev/null +++ b/venv/lib/python3.10/site-packages/functorch/experimental/ops.py @@ -0,0 +1 @@ +from torch._ops import HigherOrderOperator # noqa: F401 diff --git a/venv/lib/python3.10/site-packages/httpcore/__init__.py b/venv/lib/python3.10/site-packages/httpcore/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..9a92dc4a440bdf6f259ec1083c89c817eb7b631b --- /dev/null +++ b/venv/lib/python3.10/site-packages/httpcore/__init__.py @@ -0,0 +1,141 @@ +from ._api import request, stream +from ._async import ( + AsyncConnectionInterface, + AsyncConnectionPool, + AsyncHTTP2Connection, + AsyncHTTP11Connection, + AsyncHTTPConnection, + AsyncHTTPProxy, + AsyncSOCKSProxy, +) +from ._backends.base import ( + SOCKET_OPTION, + AsyncNetworkBackend, + AsyncNetworkStream, + NetworkBackend, + NetworkStream, +) +from ._backends.mock import AsyncMockBackend, AsyncMockStream, MockBackend, MockStream +from ._backends.sync import SyncBackend +from ._exceptions import ( + ConnectError, + ConnectionNotAvailable, + ConnectTimeout, + LocalProtocolError, + NetworkError, + PoolTimeout, + ProtocolError, + ProxyError, + ReadError, + ReadTimeout, + RemoteProtocolError, + TimeoutException, + UnsupportedProtocol, + WriteError, + WriteTimeout, +) +from ._models import URL, Origin, Proxy, Request, Response +from ._ssl import default_ssl_context +from ._sync import ( + ConnectionInterface, + ConnectionPool, + HTTP2Connection, + HTTP11Connection, + HTTPConnection, + HTTPProxy, + SOCKSProxy, +) + +# The 'httpcore.AnyIOBackend' class is conditional on 'anyio' being installed. +try: + from ._backends.anyio import AnyIOBackend +except ImportError: # pragma: nocover + + class AnyIOBackend: # type: ignore + def __init__(self, *args, **kwargs): # type: ignore + msg = ( + "Attempted to use 'httpcore.AnyIOBackend' but 'anyio' is not installed." + ) + raise RuntimeError(msg) + + +# The 'httpcore.TrioBackend' class is conditional on 'trio' being installed. +try: + from ._backends.trio import TrioBackend +except ImportError: # pragma: nocover + + class TrioBackend: # type: ignore + def __init__(self, *args, **kwargs): # type: ignore + msg = "Attempted to use 'httpcore.TrioBackend' but 'trio' is not installed." + raise RuntimeError(msg) + + +__all__ = [ + # top-level requests + "request", + "stream", + # models + "Origin", + "URL", + "Request", + "Response", + "Proxy", + # async + "AsyncHTTPConnection", + "AsyncConnectionPool", + "AsyncHTTPProxy", + "AsyncHTTP11Connection", + "AsyncHTTP2Connection", + "AsyncConnectionInterface", + "AsyncSOCKSProxy", + # sync + "HTTPConnection", + "ConnectionPool", + "HTTPProxy", + "HTTP11Connection", + "HTTP2Connection", + "ConnectionInterface", + "SOCKSProxy", + # network backends, implementations + "SyncBackend", + "AnyIOBackend", + "TrioBackend", + # network backends, mock implementations + "AsyncMockBackend", + "AsyncMockStream", + "MockBackend", + "MockStream", + # network backends, interface + "AsyncNetworkStream", + "AsyncNetworkBackend", + "NetworkStream", + "NetworkBackend", + # util + "default_ssl_context", + "SOCKET_OPTION", + # exceptions + "ConnectionNotAvailable", + "ProxyError", + "ProtocolError", + "LocalProtocolError", + "RemoteProtocolError", + "UnsupportedProtocol", + "TimeoutException", + "PoolTimeout", + "ConnectTimeout", + "ReadTimeout", + "WriteTimeout", + "NetworkError", + "ConnectError", + "ReadError", + "WriteError", +] + +__version__ = "1.0.9" + + +__locals = locals() +for __name in __all__: + # Exclude SOCKET_OPTION, it causes AttributeError on Python 3.14 + if not __name.startswith(("__", "SOCKET_OPTION")): + setattr(__locals[__name], "__module__", "httpcore") # noqa diff --git a/venv/lib/python3.10/site-packages/httpcore/__pycache__/__init__.cpython-310.pyc b/venv/lib/python3.10/site-packages/httpcore/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b65964a5d6d32f0f1f7776dc694ae1c1258e4c3c Binary files /dev/null and b/venv/lib/python3.10/site-packages/httpcore/__pycache__/__init__.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/httpcore/__pycache__/_api.cpython-310.pyc b/venv/lib/python3.10/site-packages/httpcore/__pycache__/_api.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1f78af7772e2638217b7e2e308b0dfc10e3640bb Binary files /dev/null and b/venv/lib/python3.10/site-packages/httpcore/__pycache__/_api.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/httpcore/__pycache__/_exceptions.cpython-310.pyc b/venv/lib/python3.10/site-packages/httpcore/__pycache__/_exceptions.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5a3f26602af2d463f9537c13a904f1c012926e74 Binary files /dev/null and b/venv/lib/python3.10/site-packages/httpcore/__pycache__/_exceptions.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/httpcore/__pycache__/_models.cpython-310.pyc b/venv/lib/python3.10/site-packages/httpcore/__pycache__/_models.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..dbcf3a5dc3704df365464f3149870f8865cdda9e Binary files /dev/null and b/venv/lib/python3.10/site-packages/httpcore/__pycache__/_models.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/httpcore/__pycache__/_ssl.cpython-310.pyc b/venv/lib/python3.10/site-packages/httpcore/__pycache__/_ssl.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3097df06457b8b28365a9c458c543aeec40cbb3e Binary files /dev/null and b/venv/lib/python3.10/site-packages/httpcore/__pycache__/_ssl.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/httpcore/__pycache__/_synchronization.cpython-310.pyc b/venv/lib/python3.10/site-packages/httpcore/__pycache__/_synchronization.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..47c3e05f8b89749f1724a5d3525413a1e45c446f Binary files /dev/null and b/venv/lib/python3.10/site-packages/httpcore/__pycache__/_synchronization.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/httpcore/__pycache__/_trace.cpython-310.pyc b/venv/lib/python3.10/site-packages/httpcore/__pycache__/_trace.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..776cd4a4aec9f98f6769e9465f447fd1fbf0b6e6 Binary files /dev/null and b/venv/lib/python3.10/site-packages/httpcore/__pycache__/_trace.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/httpcore/__pycache__/_utils.cpython-310.pyc b/venv/lib/python3.10/site-packages/httpcore/__pycache__/_utils.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..50a8778a5604f2a272553d7ba5360f6b40c9a722 Binary files /dev/null and b/venv/lib/python3.10/site-packages/httpcore/__pycache__/_utils.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/httpcore/_api.py b/venv/lib/python3.10/site-packages/httpcore/_api.py new file mode 100644 index 0000000000000000000000000000000000000000..38b961d10de88bebc98c758d0d1f14af1e7c0370 --- /dev/null +++ b/venv/lib/python3.10/site-packages/httpcore/_api.py @@ -0,0 +1,94 @@ +from __future__ import annotations + +import contextlib +import typing + +from ._models import URL, Extensions, HeaderTypes, Response +from ._sync.connection_pool import ConnectionPool + + +def request( + method: bytes | str, + url: URL | bytes | str, + *, + headers: HeaderTypes = None, + content: bytes | typing.Iterator[bytes] | None = None, + extensions: Extensions | None = None, +) -> Response: + """ + Sends an HTTP request, returning the response. + + ``` + response = httpcore.request("GET", "https://www.example.com/") + ``` + + Arguments: + method: The HTTP method for the request. Typically one of `"GET"`, + `"OPTIONS"`, `"HEAD"`, `"POST"`, `"PUT"`, `"PATCH"`, or `"DELETE"`. + url: The URL of the HTTP request. Either as an instance of `httpcore.URL`, + or as str/bytes. + headers: The HTTP request headers. Either as a dictionary of str/bytes, + or as a list of two-tuples of str/bytes. + content: The content of the request body. Either as bytes, + or as a bytes iterator. + extensions: A dictionary of optional extra information included on the request. + Possible keys include `"timeout"`. + + Returns: + An instance of `httpcore.Response`. + """ + with ConnectionPool() as pool: + return pool.request( + method=method, + url=url, + headers=headers, + content=content, + extensions=extensions, + ) + + +@contextlib.contextmanager +def stream( + method: bytes | str, + url: URL | bytes | str, + *, + headers: HeaderTypes = None, + content: bytes | typing.Iterator[bytes] | None = None, + extensions: Extensions | None = None, +) -> typing.Iterator[Response]: + """ + Sends an HTTP request, returning the response within a content manager. + + ``` + with httpcore.stream("GET", "https://www.example.com/") as response: + ... + ``` + + When using the `stream()` function, the body of the response will not be + automatically read. If you want to access the response body you should + either use `content = response.read()`, or `for chunk in response.iter_content()`. + + Arguments: + method: The HTTP method for the request. Typically one of `"GET"`, + `"OPTIONS"`, `"HEAD"`, `"POST"`, `"PUT"`, `"PATCH"`, or `"DELETE"`. + url: The URL of the HTTP request. Either as an instance of `httpcore.URL`, + or as str/bytes. + headers: The HTTP request headers. Either as a dictionary of str/bytes, + or as a list of two-tuples of str/bytes. + content: The content of the request body. Either as bytes, + or as a bytes iterator. + extensions: A dictionary of optional extra information included on the request. + Possible keys include `"timeout"`. + + Returns: + An instance of `httpcore.Response`. + """ + with ConnectionPool() as pool: + with pool.stream( + method=method, + url=url, + headers=headers, + content=content, + extensions=extensions, + ) as response: + yield response diff --git a/venv/lib/python3.10/site-packages/httpcore/_async/__init__.py b/venv/lib/python3.10/site-packages/httpcore/_async/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..88dc7f01e132933728cbcf45c88ce82e85ddf65f --- /dev/null +++ b/venv/lib/python3.10/site-packages/httpcore/_async/__init__.py @@ -0,0 +1,39 @@ +from .connection import AsyncHTTPConnection +from .connection_pool import AsyncConnectionPool +from .http11 import AsyncHTTP11Connection +from .http_proxy import AsyncHTTPProxy +from .interfaces import AsyncConnectionInterface + +try: + from .http2 import AsyncHTTP2Connection +except ImportError: # pragma: nocover + + class AsyncHTTP2Connection: # type: ignore + def __init__(self, *args, **kwargs) -> None: # type: ignore + raise RuntimeError( + "Attempted to use http2 support, but the `h2` package is not " + "installed. Use 'pip install httpcore[http2]'." + ) + + +try: + from .socks_proxy import AsyncSOCKSProxy +except ImportError: # pragma: nocover + + class AsyncSOCKSProxy: # type: ignore + def __init__(self, *args, **kwargs) -> None: # type: ignore + raise RuntimeError( + "Attempted to use SOCKS support, but the `socksio` package is not " + "installed. Use 'pip install httpcore[socks]'." + ) + + +__all__ = [ + "AsyncHTTPConnection", + "AsyncConnectionPool", + "AsyncHTTPProxy", + "AsyncHTTP11Connection", + "AsyncHTTP2Connection", + "AsyncConnectionInterface", + "AsyncSOCKSProxy", +] diff --git a/venv/lib/python3.10/site-packages/httpcore/_async/__pycache__/__init__.cpython-310.pyc b/venv/lib/python3.10/site-packages/httpcore/_async/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f8d89a36b662974666143db334c73ce28a8b6175 Binary files /dev/null and b/venv/lib/python3.10/site-packages/httpcore/_async/__pycache__/__init__.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/httpcore/_async/__pycache__/connection.cpython-310.pyc b/venv/lib/python3.10/site-packages/httpcore/_async/__pycache__/connection.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fc60b487eb3b5900a8370d2ecec488d362415a71 Binary files /dev/null and b/venv/lib/python3.10/site-packages/httpcore/_async/__pycache__/connection.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/httpcore/_async/__pycache__/connection_pool.cpython-310.pyc b/venv/lib/python3.10/site-packages/httpcore/_async/__pycache__/connection_pool.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e8568f4bba81c36e8d06d813267b720551ef7be6 Binary files /dev/null and b/venv/lib/python3.10/site-packages/httpcore/_async/__pycache__/connection_pool.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/httpcore/_async/__pycache__/http11.cpython-310.pyc b/venv/lib/python3.10/site-packages/httpcore/_async/__pycache__/http11.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f17a0dd97140ccbb0b4b35b9258782b839668dc9 Binary files /dev/null and b/venv/lib/python3.10/site-packages/httpcore/_async/__pycache__/http11.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/httpcore/_async/__pycache__/http2.cpython-310.pyc b/venv/lib/python3.10/site-packages/httpcore/_async/__pycache__/http2.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..970e6520c84d98ed1101d4660f672c3107201060 Binary files /dev/null and b/venv/lib/python3.10/site-packages/httpcore/_async/__pycache__/http2.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/httpcore/_async/__pycache__/http_proxy.cpython-310.pyc b/venv/lib/python3.10/site-packages/httpcore/_async/__pycache__/http_proxy.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a30a127f304ff19df479d4c874006d19767bf309 Binary files /dev/null and b/venv/lib/python3.10/site-packages/httpcore/_async/__pycache__/http_proxy.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/httpcore/_async/__pycache__/interfaces.cpython-310.pyc b/venv/lib/python3.10/site-packages/httpcore/_async/__pycache__/interfaces.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..eaab5053715a21b7ad6a3a043427a54b039402c6 Binary files /dev/null and b/venv/lib/python3.10/site-packages/httpcore/_async/__pycache__/interfaces.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/httpcore/_async/__pycache__/socks_proxy.cpython-310.pyc b/venv/lib/python3.10/site-packages/httpcore/_async/__pycache__/socks_proxy.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f8de8c9f1494d7afc066bbd9cec084265dcd97a1 Binary files /dev/null and b/venv/lib/python3.10/site-packages/httpcore/_async/__pycache__/socks_proxy.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/httpcore/_async/connection.py b/venv/lib/python3.10/site-packages/httpcore/_async/connection.py new file mode 100644 index 0000000000000000000000000000000000000000..b42581dff8aabf4c2ef80ffda26296e1b368d693 --- /dev/null +++ b/venv/lib/python3.10/site-packages/httpcore/_async/connection.py @@ -0,0 +1,222 @@ +from __future__ import annotations + +import itertools +import logging +import ssl +import types +import typing + +from .._backends.auto import AutoBackend +from .._backends.base import SOCKET_OPTION, AsyncNetworkBackend, AsyncNetworkStream +from .._exceptions import ConnectError, ConnectTimeout +from .._models import Origin, Request, Response +from .._ssl import default_ssl_context +from .._synchronization import AsyncLock +from .._trace import Trace +from .http11 import AsyncHTTP11Connection +from .interfaces import AsyncConnectionInterface + +RETRIES_BACKOFF_FACTOR = 0.5 # 0s, 0.5s, 1s, 2s, 4s, etc. + + +logger = logging.getLogger("httpcore.connection") + + +def exponential_backoff(factor: float) -> typing.Iterator[float]: + """ + Generate a geometric sequence that has a ratio of 2 and starts with 0. + + For example: + - `factor = 2`: `0, 2, 4, 8, 16, 32, 64, ...` + - `factor = 3`: `0, 3, 6, 12, 24, 48, 96, ...` + """ + yield 0 + for n in itertools.count(): + yield factor * 2**n + + +class AsyncHTTPConnection(AsyncConnectionInterface): + def __init__( + self, + origin: Origin, + ssl_context: ssl.SSLContext | None = None, + keepalive_expiry: float | None = None, + http1: bool = True, + http2: bool = False, + retries: int = 0, + local_address: str | None = None, + uds: str | None = None, + network_backend: AsyncNetworkBackend | None = None, + socket_options: typing.Iterable[SOCKET_OPTION] | None = None, + ) -> None: + self._origin = origin + self._ssl_context = ssl_context + self._keepalive_expiry = keepalive_expiry + self._http1 = http1 + self._http2 = http2 + self._retries = retries + self._local_address = local_address + self._uds = uds + + self._network_backend: AsyncNetworkBackend = ( + AutoBackend() if network_backend is None else network_backend + ) + self._connection: AsyncConnectionInterface | None = None + self._connect_failed: bool = False + self._request_lock = AsyncLock() + self._socket_options = socket_options + + async def handle_async_request(self, request: Request) -> Response: + if not self.can_handle_request(request.url.origin): + raise RuntimeError( + f"Attempted to send request to {request.url.origin} on connection to {self._origin}" + ) + + try: + async with self._request_lock: + if self._connection is None: + stream = await self._connect(request) + + ssl_object = stream.get_extra_info("ssl_object") + http2_negotiated = ( + ssl_object is not None + and ssl_object.selected_alpn_protocol() == "h2" + ) + if http2_negotiated or (self._http2 and not self._http1): + from .http2 import AsyncHTTP2Connection + + self._connection = AsyncHTTP2Connection( + origin=self._origin, + stream=stream, + keepalive_expiry=self._keepalive_expiry, + ) + else: + self._connection = AsyncHTTP11Connection( + origin=self._origin, + stream=stream, + keepalive_expiry=self._keepalive_expiry, + ) + except BaseException as exc: + self._connect_failed = True + raise exc + + return await self._connection.handle_async_request(request) + + async def _connect(self, request: Request) -> AsyncNetworkStream: + timeouts = request.extensions.get("timeout", {}) + sni_hostname = request.extensions.get("sni_hostname", None) + timeout = timeouts.get("connect", None) + + retries_left = self._retries + delays = exponential_backoff(factor=RETRIES_BACKOFF_FACTOR) + + while True: + try: + if self._uds is None: + kwargs = { + "host": self._origin.host.decode("ascii"), + "port": self._origin.port, + "local_address": self._local_address, + "timeout": timeout, + "socket_options": self._socket_options, + } + async with Trace("connect_tcp", logger, request, kwargs) as trace: + stream = await self._network_backend.connect_tcp(**kwargs) + trace.return_value = stream + else: + kwargs = { + "path": self._uds, + "timeout": timeout, + "socket_options": self._socket_options, + } + async with Trace( + "connect_unix_socket", logger, request, kwargs + ) as trace: + stream = await self._network_backend.connect_unix_socket( + **kwargs + ) + trace.return_value = stream + + if self._origin.scheme in (b"https", b"wss"): + ssl_context = ( + default_ssl_context() + if self._ssl_context is None + else self._ssl_context + ) + alpn_protocols = ["http/1.1", "h2"] if self._http2 else ["http/1.1"] + ssl_context.set_alpn_protocols(alpn_protocols) + + kwargs = { + "ssl_context": ssl_context, + "server_hostname": sni_hostname + or self._origin.host.decode("ascii"), + "timeout": timeout, + } + async with Trace("start_tls", logger, request, kwargs) as trace: + stream = await stream.start_tls(**kwargs) + trace.return_value = stream + return stream + except (ConnectError, ConnectTimeout): + if retries_left <= 0: + raise + retries_left -= 1 + delay = next(delays) + async with Trace("retry", logger, request, kwargs) as trace: + await self._network_backend.sleep(delay) + + def can_handle_request(self, origin: Origin) -> bool: + return origin == self._origin + + async def aclose(self) -> None: + if self._connection is not None: + async with Trace("close", logger, None, {}): + await self._connection.aclose() + + def is_available(self) -> bool: + if self._connection is None: + # If HTTP/2 support is enabled, and the resulting connection could + # end up as HTTP/2 then we should indicate the connection as being + # available to service multiple requests. + return ( + self._http2 + and (self._origin.scheme == b"https" or not self._http1) + and not self._connect_failed + ) + return self._connection.is_available() + + def has_expired(self) -> bool: + if self._connection is None: + return self._connect_failed + return self._connection.has_expired() + + def is_idle(self) -> bool: + if self._connection is None: + return self._connect_failed + return self._connection.is_idle() + + def is_closed(self) -> bool: + if self._connection is None: + return self._connect_failed + return self._connection.is_closed() + + def info(self) -> str: + if self._connection is None: + return "CONNECTION FAILED" if self._connect_failed else "CONNECTING" + return self._connection.info() + + def __repr__(self) -> str: + return f"<{self.__class__.__name__} [{self.info()}]>" + + # These context managers are not used in the standard flow, but are + # useful for testing or working with connection instances directly. + + async def __aenter__(self) -> AsyncHTTPConnection: + return self + + async def __aexit__( + self, + exc_type: type[BaseException] | None = None, + exc_value: BaseException | None = None, + traceback: types.TracebackType | None = None, + ) -> None: + await self.aclose() diff --git a/venv/lib/python3.10/site-packages/httpcore/_async/connection_pool.py b/venv/lib/python3.10/site-packages/httpcore/_async/connection_pool.py new file mode 100644 index 0000000000000000000000000000000000000000..96e973d0ce223f6bed9be9e6a6a2f3c01622c611 --- /dev/null +++ b/venv/lib/python3.10/site-packages/httpcore/_async/connection_pool.py @@ -0,0 +1,420 @@ +from __future__ import annotations + +import ssl +import sys +import types +import typing + +from .._backends.auto import AutoBackend +from .._backends.base import SOCKET_OPTION, AsyncNetworkBackend +from .._exceptions import ConnectionNotAvailable, UnsupportedProtocol +from .._models import Origin, Proxy, Request, Response +from .._synchronization import AsyncEvent, AsyncShieldCancellation, AsyncThreadLock +from .connection import AsyncHTTPConnection +from .interfaces import AsyncConnectionInterface, AsyncRequestInterface + + +class AsyncPoolRequest: + def __init__(self, request: Request) -> None: + self.request = request + self.connection: AsyncConnectionInterface | None = None + self._connection_acquired = AsyncEvent() + + def assign_to_connection(self, connection: AsyncConnectionInterface | None) -> None: + self.connection = connection + self._connection_acquired.set() + + def clear_connection(self) -> None: + self.connection = None + self._connection_acquired = AsyncEvent() + + async def wait_for_connection( + self, timeout: float | None = None + ) -> AsyncConnectionInterface: + if self.connection is None: + await self._connection_acquired.wait(timeout=timeout) + assert self.connection is not None + return self.connection + + def is_queued(self) -> bool: + return self.connection is None + + +class AsyncConnectionPool(AsyncRequestInterface): + """ + A connection pool for making HTTP requests. + """ + + def __init__( + self, + ssl_context: ssl.SSLContext | None = None, + proxy: Proxy | None = None, + max_connections: int | None = 10, + max_keepalive_connections: int | None = None, + keepalive_expiry: float | None = None, + http1: bool = True, + http2: bool = False, + retries: int = 0, + local_address: str | None = None, + uds: str | None = None, + network_backend: AsyncNetworkBackend | None = None, + socket_options: typing.Iterable[SOCKET_OPTION] | None = None, + ) -> None: + """ + A connection pool for making HTTP requests. + + Parameters: + ssl_context: An SSL context to use for verifying connections. + If not specified, the default `httpcore.default_ssl_context()` + will be used. + max_connections: The maximum number of concurrent HTTP connections that + the pool should allow. Any attempt to send a request on a pool that + would exceed this amount will block until a connection is available. + max_keepalive_connections: The maximum number of idle HTTP connections + that will be maintained in the pool. + keepalive_expiry: The duration in seconds that an idle HTTP connection + may be maintained for before being expired from the pool. + http1: A boolean indicating if HTTP/1.1 requests should be supported + by the connection pool. Defaults to True. + http2: A boolean indicating if HTTP/2 requests should be supported by + the connection pool. Defaults to False. + retries: The maximum number of retries when trying to establish a + connection. + local_address: Local address to connect from. Can also be used to connect + using a particular address family. Using `local_address="0.0.0.0"` + will connect using an `AF_INET` address (IPv4), while using + `local_address="::"` will connect using an `AF_INET6` address (IPv6). + uds: Path to a Unix Domain Socket to use instead of TCP sockets. + network_backend: A backend instance to use for handling network I/O. + socket_options: Socket options that have to be included + in the TCP socket when the connection was established. + """ + self._ssl_context = ssl_context + self._proxy = proxy + self._max_connections = ( + sys.maxsize if max_connections is None else max_connections + ) + self._max_keepalive_connections = ( + sys.maxsize + if max_keepalive_connections is None + else max_keepalive_connections + ) + self._max_keepalive_connections = min( + self._max_connections, self._max_keepalive_connections + ) + + self._keepalive_expiry = keepalive_expiry + self._http1 = http1 + self._http2 = http2 + self._retries = retries + self._local_address = local_address + self._uds = uds + + self._network_backend = ( + AutoBackend() if network_backend is None else network_backend + ) + self._socket_options = socket_options + + # The mutable state on a connection pool is the queue of incoming requests, + # and the set of connections that are servicing those requests. + self._connections: list[AsyncConnectionInterface] = [] + self._requests: list[AsyncPoolRequest] = [] + + # We only mutate the state of the connection pool within an 'optional_thread_lock' + # context. This holds a threading lock unless we're running in async mode, + # in which case it is a no-op. + self._optional_thread_lock = AsyncThreadLock() + + def create_connection(self, origin: Origin) -> AsyncConnectionInterface: + if self._proxy is not None: + if self._proxy.url.scheme in (b"socks5", b"socks5h"): + from .socks_proxy import AsyncSocks5Connection + + return AsyncSocks5Connection( + proxy_origin=self._proxy.url.origin, + proxy_auth=self._proxy.auth, + remote_origin=origin, + ssl_context=self._ssl_context, + keepalive_expiry=self._keepalive_expiry, + http1=self._http1, + http2=self._http2, + network_backend=self._network_backend, + ) + elif origin.scheme == b"http": + from .http_proxy import AsyncForwardHTTPConnection + + return AsyncForwardHTTPConnection( + proxy_origin=self._proxy.url.origin, + proxy_headers=self._proxy.headers, + proxy_ssl_context=self._proxy.ssl_context, + remote_origin=origin, + keepalive_expiry=self._keepalive_expiry, + network_backend=self._network_backend, + ) + from .http_proxy import AsyncTunnelHTTPConnection + + return AsyncTunnelHTTPConnection( + proxy_origin=self._proxy.url.origin, + proxy_headers=self._proxy.headers, + proxy_ssl_context=self._proxy.ssl_context, + remote_origin=origin, + ssl_context=self._ssl_context, + keepalive_expiry=self._keepalive_expiry, + http1=self._http1, + http2=self._http2, + network_backend=self._network_backend, + ) + + return AsyncHTTPConnection( + origin=origin, + ssl_context=self._ssl_context, + keepalive_expiry=self._keepalive_expiry, + http1=self._http1, + http2=self._http2, + retries=self._retries, + local_address=self._local_address, + uds=self._uds, + network_backend=self._network_backend, + socket_options=self._socket_options, + ) + + @property + def connections(self) -> list[AsyncConnectionInterface]: + """ + Return a list of the connections currently in the pool. + + For example: + + ```python + >>> pool.connections + [ + , + , + , + ] + ``` + """ + return list(self._connections) + + async def handle_async_request(self, request: Request) -> Response: + """ + Send an HTTP request, and return an HTTP response. + + This is the core implementation that is called into by `.request()` or `.stream()`. + """ + scheme = request.url.scheme.decode() + if scheme == "": + raise UnsupportedProtocol( + "Request URL is missing an 'http://' or 'https://' protocol." + ) + if scheme not in ("http", "https", "ws", "wss"): + raise UnsupportedProtocol( + f"Request URL has an unsupported protocol '{scheme}://'." + ) + + timeouts = request.extensions.get("timeout", {}) + timeout = timeouts.get("pool", None) + + with self._optional_thread_lock: + # Add the incoming request to our request queue. + pool_request = AsyncPoolRequest(request) + self._requests.append(pool_request) + + try: + while True: + with self._optional_thread_lock: + # Assign incoming requests to available connections, + # closing or creating new connections as required. + closing = self._assign_requests_to_connections() + await self._close_connections(closing) + + # Wait until this request has an assigned connection. + connection = await pool_request.wait_for_connection(timeout=timeout) + + try: + # Send the request on the assigned connection. + response = await connection.handle_async_request( + pool_request.request + ) + except ConnectionNotAvailable: + # In some cases a connection may initially be available to + # handle a request, but then become unavailable. + # + # In this case we clear the connection and try again. + pool_request.clear_connection() + else: + break # pragma: nocover + + except BaseException as exc: + with self._optional_thread_lock: + # For any exception or cancellation we remove the request from + # the queue, and then re-assign requests to connections. + self._requests.remove(pool_request) + closing = self._assign_requests_to_connections() + + await self._close_connections(closing) + raise exc from None + + # Return the response. Note that in this case we still have to manage + # the point at which the response is closed. + assert isinstance(response.stream, typing.AsyncIterable) + return Response( + status=response.status, + headers=response.headers, + content=PoolByteStream( + stream=response.stream, pool_request=pool_request, pool=self + ), + extensions=response.extensions, + ) + + def _assign_requests_to_connections(self) -> list[AsyncConnectionInterface]: + """ + Manage the state of the connection pool, assigning incoming + requests to connections as available. + + Called whenever a new request is added or removed from the pool. + + Any closing connections are returned, allowing the I/O for closing + those connections to be handled seperately. + """ + closing_connections = [] + + # First we handle cleaning up any connections that are closed, + # have expired their keep-alive, or surplus idle connections. + for connection in list(self._connections): + if connection.is_closed(): + # log: "removing closed connection" + self._connections.remove(connection) + elif connection.has_expired(): + # log: "closing expired connection" + self._connections.remove(connection) + closing_connections.append(connection) + elif ( + connection.is_idle() + and len([connection.is_idle() for connection in self._connections]) + > self._max_keepalive_connections + ): + # log: "closing idle connection" + self._connections.remove(connection) + closing_connections.append(connection) + + # Assign queued requests to connections. + queued_requests = [request for request in self._requests if request.is_queued()] + for pool_request in queued_requests: + origin = pool_request.request.url.origin + available_connections = [ + connection + for connection in self._connections + if connection.can_handle_request(origin) and connection.is_available() + ] + idle_connections = [ + connection for connection in self._connections if connection.is_idle() + ] + + # There are three cases for how we may be able to handle the request: + # + # 1. There is an existing connection that can handle the request. + # 2. We can create a new connection to handle the request. + # 3. We can close an idle connection and then create a new connection + # to handle the request. + if available_connections: + # log: "reusing existing connection" + connection = available_connections[0] + pool_request.assign_to_connection(connection) + elif len(self._connections) < self._max_connections: + # log: "creating new connection" + connection = self.create_connection(origin) + self._connections.append(connection) + pool_request.assign_to_connection(connection) + elif idle_connections: + # log: "closing idle connection" + connection = idle_connections[0] + self._connections.remove(connection) + closing_connections.append(connection) + # log: "creating new connection" + connection = self.create_connection(origin) + self._connections.append(connection) + pool_request.assign_to_connection(connection) + + return closing_connections + + async def _close_connections(self, closing: list[AsyncConnectionInterface]) -> None: + # Close connections which have been removed from the pool. + with AsyncShieldCancellation(): + for connection in closing: + await connection.aclose() + + async def aclose(self) -> None: + # Explicitly close the connection pool. + # Clears all existing requests and connections. + with self._optional_thread_lock: + closing_connections = list(self._connections) + self._connections = [] + await self._close_connections(closing_connections) + + async def __aenter__(self) -> AsyncConnectionPool: + return self + + async def __aexit__( + self, + exc_type: type[BaseException] | None = None, + exc_value: BaseException | None = None, + traceback: types.TracebackType | None = None, + ) -> None: + await self.aclose() + + def __repr__(self) -> str: + class_name = self.__class__.__name__ + with self._optional_thread_lock: + request_is_queued = [request.is_queued() for request in self._requests] + connection_is_idle = [ + connection.is_idle() for connection in self._connections + ] + + num_active_requests = request_is_queued.count(False) + num_queued_requests = request_is_queued.count(True) + num_active_connections = connection_is_idle.count(False) + num_idle_connections = connection_is_idle.count(True) + + requests_info = ( + f"Requests: {num_active_requests} active, {num_queued_requests} queued" + ) + connection_info = ( + f"Connections: {num_active_connections} active, {num_idle_connections} idle" + ) + + return f"<{class_name} [{requests_info} | {connection_info}]>" + + +class PoolByteStream: + def __init__( + self, + stream: typing.AsyncIterable[bytes], + pool_request: AsyncPoolRequest, + pool: AsyncConnectionPool, + ) -> None: + self._stream = stream + self._pool_request = pool_request + self._pool = pool + self._closed = False + + async def __aiter__(self) -> typing.AsyncIterator[bytes]: + try: + async for part in self._stream: + yield part + except BaseException as exc: + await self.aclose() + raise exc from None + + async def aclose(self) -> None: + if not self._closed: + self._closed = True + with AsyncShieldCancellation(): + if hasattr(self._stream, "aclose"): + await self._stream.aclose() + + with self._pool._optional_thread_lock: + self._pool._requests.remove(self._pool_request) + closing = self._pool._assign_requests_to_connections() + + await self._pool._close_connections(closing) diff --git a/venv/lib/python3.10/site-packages/httpcore/_async/http11.py b/venv/lib/python3.10/site-packages/httpcore/_async/http11.py new file mode 100644 index 0000000000000000000000000000000000000000..e6d6d709852b137a862cfe2b3af42dc790fa705d --- /dev/null +++ b/venv/lib/python3.10/site-packages/httpcore/_async/http11.py @@ -0,0 +1,379 @@ +from __future__ import annotations + +import enum +import logging +import ssl +import time +import types +import typing + +import h11 + +from .._backends.base import AsyncNetworkStream +from .._exceptions import ( + ConnectionNotAvailable, + LocalProtocolError, + RemoteProtocolError, + WriteError, + map_exceptions, +) +from .._models import Origin, Request, Response +from .._synchronization import AsyncLock, AsyncShieldCancellation +from .._trace import Trace +from .interfaces import AsyncConnectionInterface + +logger = logging.getLogger("httpcore.http11") + + +# A subset of `h11.Event` types supported by `_send_event` +H11SendEvent = typing.Union[ + h11.Request, + h11.Data, + h11.EndOfMessage, +] + + +class HTTPConnectionState(enum.IntEnum): + NEW = 0 + ACTIVE = 1 + IDLE = 2 + CLOSED = 3 + + +class AsyncHTTP11Connection(AsyncConnectionInterface): + READ_NUM_BYTES = 64 * 1024 + MAX_INCOMPLETE_EVENT_SIZE = 100 * 1024 + + def __init__( + self, + origin: Origin, + stream: AsyncNetworkStream, + keepalive_expiry: float | None = None, + ) -> None: + self._origin = origin + self._network_stream = stream + self._keepalive_expiry: float | None = keepalive_expiry + self._expire_at: float | None = None + self._state = HTTPConnectionState.NEW + self._state_lock = AsyncLock() + self._request_count = 0 + self._h11_state = h11.Connection( + our_role=h11.CLIENT, + max_incomplete_event_size=self.MAX_INCOMPLETE_EVENT_SIZE, + ) + + async def handle_async_request(self, request: Request) -> Response: + if not self.can_handle_request(request.url.origin): + raise RuntimeError( + f"Attempted to send request to {request.url.origin} on connection " + f"to {self._origin}" + ) + + async with self._state_lock: + if self._state in (HTTPConnectionState.NEW, HTTPConnectionState.IDLE): + self._request_count += 1 + self._state = HTTPConnectionState.ACTIVE + self._expire_at = None + else: + raise ConnectionNotAvailable() + + try: + kwargs = {"request": request} + try: + async with Trace( + "send_request_headers", logger, request, kwargs + ) as trace: + await self._send_request_headers(**kwargs) + async with Trace("send_request_body", logger, request, kwargs) as trace: + await self._send_request_body(**kwargs) + except WriteError: + # If we get a write error while we're writing the request, + # then we supress this error and move on to attempting to + # read the response. Servers can sometimes close the request + # pre-emptively and then respond with a well formed HTTP + # error response. + pass + + async with Trace( + "receive_response_headers", logger, request, kwargs + ) as trace: + ( + http_version, + status, + reason_phrase, + headers, + trailing_data, + ) = await self._receive_response_headers(**kwargs) + trace.return_value = ( + http_version, + status, + reason_phrase, + headers, + ) + + network_stream = self._network_stream + + # CONNECT or Upgrade request + if (status == 101) or ( + (request.method == b"CONNECT") and (200 <= status < 300) + ): + network_stream = AsyncHTTP11UpgradeStream(network_stream, trailing_data) + + return Response( + status=status, + headers=headers, + content=HTTP11ConnectionByteStream(self, request), + extensions={ + "http_version": http_version, + "reason_phrase": reason_phrase, + "network_stream": network_stream, + }, + ) + except BaseException as exc: + with AsyncShieldCancellation(): + async with Trace("response_closed", logger, request) as trace: + await self._response_closed() + raise exc + + # Sending the request... + + async def _send_request_headers(self, request: Request) -> None: + timeouts = request.extensions.get("timeout", {}) + timeout = timeouts.get("write", None) + + with map_exceptions({h11.LocalProtocolError: LocalProtocolError}): + event = h11.Request( + method=request.method, + target=request.url.target, + headers=request.headers, + ) + await self._send_event(event, timeout=timeout) + + async def _send_request_body(self, request: Request) -> None: + timeouts = request.extensions.get("timeout", {}) + timeout = timeouts.get("write", None) + + assert isinstance(request.stream, typing.AsyncIterable) + async for chunk in request.stream: + event = h11.Data(data=chunk) + await self._send_event(event, timeout=timeout) + + await self._send_event(h11.EndOfMessage(), timeout=timeout) + + async def _send_event(self, event: h11.Event, timeout: float | None = None) -> None: + bytes_to_send = self._h11_state.send(event) + if bytes_to_send is not None: + await self._network_stream.write(bytes_to_send, timeout=timeout) + + # Receiving the response... + + async def _receive_response_headers( + self, request: Request + ) -> tuple[bytes, int, bytes, list[tuple[bytes, bytes]], bytes]: + timeouts = request.extensions.get("timeout", {}) + timeout = timeouts.get("read", None) + + while True: + event = await self._receive_event(timeout=timeout) + if isinstance(event, h11.Response): + break + if ( + isinstance(event, h11.InformationalResponse) + and event.status_code == 101 + ): + break + + http_version = b"HTTP/" + event.http_version + + # h11 version 0.11+ supports a `raw_items` interface to get the + # raw header casing, rather than the enforced lowercase headers. + headers = event.headers.raw_items() + + trailing_data, _ = self._h11_state.trailing_data + + return http_version, event.status_code, event.reason, headers, trailing_data + + async def _receive_response_body( + self, request: Request + ) -> typing.AsyncIterator[bytes]: + timeouts = request.extensions.get("timeout", {}) + timeout = timeouts.get("read", None) + + while True: + event = await self._receive_event(timeout=timeout) + if isinstance(event, h11.Data): + yield bytes(event.data) + elif isinstance(event, (h11.EndOfMessage, h11.PAUSED)): + break + + async def _receive_event( + self, timeout: float | None = None + ) -> h11.Event | type[h11.PAUSED]: + while True: + with map_exceptions({h11.RemoteProtocolError: RemoteProtocolError}): + event = self._h11_state.next_event() + + if event is h11.NEED_DATA: + data = await self._network_stream.read( + self.READ_NUM_BYTES, timeout=timeout + ) + + # If we feed this case through h11 we'll raise an exception like: + # + # httpcore.RemoteProtocolError: can't handle event type + # ConnectionClosed when role=SERVER and state=SEND_RESPONSE + # + # Which is accurate, but not very informative from an end-user + # perspective. Instead we handle this case distinctly and treat + # it as a ConnectError. + if data == b"" and self._h11_state.their_state == h11.SEND_RESPONSE: + msg = "Server disconnected without sending a response." + raise RemoteProtocolError(msg) + + self._h11_state.receive_data(data) + else: + # mypy fails to narrow the type in the above if statement above + return event # type: ignore[return-value] + + async def _response_closed(self) -> None: + async with self._state_lock: + if ( + self._h11_state.our_state is h11.DONE + and self._h11_state.their_state is h11.DONE + ): + self._state = HTTPConnectionState.IDLE + self._h11_state.start_next_cycle() + if self._keepalive_expiry is not None: + now = time.monotonic() + self._expire_at = now + self._keepalive_expiry + else: + await self.aclose() + + # Once the connection is no longer required... + + async def aclose(self) -> None: + # Note that this method unilaterally closes the connection, and does + # not have any kind of locking in place around it. + self._state = HTTPConnectionState.CLOSED + await self._network_stream.aclose() + + # The AsyncConnectionInterface methods provide information about the state of + # the connection, allowing for a connection pooling implementation to + # determine when to reuse and when to close the connection... + + def can_handle_request(self, origin: Origin) -> bool: + return origin == self._origin + + def is_available(self) -> bool: + # Note that HTTP/1.1 connections in the "NEW" state are not treated as + # being "available". The control flow which created the connection will + # be able to send an outgoing request, but the connection will not be + # acquired from the connection pool for any other request. + return self._state == HTTPConnectionState.IDLE + + def has_expired(self) -> bool: + now = time.monotonic() + keepalive_expired = self._expire_at is not None and now > self._expire_at + + # If the HTTP connection is idle but the socket is readable, then the + # only valid state is that the socket is about to return b"", indicating + # a server-initiated disconnect. + server_disconnected = ( + self._state == HTTPConnectionState.IDLE + and self._network_stream.get_extra_info("is_readable") + ) + + return keepalive_expired or server_disconnected + + def is_idle(self) -> bool: + return self._state == HTTPConnectionState.IDLE + + def is_closed(self) -> bool: + return self._state == HTTPConnectionState.CLOSED + + def info(self) -> str: + origin = str(self._origin) + return ( + f"{origin!r}, HTTP/1.1, {self._state.name}, " + f"Request Count: {self._request_count}" + ) + + def __repr__(self) -> str: + class_name = self.__class__.__name__ + origin = str(self._origin) + return ( + f"<{class_name} [{origin!r}, {self._state.name}, " + f"Request Count: {self._request_count}]>" + ) + + # These context managers are not used in the standard flow, but are + # useful for testing or working with connection instances directly. + + async def __aenter__(self) -> AsyncHTTP11Connection: + return self + + async def __aexit__( + self, + exc_type: type[BaseException] | None = None, + exc_value: BaseException | None = None, + traceback: types.TracebackType | None = None, + ) -> None: + await self.aclose() + + +class HTTP11ConnectionByteStream: + def __init__(self, connection: AsyncHTTP11Connection, request: Request) -> None: + self._connection = connection + self._request = request + self._closed = False + + async def __aiter__(self) -> typing.AsyncIterator[bytes]: + kwargs = {"request": self._request} + try: + async with Trace("receive_response_body", logger, self._request, kwargs): + async for chunk in self._connection._receive_response_body(**kwargs): + yield chunk + except BaseException as exc: + # If we get an exception while streaming the response, + # we want to close the response (and possibly the connection) + # before raising that exception. + with AsyncShieldCancellation(): + await self.aclose() + raise exc + + async def aclose(self) -> None: + if not self._closed: + self._closed = True + async with Trace("response_closed", logger, self._request): + await self._connection._response_closed() + + +class AsyncHTTP11UpgradeStream(AsyncNetworkStream): + def __init__(self, stream: AsyncNetworkStream, leading_data: bytes) -> None: + self._stream = stream + self._leading_data = leading_data + + async def read(self, max_bytes: int, timeout: float | None = None) -> bytes: + if self._leading_data: + buffer = self._leading_data[:max_bytes] + self._leading_data = self._leading_data[max_bytes:] + return buffer + else: + return await self._stream.read(max_bytes, timeout) + + async def write(self, buffer: bytes, timeout: float | None = None) -> None: + await self._stream.write(buffer, timeout) + + async def aclose(self) -> None: + await self._stream.aclose() + + async def start_tls( + self, + ssl_context: ssl.SSLContext, + server_hostname: str | None = None, + timeout: float | None = None, + ) -> AsyncNetworkStream: + return await self._stream.start_tls(ssl_context, server_hostname, timeout) + + def get_extra_info(self, info: str) -> typing.Any: + return self._stream.get_extra_info(info) diff --git a/venv/lib/python3.10/site-packages/httpcore/_async/http2.py b/venv/lib/python3.10/site-packages/httpcore/_async/http2.py new file mode 100644 index 0000000000000000000000000000000000000000..dbd0beeb4da32d8c0175d412fa442eae8f837723 --- /dev/null +++ b/venv/lib/python3.10/site-packages/httpcore/_async/http2.py @@ -0,0 +1,592 @@ +from __future__ import annotations + +import enum +import logging +import time +import types +import typing + +import h2.config +import h2.connection +import h2.events +import h2.exceptions +import h2.settings + +from .._backends.base import AsyncNetworkStream +from .._exceptions import ( + ConnectionNotAvailable, + LocalProtocolError, + RemoteProtocolError, +) +from .._models import Origin, Request, Response +from .._synchronization import AsyncLock, AsyncSemaphore, AsyncShieldCancellation +from .._trace import Trace +from .interfaces import AsyncConnectionInterface + +logger = logging.getLogger("httpcore.http2") + + +def has_body_headers(request: Request) -> bool: + return any( + k.lower() == b"content-length" or k.lower() == b"transfer-encoding" + for k, v in request.headers + ) + + +class HTTPConnectionState(enum.IntEnum): + ACTIVE = 1 + IDLE = 2 + CLOSED = 3 + + +class AsyncHTTP2Connection(AsyncConnectionInterface): + READ_NUM_BYTES = 64 * 1024 + CONFIG = h2.config.H2Configuration(validate_inbound_headers=False) + + def __init__( + self, + origin: Origin, + stream: AsyncNetworkStream, + keepalive_expiry: float | None = None, + ): + self._origin = origin + self._network_stream = stream + self._keepalive_expiry: float | None = keepalive_expiry + self._h2_state = h2.connection.H2Connection(config=self.CONFIG) + self._state = HTTPConnectionState.IDLE + self._expire_at: float | None = None + self._request_count = 0 + self._init_lock = AsyncLock() + self._state_lock = AsyncLock() + self._read_lock = AsyncLock() + self._write_lock = AsyncLock() + self._sent_connection_init = False + self._used_all_stream_ids = False + self._connection_error = False + + # Mapping from stream ID to response stream events. + self._events: dict[ + int, + list[ + h2.events.ResponseReceived + | h2.events.DataReceived + | h2.events.StreamEnded + | h2.events.StreamReset, + ], + ] = {} + + # Connection terminated events are stored as state since + # we need to handle them for all streams. + self._connection_terminated: h2.events.ConnectionTerminated | None = None + + self._read_exception: Exception | None = None + self._write_exception: Exception | None = None + + async def handle_async_request(self, request: Request) -> Response: + if not self.can_handle_request(request.url.origin): + # This cannot occur in normal operation, since the connection pool + # will only send requests on connections that handle them. + # It's in place simply for resilience as a guard against incorrect + # usage, for anyone working directly with httpcore connections. + raise RuntimeError( + f"Attempted to send request to {request.url.origin} on connection " + f"to {self._origin}" + ) + + async with self._state_lock: + if self._state in (HTTPConnectionState.ACTIVE, HTTPConnectionState.IDLE): + self._request_count += 1 + self._expire_at = None + self._state = HTTPConnectionState.ACTIVE + else: + raise ConnectionNotAvailable() + + async with self._init_lock: + if not self._sent_connection_init: + try: + sci_kwargs = {"request": request} + async with Trace( + "send_connection_init", logger, request, sci_kwargs + ): + await self._send_connection_init(**sci_kwargs) + except BaseException as exc: + with AsyncShieldCancellation(): + await self.aclose() + raise exc + + self._sent_connection_init = True + + # Initially start with just 1 until the remote server provides + # its max_concurrent_streams value + self._max_streams = 1 + + local_settings_max_streams = ( + self._h2_state.local_settings.max_concurrent_streams + ) + self._max_streams_semaphore = AsyncSemaphore(local_settings_max_streams) + + for _ in range(local_settings_max_streams - self._max_streams): + await self._max_streams_semaphore.acquire() + + await self._max_streams_semaphore.acquire() + + try: + stream_id = self._h2_state.get_next_available_stream_id() + self._events[stream_id] = [] + except h2.exceptions.NoAvailableStreamIDError: # pragma: nocover + self._used_all_stream_ids = True + self._request_count -= 1 + raise ConnectionNotAvailable() + + try: + kwargs = {"request": request, "stream_id": stream_id} + async with Trace("send_request_headers", logger, request, kwargs): + await self._send_request_headers(request=request, stream_id=stream_id) + async with Trace("send_request_body", logger, request, kwargs): + await self._send_request_body(request=request, stream_id=stream_id) + async with Trace( + "receive_response_headers", logger, request, kwargs + ) as trace: + status, headers = await self._receive_response( + request=request, stream_id=stream_id + ) + trace.return_value = (status, headers) + + return Response( + status=status, + headers=headers, + content=HTTP2ConnectionByteStream(self, request, stream_id=stream_id), + extensions={ + "http_version": b"HTTP/2", + "network_stream": self._network_stream, + "stream_id": stream_id, + }, + ) + except BaseException as exc: # noqa: PIE786 + with AsyncShieldCancellation(): + kwargs = {"stream_id": stream_id} + async with Trace("response_closed", logger, request, kwargs): + await self._response_closed(stream_id=stream_id) + + if isinstance(exc, h2.exceptions.ProtocolError): + # One case where h2 can raise a protocol error is when a + # closed frame has been seen by the state machine. + # + # This happens when one stream is reading, and encounters + # a GOAWAY event. Other flows of control may then raise + # a protocol error at any point they interact with the 'h2_state'. + # + # In this case we'll have stored the event, and should raise + # it as a RemoteProtocolError. + if self._connection_terminated: # pragma: nocover + raise RemoteProtocolError(self._connection_terminated) + # If h2 raises a protocol error in some other state then we + # must somehow have made a protocol violation. + raise LocalProtocolError(exc) # pragma: nocover + + raise exc + + async def _send_connection_init(self, request: Request) -> None: + """ + The HTTP/2 connection requires some initial setup before we can start + using individual request/response streams on it. + """ + # Need to set these manually here instead of manipulating via + # __setitem__() otherwise the H2Connection will emit SettingsUpdate + # frames in addition to sending the undesired defaults. + self._h2_state.local_settings = h2.settings.Settings( + client=True, + initial_values={ + # Disable PUSH_PROMISE frames from the server since we don't do anything + # with them for now. Maybe when we support caching? + h2.settings.SettingCodes.ENABLE_PUSH: 0, + # These two are taken from h2 for safe defaults + h2.settings.SettingCodes.MAX_CONCURRENT_STREAMS: 100, + h2.settings.SettingCodes.MAX_HEADER_LIST_SIZE: 65536, + }, + ) + + # Some websites (*cough* Yahoo *cough*) balk at this setting being + # present in the initial handshake since it's not defined in the original + # RFC despite the RFC mandating ignoring settings you don't know about. + del self._h2_state.local_settings[ + h2.settings.SettingCodes.ENABLE_CONNECT_PROTOCOL + ] + + self._h2_state.initiate_connection() + self._h2_state.increment_flow_control_window(2**24) + await self._write_outgoing_data(request) + + # Sending the request... + + async def _send_request_headers(self, request: Request, stream_id: int) -> None: + """ + Send the request headers to a given stream ID. + """ + end_stream = not has_body_headers(request) + + # In HTTP/2 the ':authority' pseudo-header is used instead of 'Host'. + # In order to gracefully handle HTTP/1.1 and HTTP/2 we always require + # HTTP/1.1 style headers, and map them appropriately if we end up on + # an HTTP/2 connection. + authority = [v for k, v in request.headers if k.lower() == b"host"][0] + + headers = [ + (b":method", request.method), + (b":authority", authority), + (b":scheme", request.url.scheme), + (b":path", request.url.target), + ] + [ + (k.lower(), v) + for k, v in request.headers + if k.lower() + not in ( + b"host", + b"transfer-encoding", + ) + ] + + self._h2_state.send_headers(stream_id, headers, end_stream=end_stream) + self._h2_state.increment_flow_control_window(2**24, stream_id=stream_id) + await self._write_outgoing_data(request) + + async def _send_request_body(self, request: Request, stream_id: int) -> None: + """ + Iterate over the request body sending it to a given stream ID. + """ + if not has_body_headers(request): + return + + assert isinstance(request.stream, typing.AsyncIterable) + async for data in request.stream: + await self._send_stream_data(request, stream_id, data) + await self._send_end_stream(request, stream_id) + + async def _send_stream_data( + self, request: Request, stream_id: int, data: bytes + ) -> None: + """ + Send a single chunk of data in one or more data frames. + """ + while data: + max_flow = await self._wait_for_outgoing_flow(request, stream_id) + chunk_size = min(len(data), max_flow) + chunk, data = data[:chunk_size], data[chunk_size:] + self._h2_state.send_data(stream_id, chunk) + await self._write_outgoing_data(request) + + async def _send_end_stream(self, request: Request, stream_id: int) -> None: + """ + Send an empty data frame on on a given stream ID with the END_STREAM flag set. + """ + self._h2_state.end_stream(stream_id) + await self._write_outgoing_data(request) + + # Receiving the response... + + async def _receive_response( + self, request: Request, stream_id: int + ) -> tuple[int, list[tuple[bytes, bytes]]]: + """ + Return the response status code and headers for a given stream ID. + """ + while True: + event = await self._receive_stream_event(request, stream_id) + if isinstance(event, h2.events.ResponseReceived): + break + + status_code = 200 + headers = [] + assert event.headers is not None + for k, v in event.headers: + if k == b":status": + status_code = int(v.decode("ascii", errors="ignore")) + elif not k.startswith(b":"): + headers.append((k, v)) + + return (status_code, headers) + + async def _receive_response_body( + self, request: Request, stream_id: int + ) -> typing.AsyncIterator[bytes]: + """ + Iterator that returns the bytes of the response body for a given stream ID. + """ + while True: + event = await self._receive_stream_event(request, stream_id) + if isinstance(event, h2.events.DataReceived): + assert event.flow_controlled_length is not None + assert event.data is not None + amount = event.flow_controlled_length + self._h2_state.acknowledge_received_data(amount, stream_id) + await self._write_outgoing_data(request) + yield event.data + elif isinstance(event, h2.events.StreamEnded): + break + + async def _receive_stream_event( + self, request: Request, stream_id: int + ) -> h2.events.ResponseReceived | h2.events.DataReceived | h2.events.StreamEnded: + """ + Return the next available event for a given stream ID. + + Will read more data from the network if required. + """ + while not self._events.get(stream_id): + await self._receive_events(request, stream_id) + event = self._events[stream_id].pop(0) + if isinstance(event, h2.events.StreamReset): + raise RemoteProtocolError(event) + return event + + async def _receive_events( + self, request: Request, stream_id: int | None = None + ) -> None: + """ + Read some data from the network until we see one or more events + for a given stream ID. + """ + async with self._read_lock: + if self._connection_terminated is not None: + last_stream_id = self._connection_terminated.last_stream_id + if stream_id and last_stream_id and stream_id > last_stream_id: + self._request_count -= 1 + raise ConnectionNotAvailable() + raise RemoteProtocolError(self._connection_terminated) + + # This conditional is a bit icky. We don't want to block reading if we've + # actually got an event to return for a given stream. We need to do that + # check *within* the atomic read lock. Though it also need to be optional, + # because when we call it from `_wait_for_outgoing_flow` we *do* want to + # block until we've available flow control, event when we have events + # pending for the stream ID we're attempting to send on. + if stream_id is None or not self._events.get(stream_id): + events = await self._read_incoming_data(request) + for event in events: + if isinstance(event, h2.events.RemoteSettingsChanged): + async with Trace( + "receive_remote_settings", logger, request + ) as trace: + await self._receive_remote_settings_change(event) + trace.return_value = event + + elif isinstance( + event, + ( + h2.events.ResponseReceived, + h2.events.DataReceived, + h2.events.StreamEnded, + h2.events.StreamReset, + ), + ): + if event.stream_id in self._events: + self._events[event.stream_id].append(event) + + elif isinstance(event, h2.events.ConnectionTerminated): + self._connection_terminated = event + + await self._write_outgoing_data(request) + + async def _receive_remote_settings_change( + self, event: h2.events.RemoteSettingsChanged + ) -> None: + max_concurrent_streams = event.changed_settings.get( + h2.settings.SettingCodes.MAX_CONCURRENT_STREAMS + ) + if max_concurrent_streams: + new_max_streams = min( + max_concurrent_streams.new_value, + self._h2_state.local_settings.max_concurrent_streams, + ) + if new_max_streams and new_max_streams != self._max_streams: + while new_max_streams > self._max_streams: + await self._max_streams_semaphore.release() + self._max_streams += 1 + while new_max_streams < self._max_streams: + await self._max_streams_semaphore.acquire() + self._max_streams -= 1 + + async def _response_closed(self, stream_id: int) -> None: + await self._max_streams_semaphore.release() + del self._events[stream_id] + async with self._state_lock: + if self._connection_terminated and not self._events: + await self.aclose() + + elif self._state == HTTPConnectionState.ACTIVE and not self._events: + self._state = HTTPConnectionState.IDLE + if self._keepalive_expiry is not None: + now = time.monotonic() + self._expire_at = now + self._keepalive_expiry + if self._used_all_stream_ids: # pragma: nocover + await self.aclose() + + async def aclose(self) -> None: + # Note that this method unilaterally closes the connection, and does + # not have any kind of locking in place around it. + self._h2_state.close_connection() + self._state = HTTPConnectionState.CLOSED + await self._network_stream.aclose() + + # Wrappers around network read/write operations... + + async def _read_incoming_data(self, request: Request) -> list[h2.events.Event]: + timeouts = request.extensions.get("timeout", {}) + timeout = timeouts.get("read", None) + + if self._read_exception is not None: + raise self._read_exception # pragma: nocover + + try: + data = await self._network_stream.read(self.READ_NUM_BYTES, timeout) + if data == b"": + raise RemoteProtocolError("Server disconnected") + except Exception as exc: + # If we get a network error we should: + # + # 1. Save the exception and just raise it immediately on any future reads. + # (For example, this means that a single read timeout or disconnect will + # immediately close all pending streams. Without requiring multiple + # sequential timeouts.) + # 2. Mark the connection as errored, so that we don't accept any other + # incoming requests. + self._read_exception = exc + self._connection_error = True + raise exc + + events: list[h2.events.Event] = self._h2_state.receive_data(data) + + return events + + async def _write_outgoing_data(self, request: Request) -> None: + timeouts = request.extensions.get("timeout", {}) + timeout = timeouts.get("write", None) + + async with self._write_lock: + data_to_send = self._h2_state.data_to_send() + + if self._write_exception is not None: + raise self._write_exception # pragma: nocover + + try: + await self._network_stream.write(data_to_send, timeout) + except Exception as exc: # pragma: nocover + # If we get a network error we should: + # + # 1. Save the exception and just raise it immediately on any future write. + # (For example, this means that a single write timeout or disconnect will + # immediately close all pending streams. Without requiring multiple + # sequential timeouts.) + # 2. Mark the connection as errored, so that we don't accept any other + # incoming requests. + self._write_exception = exc + self._connection_error = True + raise exc + + # Flow control... + + async def _wait_for_outgoing_flow(self, request: Request, stream_id: int) -> int: + """ + Returns the maximum allowable outgoing flow for a given stream. + + If the allowable flow is zero, then waits on the network until + WindowUpdated frames have increased the flow rate. + https://tools.ietf.org/html/rfc7540#section-6.9 + """ + local_flow: int = self._h2_state.local_flow_control_window(stream_id) + max_frame_size: int = self._h2_state.max_outbound_frame_size + flow = min(local_flow, max_frame_size) + while flow == 0: + await self._receive_events(request) + local_flow = self._h2_state.local_flow_control_window(stream_id) + max_frame_size = self._h2_state.max_outbound_frame_size + flow = min(local_flow, max_frame_size) + return flow + + # Interface for connection pooling... + + def can_handle_request(self, origin: Origin) -> bool: + return origin == self._origin + + def is_available(self) -> bool: + return ( + self._state != HTTPConnectionState.CLOSED + and not self._connection_error + and not self._used_all_stream_ids + and not ( + self._h2_state.state_machine.state + == h2.connection.ConnectionState.CLOSED + ) + ) + + def has_expired(self) -> bool: + now = time.monotonic() + return self._expire_at is not None and now > self._expire_at + + def is_idle(self) -> bool: + return self._state == HTTPConnectionState.IDLE + + def is_closed(self) -> bool: + return self._state == HTTPConnectionState.CLOSED + + def info(self) -> str: + origin = str(self._origin) + return ( + f"{origin!r}, HTTP/2, {self._state.name}, " + f"Request Count: {self._request_count}" + ) + + def __repr__(self) -> str: + class_name = self.__class__.__name__ + origin = str(self._origin) + return ( + f"<{class_name} [{origin!r}, {self._state.name}, " + f"Request Count: {self._request_count}]>" + ) + + # These context managers are not used in the standard flow, but are + # useful for testing or working with connection instances directly. + + async def __aenter__(self) -> AsyncHTTP2Connection: + return self + + async def __aexit__( + self, + exc_type: type[BaseException] | None = None, + exc_value: BaseException | None = None, + traceback: types.TracebackType | None = None, + ) -> None: + await self.aclose() + + +class HTTP2ConnectionByteStream: + def __init__( + self, connection: AsyncHTTP2Connection, request: Request, stream_id: int + ) -> None: + self._connection = connection + self._request = request + self._stream_id = stream_id + self._closed = False + + async def __aiter__(self) -> typing.AsyncIterator[bytes]: + kwargs = {"request": self._request, "stream_id": self._stream_id} + try: + async with Trace("receive_response_body", logger, self._request, kwargs): + async for chunk in self._connection._receive_response_body( + request=self._request, stream_id=self._stream_id + ): + yield chunk + except BaseException as exc: + # If we get an exception while streaming the response, + # we want to close the response (and possibly the connection) + # before raising that exception. + with AsyncShieldCancellation(): + await self.aclose() + raise exc + + async def aclose(self) -> None: + if not self._closed: + self._closed = True + kwargs = {"stream_id": self._stream_id} + async with Trace("response_closed", logger, self._request, kwargs): + await self._connection._response_closed(stream_id=self._stream_id) diff --git a/venv/lib/python3.10/site-packages/httpcore/_async/http_proxy.py b/venv/lib/python3.10/site-packages/httpcore/_async/http_proxy.py new file mode 100644 index 0000000000000000000000000000000000000000..cc9d92066e1680576846e46ccdf645a2b1dd5718 --- /dev/null +++ b/venv/lib/python3.10/site-packages/httpcore/_async/http_proxy.py @@ -0,0 +1,367 @@ +from __future__ import annotations + +import base64 +import logging +import ssl +import typing + +from .._backends.base import SOCKET_OPTION, AsyncNetworkBackend +from .._exceptions import ProxyError +from .._models import ( + URL, + Origin, + Request, + Response, + enforce_bytes, + enforce_headers, + enforce_url, +) +from .._ssl import default_ssl_context +from .._synchronization import AsyncLock +from .._trace import Trace +from .connection import AsyncHTTPConnection +from .connection_pool import AsyncConnectionPool +from .http11 import AsyncHTTP11Connection +from .interfaces import AsyncConnectionInterface + +ByteOrStr = typing.Union[bytes, str] +HeadersAsSequence = typing.Sequence[typing.Tuple[ByteOrStr, ByteOrStr]] +HeadersAsMapping = typing.Mapping[ByteOrStr, ByteOrStr] + + +logger = logging.getLogger("httpcore.proxy") + + +def merge_headers( + default_headers: typing.Sequence[tuple[bytes, bytes]] | None = None, + override_headers: typing.Sequence[tuple[bytes, bytes]] | None = None, +) -> list[tuple[bytes, bytes]]: + """ + Append default_headers and override_headers, de-duplicating if a key exists + in both cases. + """ + default_headers = [] if default_headers is None else list(default_headers) + override_headers = [] if override_headers is None else list(override_headers) + has_override = set(key.lower() for key, value in override_headers) + default_headers = [ + (key, value) + for key, value in default_headers + if key.lower() not in has_override + ] + return default_headers + override_headers + + +class AsyncHTTPProxy(AsyncConnectionPool): # pragma: nocover + """ + A connection pool that sends requests via an HTTP proxy. + """ + + def __init__( + self, + proxy_url: URL | bytes | str, + proxy_auth: tuple[bytes | str, bytes | str] | None = None, + proxy_headers: HeadersAsMapping | HeadersAsSequence | None = None, + ssl_context: ssl.SSLContext | None = None, + proxy_ssl_context: ssl.SSLContext | None = None, + max_connections: int | None = 10, + max_keepalive_connections: int | None = None, + keepalive_expiry: float | None = None, + http1: bool = True, + http2: bool = False, + retries: int = 0, + local_address: str | None = None, + uds: str | None = None, + network_backend: AsyncNetworkBackend | None = None, + socket_options: typing.Iterable[SOCKET_OPTION] | None = None, + ) -> None: + """ + A connection pool for making HTTP requests. + + Parameters: + proxy_url: The URL to use when connecting to the proxy server. + For example `"http://127.0.0.1:8080/"`. + proxy_auth: Any proxy authentication as a two-tuple of + (username, password). May be either bytes or ascii-only str. + proxy_headers: Any HTTP headers to use for the proxy requests. + For example `{"Proxy-Authorization": "Basic :"}`. + ssl_context: An SSL context to use for verifying connections. + If not specified, the default `httpcore.default_ssl_context()` + will be used. + proxy_ssl_context: The same as `ssl_context`, but for a proxy server rather than a remote origin. + max_connections: The maximum number of concurrent HTTP connections that + the pool should allow. Any attempt to send a request on a pool that + would exceed this amount will block until a connection is available. + max_keepalive_connections: The maximum number of idle HTTP connections + that will be maintained in the pool. + keepalive_expiry: The duration in seconds that an idle HTTP connection + may be maintained for before being expired from the pool. + http1: A boolean indicating if HTTP/1.1 requests should be supported + by the connection pool. Defaults to True. + http2: A boolean indicating if HTTP/2 requests should be supported by + the connection pool. Defaults to False. + retries: The maximum number of retries when trying to establish + a connection. + local_address: Local address to connect from. Can also be used to + connect using a particular address family. Using + `local_address="0.0.0.0"` will connect using an `AF_INET` address + (IPv4), while using `local_address="::"` will connect using an + `AF_INET6` address (IPv6). + uds: Path to a Unix Domain Socket to use instead of TCP sockets. + network_backend: A backend instance to use for handling network I/O. + """ + super().__init__( + ssl_context=ssl_context, + max_connections=max_connections, + max_keepalive_connections=max_keepalive_connections, + keepalive_expiry=keepalive_expiry, + http1=http1, + http2=http2, + network_backend=network_backend, + retries=retries, + local_address=local_address, + uds=uds, + socket_options=socket_options, + ) + + self._proxy_url = enforce_url(proxy_url, name="proxy_url") + if ( + self._proxy_url.scheme == b"http" and proxy_ssl_context is not None + ): # pragma: no cover + raise RuntimeError( + "The `proxy_ssl_context` argument is not allowed for the http scheme" + ) + + self._ssl_context = ssl_context + self._proxy_ssl_context = proxy_ssl_context + self._proxy_headers = enforce_headers(proxy_headers, name="proxy_headers") + if proxy_auth is not None: + username = enforce_bytes(proxy_auth[0], name="proxy_auth") + password = enforce_bytes(proxy_auth[1], name="proxy_auth") + userpass = username + b":" + password + authorization = b"Basic " + base64.b64encode(userpass) + self._proxy_headers = [ + (b"Proxy-Authorization", authorization) + ] + self._proxy_headers + + def create_connection(self, origin: Origin) -> AsyncConnectionInterface: + if origin.scheme == b"http": + return AsyncForwardHTTPConnection( + proxy_origin=self._proxy_url.origin, + proxy_headers=self._proxy_headers, + remote_origin=origin, + keepalive_expiry=self._keepalive_expiry, + network_backend=self._network_backend, + proxy_ssl_context=self._proxy_ssl_context, + ) + return AsyncTunnelHTTPConnection( + proxy_origin=self._proxy_url.origin, + proxy_headers=self._proxy_headers, + remote_origin=origin, + ssl_context=self._ssl_context, + proxy_ssl_context=self._proxy_ssl_context, + keepalive_expiry=self._keepalive_expiry, + http1=self._http1, + http2=self._http2, + network_backend=self._network_backend, + ) + + +class AsyncForwardHTTPConnection(AsyncConnectionInterface): + def __init__( + self, + proxy_origin: Origin, + remote_origin: Origin, + proxy_headers: HeadersAsMapping | HeadersAsSequence | None = None, + keepalive_expiry: float | None = None, + network_backend: AsyncNetworkBackend | None = None, + socket_options: typing.Iterable[SOCKET_OPTION] | None = None, + proxy_ssl_context: ssl.SSLContext | None = None, + ) -> None: + self._connection = AsyncHTTPConnection( + origin=proxy_origin, + keepalive_expiry=keepalive_expiry, + network_backend=network_backend, + socket_options=socket_options, + ssl_context=proxy_ssl_context, + ) + self._proxy_origin = proxy_origin + self._proxy_headers = enforce_headers(proxy_headers, name="proxy_headers") + self._remote_origin = remote_origin + + async def handle_async_request(self, request: Request) -> Response: + headers = merge_headers(self._proxy_headers, request.headers) + url = URL( + scheme=self._proxy_origin.scheme, + host=self._proxy_origin.host, + port=self._proxy_origin.port, + target=bytes(request.url), + ) + proxy_request = Request( + method=request.method, + url=url, + headers=headers, + content=request.stream, + extensions=request.extensions, + ) + return await self._connection.handle_async_request(proxy_request) + + def can_handle_request(self, origin: Origin) -> bool: + return origin == self._remote_origin + + async def aclose(self) -> None: + await self._connection.aclose() + + def info(self) -> str: + return self._connection.info() + + def is_available(self) -> bool: + return self._connection.is_available() + + def has_expired(self) -> bool: + return self._connection.has_expired() + + def is_idle(self) -> bool: + return self._connection.is_idle() + + def is_closed(self) -> bool: + return self._connection.is_closed() + + def __repr__(self) -> str: + return f"<{self.__class__.__name__} [{self.info()}]>" + + +class AsyncTunnelHTTPConnection(AsyncConnectionInterface): + def __init__( + self, + proxy_origin: Origin, + remote_origin: Origin, + ssl_context: ssl.SSLContext | None = None, + proxy_ssl_context: ssl.SSLContext | None = None, + proxy_headers: typing.Sequence[tuple[bytes, bytes]] | None = None, + keepalive_expiry: float | None = None, + http1: bool = True, + http2: bool = False, + network_backend: AsyncNetworkBackend | None = None, + socket_options: typing.Iterable[SOCKET_OPTION] | None = None, + ) -> None: + self._connection: AsyncConnectionInterface = AsyncHTTPConnection( + origin=proxy_origin, + keepalive_expiry=keepalive_expiry, + network_backend=network_backend, + socket_options=socket_options, + ssl_context=proxy_ssl_context, + ) + self._proxy_origin = proxy_origin + self._remote_origin = remote_origin + self._ssl_context = ssl_context + self._proxy_ssl_context = proxy_ssl_context + self._proxy_headers = enforce_headers(proxy_headers, name="proxy_headers") + self._keepalive_expiry = keepalive_expiry + self._http1 = http1 + self._http2 = http2 + self._connect_lock = AsyncLock() + self._connected = False + + async def handle_async_request(self, request: Request) -> Response: + timeouts = request.extensions.get("timeout", {}) + timeout = timeouts.get("connect", None) + + async with self._connect_lock: + if not self._connected: + target = b"%b:%d" % (self._remote_origin.host, self._remote_origin.port) + + connect_url = URL( + scheme=self._proxy_origin.scheme, + host=self._proxy_origin.host, + port=self._proxy_origin.port, + target=target, + ) + connect_headers = merge_headers( + [(b"Host", target), (b"Accept", b"*/*")], self._proxy_headers + ) + connect_request = Request( + method=b"CONNECT", + url=connect_url, + headers=connect_headers, + extensions=request.extensions, + ) + connect_response = await self._connection.handle_async_request( + connect_request + ) + + if connect_response.status < 200 or connect_response.status > 299: + reason_bytes = connect_response.extensions.get("reason_phrase", b"") + reason_str = reason_bytes.decode("ascii", errors="ignore") + msg = "%d %s" % (connect_response.status, reason_str) + await self._connection.aclose() + raise ProxyError(msg) + + stream = connect_response.extensions["network_stream"] + + # Upgrade the stream to SSL + ssl_context = ( + default_ssl_context() + if self._ssl_context is None + else self._ssl_context + ) + alpn_protocols = ["http/1.1", "h2"] if self._http2 else ["http/1.1"] + ssl_context.set_alpn_protocols(alpn_protocols) + + kwargs = { + "ssl_context": ssl_context, + "server_hostname": self._remote_origin.host.decode("ascii"), + "timeout": timeout, + } + async with Trace("start_tls", logger, request, kwargs) as trace: + stream = await stream.start_tls(**kwargs) + trace.return_value = stream + + # Determine if we should be using HTTP/1.1 or HTTP/2 + ssl_object = stream.get_extra_info("ssl_object") + http2_negotiated = ( + ssl_object is not None + and ssl_object.selected_alpn_protocol() == "h2" + ) + + # Create the HTTP/1.1 or HTTP/2 connection + if http2_negotiated or (self._http2 and not self._http1): + from .http2 import AsyncHTTP2Connection + + self._connection = AsyncHTTP2Connection( + origin=self._remote_origin, + stream=stream, + keepalive_expiry=self._keepalive_expiry, + ) + else: + self._connection = AsyncHTTP11Connection( + origin=self._remote_origin, + stream=stream, + keepalive_expiry=self._keepalive_expiry, + ) + + self._connected = True + return await self._connection.handle_async_request(request) + + def can_handle_request(self, origin: Origin) -> bool: + return origin == self._remote_origin + + async def aclose(self) -> None: + await self._connection.aclose() + + def info(self) -> str: + return self._connection.info() + + def is_available(self) -> bool: + return self._connection.is_available() + + def has_expired(self) -> bool: + return self._connection.has_expired() + + def is_idle(self) -> bool: + return self._connection.is_idle() + + def is_closed(self) -> bool: + return self._connection.is_closed() + + def __repr__(self) -> str: + return f"<{self.__class__.__name__} [{self.info()}]>" diff --git a/venv/lib/python3.10/site-packages/httpcore/_async/interfaces.py b/venv/lib/python3.10/site-packages/httpcore/_async/interfaces.py new file mode 100644 index 0000000000000000000000000000000000000000..361583bede6b2b84088b38054d5d8116ef9f1597 --- /dev/null +++ b/venv/lib/python3.10/site-packages/httpcore/_async/interfaces.py @@ -0,0 +1,137 @@ +from __future__ import annotations + +import contextlib +import typing + +from .._models import ( + URL, + Extensions, + HeaderTypes, + Origin, + Request, + Response, + enforce_bytes, + enforce_headers, + enforce_url, + include_request_headers, +) + + +class AsyncRequestInterface: + async def request( + self, + method: bytes | str, + url: URL | bytes | str, + *, + headers: HeaderTypes = None, + content: bytes | typing.AsyncIterator[bytes] | None = None, + extensions: Extensions | None = None, + ) -> Response: + # Strict type checking on our parameters. + method = enforce_bytes(method, name="method") + url = enforce_url(url, name="url") + headers = enforce_headers(headers, name="headers") + + # Include Host header, and optionally Content-Length or Transfer-Encoding. + headers = include_request_headers(headers, url=url, content=content) + + request = Request( + method=method, + url=url, + headers=headers, + content=content, + extensions=extensions, + ) + response = await self.handle_async_request(request) + try: + await response.aread() + finally: + await response.aclose() + return response + + @contextlib.asynccontextmanager + async def stream( + self, + method: bytes | str, + url: URL | bytes | str, + *, + headers: HeaderTypes = None, + content: bytes | typing.AsyncIterator[bytes] | None = None, + extensions: Extensions | None = None, + ) -> typing.AsyncIterator[Response]: + # Strict type checking on our parameters. + method = enforce_bytes(method, name="method") + url = enforce_url(url, name="url") + headers = enforce_headers(headers, name="headers") + + # Include Host header, and optionally Content-Length or Transfer-Encoding. + headers = include_request_headers(headers, url=url, content=content) + + request = Request( + method=method, + url=url, + headers=headers, + content=content, + extensions=extensions, + ) + response = await self.handle_async_request(request) + try: + yield response + finally: + await response.aclose() + + async def handle_async_request(self, request: Request) -> Response: + raise NotImplementedError() # pragma: nocover + + +class AsyncConnectionInterface(AsyncRequestInterface): + async def aclose(self) -> None: + raise NotImplementedError() # pragma: nocover + + def info(self) -> str: + raise NotImplementedError() # pragma: nocover + + def can_handle_request(self, origin: Origin) -> bool: + raise NotImplementedError() # pragma: nocover + + def is_available(self) -> bool: + """ + Return `True` if the connection is currently able to accept an + outgoing request. + + An HTTP/1.1 connection will only be available if it is currently idle. + + An HTTP/2 connection will be available so long as the stream ID space is + not yet exhausted, and the connection is not in an error state. + + While the connection is being established we may not yet know if it is going + to result in an HTTP/1.1 or HTTP/2 connection. The connection should be + treated as being available, but might ultimately raise `NewConnectionRequired` + required exceptions if multiple requests are attempted over a connection + that ends up being established as HTTP/1.1. + """ + raise NotImplementedError() # pragma: nocover + + def has_expired(self) -> bool: + """ + Return `True` if the connection is in a state where it should be closed. + + This either means that the connection is idle and it has passed the + expiry time on its keep-alive, or that server has sent an EOF. + """ + raise NotImplementedError() # pragma: nocover + + def is_idle(self) -> bool: + """ + Return `True` if the connection is currently idle. + """ + raise NotImplementedError() # pragma: nocover + + def is_closed(self) -> bool: + """ + Return `True` if the connection has been closed. + + Used when a response is closed to determine if the connection may be + returned to the connection pool or not. + """ + raise NotImplementedError() # pragma: nocover diff --git a/venv/lib/python3.10/site-packages/httpcore/_async/socks_proxy.py b/venv/lib/python3.10/site-packages/httpcore/_async/socks_proxy.py new file mode 100644 index 0000000000000000000000000000000000000000..b363f55a0b071de6c5f377726be82dc2110e373c --- /dev/null +++ b/venv/lib/python3.10/site-packages/httpcore/_async/socks_proxy.py @@ -0,0 +1,341 @@ +from __future__ import annotations + +import logging +import ssl + +import socksio + +from .._backends.auto import AutoBackend +from .._backends.base import AsyncNetworkBackend, AsyncNetworkStream +from .._exceptions import ConnectionNotAvailable, ProxyError +from .._models import URL, Origin, Request, Response, enforce_bytes, enforce_url +from .._ssl import default_ssl_context +from .._synchronization import AsyncLock +from .._trace import Trace +from .connection_pool import AsyncConnectionPool +from .http11 import AsyncHTTP11Connection +from .interfaces import AsyncConnectionInterface + +logger = logging.getLogger("httpcore.socks") + + +AUTH_METHODS = { + b"\x00": "NO AUTHENTICATION REQUIRED", + b"\x01": "GSSAPI", + b"\x02": "USERNAME/PASSWORD", + b"\xff": "NO ACCEPTABLE METHODS", +} + +REPLY_CODES = { + b"\x00": "Succeeded", + b"\x01": "General SOCKS server failure", + b"\x02": "Connection not allowed by ruleset", + b"\x03": "Network unreachable", + b"\x04": "Host unreachable", + b"\x05": "Connection refused", + b"\x06": "TTL expired", + b"\x07": "Command not supported", + b"\x08": "Address type not supported", +} + + +async def _init_socks5_connection( + stream: AsyncNetworkStream, + *, + host: bytes, + port: int, + auth: tuple[bytes, bytes] | None = None, +) -> None: + conn = socksio.socks5.SOCKS5Connection() + + # Auth method request + auth_method = ( + socksio.socks5.SOCKS5AuthMethod.NO_AUTH_REQUIRED + if auth is None + else socksio.socks5.SOCKS5AuthMethod.USERNAME_PASSWORD + ) + conn.send(socksio.socks5.SOCKS5AuthMethodsRequest([auth_method])) + outgoing_bytes = conn.data_to_send() + await stream.write(outgoing_bytes) + + # Auth method response + incoming_bytes = await stream.read(max_bytes=4096) + response = conn.receive_data(incoming_bytes) + assert isinstance(response, socksio.socks5.SOCKS5AuthReply) + if response.method != auth_method: + requested = AUTH_METHODS.get(auth_method, "UNKNOWN") + responded = AUTH_METHODS.get(response.method, "UNKNOWN") + raise ProxyError( + f"Requested {requested} from proxy server, but got {responded}." + ) + + if response.method == socksio.socks5.SOCKS5AuthMethod.USERNAME_PASSWORD: + # Username/password request + assert auth is not None + username, password = auth + conn.send(socksio.socks5.SOCKS5UsernamePasswordRequest(username, password)) + outgoing_bytes = conn.data_to_send() + await stream.write(outgoing_bytes) + + # Username/password response + incoming_bytes = await stream.read(max_bytes=4096) + response = conn.receive_data(incoming_bytes) + assert isinstance(response, socksio.socks5.SOCKS5UsernamePasswordReply) + if not response.success: + raise ProxyError("Invalid username/password") + + # Connect request + conn.send( + socksio.socks5.SOCKS5CommandRequest.from_address( + socksio.socks5.SOCKS5Command.CONNECT, (host, port) + ) + ) + outgoing_bytes = conn.data_to_send() + await stream.write(outgoing_bytes) + + # Connect response + incoming_bytes = await stream.read(max_bytes=4096) + response = conn.receive_data(incoming_bytes) + assert isinstance(response, socksio.socks5.SOCKS5Reply) + if response.reply_code != socksio.socks5.SOCKS5ReplyCode.SUCCEEDED: + reply_code = REPLY_CODES.get(response.reply_code, "UNKOWN") + raise ProxyError(f"Proxy Server could not connect: {reply_code}.") + + +class AsyncSOCKSProxy(AsyncConnectionPool): # pragma: nocover + """ + A connection pool that sends requests via an HTTP proxy. + """ + + def __init__( + self, + proxy_url: URL | bytes | str, + proxy_auth: tuple[bytes | str, bytes | str] | None = None, + ssl_context: ssl.SSLContext | None = None, + max_connections: int | None = 10, + max_keepalive_connections: int | None = None, + keepalive_expiry: float | None = None, + http1: bool = True, + http2: bool = False, + retries: int = 0, + network_backend: AsyncNetworkBackend | None = None, + ) -> None: + """ + A connection pool for making HTTP requests. + + Parameters: + proxy_url: The URL to use when connecting to the proxy server. + For example `"http://127.0.0.1:8080/"`. + ssl_context: An SSL context to use for verifying connections. + If not specified, the default `httpcore.default_ssl_context()` + will be used. + max_connections: The maximum number of concurrent HTTP connections that + the pool should allow. Any attempt to send a request on a pool that + would exceed this amount will block until a connection is available. + max_keepalive_connections: The maximum number of idle HTTP connections + that will be maintained in the pool. + keepalive_expiry: The duration in seconds that an idle HTTP connection + may be maintained for before being expired from the pool. + http1: A boolean indicating if HTTP/1.1 requests should be supported + by the connection pool. Defaults to True. + http2: A boolean indicating if HTTP/2 requests should be supported by + the connection pool. Defaults to False. + retries: The maximum number of retries when trying to establish + a connection. + local_address: Local address to connect from. Can also be used to + connect using a particular address family. Using + `local_address="0.0.0.0"` will connect using an `AF_INET` address + (IPv4), while using `local_address="::"` will connect using an + `AF_INET6` address (IPv6). + uds: Path to a Unix Domain Socket to use instead of TCP sockets. + network_backend: A backend instance to use for handling network I/O. + """ + super().__init__( + ssl_context=ssl_context, + max_connections=max_connections, + max_keepalive_connections=max_keepalive_connections, + keepalive_expiry=keepalive_expiry, + http1=http1, + http2=http2, + network_backend=network_backend, + retries=retries, + ) + self._ssl_context = ssl_context + self._proxy_url = enforce_url(proxy_url, name="proxy_url") + if proxy_auth is not None: + username, password = proxy_auth + username_bytes = enforce_bytes(username, name="proxy_auth") + password_bytes = enforce_bytes(password, name="proxy_auth") + self._proxy_auth: tuple[bytes, bytes] | None = ( + username_bytes, + password_bytes, + ) + else: + self._proxy_auth = None + + def create_connection(self, origin: Origin) -> AsyncConnectionInterface: + return AsyncSocks5Connection( + proxy_origin=self._proxy_url.origin, + remote_origin=origin, + proxy_auth=self._proxy_auth, + ssl_context=self._ssl_context, + keepalive_expiry=self._keepalive_expiry, + http1=self._http1, + http2=self._http2, + network_backend=self._network_backend, + ) + + +class AsyncSocks5Connection(AsyncConnectionInterface): + def __init__( + self, + proxy_origin: Origin, + remote_origin: Origin, + proxy_auth: tuple[bytes, bytes] | None = None, + ssl_context: ssl.SSLContext | None = None, + keepalive_expiry: float | None = None, + http1: bool = True, + http2: bool = False, + network_backend: AsyncNetworkBackend | None = None, + ) -> None: + self._proxy_origin = proxy_origin + self._remote_origin = remote_origin + self._proxy_auth = proxy_auth + self._ssl_context = ssl_context + self._keepalive_expiry = keepalive_expiry + self._http1 = http1 + self._http2 = http2 + + self._network_backend: AsyncNetworkBackend = ( + AutoBackend() if network_backend is None else network_backend + ) + self._connect_lock = AsyncLock() + self._connection: AsyncConnectionInterface | None = None + self._connect_failed = False + + async def handle_async_request(self, request: Request) -> Response: + timeouts = request.extensions.get("timeout", {}) + sni_hostname = request.extensions.get("sni_hostname", None) + timeout = timeouts.get("connect", None) + + async with self._connect_lock: + if self._connection is None: + try: + # Connect to the proxy + kwargs = { + "host": self._proxy_origin.host.decode("ascii"), + "port": self._proxy_origin.port, + "timeout": timeout, + } + async with Trace("connect_tcp", logger, request, kwargs) as trace: + stream = await self._network_backend.connect_tcp(**kwargs) + trace.return_value = stream + + # Connect to the remote host using socks5 + kwargs = { + "stream": stream, + "host": self._remote_origin.host.decode("ascii"), + "port": self._remote_origin.port, + "auth": self._proxy_auth, + } + async with Trace( + "setup_socks5_connection", logger, request, kwargs + ) as trace: + await _init_socks5_connection(**kwargs) + trace.return_value = stream + + # Upgrade the stream to SSL + if self._remote_origin.scheme == b"https": + ssl_context = ( + default_ssl_context() + if self._ssl_context is None + else self._ssl_context + ) + alpn_protocols = ( + ["http/1.1", "h2"] if self._http2 else ["http/1.1"] + ) + ssl_context.set_alpn_protocols(alpn_protocols) + + kwargs = { + "ssl_context": ssl_context, + "server_hostname": sni_hostname + or self._remote_origin.host.decode("ascii"), + "timeout": timeout, + } + async with Trace("start_tls", logger, request, kwargs) as trace: + stream = await stream.start_tls(**kwargs) + trace.return_value = stream + + # Determine if we should be using HTTP/1.1 or HTTP/2 + ssl_object = stream.get_extra_info("ssl_object") + http2_negotiated = ( + ssl_object is not None + and ssl_object.selected_alpn_protocol() == "h2" + ) + + # Create the HTTP/1.1 or HTTP/2 connection + if http2_negotiated or ( + self._http2 and not self._http1 + ): # pragma: nocover + from .http2 import AsyncHTTP2Connection + + self._connection = AsyncHTTP2Connection( + origin=self._remote_origin, + stream=stream, + keepalive_expiry=self._keepalive_expiry, + ) + else: + self._connection = AsyncHTTP11Connection( + origin=self._remote_origin, + stream=stream, + keepalive_expiry=self._keepalive_expiry, + ) + except Exception as exc: + self._connect_failed = True + raise exc + elif not self._connection.is_available(): # pragma: nocover + raise ConnectionNotAvailable() + + return await self._connection.handle_async_request(request) + + def can_handle_request(self, origin: Origin) -> bool: + return origin == self._remote_origin + + async def aclose(self) -> None: + if self._connection is not None: + await self._connection.aclose() + + def is_available(self) -> bool: + if self._connection is None: # pragma: nocover + # If HTTP/2 support is enabled, and the resulting connection could + # end up as HTTP/2 then we should indicate the connection as being + # available to service multiple requests. + return ( + self._http2 + and (self._remote_origin.scheme == b"https" or not self._http1) + and not self._connect_failed + ) + return self._connection.is_available() + + def has_expired(self) -> bool: + if self._connection is None: # pragma: nocover + return self._connect_failed + return self._connection.has_expired() + + def is_idle(self) -> bool: + if self._connection is None: # pragma: nocover + return self._connect_failed + return self._connection.is_idle() + + def is_closed(self) -> bool: + if self._connection is None: # pragma: nocover + return self._connect_failed + return self._connection.is_closed() + + def info(self) -> str: + if self._connection is None: # pragma: nocover + return "CONNECTION FAILED" if self._connect_failed else "CONNECTING" + return self._connection.info() + + def __repr__(self) -> str: + return f"<{self.__class__.__name__} [{self.info()}]>" diff --git a/venv/lib/python3.10/site-packages/httpcore/_backends/__init__.py b/venv/lib/python3.10/site-packages/httpcore/_backends/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/venv/lib/python3.10/site-packages/httpcore/_backends/__pycache__/__init__.cpython-310.pyc b/venv/lib/python3.10/site-packages/httpcore/_backends/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9a0d5b0cb5ebb64b0840a1ff4d1ec4c941b3ae87 Binary files /dev/null and b/venv/lib/python3.10/site-packages/httpcore/_backends/__pycache__/__init__.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/httpcore/_backends/__pycache__/anyio.cpython-310.pyc b/venv/lib/python3.10/site-packages/httpcore/_backends/__pycache__/anyio.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..741ef662d6c28bbc744935afd9de422bfd78f436 Binary files /dev/null and b/venv/lib/python3.10/site-packages/httpcore/_backends/__pycache__/anyio.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/httpcore/_backends/__pycache__/auto.cpython-310.pyc b/venv/lib/python3.10/site-packages/httpcore/_backends/__pycache__/auto.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b92e9860127a3144c71dbb9b39ef8c40b17e6078 Binary files /dev/null and b/venv/lib/python3.10/site-packages/httpcore/_backends/__pycache__/auto.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/httpcore/_backends/__pycache__/base.cpython-310.pyc b/venv/lib/python3.10/site-packages/httpcore/_backends/__pycache__/base.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..79279df35ea58e2f72264123ce4e3bca4c820234 Binary files /dev/null and b/venv/lib/python3.10/site-packages/httpcore/_backends/__pycache__/base.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/httpcore/_backends/__pycache__/mock.cpython-310.pyc b/venv/lib/python3.10/site-packages/httpcore/_backends/__pycache__/mock.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..bd953404ed781a6bdac13c499ce31707b398f0bb Binary files /dev/null and b/venv/lib/python3.10/site-packages/httpcore/_backends/__pycache__/mock.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/httpcore/_backends/__pycache__/sync.cpython-310.pyc b/venv/lib/python3.10/site-packages/httpcore/_backends/__pycache__/sync.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6100e7149a4093f19b96385eb4e342692a0d98ed Binary files /dev/null and b/venv/lib/python3.10/site-packages/httpcore/_backends/__pycache__/sync.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/httpcore/_backends/__pycache__/trio.cpython-310.pyc b/venv/lib/python3.10/site-packages/httpcore/_backends/__pycache__/trio.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6196bc3174be31ed925cfa638d3dadcc56ea32bc Binary files /dev/null and b/venv/lib/python3.10/site-packages/httpcore/_backends/__pycache__/trio.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/httpcore/_backends/anyio.py b/venv/lib/python3.10/site-packages/httpcore/_backends/anyio.py new file mode 100644 index 0000000000000000000000000000000000000000..a140095e1b8de022f321a41c0125e0e5febc0749 --- /dev/null +++ b/venv/lib/python3.10/site-packages/httpcore/_backends/anyio.py @@ -0,0 +1,146 @@ +from __future__ import annotations + +import ssl +import typing + +import anyio + +from .._exceptions import ( + ConnectError, + ConnectTimeout, + ReadError, + ReadTimeout, + WriteError, + WriteTimeout, + map_exceptions, +) +from .._utils import is_socket_readable +from .base import SOCKET_OPTION, AsyncNetworkBackend, AsyncNetworkStream + + +class AnyIOStream(AsyncNetworkStream): + def __init__(self, stream: anyio.abc.ByteStream) -> None: + self._stream = stream + + async def read(self, max_bytes: int, timeout: float | None = None) -> bytes: + exc_map = { + TimeoutError: ReadTimeout, + anyio.BrokenResourceError: ReadError, + anyio.ClosedResourceError: ReadError, + anyio.EndOfStream: ReadError, + } + with map_exceptions(exc_map): + with anyio.fail_after(timeout): + try: + return await self._stream.receive(max_bytes=max_bytes) + except anyio.EndOfStream: # pragma: nocover + return b"" + + async def write(self, buffer: bytes, timeout: float | None = None) -> None: + if not buffer: + return + + exc_map = { + TimeoutError: WriteTimeout, + anyio.BrokenResourceError: WriteError, + anyio.ClosedResourceError: WriteError, + } + with map_exceptions(exc_map): + with anyio.fail_after(timeout): + await self._stream.send(item=buffer) + + async def aclose(self) -> None: + await self._stream.aclose() + + async def start_tls( + self, + ssl_context: ssl.SSLContext, + server_hostname: str | None = None, + timeout: float | None = None, + ) -> AsyncNetworkStream: + exc_map = { + TimeoutError: ConnectTimeout, + anyio.BrokenResourceError: ConnectError, + anyio.EndOfStream: ConnectError, + ssl.SSLError: ConnectError, + } + with map_exceptions(exc_map): + try: + with anyio.fail_after(timeout): + ssl_stream = await anyio.streams.tls.TLSStream.wrap( + self._stream, + ssl_context=ssl_context, + hostname=server_hostname, + standard_compatible=False, + server_side=False, + ) + except Exception as exc: # pragma: nocover + await self.aclose() + raise exc + return AnyIOStream(ssl_stream) + + def get_extra_info(self, info: str) -> typing.Any: + if info == "ssl_object": + return self._stream.extra(anyio.streams.tls.TLSAttribute.ssl_object, None) + if info == "client_addr": + return self._stream.extra(anyio.abc.SocketAttribute.local_address, None) + if info == "server_addr": + return self._stream.extra(anyio.abc.SocketAttribute.remote_address, None) + if info == "socket": + return self._stream.extra(anyio.abc.SocketAttribute.raw_socket, None) + if info == "is_readable": + sock = self._stream.extra(anyio.abc.SocketAttribute.raw_socket, None) + return is_socket_readable(sock) + return None + + +class AnyIOBackend(AsyncNetworkBackend): + async def connect_tcp( + self, + host: str, + port: int, + timeout: float | None = None, + local_address: str | None = None, + socket_options: typing.Iterable[SOCKET_OPTION] | None = None, + ) -> AsyncNetworkStream: # pragma: nocover + if socket_options is None: + socket_options = [] + exc_map = { + TimeoutError: ConnectTimeout, + OSError: ConnectError, + anyio.BrokenResourceError: ConnectError, + } + with map_exceptions(exc_map): + with anyio.fail_after(timeout): + stream: anyio.abc.ByteStream = await anyio.connect_tcp( + remote_host=host, + remote_port=port, + local_host=local_address, + ) + # By default TCP sockets opened in `asyncio` include TCP_NODELAY. + for option in socket_options: + stream._raw_socket.setsockopt(*option) # type: ignore[attr-defined] # pragma: no cover + return AnyIOStream(stream) + + async def connect_unix_socket( + self, + path: str, + timeout: float | None = None, + socket_options: typing.Iterable[SOCKET_OPTION] | None = None, + ) -> AsyncNetworkStream: # pragma: nocover + if socket_options is None: + socket_options = [] + exc_map = { + TimeoutError: ConnectTimeout, + OSError: ConnectError, + anyio.BrokenResourceError: ConnectError, + } + with map_exceptions(exc_map): + with anyio.fail_after(timeout): + stream: anyio.abc.ByteStream = await anyio.connect_unix(path) + for option in socket_options: + stream._raw_socket.setsockopt(*option) # type: ignore[attr-defined] # pragma: no cover + return AnyIOStream(stream) + + async def sleep(self, seconds: float) -> None: + await anyio.sleep(seconds) # pragma: nocover diff --git a/venv/lib/python3.10/site-packages/httpcore/_backends/auto.py b/venv/lib/python3.10/site-packages/httpcore/_backends/auto.py new file mode 100644 index 0000000000000000000000000000000000000000..49f0e698c97ad5623f376d8182675352e21c2c3c --- /dev/null +++ b/venv/lib/python3.10/site-packages/httpcore/_backends/auto.py @@ -0,0 +1,52 @@ +from __future__ import annotations + +import typing + +from .._synchronization import current_async_library +from .base import SOCKET_OPTION, AsyncNetworkBackend, AsyncNetworkStream + + +class AutoBackend(AsyncNetworkBackend): + async def _init_backend(self) -> None: + if not (hasattr(self, "_backend")): + backend = current_async_library() + if backend == "trio": + from .trio import TrioBackend + + self._backend: AsyncNetworkBackend = TrioBackend() + else: + from .anyio import AnyIOBackend + + self._backend = AnyIOBackend() + + async def connect_tcp( + self, + host: str, + port: int, + timeout: float | None = None, + local_address: str | None = None, + socket_options: typing.Iterable[SOCKET_OPTION] | None = None, + ) -> AsyncNetworkStream: + await self._init_backend() + return await self._backend.connect_tcp( + host, + port, + timeout=timeout, + local_address=local_address, + socket_options=socket_options, + ) + + async def connect_unix_socket( + self, + path: str, + timeout: float | None = None, + socket_options: typing.Iterable[SOCKET_OPTION] | None = None, + ) -> AsyncNetworkStream: # pragma: nocover + await self._init_backend() + return await self._backend.connect_unix_socket( + path, timeout=timeout, socket_options=socket_options + ) + + async def sleep(self, seconds: float) -> None: # pragma: nocover + await self._init_backend() + return await self._backend.sleep(seconds) diff --git a/venv/lib/python3.10/site-packages/httpcore/_backends/base.py b/venv/lib/python3.10/site-packages/httpcore/_backends/base.py new file mode 100644 index 0000000000000000000000000000000000000000..cf55c8b10eb543872550be863206fe2f760d0d8d --- /dev/null +++ b/venv/lib/python3.10/site-packages/httpcore/_backends/base.py @@ -0,0 +1,101 @@ +from __future__ import annotations + +import ssl +import time +import typing + +SOCKET_OPTION = typing.Union[ + typing.Tuple[int, int, int], + typing.Tuple[int, int, typing.Union[bytes, bytearray]], + typing.Tuple[int, int, None, int], +] + + +class NetworkStream: + def read(self, max_bytes: int, timeout: float | None = None) -> bytes: + raise NotImplementedError() # pragma: nocover + + def write(self, buffer: bytes, timeout: float | None = None) -> None: + raise NotImplementedError() # pragma: nocover + + def close(self) -> None: + raise NotImplementedError() # pragma: nocover + + def start_tls( + self, + ssl_context: ssl.SSLContext, + server_hostname: str | None = None, + timeout: float | None = None, + ) -> NetworkStream: + raise NotImplementedError() # pragma: nocover + + def get_extra_info(self, info: str) -> typing.Any: + return None # pragma: nocover + + +class NetworkBackend: + def connect_tcp( + self, + host: str, + port: int, + timeout: float | None = None, + local_address: str | None = None, + socket_options: typing.Iterable[SOCKET_OPTION] | None = None, + ) -> NetworkStream: + raise NotImplementedError() # pragma: nocover + + def connect_unix_socket( + self, + path: str, + timeout: float | None = None, + socket_options: typing.Iterable[SOCKET_OPTION] | None = None, + ) -> NetworkStream: + raise NotImplementedError() # pragma: nocover + + def sleep(self, seconds: float) -> None: + time.sleep(seconds) # pragma: nocover + + +class AsyncNetworkStream: + async def read(self, max_bytes: int, timeout: float | None = None) -> bytes: + raise NotImplementedError() # pragma: nocover + + async def write(self, buffer: bytes, timeout: float | None = None) -> None: + raise NotImplementedError() # pragma: nocover + + async def aclose(self) -> None: + raise NotImplementedError() # pragma: nocover + + async def start_tls( + self, + ssl_context: ssl.SSLContext, + server_hostname: str | None = None, + timeout: float | None = None, + ) -> AsyncNetworkStream: + raise NotImplementedError() # pragma: nocover + + def get_extra_info(self, info: str) -> typing.Any: + return None # pragma: nocover + + +class AsyncNetworkBackend: + async def connect_tcp( + self, + host: str, + port: int, + timeout: float | None = None, + local_address: str | None = None, + socket_options: typing.Iterable[SOCKET_OPTION] | None = None, + ) -> AsyncNetworkStream: + raise NotImplementedError() # pragma: nocover + + async def connect_unix_socket( + self, + path: str, + timeout: float | None = None, + socket_options: typing.Iterable[SOCKET_OPTION] | None = None, + ) -> AsyncNetworkStream: + raise NotImplementedError() # pragma: nocover + + async def sleep(self, seconds: float) -> None: + raise NotImplementedError() # pragma: nocover diff --git a/venv/lib/python3.10/site-packages/httpcore/_backends/mock.py b/venv/lib/python3.10/site-packages/httpcore/_backends/mock.py new file mode 100644 index 0000000000000000000000000000000000000000..9b6edca03d4d4b34f355fd53e49d4b4c699c972c --- /dev/null +++ b/venv/lib/python3.10/site-packages/httpcore/_backends/mock.py @@ -0,0 +1,143 @@ +from __future__ import annotations + +import ssl +import typing + +from .._exceptions import ReadError +from .base import ( + SOCKET_OPTION, + AsyncNetworkBackend, + AsyncNetworkStream, + NetworkBackend, + NetworkStream, +) + + +class MockSSLObject: + def __init__(self, http2: bool): + self._http2 = http2 + + def selected_alpn_protocol(self) -> str: + return "h2" if self._http2 else "http/1.1" + + +class MockStream(NetworkStream): + def __init__(self, buffer: list[bytes], http2: bool = False) -> None: + self._buffer = buffer + self._http2 = http2 + self._closed = False + + def read(self, max_bytes: int, timeout: float | None = None) -> bytes: + if self._closed: + raise ReadError("Connection closed") + if not self._buffer: + return b"" + return self._buffer.pop(0) + + def write(self, buffer: bytes, timeout: float | None = None) -> None: + pass + + def close(self) -> None: + self._closed = True + + def start_tls( + self, + ssl_context: ssl.SSLContext, + server_hostname: str | None = None, + timeout: float | None = None, + ) -> NetworkStream: + return self + + def get_extra_info(self, info: str) -> typing.Any: + return MockSSLObject(http2=self._http2) if info == "ssl_object" else None + + def __repr__(self) -> str: + return "" + + +class MockBackend(NetworkBackend): + def __init__(self, buffer: list[bytes], http2: bool = False) -> None: + self._buffer = buffer + self._http2 = http2 + + def connect_tcp( + self, + host: str, + port: int, + timeout: float | None = None, + local_address: str | None = None, + socket_options: typing.Iterable[SOCKET_OPTION] | None = None, + ) -> NetworkStream: + return MockStream(list(self._buffer), http2=self._http2) + + def connect_unix_socket( + self, + path: str, + timeout: float | None = None, + socket_options: typing.Iterable[SOCKET_OPTION] | None = None, + ) -> NetworkStream: + return MockStream(list(self._buffer), http2=self._http2) + + def sleep(self, seconds: float) -> None: + pass + + +class AsyncMockStream(AsyncNetworkStream): + def __init__(self, buffer: list[bytes], http2: bool = False) -> None: + self._buffer = buffer + self._http2 = http2 + self._closed = False + + async def read(self, max_bytes: int, timeout: float | None = None) -> bytes: + if self._closed: + raise ReadError("Connection closed") + if not self._buffer: + return b"" + return self._buffer.pop(0) + + async def write(self, buffer: bytes, timeout: float | None = None) -> None: + pass + + async def aclose(self) -> None: + self._closed = True + + async def start_tls( + self, + ssl_context: ssl.SSLContext, + server_hostname: str | None = None, + timeout: float | None = None, + ) -> AsyncNetworkStream: + return self + + def get_extra_info(self, info: str) -> typing.Any: + return MockSSLObject(http2=self._http2) if info == "ssl_object" else None + + def __repr__(self) -> str: + return "" + + +class AsyncMockBackend(AsyncNetworkBackend): + def __init__(self, buffer: list[bytes], http2: bool = False) -> None: + self._buffer = buffer + self._http2 = http2 + + async def connect_tcp( + self, + host: str, + port: int, + timeout: float | None = None, + local_address: str | None = None, + socket_options: typing.Iterable[SOCKET_OPTION] | None = None, + ) -> AsyncNetworkStream: + return AsyncMockStream(list(self._buffer), http2=self._http2) + + async def connect_unix_socket( + self, + path: str, + timeout: float | None = None, + socket_options: typing.Iterable[SOCKET_OPTION] | None = None, + ) -> AsyncNetworkStream: + return AsyncMockStream(list(self._buffer), http2=self._http2) + + async def sleep(self, seconds: float) -> None: + pass diff --git a/venv/lib/python3.10/site-packages/httpcore/_backends/sync.py b/venv/lib/python3.10/site-packages/httpcore/_backends/sync.py new file mode 100644 index 0000000000000000000000000000000000000000..4018a09c6fb1e0ef1b03ab8d84b13ebef4031f7c --- /dev/null +++ b/venv/lib/python3.10/site-packages/httpcore/_backends/sync.py @@ -0,0 +1,241 @@ +from __future__ import annotations + +import functools +import socket +import ssl +import sys +import typing + +from .._exceptions import ( + ConnectError, + ConnectTimeout, + ExceptionMapping, + ReadError, + ReadTimeout, + WriteError, + WriteTimeout, + map_exceptions, +) +from .._utils import is_socket_readable +from .base import SOCKET_OPTION, NetworkBackend, NetworkStream + + +class TLSinTLSStream(NetworkStream): # pragma: no cover + """ + Because the standard `SSLContext.wrap_socket` method does + not work for `SSLSocket` objects, we need this class + to implement TLS stream using an underlying `SSLObject` + instance in order to support TLS on top of TLS. + """ + + # Defined in RFC 8449 + TLS_RECORD_SIZE = 16384 + + def __init__( + self, + sock: socket.socket, + ssl_context: ssl.SSLContext, + server_hostname: str | None = None, + timeout: float | None = None, + ): + self._sock = sock + self._incoming = ssl.MemoryBIO() + self._outgoing = ssl.MemoryBIO() + + self.ssl_obj = ssl_context.wrap_bio( + incoming=self._incoming, + outgoing=self._outgoing, + server_hostname=server_hostname, + ) + + self._sock.settimeout(timeout) + self._perform_io(self.ssl_obj.do_handshake) + + def _perform_io( + self, + func: typing.Callable[..., typing.Any], + ) -> typing.Any: + ret = None + + while True: + errno = None + try: + ret = func() + except (ssl.SSLWantReadError, ssl.SSLWantWriteError) as e: + errno = e.errno + + self._sock.sendall(self._outgoing.read()) + + if errno == ssl.SSL_ERROR_WANT_READ: + buf = self._sock.recv(self.TLS_RECORD_SIZE) + + if buf: + self._incoming.write(buf) + else: + self._incoming.write_eof() + if errno is None: + return ret + + def read(self, max_bytes: int, timeout: float | None = None) -> bytes: + exc_map: ExceptionMapping = {socket.timeout: ReadTimeout, OSError: ReadError} + with map_exceptions(exc_map): + self._sock.settimeout(timeout) + return typing.cast( + bytes, self._perform_io(functools.partial(self.ssl_obj.read, max_bytes)) + ) + + def write(self, buffer: bytes, timeout: float | None = None) -> None: + exc_map: ExceptionMapping = {socket.timeout: WriteTimeout, OSError: WriteError} + with map_exceptions(exc_map): + self._sock.settimeout(timeout) + while buffer: + nsent = self._perform_io(functools.partial(self.ssl_obj.write, buffer)) + buffer = buffer[nsent:] + + def close(self) -> None: + self._sock.close() + + def start_tls( + self, + ssl_context: ssl.SSLContext, + server_hostname: str | None = None, + timeout: float | None = None, + ) -> NetworkStream: + raise NotImplementedError() + + def get_extra_info(self, info: str) -> typing.Any: + if info == "ssl_object": + return self.ssl_obj + if info == "client_addr": + return self._sock.getsockname() + if info == "server_addr": + return self._sock.getpeername() + if info == "socket": + return self._sock + if info == "is_readable": + return is_socket_readable(self._sock) + return None + + +class SyncStream(NetworkStream): + def __init__(self, sock: socket.socket) -> None: + self._sock = sock + + def read(self, max_bytes: int, timeout: float | None = None) -> bytes: + exc_map: ExceptionMapping = {socket.timeout: ReadTimeout, OSError: ReadError} + with map_exceptions(exc_map): + self._sock.settimeout(timeout) + return self._sock.recv(max_bytes) + + def write(self, buffer: bytes, timeout: float | None = None) -> None: + if not buffer: + return + + exc_map: ExceptionMapping = {socket.timeout: WriteTimeout, OSError: WriteError} + with map_exceptions(exc_map): + while buffer: + self._sock.settimeout(timeout) + n = self._sock.send(buffer) + buffer = buffer[n:] + + def close(self) -> None: + self._sock.close() + + def start_tls( + self, + ssl_context: ssl.SSLContext, + server_hostname: str | None = None, + timeout: float | None = None, + ) -> NetworkStream: + exc_map: ExceptionMapping = { + socket.timeout: ConnectTimeout, + OSError: ConnectError, + } + with map_exceptions(exc_map): + try: + if isinstance(self._sock, ssl.SSLSocket): # pragma: no cover + # If the underlying socket has already been upgraded + # to the TLS layer (i.e. is an instance of SSLSocket), + # we need some additional smarts to support TLS-in-TLS. + return TLSinTLSStream( + self._sock, ssl_context, server_hostname, timeout + ) + else: + self._sock.settimeout(timeout) + sock = ssl_context.wrap_socket( + self._sock, server_hostname=server_hostname + ) + except Exception as exc: # pragma: nocover + self.close() + raise exc + return SyncStream(sock) + + def get_extra_info(self, info: str) -> typing.Any: + if info == "ssl_object" and isinstance(self._sock, ssl.SSLSocket): + return self._sock._sslobj # type: ignore + if info == "client_addr": + return self._sock.getsockname() + if info == "server_addr": + return self._sock.getpeername() + if info == "socket": + return self._sock + if info == "is_readable": + return is_socket_readable(self._sock) + return None + + +class SyncBackend(NetworkBackend): + def connect_tcp( + self, + host: str, + port: int, + timeout: float | None = None, + local_address: str | None = None, + socket_options: typing.Iterable[SOCKET_OPTION] | None = None, + ) -> NetworkStream: + # Note that we automatically include `TCP_NODELAY` + # in addition to any other custom socket options. + if socket_options is None: + socket_options = [] # pragma: no cover + address = (host, port) + source_address = None if local_address is None else (local_address, 0) + exc_map: ExceptionMapping = { + socket.timeout: ConnectTimeout, + OSError: ConnectError, + } + + with map_exceptions(exc_map): + sock = socket.create_connection( + address, + timeout, + source_address=source_address, + ) + for option in socket_options: + sock.setsockopt(*option) # pragma: no cover + sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1) + return SyncStream(sock) + + def connect_unix_socket( + self, + path: str, + timeout: float | None = None, + socket_options: typing.Iterable[SOCKET_OPTION] | None = None, + ) -> NetworkStream: # pragma: nocover + if sys.platform == "win32": + raise RuntimeError( + "Attempted to connect to a UNIX socket on a Windows system." + ) + if socket_options is None: + socket_options = [] + + exc_map: ExceptionMapping = { + socket.timeout: ConnectTimeout, + OSError: ConnectError, + } + with map_exceptions(exc_map): + sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) + for option in socket_options: + sock.setsockopt(*option) + sock.settimeout(timeout) + sock.connect(path) + return SyncStream(sock) diff --git a/venv/lib/python3.10/site-packages/httpcore/_backends/trio.py b/venv/lib/python3.10/site-packages/httpcore/_backends/trio.py new file mode 100644 index 0000000000000000000000000000000000000000..6f53f5f2a025e01e9949e2530bd9ca6928859251 --- /dev/null +++ b/venv/lib/python3.10/site-packages/httpcore/_backends/trio.py @@ -0,0 +1,159 @@ +from __future__ import annotations + +import ssl +import typing + +import trio + +from .._exceptions import ( + ConnectError, + ConnectTimeout, + ExceptionMapping, + ReadError, + ReadTimeout, + WriteError, + WriteTimeout, + map_exceptions, +) +from .base import SOCKET_OPTION, AsyncNetworkBackend, AsyncNetworkStream + + +class TrioStream(AsyncNetworkStream): + def __init__(self, stream: trio.abc.Stream) -> None: + self._stream = stream + + async def read(self, max_bytes: int, timeout: float | None = None) -> bytes: + timeout_or_inf = float("inf") if timeout is None else timeout + exc_map: ExceptionMapping = { + trio.TooSlowError: ReadTimeout, + trio.BrokenResourceError: ReadError, + trio.ClosedResourceError: ReadError, + } + with map_exceptions(exc_map): + with trio.fail_after(timeout_or_inf): + data: bytes = await self._stream.receive_some(max_bytes=max_bytes) + return data + + async def write(self, buffer: bytes, timeout: float | None = None) -> None: + if not buffer: + return + + timeout_or_inf = float("inf") if timeout is None else timeout + exc_map: ExceptionMapping = { + trio.TooSlowError: WriteTimeout, + trio.BrokenResourceError: WriteError, + trio.ClosedResourceError: WriteError, + } + with map_exceptions(exc_map): + with trio.fail_after(timeout_or_inf): + await self._stream.send_all(data=buffer) + + async def aclose(self) -> None: + await self._stream.aclose() + + async def start_tls( + self, + ssl_context: ssl.SSLContext, + server_hostname: str | None = None, + timeout: float | None = None, + ) -> AsyncNetworkStream: + timeout_or_inf = float("inf") if timeout is None else timeout + exc_map: ExceptionMapping = { + trio.TooSlowError: ConnectTimeout, + trio.BrokenResourceError: ConnectError, + } + ssl_stream = trio.SSLStream( + self._stream, + ssl_context=ssl_context, + server_hostname=server_hostname, + https_compatible=True, + server_side=False, + ) + with map_exceptions(exc_map): + try: + with trio.fail_after(timeout_or_inf): + await ssl_stream.do_handshake() + except Exception as exc: # pragma: nocover + await self.aclose() + raise exc + return TrioStream(ssl_stream) + + def get_extra_info(self, info: str) -> typing.Any: + if info == "ssl_object" and isinstance(self._stream, trio.SSLStream): + # Type checkers cannot see `_ssl_object` attribute because trio._ssl.SSLStream uses __getattr__/__setattr__. + # Tracked at https://github.com/python-trio/trio/issues/542 + return self._stream._ssl_object # type: ignore[attr-defined] + if info == "client_addr": + return self._get_socket_stream().socket.getsockname() + if info == "server_addr": + return self._get_socket_stream().socket.getpeername() + if info == "socket": + stream = self._stream + while isinstance(stream, trio.SSLStream): + stream = stream.transport_stream + assert isinstance(stream, trio.SocketStream) + return stream.socket + if info == "is_readable": + socket = self.get_extra_info("socket") + return socket.is_readable() + return None + + def _get_socket_stream(self) -> trio.SocketStream: + stream = self._stream + while isinstance(stream, trio.SSLStream): + stream = stream.transport_stream + assert isinstance(stream, trio.SocketStream) + return stream + + +class TrioBackend(AsyncNetworkBackend): + async def connect_tcp( + self, + host: str, + port: int, + timeout: float | None = None, + local_address: str | None = None, + socket_options: typing.Iterable[SOCKET_OPTION] | None = None, + ) -> AsyncNetworkStream: + # By default for TCP sockets, trio enables TCP_NODELAY. + # https://trio.readthedocs.io/en/stable/reference-io.html#trio.SocketStream + if socket_options is None: + socket_options = [] # pragma: no cover + timeout_or_inf = float("inf") if timeout is None else timeout + exc_map: ExceptionMapping = { + trio.TooSlowError: ConnectTimeout, + trio.BrokenResourceError: ConnectError, + OSError: ConnectError, + } + with map_exceptions(exc_map): + with trio.fail_after(timeout_or_inf): + stream: trio.abc.Stream = await trio.open_tcp_stream( + host=host, port=port, local_address=local_address + ) + for option in socket_options: + stream.setsockopt(*option) # type: ignore[attr-defined] # pragma: no cover + return TrioStream(stream) + + async def connect_unix_socket( + self, + path: str, + timeout: float | None = None, + socket_options: typing.Iterable[SOCKET_OPTION] | None = None, + ) -> AsyncNetworkStream: # pragma: nocover + if socket_options is None: + socket_options = [] + timeout_or_inf = float("inf") if timeout is None else timeout + exc_map: ExceptionMapping = { + trio.TooSlowError: ConnectTimeout, + trio.BrokenResourceError: ConnectError, + OSError: ConnectError, + } + with map_exceptions(exc_map): + with trio.fail_after(timeout_or_inf): + stream: trio.abc.Stream = await trio.open_unix_socket(path) + for option in socket_options: + stream.setsockopt(*option) # type: ignore[attr-defined] # pragma: no cover + return TrioStream(stream) + + async def sleep(self, seconds: float) -> None: + await trio.sleep(seconds) # pragma: nocover diff --git a/venv/lib/python3.10/site-packages/httpcore/_exceptions.py b/venv/lib/python3.10/site-packages/httpcore/_exceptions.py new file mode 100644 index 0000000000000000000000000000000000000000..bc28d44f55bdc4b872951a74780469a3999d9ab4 --- /dev/null +++ b/venv/lib/python3.10/site-packages/httpcore/_exceptions.py @@ -0,0 +1,81 @@ +import contextlib +import typing + +ExceptionMapping = typing.Mapping[typing.Type[Exception], typing.Type[Exception]] + + +@contextlib.contextmanager +def map_exceptions(map: ExceptionMapping) -> typing.Iterator[None]: + try: + yield + except Exception as exc: # noqa: PIE786 + for from_exc, to_exc in map.items(): + if isinstance(exc, from_exc): + raise to_exc(exc) from exc + raise # pragma: nocover + + +class ConnectionNotAvailable(Exception): + pass + + +class ProxyError(Exception): + pass + + +class UnsupportedProtocol(Exception): + pass + + +class ProtocolError(Exception): + pass + + +class RemoteProtocolError(ProtocolError): + pass + + +class LocalProtocolError(ProtocolError): + pass + + +# Timeout errors + + +class TimeoutException(Exception): + pass + + +class PoolTimeout(TimeoutException): + pass + + +class ConnectTimeout(TimeoutException): + pass + + +class ReadTimeout(TimeoutException): + pass + + +class WriteTimeout(TimeoutException): + pass + + +# Network errors + + +class NetworkError(Exception): + pass + + +class ConnectError(NetworkError): + pass + + +class ReadError(NetworkError): + pass + + +class WriteError(NetworkError): + pass diff --git a/venv/lib/python3.10/site-packages/httpcore/_models.py b/venv/lib/python3.10/site-packages/httpcore/_models.py new file mode 100644 index 0000000000000000000000000000000000000000..8a65f13347d6621289a166d08123cbc8e1ad0157 --- /dev/null +++ b/venv/lib/python3.10/site-packages/httpcore/_models.py @@ -0,0 +1,516 @@ +from __future__ import annotations + +import base64 +import ssl +import typing +import urllib.parse + +# Functions for typechecking... + + +ByteOrStr = typing.Union[bytes, str] +HeadersAsSequence = typing.Sequence[typing.Tuple[ByteOrStr, ByteOrStr]] +HeadersAsMapping = typing.Mapping[ByteOrStr, ByteOrStr] +HeaderTypes = typing.Union[HeadersAsSequence, HeadersAsMapping, None] + +Extensions = typing.MutableMapping[str, typing.Any] + + +def enforce_bytes(value: bytes | str, *, name: str) -> bytes: + """ + Any arguments that are ultimately represented as bytes can be specified + either as bytes or as strings. + + However we enforce that any string arguments must only contain characters in + the plain ASCII range. chr(0)...chr(127). If you need to use characters + outside that range then be precise, and use a byte-wise argument. + """ + if isinstance(value, str): + try: + return value.encode("ascii") + except UnicodeEncodeError: + raise TypeError(f"{name} strings may not include unicode characters.") + elif isinstance(value, bytes): + return value + + seen_type = type(value).__name__ + raise TypeError(f"{name} must be bytes or str, but got {seen_type}.") + + +def enforce_url(value: URL | bytes | str, *, name: str) -> URL: + """ + Type check for URL parameters. + """ + if isinstance(value, (bytes, str)): + return URL(value) + elif isinstance(value, URL): + return value + + seen_type = type(value).__name__ + raise TypeError(f"{name} must be a URL, bytes, or str, but got {seen_type}.") + + +def enforce_headers( + value: HeadersAsMapping | HeadersAsSequence | None = None, *, name: str +) -> list[tuple[bytes, bytes]]: + """ + Convienence function that ensure all items in request or response headers + are either bytes or strings in the plain ASCII range. + """ + if value is None: + return [] + elif isinstance(value, typing.Mapping): + return [ + ( + enforce_bytes(k, name="header name"), + enforce_bytes(v, name="header value"), + ) + for k, v in value.items() + ] + elif isinstance(value, typing.Sequence): + return [ + ( + enforce_bytes(k, name="header name"), + enforce_bytes(v, name="header value"), + ) + for k, v in value + ] + + seen_type = type(value).__name__ + raise TypeError( + f"{name} must be a mapping or sequence of two-tuples, but got {seen_type}." + ) + + +def enforce_stream( + value: bytes | typing.Iterable[bytes] | typing.AsyncIterable[bytes] | None, + *, + name: str, +) -> typing.Iterable[bytes] | typing.AsyncIterable[bytes]: + if value is None: + return ByteStream(b"") + elif isinstance(value, bytes): + return ByteStream(value) + return value + + +# * https://tools.ietf.org/html/rfc3986#section-3.2.3 +# * https://url.spec.whatwg.org/#url-miscellaneous +# * https://url.spec.whatwg.org/#scheme-state +DEFAULT_PORTS = { + b"ftp": 21, + b"http": 80, + b"https": 443, + b"ws": 80, + b"wss": 443, +} + + +def include_request_headers( + headers: list[tuple[bytes, bytes]], + *, + url: "URL", + content: None | bytes | typing.Iterable[bytes] | typing.AsyncIterable[bytes], +) -> list[tuple[bytes, bytes]]: + headers_set = set(k.lower() for k, v in headers) + + if b"host" not in headers_set: + default_port = DEFAULT_PORTS.get(url.scheme) + if url.port is None or url.port == default_port: + header_value = url.host + else: + header_value = b"%b:%d" % (url.host, url.port) + headers = [(b"Host", header_value)] + headers + + if ( + content is not None + and b"content-length" not in headers_set + and b"transfer-encoding" not in headers_set + ): + if isinstance(content, bytes): + content_length = str(len(content)).encode("ascii") + headers += [(b"Content-Length", content_length)] + else: + headers += [(b"Transfer-Encoding", b"chunked")] # pragma: nocover + + return headers + + +# Interfaces for byte streams... + + +class ByteStream: + """ + A container for non-streaming content, and that supports both sync and async + stream iteration. + """ + + def __init__(self, content: bytes) -> None: + self._content = content + + def __iter__(self) -> typing.Iterator[bytes]: + yield self._content + + async def __aiter__(self) -> typing.AsyncIterator[bytes]: + yield self._content + + def __repr__(self) -> str: + return f"<{self.__class__.__name__} [{len(self._content)} bytes]>" + + +class Origin: + def __init__(self, scheme: bytes, host: bytes, port: int) -> None: + self.scheme = scheme + self.host = host + self.port = port + + def __eq__(self, other: typing.Any) -> bool: + return ( + isinstance(other, Origin) + and self.scheme == other.scheme + and self.host == other.host + and self.port == other.port + ) + + def __str__(self) -> str: + scheme = self.scheme.decode("ascii") + host = self.host.decode("ascii") + port = str(self.port) + return f"{scheme}://{host}:{port}" + + +class URL: + """ + Represents the URL against which an HTTP request may be made. + + The URL may either be specified as a plain string, for convienence: + + ```python + url = httpcore.URL("https://www.example.com/") + ``` + + Or be constructed with explicitily pre-parsed components: + + ```python + url = httpcore.URL(scheme=b'https', host=b'www.example.com', port=None, target=b'/') + ``` + + Using this second more explicit style allows integrations that are using + `httpcore` to pass through URLs that have already been parsed in order to use + libraries such as `rfc-3986` rather than relying on the stdlib. It also ensures + that URL parsing is treated identically at both the networking level and at any + higher layers of abstraction. + + The four components are important here, as they allow the URL to be precisely + specified in a pre-parsed format. They also allow certain types of request to + be created that could not otherwise be expressed. + + For example, an HTTP request to `http://www.example.com/` forwarded via a proxy + at `http://localhost:8080`... + + ```python + # Constructs an HTTP request with a complete URL as the target: + # GET https://www.example.com/ HTTP/1.1 + url = httpcore.URL( + scheme=b'http', + host=b'localhost', + port=8080, + target=b'https://www.example.com/' + ) + request = httpcore.Request( + method="GET", + url=url + ) + ``` + + Another example is constructing an `OPTIONS *` request... + + ```python + # Constructs an 'OPTIONS *' HTTP request: + # OPTIONS * HTTP/1.1 + url = httpcore.URL(scheme=b'https', host=b'www.example.com', target=b'*') + request = httpcore.Request(method="OPTIONS", url=url) + ``` + + This kind of request is not possible to formulate with a URL string, + because the `/` delimiter is always used to demark the target from the + host/port portion of the URL. + + For convenience, string-like arguments may be specified either as strings or + as bytes. However, once a request is being issue over-the-wire, the URL + components are always ultimately required to be a bytewise representation. + + In order to avoid any ambiguity over character encodings, when strings are used + as arguments, they must be strictly limited to the ASCII range `chr(0)`-`chr(127)`. + If you require a bytewise representation that is outside this range you must + handle the character encoding directly, and pass a bytes instance. + """ + + def __init__( + self, + url: bytes | str = "", + *, + scheme: bytes | str = b"", + host: bytes | str = b"", + port: int | None = None, + target: bytes | str = b"", + ) -> None: + """ + Parameters: + url: The complete URL as a string or bytes. + scheme: The URL scheme as a string or bytes. + Typically either `"http"` or `"https"`. + host: The URL host as a string or bytes. Such as `"www.example.com"`. + port: The port to connect to. Either an integer or `None`. + target: The target of the HTTP request. Such as `"/items?search=red"`. + """ + if url: + parsed = urllib.parse.urlparse(enforce_bytes(url, name="url")) + self.scheme = parsed.scheme + self.host = parsed.hostname or b"" + self.port = parsed.port + self.target = (parsed.path or b"/") + ( + b"?" + parsed.query if parsed.query else b"" + ) + else: + self.scheme = enforce_bytes(scheme, name="scheme") + self.host = enforce_bytes(host, name="host") + self.port = port + self.target = enforce_bytes(target, name="target") + + @property + def origin(self) -> Origin: + default_port = { + b"http": 80, + b"https": 443, + b"ws": 80, + b"wss": 443, + b"socks5": 1080, + b"socks5h": 1080, + }[self.scheme] + return Origin( + scheme=self.scheme, host=self.host, port=self.port or default_port + ) + + def __eq__(self, other: typing.Any) -> bool: + return ( + isinstance(other, URL) + and other.scheme == self.scheme + and other.host == self.host + and other.port == self.port + and other.target == self.target + ) + + def __bytes__(self) -> bytes: + if self.port is None: + return b"%b://%b%b" % (self.scheme, self.host, self.target) + return b"%b://%b:%d%b" % (self.scheme, self.host, self.port, self.target) + + def __repr__(self) -> str: + return ( + f"{self.__class__.__name__}(scheme={self.scheme!r}, " + f"host={self.host!r}, port={self.port!r}, target={self.target!r})" + ) + + +class Request: + """ + An HTTP request. + """ + + def __init__( + self, + method: bytes | str, + url: URL | bytes | str, + *, + headers: HeaderTypes = None, + content: bytes + | typing.Iterable[bytes] + | typing.AsyncIterable[bytes] + | None = None, + extensions: Extensions | None = None, + ) -> None: + """ + Parameters: + method: The HTTP request method, either as a string or bytes. + For example: `GET`. + url: The request URL, either as a `URL` instance, or as a string or bytes. + For example: `"https://www.example.com".` + headers: The HTTP request headers. + content: The content of the request body. + extensions: A dictionary of optional extra information included on + the request. Possible keys include `"timeout"`, and `"trace"`. + """ + self.method: bytes = enforce_bytes(method, name="method") + self.url: URL = enforce_url(url, name="url") + self.headers: list[tuple[bytes, bytes]] = enforce_headers( + headers, name="headers" + ) + self.stream: typing.Iterable[bytes] | typing.AsyncIterable[bytes] = ( + enforce_stream(content, name="content") + ) + self.extensions = {} if extensions is None else extensions + + if "target" in self.extensions: + self.url = URL( + scheme=self.url.scheme, + host=self.url.host, + port=self.url.port, + target=self.extensions["target"], + ) + + def __repr__(self) -> str: + return f"<{self.__class__.__name__} [{self.method!r}]>" + + +class Response: + """ + An HTTP response. + """ + + def __init__( + self, + status: int, + *, + headers: HeaderTypes = None, + content: bytes + | typing.Iterable[bytes] + | typing.AsyncIterable[bytes] + | None = None, + extensions: Extensions | None = None, + ) -> None: + """ + Parameters: + status: The HTTP status code of the response. For example `200`. + headers: The HTTP response headers. + content: The content of the response body. + extensions: A dictionary of optional extra information included on + the responseself.Possible keys include `"http_version"`, + `"reason_phrase"`, and `"network_stream"`. + """ + self.status: int = status + self.headers: list[tuple[bytes, bytes]] = enforce_headers( + headers, name="headers" + ) + self.stream: typing.Iterable[bytes] | typing.AsyncIterable[bytes] = ( + enforce_stream(content, name="content") + ) + self.extensions = {} if extensions is None else extensions + + self._stream_consumed = False + + @property + def content(self) -> bytes: + if not hasattr(self, "_content"): + if isinstance(self.stream, typing.Iterable): + raise RuntimeError( + "Attempted to access 'response.content' on a streaming response. " + "Call 'response.read()' first." + ) + else: + raise RuntimeError( + "Attempted to access 'response.content' on a streaming response. " + "Call 'await response.aread()' first." + ) + return self._content + + def __repr__(self) -> str: + return f"<{self.__class__.__name__} [{self.status}]>" + + # Sync interface... + + def read(self) -> bytes: + if not isinstance(self.stream, typing.Iterable): # pragma: nocover + raise RuntimeError( + "Attempted to read an asynchronous response using 'response.read()'. " + "You should use 'await response.aread()' instead." + ) + if not hasattr(self, "_content"): + self._content = b"".join([part for part in self.iter_stream()]) + return self._content + + def iter_stream(self) -> typing.Iterator[bytes]: + if not isinstance(self.stream, typing.Iterable): # pragma: nocover + raise RuntimeError( + "Attempted to stream an asynchronous response using 'for ... in " + "response.iter_stream()'. " + "You should use 'async for ... in response.aiter_stream()' instead." + ) + if self._stream_consumed: + raise RuntimeError( + "Attempted to call 'for ... in response.iter_stream()' more than once." + ) + self._stream_consumed = True + for chunk in self.stream: + yield chunk + + def close(self) -> None: + if not isinstance(self.stream, typing.Iterable): # pragma: nocover + raise RuntimeError( + "Attempted to close an asynchronous response using 'response.close()'. " + "You should use 'await response.aclose()' instead." + ) + if hasattr(self.stream, "close"): + self.stream.close() + + # Async interface... + + async def aread(self) -> bytes: + if not isinstance(self.stream, typing.AsyncIterable): # pragma: nocover + raise RuntimeError( + "Attempted to read an synchronous response using " + "'await response.aread()'. " + "You should use 'response.read()' instead." + ) + if not hasattr(self, "_content"): + self._content = b"".join([part async for part in self.aiter_stream()]) + return self._content + + async def aiter_stream(self) -> typing.AsyncIterator[bytes]: + if not isinstance(self.stream, typing.AsyncIterable): # pragma: nocover + raise RuntimeError( + "Attempted to stream an synchronous response using 'async for ... in " + "response.aiter_stream()'. " + "You should use 'for ... in response.iter_stream()' instead." + ) + if self._stream_consumed: + raise RuntimeError( + "Attempted to call 'async for ... in response.aiter_stream()' " + "more than once." + ) + self._stream_consumed = True + async for chunk in self.stream: + yield chunk + + async def aclose(self) -> None: + if not isinstance(self.stream, typing.AsyncIterable): # pragma: nocover + raise RuntimeError( + "Attempted to close a synchronous response using " + "'await response.aclose()'. " + "You should use 'response.close()' instead." + ) + if hasattr(self.stream, "aclose"): + await self.stream.aclose() + + +class Proxy: + def __init__( + self, + url: URL | bytes | str, + auth: tuple[bytes | str, bytes | str] | None = None, + headers: HeadersAsMapping | HeadersAsSequence | None = None, + ssl_context: ssl.SSLContext | None = None, + ): + self.url = enforce_url(url, name="url") + self.headers = enforce_headers(headers, name="headers") + self.ssl_context = ssl_context + + if auth is not None: + username = enforce_bytes(auth[0], name="auth") + password = enforce_bytes(auth[1], name="auth") + userpass = username + b":" + password + authorization = b"Basic " + base64.b64encode(userpass) + self.auth: tuple[bytes, bytes] | None = (username, password) + self.headers = [(b"Proxy-Authorization", authorization)] + self.headers + else: + self.auth = None diff --git a/venv/lib/python3.10/site-packages/httpcore/_ssl.py b/venv/lib/python3.10/site-packages/httpcore/_ssl.py new file mode 100644 index 0000000000000000000000000000000000000000..c99c5a67945b8a3a3544d481e979c791ab45fe23 --- /dev/null +++ b/venv/lib/python3.10/site-packages/httpcore/_ssl.py @@ -0,0 +1,9 @@ +import ssl + +import certifi + + +def default_ssl_context() -> ssl.SSLContext: + context = ssl.create_default_context() + context.load_verify_locations(certifi.where()) + return context diff --git a/venv/lib/python3.10/site-packages/httpcore/_sync/__init__.py b/venv/lib/python3.10/site-packages/httpcore/_sync/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b476d76d9a7ff45de8d18ec22d33d6af2982f92e --- /dev/null +++ b/venv/lib/python3.10/site-packages/httpcore/_sync/__init__.py @@ -0,0 +1,39 @@ +from .connection import HTTPConnection +from .connection_pool import ConnectionPool +from .http11 import HTTP11Connection +from .http_proxy import HTTPProxy +from .interfaces import ConnectionInterface + +try: + from .http2 import HTTP2Connection +except ImportError: # pragma: nocover + + class HTTP2Connection: # type: ignore + def __init__(self, *args, **kwargs) -> None: # type: ignore + raise RuntimeError( + "Attempted to use http2 support, but the `h2` package is not " + "installed. Use 'pip install httpcore[http2]'." + ) + + +try: + from .socks_proxy import SOCKSProxy +except ImportError: # pragma: nocover + + class SOCKSProxy: # type: ignore + def __init__(self, *args, **kwargs) -> None: # type: ignore + raise RuntimeError( + "Attempted to use SOCKS support, but the `socksio` package is not " + "installed. Use 'pip install httpcore[socks]'." + ) + + +__all__ = [ + "HTTPConnection", + "ConnectionPool", + "HTTPProxy", + "HTTP11Connection", + "HTTP2Connection", + "ConnectionInterface", + "SOCKSProxy", +] diff --git a/venv/lib/python3.10/site-packages/httpcore/_sync/__pycache__/__init__.cpython-310.pyc b/venv/lib/python3.10/site-packages/httpcore/_sync/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8c18f2f793ab48a448b8b35cf49815e26bef17fd Binary files /dev/null and b/venv/lib/python3.10/site-packages/httpcore/_sync/__pycache__/__init__.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/httpcore/_sync/__pycache__/connection.cpython-310.pyc b/venv/lib/python3.10/site-packages/httpcore/_sync/__pycache__/connection.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7b44679f7f596e064456274f713216659ec9ca1e Binary files /dev/null and b/venv/lib/python3.10/site-packages/httpcore/_sync/__pycache__/connection.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/httpcore/_sync/__pycache__/connection_pool.cpython-310.pyc b/venv/lib/python3.10/site-packages/httpcore/_sync/__pycache__/connection_pool.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..05f02a2ce8a569186e4f656dd02c8e6a18fef8b1 Binary files /dev/null and b/venv/lib/python3.10/site-packages/httpcore/_sync/__pycache__/connection_pool.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/httpcore/_sync/__pycache__/http11.cpython-310.pyc b/venv/lib/python3.10/site-packages/httpcore/_sync/__pycache__/http11.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ef2ad2e05250e216d1dd9f955e56e4d790aa4ac9 Binary files /dev/null and b/venv/lib/python3.10/site-packages/httpcore/_sync/__pycache__/http11.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/httpcore/_sync/__pycache__/http2.cpython-310.pyc b/venv/lib/python3.10/site-packages/httpcore/_sync/__pycache__/http2.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5070f23114501bcf1aab86fb3339697198b7e791 Binary files /dev/null and b/venv/lib/python3.10/site-packages/httpcore/_sync/__pycache__/http2.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/httpcore/_sync/__pycache__/http_proxy.cpython-310.pyc b/venv/lib/python3.10/site-packages/httpcore/_sync/__pycache__/http_proxy.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..90493833a6954db62ddc133502f4dad8f5db5f12 Binary files /dev/null and b/venv/lib/python3.10/site-packages/httpcore/_sync/__pycache__/http_proxy.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/httpcore/_sync/__pycache__/interfaces.cpython-310.pyc b/venv/lib/python3.10/site-packages/httpcore/_sync/__pycache__/interfaces.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8becf534df355c43e264425ae9d9ce5f387cdc9a Binary files /dev/null and b/venv/lib/python3.10/site-packages/httpcore/_sync/__pycache__/interfaces.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/httpcore/_sync/__pycache__/socks_proxy.cpython-310.pyc b/venv/lib/python3.10/site-packages/httpcore/_sync/__pycache__/socks_proxy.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..cbd4cfb95b934db8168fb6e1dc8d6fcc289a8716 Binary files /dev/null and b/venv/lib/python3.10/site-packages/httpcore/_sync/__pycache__/socks_proxy.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/httpcore/_sync/connection.py b/venv/lib/python3.10/site-packages/httpcore/_sync/connection.py new file mode 100644 index 0000000000000000000000000000000000000000..363f8be819d2576ea65365e625dd1596ea40429a --- /dev/null +++ b/venv/lib/python3.10/site-packages/httpcore/_sync/connection.py @@ -0,0 +1,222 @@ +from __future__ import annotations + +import itertools +import logging +import ssl +import types +import typing + +from .._backends.sync import SyncBackend +from .._backends.base import SOCKET_OPTION, NetworkBackend, NetworkStream +from .._exceptions import ConnectError, ConnectTimeout +from .._models import Origin, Request, Response +from .._ssl import default_ssl_context +from .._synchronization import Lock +from .._trace import Trace +from .http11 import HTTP11Connection +from .interfaces import ConnectionInterface + +RETRIES_BACKOFF_FACTOR = 0.5 # 0s, 0.5s, 1s, 2s, 4s, etc. + + +logger = logging.getLogger("httpcore.connection") + + +def exponential_backoff(factor: float) -> typing.Iterator[float]: + """ + Generate a geometric sequence that has a ratio of 2 and starts with 0. + + For example: + - `factor = 2`: `0, 2, 4, 8, 16, 32, 64, ...` + - `factor = 3`: `0, 3, 6, 12, 24, 48, 96, ...` + """ + yield 0 + for n in itertools.count(): + yield factor * 2**n + + +class HTTPConnection(ConnectionInterface): + def __init__( + self, + origin: Origin, + ssl_context: ssl.SSLContext | None = None, + keepalive_expiry: float | None = None, + http1: bool = True, + http2: bool = False, + retries: int = 0, + local_address: str | None = None, + uds: str | None = None, + network_backend: NetworkBackend | None = None, + socket_options: typing.Iterable[SOCKET_OPTION] | None = None, + ) -> None: + self._origin = origin + self._ssl_context = ssl_context + self._keepalive_expiry = keepalive_expiry + self._http1 = http1 + self._http2 = http2 + self._retries = retries + self._local_address = local_address + self._uds = uds + + self._network_backend: NetworkBackend = ( + SyncBackend() if network_backend is None else network_backend + ) + self._connection: ConnectionInterface | None = None + self._connect_failed: bool = False + self._request_lock = Lock() + self._socket_options = socket_options + + def handle_request(self, request: Request) -> Response: + if not self.can_handle_request(request.url.origin): + raise RuntimeError( + f"Attempted to send request to {request.url.origin} on connection to {self._origin}" + ) + + try: + with self._request_lock: + if self._connection is None: + stream = self._connect(request) + + ssl_object = stream.get_extra_info("ssl_object") + http2_negotiated = ( + ssl_object is not None + and ssl_object.selected_alpn_protocol() == "h2" + ) + if http2_negotiated or (self._http2 and not self._http1): + from .http2 import HTTP2Connection + + self._connection = HTTP2Connection( + origin=self._origin, + stream=stream, + keepalive_expiry=self._keepalive_expiry, + ) + else: + self._connection = HTTP11Connection( + origin=self._origin, + stream=stream, + keepalive_expiry=self._keepalive_expiry, + ) + except BaseException as exc: + self._connect_failed = True + raise exc + + return self._connection.handle_request(request) + + def _connect(self, request: Request) -> NetworkStream: + timeouts = request.extensions.get("timeout", {}) + sni_hostname = request.extensions.get("sni_hostname", None) + timeout = timeouts.get("connect", None) + + retries_left = self._retries + delays = exponential_backoff(factor=RETRIES_BACKOFF_FACTOR) + + while True: + try: + if self._uds is None: + kwargs = { + "host": self._origin.host.decode("ascii"), + "port": self._origin.port, + "local_address": self._local_address, + "timeout": timeout, + "socket_options": self._socket_options, + } + with Trace("connect_tcp", logger, request, kwargs) as trace: + stream = self._network_backend.connect_tcp(**kwargs) + trace.return_value = stream + else: + kwargs = { + "path": self._uds, + "timeout": timeout, + "socket_options": self._socket_options, + } + with Trace( + "connect_unix_socket", logger, request, kwargs + ) as trace: + stream = self._network_backend.connect_unix_socket( + **kwargs + ) + trace.return_value = stream + + if self._origin.scheme in (b"https", b"wss"): + ssl_context = ( + default_ssl_context() + if self._ssl_context is None + else self._ssl_context + ) + alpn_protocols = ["http/1.1", "h2"] if self._http2 else ["http/1.1"] + ssl_context.set_alpn_protocols(alpn_protocols) + + kwargs = { + "ssl_context": ssl_context, + "server_hostname": sni_hostname + or self._origin.host.decode("ascii"), + "timeout": timeout, + } + with Trace("start_tls", logger, request, kwargs) as trace: + stream = stream.start_tls(**kwargs) + trace.return_value = stream + return stream + except (ConnectError, ConnectTimeout): + if retries_left <= 0: + raise + retries_left -= 1 + delay = next(delays) + with Trace("retry", logger, request, kwargs) as trace: + self._network_backend.sleep(delay) + + def can_handle_request(self, origin: Origin) -> bool: + return origin == self._origin + + def close(self) -> None: + if self._connection is not None: + with Trace("close", logger, None, {}): + self._connection.close() + + def is_available(self) -> bool: + if self._connection is None: + # If HTTP/2 support is enabled, and the resulting connection could + # end up as HTTP/2 then we should indicate the connection as being + # available to service multiple requests. + return ( + self._http2 + and (self._origin.scheme == b"https" or not self._http1) + and not self._connect_failed + ) + return self._connection.is_available() + + def has_expired(self) -> bool: + if self._connection is None: + return self._connect_failed + return self._connection.has_expired() + + def is_idle(self) -> bool: + if self._connection is None: + return self._connect_failed + return self._connection.is_idle() + + def is_closed(self) -> bool: + if self._connection is None: + return self._connect_failed + return self._connection.is_closed() + + def info(self) -> str: + if self._connection is None: + return "CONNECTION FAILED" if self._connect_failed else "CONNECTING" + return self._connection.info() + + def __repr__(self) -> str: + return f"<{self.__class__.__name__} [{self.info()}]>" + + # These context managers are not used in the standard flow, but are + # useful for testing or working with connection instances directly. + + def __enter__(self) -> HTTPConnection: + return self + + def __exit__( + self, + exc_type: type[BaseException] | None = None, + exc_value: BaseException | None = None, + traceback: types.TracebackType | None = None, + ) -> None: + self.close() diff --git a/venv/lib/python3.10/site-packages/httpcore/_sync/connection_pool.py b/venv/lib/python3.10/site-packages/httpcore/_sync/connection_pool.py new file mode 100644 index 0000000000000000000000000000000000000000..9ccfa53e597a29ee387f9d16f3af4f695ac0d33a --- /dev/null +++ b/venv/lib/python3.10/site-packages/httpcore/_sync/connection_pool.py @@ -0,0 +1,420 @@ +from __future__ import annotations + +import ssl +import sys +import types +import typing + +from .._backends.sync import SyncBackend +from .._backends.base import SOCKET_OPTION, NetworkBackend +from .._exceptions import ConnectionNotAvailable, UnsupportedProtocol +from .._models import Origin, Proxy, Request, Response +from .._synchronization import Event, ShieldCancellation, ThreadLock +from .connection import HTTPConnection +from .interfaces import ConnectionInterface, RequestInterface + + +class PoolRequest: + def __init__(self, request: Request) -> None: + self.request = request + self.connection: ConnectionInterface | None = None + self._connection_acquired = Event() + + def assign_to_connection(self, connection: ConnectionInterface | None) -> None: + self.connection = connection + self._connection_acquired.set() + + def clear_connection(self) -> None: + self.connection = None + self._connection_acquired = Event() + + def wait_for_connection( + self, timeout: float | None = None + ) -> ConnectionInterface: + if self.connection is None: + self._connection_acquired.wait(timeout=timeout) + assert self.connection is not None + return self.connection + + def is_queued(self) -> bool: + return self.connection is None + + +class ConnectionPool(RequestInterface): + """ + A connection pool for making HTTP requests. + """ + + def __init__( + self, + ssl_context: ssl.SSLContext | None = None, + proxy: Proxy | None = None, + max_connections: int | None = 10, + max_keepalive_connections: int | None = None, + keepalive_expiry: float | None = None, + http1: bool = True, + http2: bool = False, + retries: int = 0, + local_address: str | None = None, + uds: str | None = None, + network_backend: NetworkBackend | None = None, + socket_options: typing.Iterable[SOCKET_OPTION] | None = None, + ) -> None: + """ + A connection pool for making HTTP requests. + + Parameters: + ssl_context: An SSL context to use for verifying connections. + If not specified, the default `httpcore.default_ssl_context()` + will be used. + max_connections: The maximum number of concurrent HTTP connections that + the pool should allow. Any attempt to send a request on a pool that + would exceed this amount will block until a connection is available. + max_keepalive_connections: The maximum number of idle HTTP connections + that will be maintained in the pool. + keepalive_expiry: The duration in seconds that an idle HTTP connection + may be maintained for before being expired from the pool. + http1: A boolean indicating if HTTP/1.1 requests should be supported + by the connection pool. Defaults to True. + http2: A boolean indicating if HTTP/2 requests should be supported by + the connection pool. Defaults to False. + retries: The maximum number of retries when trying to establish a + connection. + local_address: Local address to connect from. Can also be used to connect + using a particular address family. Using `local_address="0.0.0.0"` + will connect using an `AF_INET` address (IPv4), while using + `local_address="::"` will connect using an `AF_INET6` address (IPv6). + uds: Path to a Unix Domain Socket to use instead of TCP sockets. + network_backend: A backend instance to use for handling network I/O. + socket_options: Socket options that have to be included + in the TCP socket when the connection was established. + """ + self._ssl_context = ssl_context + self._proxy = proxy + self._max_connections = ( + sys.maxsize if max_connections is None else max_connections + ) + self._max_keepalive_connections = ( + sys.maxsize + if max_keepalive_connections is None + else max_keepalive_connections + ) + self._max_keepalive_connections = min( + self._max_connections, self._max_keepalive_connections + ) + + self._keepalive_expiry = keepalive_expiry + self._http1 = http1 + self._http2 = http2 + self._retries = retries + self._local_address = local_address + self._uds = uds + + self._network_backend = ( + SyncBackend() if network_backend is None else network_backend + ) + self._socket_options = socket_options + + # The mutable state on a connection pool is the queue of incoming requests, + # and the set of connections that are servicing those requests. + self._connections: list[ConnectionInterface] = [] + self._requests: list[PoolRequest] = [] + + # We only mutate the state of the connection pool within an 'optional_thread_lock' + # context. This holds a threading lock unless we're running in async mode, + # in which case it is a no-op. + self._optional_thread_lock = ThreadLock() + + def create_connection(self, origin: Origin) -> ConnectionInterface: + if self._proxy is not None: + if self._proxy.url.scheme in (b"socks5", b"socks5h"): + from .socks_proxy import Socks5Connection + + return Socks5Connection( + proxy_origin=self._proxy.url.origin, + proxy_auth=self._proxy.auth, + remote_origin=origin, + ssl_context=self._ssl_context, + keepalive_expiry=self._keepalive_expiry, + http1=self._http1, + http2=self._http2, + network_backend=self._network_backend, + ) + elif origin.scheme == b"http": + from .http_proxy import ForwardHTTPConnection + + return ForwardHTTPConnection( + proxy_origin=self._proxy.url.origin, + proxy_headers=self._proxy.headers, + proxy_ssl_context=self._proxy.ssl_context, + remote_origin=origin, + keepalive_expiry=self._keepalive_expiry, + network_backend=self._network_backend, + ) + from .http_proxy import TunnelHTTPConnection + + return TunnelHTTPConnection( + proxy_origin=self._proxy.url.origin, + proxy_headers=self._proxy.headers, + proxy_ssl_context=self._proxy.ssl_context, + remote_origin=origin, + ssl_context=self._ssl_context, + keepalive_expiry=self._keepalive_expiry, + http1=self._http1, + http2=self._http2, + network_backend=self._network_backend, + ) + + return HTTPConnection( + origin=origin, + ssl_context=self._ssl_context, + keepalive_expiry=self._keepalive_expiry, + http1=self._http1, + http2=self._http2, + retries=self._retries, + local_address=self._local_address, + uds=self._uds, + network_backend=self._network_backend, + socket_options=self._socket_options, + ) + + @property + def connections(self) -> list[ConnectionInterface]: + """ + Return a list of the connections currently in the pool. + + For example: + + ```python + >>> pool.connections + [ + , + , + , + ] + ``` + """ + return list(self._connections) + + def handle_request(self, request: Request) -> Response: + """ + Send an HTTP request, and return an HTTP response. + + This is the core implementation that is called into by `.request()` or `.stream()`. + """ + scheme = request.url.scheme.decode() + if scheme == "": + raise UnsupportedProtocol( + "Request URL is missing an 'http://' or 'https://' protocol." + ) + if scheme not in ("http", "https", "ws", "wss"): + raise UnsupportedProtocol( + f"Request URL has an unsupported protocol '{scheme}://'." + ) + + timeouts = request.extensions.get("timeout", {}) + timeout = timeouts.get("pool", None) + + with self._optional_thread_lock: + # Add the incoming request to our request queue. + pool_request = PoolRequest(request) + self._requests.append(pool_request) + + try: + while True: + with self._optional_thread_lock: + # Assign incoming requests to available connections, + # closing or creating new connections as required. + closing = self._assign_requests_to_connections() + self._close_connections(closing) + + # Wait until this request has an assigned connection. + connection = pool_request.wait_for_connection(timeout=timeout) + + try: + # Send the request on the assigned connection. + response = connection.handle_request( + pool_request.request + ) + except ConnectionNotAvailable: + # In some cases a connection may initially be available to + # handle a request, but then become unavailable. + # + # In this case we clear the connection and try again. + pool_request.clear_connection() + else: + break # pragma: nocover + + except BaseException as exc: + with self._optional_thread_lock: + # For any exception or cancellation we remove the request from + # the queue, and then re-assign requests to connections. + self._requests.remove(pool_request) + closing = self._assign_requests_to_connections() + + self._close_connections(closing) + raise exc from None + + # Return the response. Note that in this case we still have to manage + # the point at which the response is closed. + assert isinstance(response.stream, typing.Iterable) + return Response( + status=response.status, + headers=response.headers, + content=PoolByteStream( + stream=response.stream, pool_request=pool_request, pool=self + ), + extensions=response.extensions, + ) + + def _assign_requests_to_connections(self) -> list[ConnectionInterface]: + """ + Manage the state of the connection pool, assigning incoming + requests to connections as available. + + Called whenever a new request is added or removed from the pool. + + Any closing connections are returned, allowing the I/O for closing + those connections to be handled seperately. + """ + closing_connections = [] + + # First we handle cleaning up any connections that are closed, + # have expired their keep-alive, or surplus idle connections. + for connection in list(self._connections): + if connection.is_closed(): + # log: "removing closed connection" + self._connections.remove(connection) + elif connection.has_expired(): + # log: "closing expired connection" + self._connections.remove(connection) + closing_connections.append(connection) + elif ( + connection.is_idle() + and len([connection.is_idle() for connection in self._connections]) + > self._max_keepalive_connections + ): + # log: "closing idle connection" + self._connections.remove(connection) + closing_connections.append(connection) + + # Assign queued requests to connections. + queued_requests = [request for request in self._requests if request.is_queued()] + for pool_request in queued_requests: + origin = pool_request.request.url.origin + available_connections = [ + connection + for connection in self._connections + if connection.can_handle_request(origin) and connection.is_available() + ] + idle_connections = [ + connection for connection in self._connections if connection.is_idle() + ] + + # There are three cases for how we may be able to handle the request: + # + # 1. There is an existing connection that can handle the request. + # 2. We can create a new connection to handle the request. + # 3. We can close an idle connection and then create a new connection + # to handle the request. + if available_connections: + # log: "reusing existing connection" + connection = available_connections[0] + pool_request.assign_to_connection(connection) + elif len(self._connections) < self._max_connections: + # log: "creating new connection" + connection = self.create_connection(origin) + self._connections.append(connection) + pool_request.assign_to_connection(connection) + elif idle_connections: + # log: "closing idle connection" + connection = idle_connections[0] + self._connections.remove(connection) + closing_connections.append(connection) + # log: "creating new connection" + connection = self.create_connection(origin) + self._connections.append(connection) + pool_request.assign_to_connection(connection) + + return closing_connections + + def _close_connections(self, closing: list[ConnectionInterface]) -> None: + # Close connections which have been removed from the pool. + with ShieldCancellation(): + for connection in closing: + connection.close() + + def close(self) -> None: + # Explicitly close the connection pool. + # Clears all existing requests and connections. + with self._optional_thread_lock: + closing_connections = list(self._connections) + self._connections = [] + self._close_connections(closing_connections) + + def __enter__(self) -> ConnectionPool: + return self + + def __exit__( + self, + exc_type: type[BaseException] | None = None, + exc_value: BaseException | None = None, + traceback: types.TracebackType | None = None, + ) -> None: + self.close() + + def __repr__(self) -> str: + class_name = self.__class__.__name__ + with self._optional_thread_lock: + request_is_queued = [request.is_queued() for request in self._requests] + connection_is_idle = [ + connection.is_idle() for connection in self._connections + ] + + num_active_requests = request_is_queued.count(False) + num_queued_requests = request_is_queued.count(True) + num_active_connections = connection_is_idle.count(False) + num_idle_connections = connection_is_idle.count(True) + + requests_info = ( + f"Requests: {num_active_requests} active, {num_queued_requests} queued" + ) + connection_info = ( + f"Connections: {num_active_connections} active, {num_idle_connections} idle" + ) + + return f"<{class_name} [{requests_info} | {connection_info}]>" + + +class PoolByteStream: + def __init__( + self, + stream: typing.Iterable[bytes], + pool_request: PoolRequest, + pool: ConnectionPool, + ) -> None: + self._stream = stream + self._pool_request = pool_request + self._pool = pool + self._closed = False + + def __iter__(self) -> typing.Iterator[bytes]: + try: + for part in self._stream: + yield part + except BaseException as exc: + self.close() + raise exc from None + + def close(self) -> None: + if not self._closed: + self._closed = True + with ShieldCancellation(): + if hasattr(self._stream, "close"): + self._stream.close() + + with self._pool._optional_thread_lock: + self._pool._requests.remove(self._pool_request) + closing = self._pool._assign_requests_to_connections() + + self._pool._close_connections(closing) diff --git a/venv/lib/python3.10/site-packages/httpcore/_sync/http11.py b/venv/lib/python3.10/site-packages/httpcore/_sync/http11.py new file mode 100644 index 0000000000000000000000000000000000000000..ebd3a97480c720d418acb1285a7b75da19b62c8c --- /dev/null +++ b/venv/lib/python3.10/site-packages/httpcore/_sync/http11.py @@ -0,0 +1,379 @@ +from __future__ import annotations + +import enum +import logging +import ssl +import time +import types +import typing + +import h11 + +from .._backends.base import NetworkStream +from .._exceptions import ( + ConnectionNotAvailable, + LocalProtocolError, + RemoteProtocolError, + WriteError, + map_exceptions, +) +from .._models import Origin, Request, Response +from .._synchronization import Lock, ShieldCancellation +from .._trace import Trace +from .interfaces import ConnectionInterface + +logger = logging.getLogger("httpcore.http11") + + +# A subset of `h11.Event` types supported by `_send_event` +H11SendEvent = typing.Union[ + h11.Request, + h11.Data, + h11.EndOfMessage, +] + + +class HTTPConnectionState(enum.IntEnum): + NEW = 0 + ACTIVE = 1 + IDLE = 2 + CLOSED = 3 + + +class HTTP11Connection(ConnectionInterface): + READ_NUM_BYTES = 64 * 1024 + MAX_INCOMPLETE_EVENT_SIZE = 100 * 1024 + + def __init__( + self, + origin: Origin, + stream: NetworkStream, + keepalive_expiry: float | None = None, + ) -> None: + self._origin = origin + self._network_stream = stream + self._keepalive_expiry: float | None = keepalive_expiry + self._expire_at: float | None = None + self._state = HTTPConnectionState.NEW + self._state_lock = Lock() + self._request_count = 0 + self._h11_state = h11.Connection( + our_role=h11.CLIENT, + max_incomplete_event_size=self.MAX_INCOMPLETE_EVENT_SIZE, + ) + + def handle_request(self, request: Request) -> Response: + if not self.can_handle_request(request.url.origin): + raise RuntimeError( + f"Attempted to send request to {request.url.origin} on connection " + f"to {self._origin}" + ) + + with self._state_lock: + if self._state in (HTTPConnectionState.NEW, HTTPConnectionState.IDLE): + self._request_count += 1 + self._state = HTTPConnectionState.ACTIVE + self._expire_at = None + else: + raise ConnectionNotAvailable() + + try: + kwargs = {"request": request} + try: + with Trace( + "send_request_headers", logger, request, kwargs + ) as trace: + self._send_request_headers(**kwargs) + with Trace("send_request_body", logger, request, kwargs) as trace: + self._send_request_body(**kwargs) + except WriteError: + # If we get a write error while we're writing the request, + # then we supress this error and move on to attempting to + # read the response. Servers can sometimes close the request + # pre-emptively and then respond with a well formed HTTP + # error response. + pass + + with Trace( + "receive_response_headers", logger, request, kwargs + ) as trace: + ( + http_version, + status, + reason_phrase, + headers, + trailing_data, + ) = self._receive_response_headers(**kwargs) + trace.return_value = ( + http_version, + status, + reason_phrase, + headers, + ) + + network_stream = self._network_stream + + # CONNECT or Upgrade request + if (status == 101) or ( + (request.method == b"CONNECT") and (200 <= status < 300) + ): + network_stream = HTTP11UpgradeStream(network_stream, trailing_data) + + return Response( + status=status, + headers=headers, + content=HTTP11ConnectionByteStream(self, request), + extensions={ + "http_version": http_version, + "reason_phrase": reason_phrase, + "network_stream": network_stream, + }, + ) + except BaseException as exc: + with ShieldCancellation(): + with Trace("response_closed", logger, request) as trace: + self._response_closed() + raise exc + + # Sending the request... + + def _send_request_headers(self, request: Request) -> None: + timeouts = request.extensions.get("timeout", {}) + timeout = timeouts.get("write", None) + + with map_exceptions({h11.LocalProtocolError: LocalProtocolError}): + event = h11.Request( + method=request.method, + target=request.url.target, + headers=request.headers, + ) + self._send_event(event, timeout=timeout) + + def _send_request_body(self, request: Request) -> None: + timeouts = request.extensions.get("timeout", {}) + timeout = timeouts.get("write", None) + + assert isinstance(request.stream, typing.Iterable) + for chunk in request.stream: + event = h11.Data(data=chunk) + self._send_event(event, timeout=timeout) + + self._send_event(h11.EndOfMessage(), timeout=timeout) + + def _send_event(self, event: h11.Event, timeout: float | None = None) -> None: + bytes_to_send = self._h11_state.send(event) + if bytes_to_send is not None: + self._network_stream.write(bytes_to_send, timeout=timeout) + + # Receiving the response... + + def _receive_response_headers( + self, request: Request + ) -> tuple[bytes, int, bytes, list[tuple[bytes, bytes]], bytes]: + timeouts = request.extensions.get("timeout", {}) + timeout = timeouts.get("read", None) + + while True: + event = self._receive_event(timeout=timeout) + if isinstance(event, h11.Response): + break + if ( + isinstance(event, h11.InformationalResponse) + and event.status_code == 101 + ): + break + + http_version = b"HTTP/" + event.http_version + + # h11 version 0.11+ supports a `raw_items` interface to get the + # raw header casing, rather than the enforced lowercase headers. + headers = event.headers.raw_items() + + trailing_data, _ = self._h11_state.trailing_data + + return http_version, event.status_code, event.reason, headers, trailing_data + + def _receive_response_body( + self, request: Request + ) -> typing.Iterator[bytes]: + timeouts = request.extensions.get("timeout", {}) + timeout = timeouts.get("read", None) + + while True: + event = self._receive_event(timeout=timeout) + if isinstance(event, h11.Data): + yield bytes(event.data) + elif isinstance(event, (h11.EndOfMessage, h11.PAUSED)): + break + + def _receive_event( + self, timeout: float | None = None + ) -> h11.Event | type[h11.PAUSED]: + while True: + with map_exceptions({h11.RemoteProtocolError: RemoteProtocolError}): + event = self._h11_state.next_event() + + if event is h11.NEED_DATA: + data = self._network_stream.read( + self.READ_NUM_BYTES, timeout=timeout + ) + + # If we feed this case through h11 we'll raise an exception like: + # + # httpcore.RemoteProtocolError: can't handle event type + # ConnectionClosed when role=SERVER and state=SEND_RESPONSE + # + # Which is accurate, but not very informative from an end-user + # perspective. Instead we handle this case distinctly and treat + # it as a ConnectError. + if data == b"" and self._h11_state.their_state == h11.SEND_RESPONSE: + msg = "Server disconnected without sending a response." + raise RemoteProtocolError(msg) + + self._h11_state.receive_data(data) + else: + # mypy fails to narrow the type in the above if statement above + return event # type: ignore[return-value] + + def _response_closed(self) -> None: + with self._state_lock: + if ( + self._h11_state.our_state is h11.DONE + and self._h11_state.their_state is h11.DONE + ): + self._state = HTTPConnectionState.IDLE + self._h11_state.start_next_cycle() + if self._keepalive_expiry is not None: + now = time.monotonic() + self._expire_at = now + self._keepalive_expiry + else: + self.close() + + # Once the connection is no longer required... + + def close(self) -> None: + # Note that this method unilaterally closes the connection, and does + # not have any kind of locking in place around it. + self._state = HTTPConnectionState.CLOSED + self._network_stream.close() + + # The ConnectionInterface methods provide information about the state of + # the connection, allowing for a connection pooling implementation to + # determine when to reuse and when to close the connection... + + def can_handle_request(self, origin: Origin) -> bool: + return origin == self._origin + + def is_available(self) -> bool: + # Note that HTTP/1.1 connections in the "NEW" state are not treated as + # being "available". The control flow which created the connection will + # be able to send an outgoing request, but the connection will not be + # acquired from the connection pool for any other request. + return self._state == HTTPConnectionState.IDLE + + def has_expired(self) -> bool: + now = time.monotonic() + keepalive_expired = self._expire_at is not None and now > self._expire_at + + # If the HTTP connection is idle but the socket is readable, then the + # only valid state is that the socket is about to return b"", indicating + # a server-initiated disconnect. + server_disconnected = ( + self._state == HTTPConnectionState.IDLE + and self._network_stream.get_extra_info("is_readable") + ) + + return keepalive_expired or server_disconnected + + def is_idle(self) -> bool: + return self._state == HTTPConnectionState.IDLE + + def is_closed(self) -> bool: + return self._state == HTTPConnectionState.CLOSED + + def info(self) -> str: + origin = str(self._origin) + return ( + f"{origin!r}, HTTP/1.1, {self._state.name}, " + f"Request Count: {self._request_count}" + ) + + def __repr__(self) -> str: + class_name = self.__class__.__name__ + origin = str(self._origin) + return ( + f"<{class_name} [{origin!r}, {self._state.name}, " + f"Request Count: {self._request_count}]>" + ) + + # These context managers are not used in the standard flow, but are + # useful for testing or working with connection instances directly. + + def __enter__(self) -> HTTP11Connection: + return self + + def __exit__( + self, + exc_type: type[BaseException] | None = None, + exc_value: BaseException | None = None, + traceback: types.TracebackType | None = None, + ) -> None: + self.close() + + +class HTTP11ConnectionByteStream: + def __init__(self, connection: HTTP11Connection, request: Request) -> None: + self._connection = connection + self._request = request + self._closed = False + + def __iter__(self) -> typing.Iterator[bytes]: + kwargs = {"request": self._request} + try: + with Trace("receive_response_body", logger, self._request, kwargs): + for chunk in self._connection._receive_response_body(**kwargs): + yield chunk + except BaseException as exc: + # If we get an exception while streaming the response, + # we want to close the response (and possibly the connection) + # before raising that exception. + with ShieldCancellation(): + self.close() + raise exc + + def close(self) -> None: + if not self._closed: + self._closed = True + with Trace("response_closed", logger, self._request): + self._connection._response_closed() + + +class HTTP11UpgradeStream(NetworkStream): + def __init__(self, stream: NetworkStream, leading_data: bytes) -> None: + self._stream = stream + self._leading_data = leading_data + + def read(self, max_bytes: int, timeout: float | None = None) -> bytes: + if self._leading_data: + buffer = self._leading_data[:max_bytes] + self._leading_data = self._leading_data[max_bytes:] + return buffer + else: + return self._stream.read(max_bytes, timeout) + + def write(self, buffer: bytes, timeout: float | None = None) -> None: + self._stream.write(buffer, timeout) + + def close(self) -> None: + self._stream.close() + + def start_tls( + self, + ssl_context: ssl.SSLContext, + server_hostname: str | None = None, + timeout: float | None = None, + ) -> NetworkStream: + return self._stream.start_tls(ssl_context, server_hostname, timeout) + + def get_extra_info(self, info: str) -> typing.Any: + return self._stream.get_extra_info(info) diff --git a/venv/lib/python3.10/site-packages/httpcore/_sync/http2.py b/venv/lib/python3.10/site-packages/httpcore/_sync/http2.py new file mode 100644 index 0000000000000000000000000000000000000000..ddcc189001c50c37c6a03810dc21d955df919f10 --- /dev/null +++ b/venv/lib/python3.10/site-packages/httpcore/_sync/http2.py @@ -0,0 +1,592 @@ +from __future__ import annotations + +import enum +import logging +import time +import types +import typing + +import h2.config +import h2.connection +import h2.events +import h2.exceptions +import h2.settings + +from .._backends.base import NetworkStream +from .._exceptions import ( + ConnectionNotAvailable, + LocalProtocolError, + RemoteProtocolError, +) +from .._models import Origin, Request, Response +from .._synchronization import Lock, Semaphore, ShieldCancellation +from .._trace import Trace +from .interfaces import ConnectionInterface + +logger = logging.getLogger("httpcore.http2") + + +def has_body_headers(request: Request) -> bool: + return any( + k.lower() == b"content-length" or k.lower() == b"transfer-encoding" + for k, v in request.headers + ) + + +class HTTPConnectionState(enum.IntEnum): + ACTIVE = 1 + IDLE = 2 + CLOSED = 3 + + +class HTTP2Connection(ConnectionInterface): + READ_NUM_BYTES = 64 * 1024 + CONFIG = h2.config.H2Configuration(validate_inbound_headers=False) + + def __init__( + self, + origin: Origin, + stream: NetworkStream, + keepalive_expiry: float | None = None, + ): + self._origin = origin + self._network_stream = stream + self._keepalive_expiry: float | None = keepalive_expiry + self._h2_state = h2.connection.H2Connection(config=self.CONFIG) + self._state = HTTPConnectionState.IDLE + self._expire_at: float | None = None + self._request_count = 0 + self._init_lock = Lock() + self._state_lock = Lock() + self._read_lock = Lock() + self._write_lock = Lock() + self._sent_connection_init = False + self._used_all_stream_ids = False + self._connection_error = False + + # Mapping from stream ID to response stream events. + self._events: dict[ + int, + list[ + h2.events.ResponseReceived + | h2.events.DataReceived + | h2.events.StreamEnded + | h2.events.StreamReset, + ], + ] = {} + + # Connection terminated events are stored as state since + # we need to handle them for all streams. + self._connection_terminated: h2.events.ConnectionTerminated | None = None + + self._read_exception: Exception | None = None + self._write_exception: Exception | None = None + + def handle_request(self, request: Request) -> Response: + if not self.can_handle_request(request.url.origin): + # This cannot occur in normal operation, since the connection pool + # will only send requests on connections that handle them. + # It's in place simply for resilience as a guard against incorrect + # usage, for anyone working directly with httpcore connections. + raise RuntimeError( + f"Attempted to send request to {request.url.origin} on connection " + f"to {self._origin}" + ) + + with self._state_lock: + if self._state in (HTTPConnectionState.ACTIVE, HTTPConnectionState.IDLE): + self._request_count += 1 + self._expire_at = None + self._state = HTTPConnectionState.ACTIVE + else: + raise ConnectionNotAvailable() + + with self._init_lock: + if not self._sent_connection_init: + try: + sci_kwargs = {"request": request} + with Trace( + "send_connection_init", logger, request, sci_kwargs + ): + self._send_connection_init(**sci_kwargs) + except BaseException as exc: + with ShieldCancellation(): + self.close() + raise exc + + self._sent_connection_init = True + + # Initially start with just 1 until the remote server provides + # its max_concurrent_streams value + self._max_streams = 1 + + local_settings_max_streams = ( + self._h2_state.local_settings.max_concurrent_streams + ) + self._max_streams_semaphore = Semaphore(local_settings_max_streams) + + for _ in range(local_settings_max_streams - self._max_streams): + self._max_streams_semaphore.acquire() + + self._max_streams_semaphore.acquire() + + try: + stream_id = self._h2_state.get_next_available_stream_id() + self._events[stream_id] = [] + except h2.exceptions.NoAvailableStreamIDError: # pragma: nocover + self._used_all_stream_ids = True + self._request_count -= 1 + raise ConnectionNotAvailable() + + try: + kwargs = {"request": request, "stream_id": stream_id} + with Trace("send_request_headers", logger, request, kwargs): + self._send_request_headers(request=request, stream_id=stream_id) + with Trace("send_request_body", logger, request, kwargs): + self._send_request_body(request=request, stream_id=stream_id) + with Trace( + "receive_response_headers", logger, request, kwargs + ) as trace: + status, headers = self._receive_response( + request=request, stream_id=stream_id + ) + trace.return_value = (status, headers) + + return Response( + status=status, + headers=headers, + content=HTTP2ConnectionByteStream(self, request, stream_id=stream_id), + extensions={ + "http_version": b"HTTP/2", + "network_stream": self._network_stream, + "stream_id": stream_id, + }, + ) + except BaseException as exc: # noqa: PIE786 + with ShieldCancellation(): + kwargs = {"stream_id": stream_id} + with Trace("response_closed", logger, request, kwargs): + self._response_closed(stream_id=stream_id) + + if isinstance(exc, h2.exceptions.ProtocolError): + # One case where h2 can raise a protocol error is when a + # closed frame has been seen by the state machine. + # + # This happens when one stream is reading, and encounters + # a GOAWAY event. Other flows of control may then raise + # a protocol error at any point they interact with the 'h2_state'. + # + # In this case we'll have stored the event, and should raise + # it as a RemoteProtocolError. + if self._connection_terminated: # pragma: nocover + raise RemoteProtocolError(self._connection_terminated) + # If h2 raises a protocol error in some other state then we + # must somehow have made a protocol violation. + raise LocalProtocolError(exc) # pragma: nocover + + raise exc + + def _send_connection_init(self, request: Request) -> None: + """ + The HTTP/2 connection requires some initial setup before we can start + using individual request/response streams on it. + """ + # Need to set these manually here instead of manipulating via + # __setitem__() otherwise the H2Connection will emit SettingsUpdate + # frames in addition to sending the undesired defaults. + self._h2_state.local_settings = h2.settings.Settings( + client=True, + initial_values={ + # Disable PUSH_PROMISE frames from the server since we don't do anything + # with them for now. Maybe when we support caching? + h2.settings.SettingCodes.ENABLE_PUSH: 0, + # These two are taken from h2 for safe defaults + h2.settings.SettingCodes.MAX_CONCURRENT_STREAMS: 100, + h2.settings.SettingCodes.MAX_HEADER_LIST_SIZE: 65536, + }, + ) + + # Some websites (*cough* Yahoo *cough*) balk at this setting being + # present in the initial handshake since it's not defined in the original + # RFC despite the RFC mandating ignoring settings you don't know about. + del self._h2_state.local_settings[ + h2.settings.SettingCodes.ENABLE_CONNECT_PROTOCOL + ] + + self._h2_state.initiate_connection() + self._h2_state.increment_flow_control_window(2**24) + self._write_outgoing_data(request) + + # Sending the request... + + def _send_request_headers(self, request: Request, stream_id: int) -> None: + """ + Send the request headers to a given stream ID. + """ + end_stream = not has_body_headers(request) + + # In HTTP/2 the ':authority' pseudo-header is used instead of 'Host'. + # In order to gracefully handle HTTP/1.1 and HTTP/2 we always require + # HTTP/1.1 style headers, and map them appropriately if we end up on + # an HTTP/2 connection. + authority = [v for k, v in request.headers if k.lower() == b"host"][0] + + headers = [ + (b":method", request.method), + (b":authority", authority), + (b":scheme", request.url.scheme), + (b":path", request.url.target), + ] + [ + (k.lower(), v) + for k, v in request.headers + if k.lower() + not in ( + b"host", + b"transfer-encoding", + ) + ] + + self._h2_state.send_headers(stream_id, headers, end_stream=end_stream) + self._h2_state.increment_flow_control_window(2**24, stream_id=stream_id) + self._write_outgoing_data(request) + + def _send_request_body(self, request: Request, stream_id: int) -> None: + """ + Iterate over the request body sending it to a given stream ID. + """ + if not has_body_headers(request): + return + + assert isinstance(request.stream, typing.Iterable) + for data in request.stream: + self._send_stream_data(request, stream_id, data) + self._send_end_stream(request, stream_id) + + def _send_stream_data( + self, request: Request, stream_id: int, data: bytes + ) -> None: + """ + Send a single chunk of data in one or more data frames. + """ + while data: + max_flow = self._wait_for_outgoing_flow(request, stream_id) + chunk_size = min(len(data), max_flow) + chunk, data = data[:chunk_size], data[chunk_size:] + self._h2_state.send_data(stream_id, chunk) + self._write_outgoing_data(request) + + def _send_end_stream(self, request: Request, stream_id: int) -> None: + """ + Send an empty data frame on on a given stream ID with the END_STREAM flag set. + """ + self._h2_state.end_stream(stream_id) + self._write_outgoing_data(request) + + # Receiving the response... + + def _receive_response( + self, request: Request, stream_id: int + ) -> tuple[int, list[tuple[bytes, bytes]]]: + """ + Return the response status code and headers for a given stream ID. + """ + while True: + event = self._receive_stream_event(request, stream_id) + if isinstance(event, h2.events.ResponseReceived): + break + + status_code = 200 + headers = [] + assert event.headers is not None + for k, v in event.headers: + if k == b":status": + status_code = int(v.decode("ascii", errors="ignore")) + elif not k.startswith(b":"): + headers.append((k, v)) + + return (status_code, headers) + + def _receive_response_body( + self, request: Request, stream_id: int + ) -> typing.Iterator[bytes]: + """ + Iterator that returns the bytes of the response body for a given stream ID. + """ + while True: + event = self._receive_stream_event(request, stream_id) + if isinstance(event, h2.events.DataReceived): + assert event.flow_controlled_length is not None + assert event.data is not None + amount = event.flow_controlled_length + self._h2_state.acknowledge_received_data(amount, stream_id) + self._write_outgoing_data(request) + yield event.data + elif isinstance(event, h2.events.StreamEnded): + break + + def _receive_stream_event( + self, request: Request, stream_id: int + ) -> h2.events.ResponseReceived | h2.events.DataReceived | h2.events.StreamEnded: + """ + Return the next available event for a given stream ID. + + Will read more data from the network if required. + """ + while not self._events.get(stream_id): + self._receive_events(request, stream_id) + event = self._events[stream_id].pop(0) + if isinstance(event, h2.events.StreamReset): + raise RemoteProtocolError(event) + return event + + def _receive_events( + self, request: Request, stream_id: int | None = None + ) -> None: + """ + Read some data from the network until we see one or more events + for a given stream ID. + """ + with self._read_lock: + if self._connection_terminated is not None: + last_stream_id = self._connection_terminated.last_stream_id + if stream_id and last_stream_id and stream_id > last_stream_id: + self._request_count -= 1 + raise ConnectionNotAvailable() + raise RemoteProtocolError(self._connection_terminated) + + # This conditional is a bit icky. We don't want to block reading if we've + # actually got an event to return for a given stream. We need to do that + # check *within* the atomic read lock. Though it also need to be optional, + # because when we call it from `_wait_for_outgoing_flow` we *do* want to + # block until we've available flow control, event when we have events + # pending for the stream ID we're attempting to send on. + if stream_id is None or not self._events.get(stream_id): + events = self._read_incoming_data(request) + for event in events: + if isinstance(event, h2.events.RemoteSettingsChanged): + with Trace( + "receive_remote_settings", logger, request + ) as trace: + self._receive_remote_settings_change(event) + trace.return_value = event + + elif isinstance( + event, + ( + h2.events.ResponseReceived, + h2.events.DataReceived, + h2.events.StreamEnded, + h2.events.StreamReset, + ), + ): + if event.stream_id in self._events: + self._events[event.stream_id].append(event) + + elif isinstance(event, h2.events.ConnectionTerminated): + self._connection_terminated = event + + self._write_outgoing_data(request) + + def _receive_remote_settings_change( + self, event: h2.events.RemoteSettingsChanged + ) -> None: + max_concurrent_streams = event.changed_settings.get( + h2.settings.SettingCodes.MAX_CONCURRENT_STREAMS + ) + if max_concurrent_streams: + new_max_streams = min( + max_concurrent_streams.new_value, + self._h2_state.local_settings.max_concurrent_streams, + ) + if new_max_streams and new_max_streams != self._max_streams: + while new_max_streams > self._max_streams: + self._max_streams_semaphore.release() + self._max_streams += 1 + while new_max_streams < self._max_streams: + self._max_streams_semaphore.acquire() + self._max_streams -= 1 + + def _response_closed(self, stream_id: int) -> None: + self._max_streams_semaphore.release() + del self._events[stream_id] + with self._state_lock: + if self._connection_terminated and not self._events: + self.close() + + elif self._state == HTTPConnectionState.ACTIVE and not self._events: + self._state = HTTPConnectionState.IDLE + if self._keepalive_expiry is not None: + now = time.monotonic() + self._expire_at = now + self._keepalive_expiry + if self._used_all_stream_ids: # pragma: nocover + self.close() + + def close(self) -> None: + # Note that this method unilaterally closes the connection, and does + # not have any kind of locking in place around it. + self._h2_state.close_connection() + self._state = HTTPConnectionState.CLOSED + self._network_stream.close() + + # Wrappers around network read/write operations... + + def _read_incoming_data(self, request: Request) -> list[h2.events.Event]: + timeouts = request.extensions.get("timeout", {}) + timeout = timeouts.get("read", None) + + if self._read_exception is not None: + raise self._read_exception # pragma: nocover + + try: + data = self._network_stream.read(self.READ_NUM_BYTES, timeout) + if data == b"": + raise RemoteProtocolError("Server disconnected") + except Exception as exc: + # If we get a network error we should: + # + # 1. Save the exception and just raise it immediately on any future reads. + # (For example, this means that a single read timeout or disconnect will + # immediately close all pending streams. Without requiring multiple + # sequential timeouts.) + # 2. Mark the connection as errored, so that we don't accept any other + # incoming requests. + self._read_exception = exc + self._connection_error = True + raise exc + + events: list[h2.events.Event] = self._h2_state.receive_data(data) + + return events + + def _write_outgoing_data(self, request: Request) -> None: + timeouts = request.extensions.get("timeout", {}) + timeout = timeouts.get("write", None) + + with self._write_lock: + data_to_send = self._h2_state.data_to_send() + + if self._write_exception is not None: + raise self._write_exception # pragma: nocover + + try: + self._network_stream.write(data_to_send, timeout) + except Exception as exc: # pragma: nocover + # If we get a network error we should: + # + # 1. Save the exception and just raise it immediately on any future write. + # (For example, this means that a single write timeout or disconnect will + # immediately close all pending streams. Without requiring multiple + # sequential timeouts.) + # 2. Mark the connection as errored, so that we don't accept any other + # incoming requests. + self._write_exception = exc + self._connection_error = True + raise exc + + # Flow control... + + def _wait_for_outgoing_flow(self, request: Request, stream_id: int) -> int: + """ + Returns the maximum allowable outgoing flow for a given stream. + + If the allowable flow is zero, then waits on the network until + WindowUpdated frames have increased the flow rate. + https://tools.ietf.org/html/rfc7540#section-6.9 + """ + local_flow: int = self._h2_state.local_flow_control_window(stream_id) + max_frame_size: int = self._h2_state.max_outbound_frame_size + flow = min(local_flow, max_frame_size) + while flow == 0: + self._receive_events(request) + local_flow = self._h2_state.local_flow_control_window(stream_id) + max_frame_size = self._h2_state.max_outbound_frame_size + flow = min(local_flow, max_frame_size) + return flow + + # Interface for connection pooling... + + def can_handle_request(self, origin: Origin) -> bool: + return origin == self._origin + + def is_available(self) -> bool: + return ( + self._state != HTTPConnectionState.CLOSED + and not self._connection_error + and not self._used_all_stream_ids + and not ( + self._h2_state.state_machine.state + == h2.connection.ConnectionState.CLOSED + ) + ) + + def has_expired(self) -> bool: + now = time.monotonic() + return self._expire_at is not None and now > self._expire_at + + def is_idle(self) -> bool: + return self._state == HTTPConnectionState.IDLE + + def is_closed(self) -> bool: + return self._state == HTTPConnectionState.CLOSED + + def info(self) -> str: + origin = str(self._origin) + return ( + f"{origin!r}, HTTP/2, {self._state.name}, " + f"Request Count: {self._request_count}" + ) + + def __repr__(self) -> str: + class_name = self.__class__.__name__ + origin = str(self._origin) + return ( + f"<{class_name} [{origin!r}, {self._state.name}, " + f"Request Count: {self._request_count}]>" + ) + + # These context managers are not used in the standard flow, but are + # useful for testing or working with connection instances directly. + + def __enter__(self) -> HTTP2Connection: + return self + + def __exit__( + self, + exc_type: type[BaseException] | None = None, + exc_value: BaseException | None = None, + traceback: types.TracebackType | None = None, + ) -> None: + self.close() + + +class HTTP2ConnectionByteStream: + def __init__( + self, connection: HTTP2Connection, request: Request, stream_id: int + ) -> None: + self._connection = connection + self._request = request + self._stream_id = stream_id + self._closed = False + + def __iter__(self) -> typing.Iterator[bytes]: + kwargs = {"request": self._request, "stream_id": self._stream_id} + try: + with Trace("receive_response_body", logger, self._request, kwargs): + for chunk in self._connection._receive_response_body( + request=self._request, stream_id=self._stream_id + ): + yield chunk + except BaseException as exc: + # If we get an exception while streaming the response, + # we want to close the response (and possibly the connection) + # before raising that exception. + with ShieldCancellation(): + self.close() + raise exc + + def close(self) -> None: + if not self._closed: + self._closed = True + kwargs = {"stream_id": self._stream_id} + with Trace("response_closed", logger, self._request, kwargs): + self._connection._response_closed(stream_id=self._stream_id) diff --git a/venv/lib/python3.10/site-packages/httpcore/_sync/http_proxy.py b/venv/lib/python3.10/site-packages/httpcore/_sync/http_proxy.py new file mode 100644 index 0000000000000000000000000000000000000000..ecca88f7dc93b78f2aa26f16cf29d17a8a83ae27 --- /dev/null +++ b/venv/lib/python3.10/site-packages/httpcore/_sync/http_proxy.py @@ -0,0 +1,367 @@ +from __future__ import annotations + +import base64 +import logging +import ssl +import typing + +from .._backends.base import SOCKET_OPTION, NetworkBackend +from .._exceptions import ProxyError +from .._models import ( + URL, + Origin, + Request, + Response, + enforce_bytes, + enforce_headers, + enforce_url, +) +from .._ssl import default_ssl_context +from .._synchronization import Lock +from .._trace import Trace +from .connection import HTTPConnection +from .connection_pool import ConnectionPool +from .http11 import HTTP11Connection +from .interfaces import ConnectionInterface + +ByteOrStr = typing.Union[bytes, str] +HeadersAsSequence = typing.Sequence[typing.Tuple[ByteOrStr, ByteOrStr]] +HeadersAsMapping = typing.Mapping[ByteOrStr, ByteOrStr] + + +logger = logging.getLogger("httpcore.proxy") + + +def merge_headers( + default_headers: typing.Sequence[tuple[bytes, bytes]] | None = None, + override_headers: typing.Sequence[tuple[bytes, bytes]] | None = None, +) -> list[tuple[bytes, bytes]]: + """ + Append default_headers and override_headers, de-duplicating if a key exists + in both cases. + """ + default_headers = [] if default_headers is None else list(default_headers) + override_headers = [] if override_headers is None else list(override_headers) + has_override = set(key.lower() for key, value in override_headers) + default_headers = [ + (key, value) + for key, value in default_headers + if key.lower() not in has_override + ] + return default_headers + override_headers + + +class HTTPProxy(ConnectionPool): # pragma: nocover + """ + A connection pool that sends requests via an HTTP proxy. + """ + + def __init__( + self, + proxy_url: URL | bytes | str, + proxy_auth: tuple[bytes | str, bytes | str] | None = None, + proxy_headers: HeadersAsMapping | HeadersAsSequence | None = None, + ssl_context: ssl.SSLContext | None = None, + proxy_ssl_context: ssl.SSLContext | None = None, + max_connections: int | None = 10, + max_keepalive_connections: int | None = None, + keepalive_expiry: float | None = None, + http1: bool = True, + http2: bool = False, + retries: int = 0, + local_address: str | None = None, + uds: str | None = None, + network_backend: NetworkBackend | None = None, + socket_options: typing.Iterable[SOCKET_OPTION] | None = None, + ) -> None: + """ + A connection pool for making HTTP requests. + + Parameters: + proxy_url: The URL to use when connecting to the proxy server. + For example `"http://127.0.0.1:8080/"`. + proxy_auth: Any proxy authentication as a two-tuple of + (username, password). May be either bytes or ascii-only str. + proxy_headers: Any HTTP headers to use for the proxy requests. + For example `{"Proxy-Authorization": "Basic :"}`. + ssl_context: An SSL context to use for verifying connections. + If not specified, the default `httpcore.default_ssl_context()` + will be used. + proxy_ssl_context: The same as `ssl_context`, but for a proxy server rather than a remote origin. + max_connections: The maximum number of concurrent HTTP connections that + the pool should allow. Any attempt to send a request on a pool that + would exceed this amount will block until a connection is available. + max_keepalive_connections: The maximum number of idle HTTP connections + that will be maintained in the pool. + keepalive_expiry: The duration in seconds that an idle HTTP connection + may be maintained for before being expired from the pool. + http1: A boolean indicating if HTTP/1.1 requests should be supported + by the connection pool. Defaults to True. + http2: A boolean indicating if HTTP/2 requests should be supported by + the connection pool. Defaults to False. + retries: The maximum number of retries when trying to establish + a connection. + local_address: Local address to connect from. Can also be used to + connect using a particular address family. Using + `local_address="0.0.0.0"` will connect using an `AF_INET` address + (IPv4), while using `local_address="::"` will connect using an + `AF_INET6` address (IPv6). + uds: Path to a Unix Domain Socket to use instead of TCP sockets. + network_backend: A backend instance to use for handling network I/O. + """ + super().__init__( + ssl_context=ssl_context, + max_connections=max_connections, + max_keepalive_connections=max_keepalive_connections, + keepalive_expiry=keepalive_expiry, + http1=http1, + http2=http2, + network_backend=network_backend, + retries=retries, + local_address=local_address, + uds=uds, + socket_options=socket_options, + ) + + self._proxy_url = enforce_url(proxy_url, name="proxy_url") + if ( + self._proxy_url.scheme == b"http" and proxy_ssl_context is not None + ): # pragma: no cover + raise RuntimeError( + "The `proxy_ssl_context` argument is not allowed for the http scheme" + ) + + self._ssl_context = ssl_context + self._proxy_ssl_context = proxy_ssl_context + self._proxy_headers = enforce_headers(proxy_headers, name="proxy_headers") + if proxy_auth is not None: + username = enforce_bytes(proxy_auth[0], name="proxy_auth") + password = enforce_bytes(proxy_auth[1], name="proxy_auth") + userpass = username + b":" + password + authorization = b"Basic " + base64.b64encode(userpass) + self._proxy_headers = [ + (b"Proxy-Authorization", authorization) + ] + self._proxy_headers + + def create_connection(self, origin: Origin) -> ConnectionInterface: + if origin.scheme == b"http": + return ForwardHTTPConnection( + proxy_origin=self._proxy_url.origin, + proxy_headers=self._proxy_headers, + remote_origin=origin, + keepalive_expiry=self._keepalive_expiry, + network_backend=self._network_backend, + proxy_ssl_context=self._proxy_ssl_context, + ) + return TunnelHTTPConnection( + proxy_origin=self._proxy_url.origin, + proxy_headers=self._proxy_headers, + remote_origin=origin, + ssl_context=self._ssl_context, + proxy_ssl_context=self._proxy_ssl_context, + keepalive_expiry=self._keepalive_expiry, + http1=self._http1, + http2=self._http2, + network_backend=self._network_backend, + ) + + +class ForwardHTTPConnection(ConnectionInterface): + def __init__( + self, + proxy_origin: Origin, + remote_origin: Origin, + proxy_headers: HeadersAsMapping | HeadersAsSequence | None = None, + keepalive_expiry: float | None = None, + network_backend: NetworkBackend | None = None, + socket_options: typing.Iterable[SOCKET_OPTION] | None = None, + proxy_ssl_context: ssl.SSLContext | None = None, + ) -> None: + self._connection = HTTPConnection( + origin=proxy_origin, + keepalive_expiry=keepalive_expiry, + network_backend=network_backend, + socket_options=socket_options, + ssl_context=proxy_ssl_context, + ) + self._proxy_origin = proxy_origin + self._proxy_headers = enforce_headers(proxy_headers, name="proxy_headers") + self._remote_origin = remote_origin + + def handle_request(self, request: Request) -> Response: + headers = merge_headers(self._proxy_headers, request.headers) + url = URL( + scheme=self._proxy_origin.scheme, + host=self._proxy_origin.host, + port=self._proxy_origin.port, + target=bytes(request.url), + ) + proxy_request = Request( + method=request.method, + url=url, + headers=headers, + content=request.stream, + extensions=request.extensions, + ) + return self._connection.handle_request(proxy_request) + + def can_handle_request(self, origin: Origin) -> bool: + return origin == self._remote_origin + + def close(self) -> None: + self._connection.close() + + def info(self) -> str: + return self._connection.info() + + def is_available(self) -> bool: + return self._connection.is_available() + + def has_expired(self) -> bool: + return self._connection.has_expired() + + def is_idle(self) -> bool: + return self._connection.is_idle() + + def is_closed(self) -> bool: + return self._connection.is_closed() + + def __repr__(self) -> str: + return f"<{self.__class__.__name__} [{self.info()}]>" + + +class TunnelHTTPConnection(ConnectionInterface): + def __init__( + self, + proxy_origin: Origin, + remote_origin: Origin, + ssl_context: ssl.SSLContext | None = None, + proxy_ssl_context: ssl.SSLContext | None = None, + proxy_headers: typing.Sequence[tuple[bytes, bytes]] | None = None, + keepalive_expiry: float | None = None, + http1: bool = True, + http2: bool = False, + network_backend: NetworkBackend | None = None, + socket_options: typing.Iterable[SOCKET_OPTION] | None = None, + ) -> None: + self._connection: ConnectionInterface = HTTPConnection( + origin=proxy_origin, + keepalive_expiry=keepalive_expiry, + network_backend=network_backend, + socket_options=socket_options, + ssl_context=proxy_ssl_context, + ) + self._proxy_origin = proxy_origin + self._remote_origin = remote_origin + self._ssl_context = ssl_context + self._proxy_ssl_context = proxy_ssl_context + self._proxy_headers = enforce_headers(proxy_headers, name="proxy_headers") + self._keepalive_expiry = keepalive_expiry + self._http1 = http1 + self._http2 = http2 + self._connect_lock = Lock() + self._connected = False + + def handle_request(self, request: Request) -> Response: + timeouts = request.extensions.get("timeout", {}) + timeout = timeouts.get("connect", None) + + with self._connect_lock: + if not self._connected: + target = b"%b:%d" % (self._remote_origin.host, self._remote_origin.port) + + connect_url = URL( + scheme=self._proxy_origin.scheme, + host=self._proxy_origin.host, + port=self._proxy_origin.port, + target=target, + ) + connect_headers = merge_headers( + [(b"Host", target), (b"Accept", b"*/*")], self._proxy_headers + ) + connect_request = Request( + method=b"CONNECT", + url=connect_url, + headers=connect_headers, + extensions=request.extensions, + ) + connect_response = self._connection.handle_request( + connect_request + ) + + if connect_response.status < 200 or connect_response.status > 299: + reason_bytes = connect_response.extensions.get("reason_phrase", b"") + reason_str = reason_bytes.decode("ascii", errors="ignore") + msg = "%d %s" % (connect_response.status, reason_str) + self._connection.close() + raise ProxyError(msg) + + stream = connect_response.extensions["network_stream"] + + # Upgrade the stream to SSL + ssl_context = ( + default_ssl_context() + if self._ssl_context is None + else self._ssl_context + ) + alpn_protocols = ["http/1.1", "h2"] if self._http2 else ["http/1.1"] + ssl_context.set_alpn_protocols(alpn_protocols) + + kwargs = { + "ssl_context": ssl_context, + "server_hostname": self._remote_origin.host.decode("ascii"), + "timeout": timeout, + } + with Trace("start_tls", logger, request, kwargs) as trace: + stream = stream.start_tls(**kwargs) + trace.return_value = stream + + # Determine if we should be using HTTP/1.1 or HTTP/2 + ssl_object = stream.get_extra_info("ssl_object") + http2_negotiated = ( + ssl_object is not None + and ssl_object.selected_alpn_protocol() == "h2" + ) + + # Create the HTTP/1.1 or HTTP/2 connection + if http2_negotiated or (self._http2 and not self._http1): + from .http2 import HTTP2Connection + + self._connection = HTTP2Connection( + origin=self._remote_origin, + stream=stream, + keepalive_expiry=self._keepalive_expiry, + ) + else: + self._connection = HTTP11Connection( + origin=self._remote_origin, + stream=stream, + keepalive_expiry=self._keepalive_expiry, + ) + + self._connected = True + return self._connection.handle_request(request) + + def can_handle_request(self, origin: Origin) -> bool: + return origin == self._remote_origin + + def close(self) -> None: + self._connection.close() + + def info(self) -> str: + return self._connection.info() + + def is_available(self) -> bool: + return self._connection.is_available() + + def has_expired(self) -> bool: + return self._connection.has_expired() + + def is_idle(self) -> bool: + return self._connection.is_idle() + + def is_closed(self) -> bool: + return self._connection.is_closed() + + def __repr__(self) -> str: + return f"<{self.__class__.__name__} [{self.info()}]>" diff --git a/venv/lib/python3.10/site-packages/httpcore/_sync/interfaces.py b/venv/lib/python3.10/site-packages/httpcore/_sync/interfaces.py new file mode 100644 index 0000000000000000000000000000000000000000..e673d4cc1b1dd7e7ecdbde91fd6ada386c3de03f --- /dev/null +++ b/venv/lib/python3.10/site-packages/httpcore/_sync/interfaces.py @@ -0,0 +1,137 @@ +from __future__ import annotations + +import contextlib +import typing + +from .._models import ( + URL, + Extensions, + HeaderTypes, + Origin, + Request, + Response, + enforce_bytes, + enforce_headers, + enforce_url, + include_request_headers, +) + + +class RequestInterface: + def request( + self, + method: bytes | str, + url: URL | bytes | str, + *, + headers: HeaderTypes = None, + content: bytes | typing.Iterator[bytes] | None = None, + extensions: Extensions | None = None, + ) -> Response: + # Strict type checking on our parameters. + method = enforce_bytes(method, name="method") + url = enforce_url(url, name="url") + headers = enforce_headers(headers, name="headers") + + # Include Host header, and optionally Content-Length or Transfer-Encoding. + headers = include_request_headers(headers, url=url, content=content) + + request = Request( + method=method, + url=url, + headers=headers, + content=content, + extensions=extensions, + ) + response = self.handle_request(request) + try: + response.read() + finally: + response.close() + return response + + @contextlib.contextmanager + def stream( + self, + method: bytes | str, + url: URL | bytes | str, + *, + headers: HeaderTypes = None, + content: bytes | typing.Iterator[bytes] | None = None, + extensions: Extensions | None = None, + ) -> typing.Iterator[Response]: + # Strict type checking on our parameters. + method = enforce_bytes(method, name="method") + url = enforce_url(url, name="url") + headers = enforce_headers(headers, name="headers") + + # Include Host header, and optionally Content-Length or Transfer-Encoding. + headers = include_request_headers(headers, url=url, content=content) + + request = Request( + method=method, + url=url, + headers=headers, + content=content, + extensions=extensions, + ) + response = self.handle_request(request) + try: + yield response + finally: + response.close() + + def handle_request(self, request: Request) -> Response: + raise NotImplementedError() # pragma: nocover + + +class ConnectionInterface(RequestInterface): + def close(self) -> None: + raise NotImplementedError() # pragma: nocover + + def info(self) -> str: + raise NotImplementedError() # pragma: nocover + + def can_handle_request(self, origin: Origin) -> bool: + raise NotImplementedError() # pragma: nocover + + def is_available(self) -> bool: + """ + Return `True` if the connection is currently able to accept an + outgoing request. + + An HTTP/1.1 connection will only be available if it is currently idle. + + An HTTP/2 connection will be available so long as the stream ID space is + not yet exhausted, and the connection is not in an error state. + + While the connection is being established we may not yet know if it is going + to result in an HTTP/1.1 or HTTP/2 connection. The connection should be + treated as being available, but might ultimately raise `NewConnectionRequired` + required exceptions if multiple requests are attempted over a connection + that ends up being established as HTTP/1.1. + """ + raise NotImplementedError() # pragma: nocover + + def has_expired(self) -> bool: + """ + Return `True` if the connection is in a state where it should be closed. + + This either means that the connection is idle and it has passed the + expiry time on its keep-alive, or that server has sent an EOF. + """ + raise NotImplementedError() # pragma: nocover + + def is_idle(self) -> bool: + """ + Return `True` if the connection is currently idle. + """ + raise NotImplementedError() # pragma: nocover + + def is_closed(self) -> bool: + """ + Return `True` if the connection has been closed. + + Used when a response is closed to determine if the connection may be + returned to the connection pool or not. + """ + raise NotImplementedError() # pragma: nocover diff --git a/venv/lib/python3.10/site-packages/httpcore/_sync/socks_proxy.py b/venv/lib/python3.10/site-packages/httpcore/_sync/socks_proxy.py new file mode 100644 index 0000000000000000000000000000000000000000..0ca96ddfb580b19413797f41e79f7abcecdd9d79 --- /dev/null +++ b/venv/lib/python3.10/site-packages/httpcore/_sync/socks_proxy.py @@ -0,0 +1,341 @@ +from __future__ import annotations + +import logging +import ssl + +import socksio + +from .._backends.sync import SyncBackend +from .._backends.base import NetworkBackend, NetworkStream +from .._exceptions import ConnectionNotAvailable, ProxyError +from .._models import URL, Origin, Request, Response, enforce_bytes, enforce_url +from .._ssl import default_ssl_context +from .._synchronization import Lock +from .._trace import Trace +from .connection_pool import ConnectionPool +from .http11 import HTTP11Connection +from .interfaces import ConnectionInterface + +logger = logging.getLogger("httpcore.socks") + + +AUTH_METHODS = { + b"\x00": "NO AUTHENTICATION REQUIRED", + b"\x01": "GSSAPI", + b"\x02": "USERNAME/PASSWORD", + b"\xff": "NO ACCEPTABLE METHODS", +} + +REPLY_CODES = { + b"\x00": "Succeeded", + b"\x01": "General SOCKS server failure", + b"\x02": "Connection not allowed by ruleset", + b"\x03": "Network unreachable", + b"\x04": "Host unreachable", + b"\x05": "Connection refused", + b"\x06": "TTL expired", + b"\x07": "Command not supported", + b"\x08": "Address type not supported", +} + + +def _init_socks5_connection( + stream: NetworkStream, + *, + host: bytes, + port: int, + auth: tuple[bytes, bytes] | None = None, +) -> None: + conn = socksio.socks5.SOCKS5Connection() + + # Auth method request + auth_method = ( + socksio.socks5.SOCKS5AuthMethod.NO_AUTH_REQUIRED + if auth is None + else socksio.socks5.SOCKS5AuthMethod.USERNAME_PASSWORD + ) + conn.send(socksio.socks5.SOCKS5AuthMethodsRequest([auth_method])) + outgoing_bytes = conn.data_to_send() + stream.write(outgoing_bytes) + + # Auth method response + incoming_bytes = stream.read(max_bytes=4096) + response = conn.receive_data(incoming_bytes) + assert isinstance(response, socksio.socks5.SOCKS5AuthReply) + if response.method != auth_method: + requested = AUTH_METHODS.get(auth_method, "UNKNOWN") + responded = AUTH_METHODS.get(response.method, "UNKNOWN") + raise ProxyError( + f"Requested {requested} from proxy server, but got {responded}." + ) + + if response.method == socksio.socks5.SOCKS5AuthMethod.USERNAME_PASSWORD: + # Username/password request + assert auth is not None + username, password = auth + conn.send(socksio.socks5.SOCKS5UsernamePasswordRequest(username, password)) + outgoing_bytes = conn.data_to_send() + stream.write(outgoing_bytes) + + # Username/password response + incoming_bytes = stream.read(max_bytes=4096) + response = conn.receive_data(incoming_bytes) + assert isinstance(response, socksio.socks5.SOCKS5UsernamePasswordReply) + if not response.success: + raise ProxyError("Invalid username/password") + + # Connect request + conn.send( + socksio.socks5.SOCKS5CommandRequest.from_address( + socksio.socks5.SOCKS5Command.CONNECT, (host, port) + ) + ) + outgoing_bytes = conn.data_to_send() + stream.write(outgoing_bytes) + + # Connect response + incoming_bytes = stream.read(max_bytes=4096) + response = conn.receive_data(incoming_bytes) + assert isinstance(response, socksio.socks5.SOCKS5Reply) + if response.reply_code != socksio.socks5.SOCKS5ReplyCode.SUCCEEDED: + reply_code = REPLY_CODES.get(response.reply_code, "UNKOWN") + raise ProxyError(f"Proxy Server could not connect: {reply_code}.") + + +class SOCKSProxy(ConnectionPool): # pragma: nocover + """ + A connection pool that sends requests via an HTTP proxy. + """ + + def __init__( + self, + proxy_url: URL | bytes | str, + proxy_auth: tuple[bytes | str, bytes | str] | None = None, + ssl_context: ssl.SSLContext | None = None, + max_connections: int | None = 10, + max_keepalive_connections: int | None = None, + keepalive_expiry: float | None = None, + http1: bool = True, + http2: bool = False, + retries: int = 0, + network_backend: NetworkBackend | None = None, + ) -> None: + """ + A connection pool for making HTTP requests. + + Parameters: + proxy_url: The URL to use when connecting to the proxy server. + For example `"http://127.0.0.1:8080/"`. + ssl_context: An SSL context to use for verifying connections. + If not specified, the default `httpcore.default_ssl_context()` + will be used. + max_connections: The maximum number of concurrent HTTP connections that + the pool should allow. Any attempt to send a request on a pool that + would exceed this amount will block until a connection is available. + max_keepalive_connections: The maximum number of idle HTTP connections + that will be maintained in the pool. + keepalive_expiry: The duration in seconds that an idle HTTP connection + may be maintained for before being expired from the pool. + http1: A boolean indicating if HTTP/1.1 requests should be supported + by the connection pool. Defaults to True. + http2: A boolean indicating if HTTP/2 requests should be supported by + the connection pool. Defaults to False. + retries: The maximum number of retries when trying to establish + a connection. + local_address: Local address to connect from. Can also be used to + connect using a particular address family. Using + `local_address="0.0.0.0"` will connect using an `AF_INET` address + (IPv4), while using `local_address="::"` will connect using an + `AF_INET6` address (IPv6). + uds: Path to a Unix Domain Socket to use instead of TCP sockets. + network_backend: A backend instance to use for handling network I/O. + """ + super().__init__( + ssl_context=ssl_context, + max_connections=max_connections, + max_keepalive_connections=max_keepalive_connections, + keepalive_expiry=keepalive_expiry, + http1=http1, + http2=http2, + network_backend=network_backend, + retries=retries, + ) + self._ssl_context = ssl_context + self._proxy_url = enforce_url(proxy_url, name="proxy_url") + if proxy_auth is not None: + username, password = proxy_auth + username_bytes = enforce_bytes(username, name="proxy_auth") + password_bytes = enforce_bytes(password, name="proxy_auth") + self._proxy_auth: tuple[bytes, bytes] | None = ( + username_bytes, + password_bytes, + ) + else: + self._proxy_auth = None + + def create_connection(self, origin: Origin) -> ConnectionInterface: + return Socks5Connection( + proxy_origin=self._proxy_url.origin, + remote_origin=origin, + proxy_auth=self._proxy_auth, + ssl_context=self._ssl_context, + keepalive_expiry=self._keepalive_expiry, + http1=self._http1, + http2=self._http2, + network_backend=self._network_backend, + ) + + +class Socks5Connection(ConnectionInterface): + def __init__( + self, + proxy_origin: Origin, + remote_origin: Origin, + proxy_auth: tuple[bytes, bytes] | None = None, + ssl_context: ssl.SSLContext | None = None, + keepalive_expiry: float | None = None, + http1: bool = True, + http2: bool = False, + network_backend: NetworkBackend | None = None, + ) -> None: + self._proxy_origin = proxy_origin + self._remote_origin = remote_origin + self._proxy_auth = proxy_auth + self._ssl_context = ssl_context + self._keepalive_expiry = keepalive_expiry + self._http1 = http1 + self._http2 = http2 + + self._network_backend: NetworkBackend = ( + SyncBackend() if network_backend is None else network_backend + ) + self._connect_lock = Lock() + self._connection: ConnectionInterface | None = None + self._connect_failed = False + + def handle_request(self, request: Request) -> Response: + timeouts = request.extensions.get("timeout", {}) + sni_hostname = request.extensions.get("sni_hostname", None) + timeout = timeouts.get("connect", None) + + with self._connect_lock: + if self._connection is None: + try: + # Connect to the proxy + kwargs = { + "host": self._proxy_origin.host.decode("ascii"), + "port": self._proxy_origin.port, + "timeout": timeout, + } + with Trace("connect_tcp", logger, request, kwargs) as trace: + stream = self._network_backend.connect_tcp(**kwargs) + trace.return_value = stream + + # Connect to the remote host using socks5 + kwargs = { + "stream": stream, + "host": self._remote_origin.host.decode("ascii"), + "port": self._remote_origin.port, + "auth": self._proxy_auth, + } + with Trace( + "setup_socks5_connection", logger, request, kwargs + ) as trace: + _init_socks5_connection(**kwargs) + trace.return_value = stream + + # Upgrade the stream to SSL + if self._remote_origin.scheme == b"https": + ssl_context = ( + default_ssl_context() + if self._ssl_context is None + else self._ssl_context + ) + alpn_protocols = ( + ["http/1.1", "h2"] if self._http2 else ["http/1.1"] + ) + ssl_context.set_alpn_protocols(alpn_protocols) + + kwargs = { + "ssl_context": ssl_context, + "server_hostname": sni_hostname + or self._remote_origin.host.decode("ascii"), + "timeout": timeout, + } + with Trace("start_tls", logger, request, kwargs) as trace: + stream = stream.start_tls(**kwargs) + trace.return_value = stream + + # Determine if we should be using HTTP/1.1 or HTTP/2 + ssl_object = stream.get_extra_info("ssl_object") + http2_negotiated = ( + ssl_object is not None + and ssl_object.selected_alpn_protocol() == "h2" + ) + + # Create the HTTP/1.1 or HTTP/2 connection + if http2_negotiated or ( + self._http2 and not self._http1 + ): # pragma: nocover + from .http2 import HTTP2Connection + + self._connection = HTTP2Connection( + origin=self._remote_origin, + stream=stream, + keepalive_expiry=self._keepalive_expiry, + ) + else: + self._connection = HTTP11Connection( + origin=self._remote_origin, + stream=stream, + keepalive_expiry=self._keepalive_expiry, + ) + except Exception as exc: + self._connect_failed = True + raise exc + elif not self._connection.is_available(): # pragma: nocover + raise ConnectionNotAvailable() + + return self._connection.handle_request(request) + + def can_handle_request(self, origin: Origin) -> bool: + return origin == self._remote_origin + + def close(self) -> None: + if self._connection is not None: + self._connection.close() + + def is_available(self) -> bool: + if self._connection is None: # pragma: nocover + # If HTTP/2 support is enabled, and the resulting connection could + # end up as HTTP/2 then we should indicate the connection as being + # available to service multiple requests. + return ( + self._http2 + and (self._remote_origin.scheme == b"https" or not self._http1) + and not self._connect_failed + ) + return self._connection.is_available() + + def has_expired(self) -> bool: + if self._connection is None: # pragma: nocover + return self._connect_failed + return self._connection.has_expired() + + def is_idle(self) -> bool: + if self._connection is None: # pragma: nocover + return self._connect_failed + return self._connection.is_idle() + + def is_closed(self) -> bool: + if self._connection is None: # pragma: nocover + return self._connect_failed + return self._connection.is_closed() + + def info(self) -> str: + if self._connection is None: # pragma: nocover + return "CONNECTION FAILED" if self._connect_failed else "CONNECTING" + return self._connection.info() + + def __repr__(self) -> str: + return f"<{self.__class__.__name__} [{self.info()}]>" diff --git a/venv/lib/python3.10/site-packages/httpcore/_synchronization.py b/venv/lib/python3.10/site-packages/httpcore/_synchronization.py new file mode 100644 index 0000000000000000000000000000000000000000..2ecc9e9c363e2f16c4f934cf41cf871826d6a495 --- /dev/null +++ b/venv/lib/python3.10/site-packages/httpcore/_synchronization.py @@ -0,0 +1,318 @@ +from __future__ import annotations + +import threading +import types + +from ._exceptions import ExceptionMapping, PoolTimeout, map_exceptions + +# Our async synchronization primatives use either 'anyio' or 'trio' depending +# on if they're running under asyncio or trio. + +try: + import trio +except (ImportError, NotImplementedError): # pragma: nocover + trio = None # type: ignore + +try: + import anyio +except ImportError: # pragma: nocover + anyio = None # type: ignore + + +def current_async_library() -> str: + # Determine if we're running under trio or asyncio. + # See https://sniffio.readthedocs.io/en/latest/ + try: + import sniffio + except ImportError: # pragma: nocover + environment = "asyncio" + else: + environment = sniffio.current_async_library() + + if environment not in ("asyncio", "trio"): # pragma: nocover + raise RuntimeError("Running under an unsupported async environment.") + + if environment == "asyncio" and anyio is None: # pragma: nocover + raise RuntimeError( + "Running with asyncio requires installation of 'httpcore[asyncio]'." + ) + + if environment == "trio" and trio is None: # pragma: nocover + raise RuntimeError( + "Running with trio requires installation of 'httpcore[trio]'." + ) + + return environment + + +class AsyncLock: + """ + This is a standard lock. + + In the sync case `Lock` provides thread locking. + In the async case `AsyncLock` provides async locking. + """ + + def __init__(self) -> None: + self._backend = "" + + def setup(self) -> None: + """ + Detect if we're running under 'asyncio' or 'trio' and create + a lock with the correct implementation. + """ + self._backend = current_async_library() + if self._backend == "trio": + self._trio_lock = trio.Lock() + elif self._backend == "asyncio": + self._anyio_lock = anyio.Lock() + + async def __aenter__(self) -> AsyncLock: + if not self._backend: + self.setup() + + if self._backend == "trio": + await self._trio_lock.acquire() + elif self._backend == "asyncio": + await self._anyio_lock.acquire() + + return self + + async def __aexit__( + self, + exc_type: type[BaseException] | None = None, + exc_value: BaseException | None = None, + traceback: types.TracebackType | None = None, + ) -> None: + if self._backend == "trio": + self._trio_lock.release() + elif self._backend == "asyncio": + self._anyio_lock.release() + + +class AsyncThreadLock: + """ + This is a threading-only lock for no-I/O contexts. + + In the sync case `ThreadLock` provides thread locking. + In the async case `AsyncThreadLock` is a no-op. + """ + + def __enter__(self) -> AsyncThreadLock: + return self + + def __exit__( + self, + exc_type: type[BaseException] | None = None, + exc_value: BaseException | None = None, + traceback: types.TracebackType | None = None, + ) -> None: + pass + + +class AsyncEvent: + def __init__(self) -> None: + self._backend = "" + + def setup(self) -> None: + """ + Detect if we're running under 'asyncio' or 'trio' and create + a lock with the correct implementation. + """ + self._backend = current_async_library() + if self._backend == "trio": + self._trio_event = trio.Event() + elif self._backend == "asyncio": + self._anyio_event = anyio.Event() + + def set(self) -> None: + if not self._backend: + self.setup() + + if self._backend == "trio": + self._trio_event.set() + elif self._backend == "asyncio": + self._anyio_event.set() + + async def wait(self, timeout: float | None = None) -> None: + if not self._backend: + self.setup() + + if self._backend == "trio": + trio_exc_map: ExceptionMapping = {trio.TooSlowError: PoolTimeout} + timeout_or_inf = float("inf") if timeout is None else timeout + with map_exceptions(trio_exc_map): + with trio.fail_after(timeout_or_inf): + await self._trio_event.wait() + elif self._backend == "asyncio": + anyio_exc_map: ExceptionMapping = {TimeoutError: PoolTimeout} + with map_exceptions(anyio_exc_map): + with anyio.fail_after(timeout): + await self._anyio_event.wait() + + +class AsyncSemaphore: + def __init__(self, bound: int) -> None: + self._bound = bound + self._backend = "" + + def setup(self) -> None: + """ + Detect if we're running under 'asyncio' or 'trio' and create + a semaphore with the correct implementation. + """ + self._backend = current_async_library() + if self._backend == "trio": + self._trio_semaphore = trio.Semaphore( + initial_value=self._bound, max_value=self._bound + ) + elif self._backend == "asyncio": + self._anyio_semaphore = anyio.Semaphore( + initial_value=self._bound, max_value=self._bound + ) + + async def acquire(self) -> None: + if not self._backend: + self.setup() + + if self._backend == "trio": + await self._trio_semaphore.acquire() + elif self._backend == "asyncio": + await self._anyio_semaphore.acquire() + + async def release(self) -> None: + if self._backend == "trio": + self._trio_semaphore.release() + elif self._backend == "asyncio": + self._anyio_semaphore.release() + + +class AsyncShieldCancellation: + # For certain portions of our codebase where we're dealing with + # closing connections during exception handling we want to shield + # the operation from being cancelled. + # + # with AsyncShieldCancellation(): + # ... # clean-up operations, shielded from cancellation. + + def __init__(self) -> None: + """ + Detect if we're running under 'asyncio' or 'trio' and create + a shielded scope with the correct implementation. + """ + self._backend = current_async_library() + + if self._backend == "trio": + self._trio_shield = trio.CancelScope(shield=True) + elif self._backend == "asyncio": + self._anyio_shield = anyio.CancelScope(shield=True) + + def __enter__(self) -> AsyncShieldCancellation: + if self._backend == "trio": + self._trio_shield.__enter__() + elif self._backend == "asyncio": + self._anyio_shield.__enter__() + return self + + def __exit__( + self, + exc_type: type[BaseException] | None = None, + exc_value: BaseException | None = None, + traceback: types.TracebackType | None = None, + ) -> None: + if self._backend == "trio": + self._trio_shield.__exit__(exc_type, exc_value, traceback) + elif self._backend == "asyncio": + self._anyio_shield.__exit__(exc_type, exc_value, traceback) + + +# Our thread-based synchronization primitives... + + +class Lock: + """ + This is a standard lock. + + In the sync case `Lock` provides thread locking. + In the async case `AsyncLock` provides async locking. + """ + + def __init__(self) -> None: + self._lock = threading.Lock() + + def __enter__(self) -> Lock: + self._lock.acquire() + return self + + def __exit__( + self, + exc_type: type[BaseException] | None = None, + exc_value: BaseException | None = None, + traceback: types.TracebackType | None = None, + ) -> None: + self._lock.release() + + +class ThreadLock: + """ + This is a threading-only lock for no-I/O contexts. + + In the sync case `ThreadLock` provides thread locking. + In the async case `AsyncThreadLock` is a no-op. + """ + + def __init__(self) -> None: + self._lock = threading.Lock() + + def __enter__(self) -> ThreadLock: + self._lock.acquire() + return self + + def __exit__( + self, + exc_type: type[BaseException] | None = None, + exc_value: BaseException | None = None, + traceback: types.TracebackType | None = None, + ) -> None: + self._lock.release() + + +class Event: + def __init__(self) -> None: + self._event = threading.Event() + + def set(self) -> None: + self._event.set() + + def wait(self, timeout: float | None = None) -> None: + if timeout == float("inf"): # pragma: no cover + timeout = None + if not self._event.wait(timeout=timeout): + raise PoolTimeout() # pragma: nocover + + +class Semaphore: + def __init__(self, bound: int) -> None: + self._semaphore = threading.Semaphore(value=bound) + + def acquire(self) -> None: + self._semaphore.acquire() + + def release(self) -> None: + self._semaphore.release() + + +class ShieldCancellation: + # Thread-synchronous codebases don't support cancellation semantics. + # We have this class because we need to mirror the async and sync + # cases within our package, but it's just a no-op. + def __enter__(self) -> ShieldCancellation: + return self + + def __exit__( + self, + exc_type: type[BaseException] | None = None, + exc_value: BaseException | None = None, + traceback: types.TracebackType | None = None, + ) -> None: + pass diff --git a/venv/lib/python3.10/site-packages/httpcore/_trace.py b/venv/lib/python3.10/site-packages/httpcore/_trace.py new file mode 100644 index 0000000000000000000000000000000000000000..5f1cd7c47829ce17dbcf651ab56b4ffdce04a485 --- /dev/null +++ b/venv/lib/python3.10/site-packages/httpcore/_trace.py @@ -0,0 +1,107 @@ +from __future__ import annotations + +import inspect +import logging +import types +import typing + +from ._models import Request + + +class Trace: + def __init__( + self, + name: str, + logger: logging.Logger, + request: Request | None = None, + kwargs: dict[str, typing.Any] | None = None, + ) -> None: + self.name = name + self.logger = logger + self.trace_extension = ( + None if request is None else request.extensions.get("trace") + ) + self.debug = self.logger.isEnabledFor(logging.DEBUG) + self.kwargs = kwargs or {} + self.return_value: typing.Any = None + self.should_trace = self.debug or self.trace_extension is not None + self.prefix = self.logger.name.split(".")[-1] + + def trace(self, name: str, info: dict[str, typing.Any]) -> None: + if self.trace_extension is not None: + prefix_and_name = f"{self.prefix}.{name}" + ret = self.trace_extension(prefix_and_name, info) + if inspect.iscoroutine(ret): # pragma: no cover + raise TypeError( + "If you are using a synchronous interface, " + "the callback of the `trace` extension should " + "be a normal function instead of an asynchronous function." + ) + + if self.debug: + if not info or "return_value" in info and info["return_value"] is None: + message = name + else: + args = " ".join([f"{key}={value!r}" for key, value in info.items()]) + message = f"{name} {args}" + self.logger.debug(message) + + def __enter__(self) -> Trace: + if self.should_trace: + info = self.kwargs + self.trace(f"{self.name}.started", info) + return self + + def __exit__( + self, + exc_type: type[BaseException] | None = None, + exc_value: BaseException | None = None, + traceback: types.TracebackType | None = None, + ) -> None: + if self.should_trace: + if exc_value is None: + info = {"return_value": self.return_value} + self.trace(f"{self.name}.complete", info) + else: + info = {"exception": exc_value} + self.trace(f"{self.name}.failed", info) + + async def atrace(self, name: str, info: dict[str, typing.Any]) -> None: + if self.trace_extension is not None: + prefix_and_name = f"{self.prefix}.{name}" + coro = self.trace_extension(prefix_and_name, info) + if not inspect.iscoroutine(coro): # pragma: no cover + raise TypeError( + "If you're using an asynchronous interface, " + "the callback of the `trace` extension should " + "be an asynchronous function rather than a normal function." + ) + await coro + + if self.debug: + if not info or "return_value" in info and info["return_value"] is None: + message = name + else: + args = " ".join([f"{key}={value!r}" for key, value in info.items()]) + message = f"{name} {args}" + self.logger.debug(message) + + async def __aenter__(self) -> Trace: + if self.should_trace: + info = self.kwargs + await self.atrace(f"{self.name}.started", info) + return self + + async def __aexit__( + self, + exc_type: type[BaseException] | None = None, + exc_value: BaseException | None = None, + traceback: types.TracebackType | None = None, + ) -> None: + if self.should_trace: + if exc_value is None: + info = {"return_value": self.return_value} + await self.atrace(f"{self.name}.complete", info) + else: + info = {"exception": exc_value} + await self.atrace(f"{self.name}.failed", info) diff --git a/venv/lib/python3.10/site-packages/httpcore/_utils.py b/venv/lib/python3.10/site-packages/httpcore/_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..c44ff93cb2f572afc6e679308024b744b65c3b0a --- /dev/null +++ b/venv/lib/python3.10/site-packages/httpcore/_utils.py @@ -0,0 +1,37 @@ +from __future__ import annotations + +import select +import socket +import sys + + +def is_socket_readable(sock: socket.socket | None) -> bool: + """ + Return whether a socket, as identifed by its file descriptor, is readable. + "A socket is readable" means that the read buffer isn't empty, i.e. that calling + .recv() on it would immediately return some data. + """ + # NOTE: we want check for readability without actually attempting to read, because + # we don't want to block forever if it's not readable. + + # In the case that the socket no longer exists, or cannot return a file + # descriptor, we treat it as being readable, as if it the next read operation + # on it is ready to return the terminating `b""`. + sock_fd = None if sock is None else sock.fileno() + if sock_fd is None or sock_fd < 0: # pragma: nocover + return True + + # The implementation below was stolen from: + # https://github.com/python-trio/trio/blob/20ee2b1b7376db637435d80e266212a35837ddcc/trio/_socket.py#L471-L478 + # See also: https://github.com/encode/httpcore/pull/193#issuecomment-703129316 + + # Use select.select on Windows, and when poll is unavailable and select.poll + # everywhere else. (E.g. When eventlet is in use. See #327) + if ( + sys.platform == "win32" or getattr(select, "poll", None) is None + ): # pragma: nocover + rready, _, _ = select.select([sock_fd], [], [], 0) + return bool(rready) + p = select.poll() + p.register(sock_fd, select.POLLIN) + return bool(p.poll(0)) diff --git a/venv/lib/python3.10/site-packages/httpcore/py.typed b/venv/lib/python3.10/site-packages/httpcore/py.typed new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/venv/lib/python3.10/site-packages/jiter-0.10.0.dist-info/INSTALLER b/venv/lib/python3.10/site-packages/jiter-0.10.0.dist-info/INSTALLER new file mode 100644 index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68 --- /dev/null +++ b/venv/lib/python3.10/site-packages/jiter-0.10.0.dist-info/INSTALLER @@ -0,0 +1 @@ +pip diff --git a/venv/lib/python3.10/site-packages/jiter-0.10.0.dist-info/METADATA b/venv/lib/python3.10/site-packages/jiter-0.10.0.dist-info/METADATA new file mode 100644 index 0000000000000000000000000000000000000000..3a7bf2e44c15b6d2a11839501bc3badbe4ec6758 --- /dev/null +++ b/venv/lib/python3.10/site-packages/jiter-0.10.0.dist-info/METADATA @@ -0,0 +1,146 @@ +Metadata-Version: 2.4 +Name: jiter +Version: 0.10.0 +Classifier: Development Status :: 4 - Beta +Classifier: Programming Language :: Python +Classifier: Programming Language :: Python :: 3 +Classifier: Programming Language :: Python :: 3 :: Only +Classifier: Programming Language :: Python :: 3.9 +Classifier: Programming Language :: Python :: 3.10 +Classifier: Programming Language :: Python :: 3.11 +Classifier: Programming Language :: Python :: 3.12 +Classifier: Programming Language :: Python :: 3.13 +Classifier: Programming Language :: Python :: 3.14 +Classifier: Intended Audience :: Developers +Classifier: Intended Audience :: Information Technology +Classifier: Intended Audience :: System Administrators +Classifier: License :: OSI Approved :: MIT License +Classifier: Operating System :: Unix +Classifier: Operating System :: POSIX :: Linux +Classifier: Environment :: Console +Classifier: Environment :: MacOS X +Classifier: Topic :: File Formats :: JSON +Classifier: Framework :: Pydantic :: 2 +Summary: Fast iterable JSON parser. +Keywords: JSON,parsing,deserialization,iter +Home-Page: https://github.com/pydantic/jiter/ +Author: Samuel Colvin +Author-email: Samuel Colvin +License: MIT +Requires-Python: >=3.9 +Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM +Project-URL: Source Code, https://github.com/pydantic/jiter/ + +# jiter + +[![CI](https://github.com/pydantic/jiter/workflows/CI/badge.svg?event=push)](https://github.com/pydantic/jiter/actions?query=event%3Apush+branch%3Amain+workflow%3ACI) +[![pypi](https://img.shields.io/pypi/v/jiter.svg)](https://pypi.python.org/pypi/jiter) +[![versions](https://img.shields.io/pypi/pyversions/jiter.svg)](https://github.com/pydantic/jiter) +[![license](https://img.shields.io/github/license/pydantic/jiter.svg)](https://github.com/pydantic/jiter/blob/main/LICENSE) + +This is a standalone version of the JSON parser used in `pydantic-core`. The recommendation is to only use this package directly if you do not use `pydantic`. + +The API is extremely minimal: + +```python +def from_json( + json_data: bytes, + /, + *, + allow_inf_nan: bool = True, + cache_mode: Literal[True, False, "all", "keys", "none"] = "all", + partial_mode: Literal[True, False, "off", "on", "trailing-strings"] = False, + catch_duplicate_keys: bool = False, + float_mode: Literal["float", "decimal", "lossless-float"] = "float", +) -> Any: + """ + Parse input bytes into a JSON object. + + Arguments: + json_data: The JSON data to parse + allow_inf_nan: Whether to allow infinity (`Infinity` an `-Infinity`) and `NaN` values to float fields. + Defaults to True. + cache_mode: cache Python strings to improve performance at the cost of some memory usage + - True / 'all' - cache all strings + - 'keys' - cache only object keys + - False / 'none' - cache nothing + partial_mode: How to handle incomplete strings: + - False / 'off' - raise an exception if the input is incomplete + - True / 'on' - allow incomplete JSON but discard the last string if it is incomplete + - 'trailing-strings' - allow incomplete JSON, and include the last incomplete string in the output + catch_duplicate_keys: if True, raise an exception if objects contain the same key multiple times + float_mode: How to return floats: as a `float`, `Decimal` or `LosslessFloat` + + Returns: + Python object built from the JSON input. + """ + +def cache_clear() -> None: + """ + Reset the string cache. + """ + +def cache_usage() -> int: + """ + get the size of the string cache. + + Returns: + Size of the string cache in bytes. + """ +``` +## Examples + +The main function provided by Jiter is `from_json()`, which accepts a bytes object containing JSON and returns a Python dictionary, list or other value. + +```python +import jiter + +json_data = b'{"name": "John", "age": 30}' +parsed_data = jiter.from_json(json_data) +print(parsed_data) # Output: {'name': 'John', 'age': 30} +``` + +### Handling Partial JSON + +Incomplete JSON objects can be parsed using the `partial_mode=` parameter. + +```python +import jiter + +partial_json = b'{"name": "John", "age": 30, "city": "New Yor' + +# Raise error on incomplete JSON +try: + jiter.from_json(partial_json, partial_mode=False) +except ValueError as e: + print(f"Error: {e}") + +# Parse incomplete JSON, discarding incomplete last field +result = jiter.from_json(partial_json, partial_mode=True) +print(result) # Output: {'name': 'John', 'age': 30} + +# Parse incomplete JSON, including incomplete last field +result = jiter.from_json(partial_json, partial_mode='trailing-strings') +print(result) # Output: {'name': 'John', 'age': 30, 'city': 'New Yor'} +``` + +### Catching Duplicate Keys + +The `catch_duplicate_keys=True` option can be used to raise a `ValueError` if an object contains duplicate keys. + +```python +import jiter + +json_with_dupes = b'{"foo": 1, "foo": 2}' + +# Default behavior (last value wins) +result = jiter.from_json(json_with_dupes) +print(result) # Output: {'foo': 2} + +# Catch duplicate keys +try: + jiter.from_json(json_with_dupes, catch_duplicate_keys=True) +except ValueError as e: + print(f"Error: {e}") +``` + diff --git a/venv/lib/python3.10/site-packages/jiter-0.10.0.dist-info/RECORD b/venv/lib/python3.10/site-packages/jiter-0.10.0.dist-info/RECORD new file mode 100644 index 0000000000000000000000000000000000000000..a56149aec044962e9ffb04141d023560c0f530ba --- /dev/null +++ b/venv/lib/python3.10/site-packages/jiter-0.10.0.dist-info/RECORD @@ -0,0 +1,9 @@ +jiter-0.10.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +jiter-0.10.0.dist-info/METADATA,sha256=8JHMxeYrdnY2euk0whW-YDws_DXQNwF7IKVnd2GEU1Q,5232 +jiter-0.10.0.dist-info/RECORD,, +jiter-0.10.0.dist-info/WHEEL,sha256=pM2Fp-Ynaqt8ornuONT9rEZFWixKnS89Tuqp6pz8lXg,129 +jiter/__init__.py,sha256=Fp9HkOixiYYDSiC_80vmiJ_sCoCGT8OAh48yltm0lP0,103 +jiter/__init__.pyi,sha256=IXJ5QM8oWahamu-erWyWfk4hDX-K7ZJvyoZi8jLV0nQ,2365 +jiter/__pycache__/__init__.cpython-310.pyc,, +jiter/jiter.cpython-310-x86_64-linux-gnu.so,sha256=3aub3vOtJ79dwRQaloim9fwf33Y-3HBWADtSeH0qt90,843304 +jiter/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 diff --git a/venv/lib/python3.10/site-packages/jiter-0.10.0.dist-info/WHEEL b/venv/lib/python3.10/site-packages/jiter-0.10.0.dist-info/WHEEL new file mode 100644 index 0000000000000000000000000000000000000000..69ab970975f8987d1d30da6eb46632c7145ca527 --- /dev/null +++ b/venv/lib/python3.10/site-packages/jiter-0.10.0.dist-info/WHEEL @@ -0,0 +1,4 @@ +Wheel-Version: 1.0 +Generator: maturin (1.8.6) +Root-Is-Purelib: false +Tag: cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64 diff --git a/venv/lib/python3.10/site-packages/ml_dtypes-0.5.3.dist-info/INSTALLER b/venv/lib/python3.10/site-packages/ml_dtypes-0.5.3.dist-info/INSTALLER new file mode 100644 index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68 --- /dev/null +++ b/venv/lib/python3.10/site-packages/ml_dtypes-0.5.3.dist-info/INSTALLER @@ -0,0 +1 @@ +pip diff --git a/venv/lib/python3.10/site-packages/ml_dtypes-0.5.3.dist-info/METADATA b/venv/lib/python3.10/site-packages/ml_dtypes-0.5.3.dist-info/METADATA new file mode 100644 index 0000000000000000000000000000000000000000..26a4cc98aeaee60b56b95396d0d3b270cf7be0f5 --- /dev/null +++ b/venv/lib/python3.10/site-packages/ml_dtypes-0.5.3.dist-info/METADATA @@ -0,0 +1,268 @@ +Metadata-Version: 2.4 +Name: ml_dtypes +Version: 0.5.3 +Summary: ml_dtypes is a stand-alone implementation of several NumPy dtype extensions used in machine learning. +Author-email: ml_dtypes authors +License-Expression: Apache-2.0 +Project-URL: homepage, https://github.com/jax-ml/ml_dtypes +Project-URL: repository, https://github.com/jax-ml/ml_dtypes +Classifier: Programming Language :: Python :: 3 +Classifier: Programming Language :: Python :: 3 :: Only +Classifier: Intended Audience :: Science/Research +Requires-Python: >=3.9 +Description-Content-Type: text/markdown +License-File: LICENSE +License-File: LICENSE.eigen +Requires-Dist: numpy>=1.21 +Requires-Dist: numpy>=1.21.2; python_version >= "3.10" +Requires-Dist: numpy>=1.23.3; python_version >= "3.11" +Requires-Dist: numpy>=1.26.0; python_version >= "3.12" +Requires-Dist: numpy>=2.1.0; python_version >= "3.13" +Provides-Extra: dev +Requires-Dist: absl-py; extra == "dev" +Requires-Dist: pytest; extra == "dev" +Requires-Dist: pytest-xdist; extra == "dev" +Requires-Dist: pylint>=2.6.0; extra == "dev" +Requires-Dist: pyink; extra == "dev" +Dynamic: license-file + +# ml_dtypes + +[![Unittests](https://github.com/jax-ml/ml_dtypes/actions/workflows/test.yml/badge.svg)](https://github.com/jax-ml/ml_dtypes/actions/workflows/test.yml) +[![Wheel Build](https://github.com/jax-ml/ml_dtypes/actions/workflows/wheels.yml/badge.svg)](https://github.com/jax-ml/ml_dtypes/actions/workflows/wheels.yml) +[![PyPI version](https://badge.fury.io/py/ml_dtypes.svg)](https://badge.fury.io/py/ml_dtypes) + +`ml_dtypes` is a stand-alone implementation of several NumPy dtype extensions used in machine learning libraries, including: + +- [`bfloat16`](https://en.wikipedia.org/wiki/Bfloat16_floating-point_format): + an alternative to the standard [`float16`](https://en.wikipedia.org/wiki/Half-precision_floating-point_format) format +- 8-bit floating point representations, parameterized by number of exponent and + mantissa bits, as well as the bias (if any) and representability of infinity, + NaN, and signed zero. + * `float8_e3m4` + * `float8_e4m3` + * `float8_e4m3b11fnuz` + * `float8_e4m3fn` + * `float8_e4m3fnuz` + * `float8_e5m2` + * `float8_e5m2fnuz` + * `float8_e8m0fnu` +- Microscaling (MX) sub-byte floating point representations: + * `float4_e2m1fn` + * `float6_e2m3fn` + * `float6_e3m2fn` +- Narrow integer encodings: + * `int2` + * `int4` + * `uint2` + * `uint4` + +See below for specifications of these number formats. + +## Installation + +The `ml_dtypes` package is tested with Python versions 3.9-3.12, and can be installed +with the following command: +``` +pip install ml_dtypes +``` +To test your installation, you can run the following: +``` +pip install absl-py pytest +pytest --pyargs ml_dtypes +``` +To build from source, clone the repository and run: +``` +git submodule init +git submodule update +pip install . +``` + +## Example Usage + +```python +>>> from ml_dtypes import bfloat16 +>>> import numpy as np +>>> np.zeros(4, dtype=bfloat16) +array([0, 0, 0, 0], dtype=bfloat16) +``` +Importing `ml_dtypes` also registers the data types with numpy, so that they may +be referred to by their string name: + +```python +>>> np.dtype('bfloat16') +dtype(bfloat16) +>>> np.dtype('float8_e5m2') +dtype(float8_e5m2) +``` + +## Specifications of implemented floating point formats + +### `bfloat16` + +A `bfloat16` number is a single-precision float truncated at 16 bits. + +Exponent: 8, Mantissa: 7, exponent bias: 127. IEEE 754, with NaN and inf. + +### `float4_e2m1fn` + +Exponent: 2, Mantissa: 1, bias: 1. + +Extended range: no inf, no NaN. + +Microscaling format, 4 bits (encoding: `0bSEEM`) using byte storage (higher 4 +bits are unused). NaN representation is undefined. + +Possible absolute values: [`0`, `0.5`, `1`, `1.5`, `2`, `3`, `4`, `6`] + +### `float6_e2m3fn` + +Exponent: 2, Mantissa: 3, bias: 1. + +Extended range: no inf, no NaN. + +Microscaling format, 6 bits (encoding: `0bSEEMMM`) using byte storage (higher 2 +bits are unused). NaN representation is undefined. + +Possible values range: [`-7.5`; `7.5`] + +### `float6_e3m2fn` + +Exponent: 3, Mantissa: 2, bias: 3. + +Extended range: no inf, no NaN. + +Microscaling format, 4 bits (encoding: `0bSEEEMM`) using byte storage (higher 2 +bits are unused). NaN representation is undefined. + +Possible values range: [`-28`; `28`] + +### `float8_e3m4` + +Exponent: 3, Mantissa: 4, bias: 3. IEEE 754, with NaN and inf. + +### `float8_e4m3` + +Exponent: 4, Mantissa: 3, bias: 7. IEEE 754, with NaN and inf. + +### `float8_e4m3b11fnuz` + +Exponent: 4, Mantissa: 3, bias: 11. + +Extended range: no inf, NaN represented by 0b1000'0000. + +### `float8_e4m3fn` + +Exponent: 4, Mantissa: 3, bias: 7. + +Extended range: no inf, NaN represented by 0bS111'1111. + +The `fn` suffix is for consistency with the corresponding LLVM/MLIR type, signaling this type is not consistent with IEEE-754. The `f` indicates it is finite values only. The `n` indicates it includes NaNs, but only at the outer range. + +### `float8_e4m3fnuz` + +8-bit floating point with 3 bit mantissa. + +An 8-bit floating point type with 1 sign bit, 4 bits exponent and 3 bits mantissa. The suffix `fnuz` is consistent with LLVM/MLIR naming and is derived from the differences to IEEE floating point conventions. `F` is for "finite" (no infinities), `N` for with special NaN encoding, `UZ` for unsigned zero. + +This type has the following characteristics: + * bit encoding: S1E4M3 - `0bSEEEEMMM` + * exponent bias: 8 + * infinities: Not supported + * NaNs: Supported with sign bit set to 1, exponent bits and mantissa bits set to all 0s - `0b10000000` + * denormals when exponent is 0 + +### `float8_e5m2` + +Exponent: 5, Mantissa: 2, bias: 15. IEEE 754, with NaN and inf. + +### `float8_e5m2fnuz` + +8-bit floating point with 2 bit mantissa. + +An 8-bit floating point type with 1 sign bit, 5 bits exponent and 2 bits mantissa. The suffix `fnuz` is consistent with LLVM/MLIR naming and is derived from the differences to IEEE floating point conventions. `F` is for "finite" (no infinities), `N` for with special NaN encoding, `UZ` for unsigned zero. + +This type has the following characteristics: + * bit encoding: S1E5M2 - `0bSEEEEEMM` + * exponent bias: 16 + * infinities: Not supported + * NaNs: Supported with sign bit set to 1, exponent bits and mantissa bits set to all 0s - `0b10000000` + * denormals when exponent is 0 + +### `float8_e8m0fnu` + +[OpenCompute MX](https://www.opencompute.org/documents/ocp-microscaling-formats-mx-v1-0-spec-final-pdf) +scale format E8M0, which has the following properties: + * Unsigned format + * 8 exponent bits + * Exponent range from -127 to 127 + * No zero and infinity + * Single NaN value (0xFF). + +## `int2`, `int4`, `uint2` and `uint4` + +2 and 4-bit integer types, where each element is represented unpacked (i.e., +padded up to a byte in memory). + +NumPy does not support types smaller than a single byte: for example, the +distance between adjacent elements in an array (`.strides`) is expressed as +an integer number of bytes. Relaxing this restriction would be a considerable +engineering project. These types therefore use an unpacked representation, where +each element of the array is padded up to a byte in memory. The lower two or four +bits of each byte contain the representation of the number, whereas the remaining +upper bits are ignored. + +## Quirks of low-precision Arithmetic + +If you're exploring the use of low-precision dtypes in your code, you should be +careful to anticipate when the precision loss might lead to surprising results. +One example is the behavior of aggregations like `sum`; consider this `bfloat16` +summation in NumPy (run with version 1.24.2): + +```python +>>> from ml_dtypes import bfloat16 +>>> import numpy as np +>>> rng = np.random.default_rng(seed=0) +>>> vals = rng.uniform(size=10000).astype(bfloat16) +>>> vals.sum() +256 +``` +The true sum should be close to 5000, but numpy returns exactly 256: this is +because `bfloat16` does not have the precision to increment `256` by values less than +`1`: + +```python +>>> bfloat16(256) + bfloat16(1) +256 +``` +After 256, the next representable value in bfloat16 is 258: + +```python +>>> np.nextafter(bfloat16(256), bfloat16(np.inf)) +258 +``` +For better results you can specify that the accumulation should happen in a +higher-precision type like `float32`: + +```python +>>> vals.sum(dtype='float32').astype(bfloat16) +4992 +``` +In contrast to NumPy, projects like [JAX](http://jax.readthedocs.io/) which support +low-precision arithmetic more natively will often do these kinds of higher-precision +accumulations automatically: + +```python +>>> import jax.numpy as jnp +>>> jnp.array(vals).sum() +Array(4992, dtype=bfloat16) +``` + +## License + +*This is not an officially supported Google product.* + +The `ml_dtypes` source code is licensed under the Apache 2.0 license +(see [LICENSE](LICENSE)). Pre-compiled wheels are built with the +[EIGEN](https://eigen.tuxfamily.org/) project, which is released under the +MPL 2.0 license (see [LICENSE.eigen](LICENSE.eigen)). diff --git a/venv/lib/python3.10/site-packages/ml_dtypes-0.5.3.dist-info/RECORD b/venv/lib/python3.10/site-packages/ml_dtypes-0.5.3.dist-info/RECORD new file mode 100644 index 0000000000000000000000000000000000000000..6454cc8cd5633ec680b7a401564c40506af983af --- /dev/null +++ b/venv/lib/python3.10/site-packages/ml_dtypes-0.5.3.dist-info/RECORD @@ -0,0 +1,15 @@ +ml_dtypes-0.5.3.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +ml_dtypes-0.5.3.dist-info/METADATA,sha256=AP6UiJqH2SsC226sSEHWCTA1Qcl5VEhyQa1PcPzJEdM,8908 +ml_dtypes-0.5.3.dist-info/RECORD,, +ml_dtypes-0.5.3.dist-info/WHEEL,sha256=E4jxqWWo-oN7V8aTy6AlKfktgDo_Lz3zWzf3Tmu_Jv8,152 +ml_dtypes-0.5.3.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358 +ml_dtypes-0.5.3.dist-info/licenses/LICENSE.eigen,sha256=Pz2eACSxkhsGfW9_iN60pgy-enjnbGTj8df8O3ebnQQ,16726 +ml_dtypes-0.5.3.dist-info/top_level.txt,sha256=meeeNkM1LLmTU5q_0ssFs21A_42VAoES24ntCrPqASw,10 +ml_dtypes/__init__.py,sha256=p5bpV3rsc3QawqGHZgsSli7C1R_fm1dRand2uP-WAEo,2357 +ml_dtypes/__pycache__/__init__.cpython-310.pyc,, +ml_dtypes/__pycache__/_finfo.cpython-310.pyc,, +ml_dtypes/__pycache__/_iinfo.cpython-310.pyc,, +ml_dtypes/_finfo.py,sha256=agzhqwMcsmP3hDT38Py77BipUqysCnrXExXj7h0ni_o,22899 +ml_dtypes/_iinfo.py,sha256=GIsAHpvzKH8Qd6puw8AfaHRG8hCMSbiakaHv0fGR9WM,2027 +ml_dtypes/_ml_dtypes_ext.cpython-310-x86_64-linux-gnu.so,sha256=B9jGuZ7L9Ts7uFp9Nyez3aSXkoyGPUNM-32r6PjMcWU,24549808 +ml_dtypes/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 diff --git a/venv/lib/python3.10/site-packages/ml_dtypes-0.5.3.dist-info/WHEEL b/venv/lib/python3.10/site-packages/ml_dtypes-0.5.3.dist-info/WHEEL new file mode 100644 index 0000000000000000000000000000000000000000..8ccd54d54b440c531af97ce94399f5e50e8d4237 --- /dev/null +++ b/venv/lib/python3.10/site-packages/ml_dtypes-0.5.3.dist-info/WHEEL @@ -0,0 +1,6 @@ +Wheel-Version: 1.0 +Generator: setuptools (80.8.0) +Root-Is-Purelib: false +Tag: cp310-cp310-manylinux_2_27_x86_64 +Tag: cp310-cp310-manylinux_2_28_x86_64 + diff --git a/venv/lib/python3.10/site-packages/ml_dtypes-0.5.3.dist-info/licenses/LICENSE b/venv/lib/python3.10/site-packages/ml_dtypes-0.5.3.dist-info/licenses/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..d645695673349e3947e8e5ae42332d0ac3164cd7 --- /dev/null +++ b/venv/lib/python3.10/site-packages/ml_dtypes-0.5.3.dist-info/licenses/LICENSE @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/venv/lib/python3.10/site-packages/ml_dtypes-0.5.3.dist-info/licenses/LICENSE.eigen b/venv/lib/python3.10/site-packages/ml_dtypes-0.5.3.dist-info/licenses/LICENSE.eigen new file mode 100644 index 0000000000000000000000000000000000000000..d0a1fa1482eea82e19510e7920cbe3a03e41f691 --- /dev/null +++ b/venv/lib/python3.10/site-packages/ml_dtypes-0.5.3.dist-info/licenses/LICENSE.eigen @@ -0,0 +1,373 @@ +Mozilla Public License Version 2.0 +================================== + +1. Definitions +-------------- + +1.1. "Contributor" + means each individual or legal entity that creates, contributes to + the creation of, or owns Covered Software. + +1.2. "Contributor Version" + means the combination of the Contributions of others (if any) used + by a Contributor and that particular Contributor's Contribution. + +1.3. "Contribution" + means Covered Software of a particular Contributor. + +1.4. "Covered Software" + means Source Code Form to which the initial Contributor has attached + the notice in Exhibit A, the Executable Form of such Source Code + Form, and Modifications of such Source Code Form, in each case + including portions thereof. + +1.5. "Incompatible With Secondary Licenses" + means + + (a) that the initial Contributor has attached the notice described + in Exhibit B to the Covered Software; or + + (b) that the Covered Software was made available under the terms of + version 1.1 or earlier of the License, but not also under the + terms of a Secondary License. + +1.6. "Executable Form" + means any form of the work other than Source Code Form. + +1.7. "Larger Work" + means a work that combines Covered Software with other material, in + a separate file or files, that is not Covered Software. + +1.8. "License" + means this document. + +1.9. "Licensable" + means having the right to grant, to the maximum extent possible, + whether at the time of the initial grant or subsequently, any and + all of the rights conveyed by this License. + +1.10. "Modifications" + means any of the following: + + (a) any file in Source Code Form that results from an addition to, + deletion from, or modification of the contents of Covered + Software; or + + (b) any new file in Source Code Form that contains any Covered + Software. + +1.11. "Patent Claims" of a Contributor + means any patent claim(s), including without limitation, method, + process, and apparatus claims, in any patent Licensable by such + Contributor that would be infringed, but for the grant of the + License, by the making, using, selling, offering for sale, having + made, import, or transfer of either its Contributions or its + Contributor Version. + +1.12. "Secondary License" + means either the GNU General Public License, Version 2.0, the GNU + Lesser General Public License, Version 2.1, the GNU Affero General + Public License, Version 3.0, or any later versions of those + licenses. + +1.13. "Source Code Form" + means the form of the work preferred for making modifications. + +1.14. "You" (or "Your") + means an individual or a legal entity exercising rights under this + License. For legal entities, "You" includes any entity that + controls, is controlled by, or is under common control with You. For + purposes of this definition, "control" means (a) the power, direct + or indirect, to cause the direction or management of such entity, + whether by contract or otherwise, or (b) ownership of more than + fifty percent (50%) of the outstanding shares or beneficial + ownership of such entity. + +2. License Grants and Conditions +-------------------------------- + +2.1. Grants + +Each Contributor hereby grants You a world-wide, royalty-free, +non-exclusive license: + +(a) under intellectual property rights (other than patent or trademark) + Licensable by such Contributor to use, reproduce, make available, + modify, display, perform, distribute, and otherwise exploit its + Contributions, either on an unmodified basis, with Modifications, or + as part of a Larger Work; and + +(b) under Patent Claims of such Contributor to make, use, sell, offer + for sale, have made, import, and otherwise transfer either its + Contributions or its Contributor Version. + +2.2. Effective Date + +The licenses granted in Section 2.1 with respect to any Contribution +become effective for each Contribution on the date the Contributor first +distributes such Contribution. + +2.3. Limitations on Grant Scope + +The licenses granted in this Section 2 are the only rights granted under +this License. No additional rights or licenses will be implied from the +distribution or licensing of Covered Software under this License. +Notwithstanding Section 2.1(b) above, no patent license is granted by a +Contributor: + +(a) for any code that a Contributor has removed from Covered Software; + or + +(b) for infringements caused by: (i) Your and any other third party's + modifications of Covered Software, or (ii) the combination of its + Contributions with other software (except as part of its Contributor + Version); or + +(c) under Patent Claims infringed by Covered Software in the absence of + its Contributions. + +This License does not grant any rights in the trademarks, service marks, +or logos of any Contributor (except as may be necessary to comply with +the notice requirements in Section 3.4). + +2.4. Subsequent Licenses + +No Contributor makes additional grants as a result of Your choice to +distribute the Covered Software under a subsequent version of this +License (see Section 10.2) or under the terms of a Secondary License (if +permitted under the terms of Section 3.3). + +2.5. Representation + +Each Contributor represents that the Contributor believes its +Contributions are its original creation(s) or it has sufficient rights +to grant the rights to its Contributions conveyed by this License. + +2.6. Fair Use + +This License is not intended to limit any rights You have under +applicable copyright doctrines of fair use, fair dealing, or other +equivalents. + +2.7. Conditions + +Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted +in Section 2.1. + +3. Responsibilities +------------------- + +3.1. Distribution of Source Form + +All distribution of Covered Software in Source Code Form, including any +Modifications that You create or to which You contribute, must be under +the terms of this License. You must inform recipients that the Source +Code Form of the Covered Software is governed by the terms of this +License, and how they can obtain a copy of this License. You may not +attempt to alter or restrict the recipients' rights in the Source Code +Form. + +3.2. Distribution of Executable Form + +If You distribute Covered Software in Executable Form then: + +(a) such Covered Software must also be made available in Source Code + Form, as described in Section 3.1, and You must inform recipients of + the Executable Form how they can obtain a copy of such Source Code + Form by reasonable means in a timely manner, at a charge no more + than the cost of distribution to the recipient; and + +(b) You may distribute such Executable Form under the terms of this + License, or sublicense it under different terms, provided that the + license for the Executable Form does not attempt to limit or alter + the recipients' rights in the Source Code Form under this License. + +3.3. Distribution of a Larger Work + +You may create and distribute a Larger Work under terms of Your choice, +provided that You also comply with the requirements of this License for +the Covered Software. If the Larger Work is a combination of Covered +Software with a work governed by one or more Secondary Licenses, and the +Covered Software is not Incompatible With Secondary Licenses, this +License permits You to additionally distribute such Covered Software +under the terms of such Secondary License(s), so that the recipient of +the Larger Work may, at their option, further distribute the Covered +Software under the terms of either this License or such Secondary +License(s). + +3.4. Notices + +You may not remove or alter the substance of any license notices +(including copyright notices, patent notices, disclaimers of warranty, +or limitations of liability) contained within the Source Code Form of +the Covered Software, except that You may alter any license notices to +the extent required to remedy known factual inaccuracies. + +3.5. Application of Additional Terms + +You may choose to offer, and to charge a fee for, warranty, support, +indemnity or liability obligations to one or more recipients of Covered +Software. However, You may do so only on Your own behalf, and not on +behalf of any Contributor. You must make it absolutely clear that any +such warranty, support, indemnity, or liability obligation is offered by +You alone, and You hereby agree to indemnify every Contributor for any +liability incurred by such Contributor as a result of warranty, support, +indemnity or liability terms You offer. You may include additional +disclaimers of warranty and limitations of liability specific to any +jurisdiction. + +4. Inability to Comply Due to Statute or Regulation +--------------------------------------------------- + +If it is impossible for You to comply with any of the terms of this +License with respect to some or all of the Covered Software due to +statute, judicial order, or regulation then You must: (a) comply with +the terms of this License to the maximum extent possible; and (b) +describe the limitations and the code they affect. Such description must +be placed in a text file included with all distributions of the Covered +Software under this License. Except to the extent prohibited by statute +or regulation, such description must be sufficiently detailed for a +recipient of ordinary skill to be able to understand it. + +5. Termination +-------------- + +5.1. The rights granted under this License will terminate automatically +if You fail to comply with any of its terms. However, if You become +compliant, then the rights granted under this License from a particular +Contributor are reinstated (a) provisionally, unless and until such +Contributor explicitly and finally terminates Your grants, and (b) on an +ongoing basis, if such Contributor fails to notify You of the +non-compliance by some reasonable means prior to 60 days after You have +come back into compliance. Moreover, Your grants from a particular +Contributor are reinstated on an ongoing basis if such Contributor +notifies You of the non-compliance by some reasonable means, this is the +first time You have received notice of non-compliance with this License +from such Contributor, and You become compliant prior to 30 days after +Your receipt of the notice. + +5.2. If You initiate litigation against any entity by asserting a patent +infringement claim (excluding declaratory judgment actions, +counter-claims, and cross-claims) alleging that a Contributor Version +directly or indirectly infringes any patent, then the rights granted to +You by any and all Contributors for the Covered Software under Section +2.1 of this License shall terminate. + +5.3. In the event of termination under Sections 5.1 or 5.2 above, all +end user license agreements (excluding distributors and resellers) which +have been validly granted by You or Your distributors under this License +prior to termination shall survive termination. + +************************************************************************ +* * +* 6. Disclaimer of Warranty * +* ------------------------- * +* * +* Covered Software is provided under this License on an "as is" * +* basis, without warranty of any kind, either expressed, implied, or * +* statutory, including, without limitation, warranties that the * +* Covered Software is free of defects, merchantable, fit for a * +* particular purpose or non-infringing. The entire risk as to the * +* quality and performance of the Covered Software is with You. * +* Should any Covered Software prove defective in any respect, You * +* (not any Contributor) assume the cost of any necessary servicing, * +* repair, or correction. This disclaimer of warranty constitutes an * +* essential part of this License. No use of any Covered Software is * +* authorized under this License except under this disclaimer. * +* * +************************************************************************ + +************************************************************************ +* * +* 7. Limitation of Liability * +* -------------------------- * +* * +* Under no circumstances and under no legal theory, whether tort * +* (including negligence), contract, or otherwise, shall any * +* Contributor, or anyone who distributes Covered Software as * +* permitted above, be liable to You for any direct, indirect, * +* special, incidental, or consequential damages of any character * +* including, without limitation, damages for lost profits, loss of * +* goodwill, work stoppage, computer failure or malfunction, or any * +* and all other commercial damages or losses, even if such party * +* shall have been informed of the possibility of such damages. This * +* limitation of liability shall not apply to liability for death or * +* personal injury resulting from such party's negligence to the * +* extent applicable law prohibits such limitation. Some * +* jurisdictions do not allow the exclusion or limitation of * +* incidental or consequential damages, so this exclusion and * +* limitation may not apply to You. * +* * +************************************************************************ + +8. Litigation +------------- + +Any litigation relating to this License may be brought only in the +courts of a jurisdiction where the defendant maintains its principal +place of business and such litigation shall be governed by laws of that +jurisdiction, without reference to its conflict-of-law provisions. +Nothing in this Section shall prevent a party's ability to bring +cross-claims or counter-claims. + +9. Miscellaneous +---------------- + +This License represents the complete agreement concerning the subject +matter hereof. If any provision of this License is held to be +unenforceable, such provision shall be reformed only to the extent +necessary to make it enforceable. Any law or regulation which provides +that the language of a contract shall be construed against the drafter +shall not be used to construe this License against a Contributor. + +10. Versions of the License +--------------------------- + +10.1. New Versions + +Mozilla Foundation is the license steward. Except as provided in Section +10.3, no one other than the license steward has the right to modify or +publish new versions of this License. Each version will be given a +distinguishing version number. + +10.2. Effect of New Versions + +You may distribute the Covered Software under the terms of the version +of the License under which You originally received the Covered Software, +or under the terms of any subsequent version published by the license +steward. + +10.3. Modified Versions + +If you create software not governed by this License, and you want to +create a new license for such software, you may create and use a +modified version of this License if you rename the license and remove +any references to the name of the license steward (except to note that +such modified license differs from this License). + +10.4. Distributing Source Code Form that is Incompatible With Secondary +Licenses + +If You choose to distribute Source Code Form that is Incompatible With +Secondary Licenses under the terms of this version of the License, the +notice described in Exhibit B of this License must be attached. + +Exhibit A - Source Code Form License Notice +------------------------------------------- + + This Source Code Form is subject to the terms of the Mozilla Public + License, v. 2.0. If a copy of the MPL was not distributed with this + file, You can obtain one at https://mozilla.org/MPL/2.0/. + +If it is not possible or desirable to put the notice in a particular +file, then You may include the notice in a location (such as a LICENSE +file in a relevant directory) where a recipient would be likely to look +for such a notice. + +You may add additional accurate notices of copyright ownership. + +Exhibit B - "Incompatible With Secondary Licenses" Notice +--------------------------------------------------------- + + This Source Code Form is "Incompatible With Secondary Licenses", as + defined by the Mozilla Public License, v. 2.0. diff --git a/venv/lib/python3.10/site-packages/ml_dtypes-0.5.3.dist-info/top_level.txt b/venv/lib/python3.10/site-packages/ml_dtypes-0.5.3.dist-info/top_level.txt new file mode 100644 index 0000000000000000000000000000000000000000..a65a36928cdc346035db028b8162cb4d637c763f --- /dev/null +++ b/venv/lib/python3.10/site-packages/ml_dtypes-0.5.3.dist-info/top_level.txt @@ -0,0 +1 @@ +ml_dtypes diff --git a/venv/lib/python3.10/site-packages/numexpr-2.11.0.dist-info/INSTALLER b/venv/lib/python3.10/site-packages/numexpr-2.11.0.dist-info/INSTALLER new file mode 100644 index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68 --- /dev/null +++ b/venv/lib/python3.10/site-packages/numexpr-2.11.0.dist-info/INSTALLER @@ -0,0 +1 @@ +pip diff --git a/venv/lib/python3.10/site-packages/numexpr-2.11.0.dist-info/METADATA b/venv/lib/python3.10/site-packages/numexpr-2.11.0.dist-info/METADATA new file mode 100644 index 0000000000000000000000000000000000000000..3d59908aee4fed9ef81dfc40e9261b23f21ccdde --- /dev/null +++ b/venv/lib/python3.10/site-packages/numexpr-2.11.0.dist-info/METADATA @@ -0,0 +1,233 @@ +Metadata-Version: 2.4 +Name: numexpr +Version: 2.11.0 +Summary: Fast numerical expression evaluator for NumPy +Author-email: "David M. Cooke, Francesc Alted, and others" +Maintainer-email: Blosc Development Team +License-Expression: MIT +Project-URL: homepage, https://github.com/pydata/numexpr +Project-URL: documentation, https://numexpr.readthedocs.io +Project-URL: repository, https://github.com/pydata/numexpr +Classifier: Development Status :: 6 - Mature +Classifier: Intended Audience :: Developers +Classifier: Intended Audience :: Information Technology +Classifier: Intended Audience :: Science/Research +Classifier: Programming Language :: Python +Classifier: Topic :: Software Development :: Libraries :: Python Modules +Classifier: Operating System :: Microsoft :: Windows +Classifier: Operating System :: Unix +Classifier: Programming Language :: Python :: 3 +Classifier: Programming Language :: Python :: 3.10 +Classifier: Programming Language :: Python :: 3.11 +Classifier: Programming Language :: Python :: 3.12 +Classifier: Programming Language :: Python :: 3.13 +Requires-Python: >=3.10 +Description-Content-Type: text/x-rst +License-File: LICENSE.txt +License-File: AUTHORS.txt +Requires-Dist: numpy>=1.23.0 +Dynamic: license-file + +====================================================== +NumExpr: Fast numerical expression evaluator for NumPy +====================================================== + +:Author: David M. Cooke, Francesc Alted, and others. +:Maintainer: Francesc Alted +:Contact: faltet@gmail.com +:URL: https://github.com/pydata/numexpr +:Documentation: http://numexpr.readthedocs.io/en/latest/ +:GitHub Actions: |actions| +:PyPi: |version| +:DOI: |doi| +:readthedocs: |docs| + +.. |actions| image:: https://github.com/pydata/numexpr/workflows/Build/badge.svg + :target: https://github.com/pydata/numexpr/actions +.. |travis| image:: https://travis-ci.org/pydata/numexpr.png?branch=master + :target: https://travis-ci.org/pydata/numexpr +.. |docs| image:: https://readthedocs.org/projects/numexpr/badge/?version=latest + :target: http://numexpr.readthedocs.io/en/latest +.. |doi| image:: https://zenodo.org/badge/doi/10.5281/zenodo.2483274.svg + :target: https://doi.org/10.5281/zenodo.2483274 +.. |version| image:: https://img.shields.io/pypi/v/numexpr + :target: https://pypi.python.org/pypi/numexpr + + +What is NumExpr? +---------------- + +NumExpr is a fast numerical expression evaluator for NumPy. With it, +expressions that operate on arrays (like :code:`'3*a+4*b'`) are accelerated +and use less memory than doing the same calculation in Python. + +In addition, its multi-threaded capabilities can make use of all your +cores -- which generally results in substantial performance scaling compared +to NumPy. + +Last but not least, numexpr can make use of Intel's VML (Vector Math +Library, normally integrated in its Math Kernel Library, or MKL). +This allows further acceleration of transcendent expressions. + + +How NumExpr achieves high performance +------------------------------------- + +The main reason why NumExpr achieves better performance than NumPy is +that it avoids allocating memory for intermediate results. This +results in better cache utilization and reduces memory access in +general. Due to this, NumExpr works best with large arrays. + +NumExpr parses expressions into its own op-codes that are then used by +an integrated computing virtual machine. The array operands are split +into small chunks that easily fit in the cache of the CPU and passed +to the virtual machine. The virtual machine then applies the +operations on each chunk. It's worth noting that all temporaries and +constants in the expression are also chunked. Chunks are distributed among +the available cores of the CPU, resulting in highly parallelized code +execution. + +The result is that NumExpr can get the most of your machine computing +capabilities for array-wise computations. Common speed-ups with regard +to NumPy are usually between 0.95x (for very simple expressions like +:code:`'a + 1'`) and 4x (for relatively complex ones like :code:`'a*b-4.1*a > 2.5*b'`), +although much higher speed-ups can be achieved for some functions and complex +math operations (up to 15x in some cases). + +NumExpr performs best on matrices that are too large to fit in L1 CPU cache. +In order to get a better idea on the different speed-ups that can be achieved +on your platform, run the provided benchmarks. + +Installation +------------ + +From wheels +^^^^^^^^^^^ + +NumExpr is available for install via `pip` for a wide range of platforms and +Python versions (which may be browsed at: https://pypi.org/project/numexpr/#files). +Installation can be performed as:: + + pip install numexpr + +If you are using the Anaconda or Miniconda distribution of Python you may prefer +to use the `conda` package manager in this case:: + + conda install numexpr + +From Source +^^^^^^^^^^^ + +On most \*nix systems your compilers will already be present. However if you +are using a virtual environment with a substantially newer version of Python than +your system Python you may be prompted to install a new version of `gcc` or `clang`. + +For Windows, you will need to install the Microsoft Visual C++ Build Tools +(which are free) first. The version depends on which version of Python you have +installed: + +https://wiki.python.org/moin/WindowsCompilers + +For Python 3.6+ simply installing the latest version of MSVC build tools should +be sufficient. Note that wheels found via pip do not include MKL support. Wheels +available via `conda` will have MKL, if the MKL backend is used for NumPy. + +See `requirements.txt` for the required version of NumPy. + +NumExpr is built in the standard Python way:: + + python setup.py build install + +You can test `numexpr` with:: + + python -c "import numexpr; numexpr.test()" + +Do not test NumExpr in the source directory or you will generate import errors. + +Enable Intel® MKL support +^^^^^^^^^^^^^^^^^^^^^^^^^ + +NumExpr includes support for Intel's MKL library. This may provide better +performance on Intel architectures, mainly when evaluating transcendental +functions (trigonometrical, exponential, ...). + +If you have Intel's MKL, copy the `site.cfg.example` that comes with the +distribution to `site.cfg` and edit the latter file to provide correct paths to +the MKL libraries in your system. After doing this, you can proceed with the +usual building instructions listed above. + +Pay attention to the messages during the building process in order to know +whether MKL has been detected or not. Finally, you can check the speed-ups on +your machine by running the `bench/vml_timing.py` script (you can play with +different parameters to the `set_vml_accuracy_mode()` and `set_vml_num_threads()` +functions in the script so as to see how it would affect performance). + +Usage +----- + +:: + + >>> import numpy as np + >>> import numexpr as ne + + >>> a = np.arange(1e6) # Choose large arrays for better speedups + >>> b = np.arange(1e6) + + >>> ne.evaluate("a + 1") # a simple expression + array([ 1.00000000e+00, 2.00000000e+00, 3.00000000e+00, ..., + 9.99998000e+05, 9.99999000e+05, 1.00000000e+06]) + + >>> ne.evaluate("a * b - 4.1 * a > 2.5 * b") # a more complex one + array([False, False, False, ..., True, True, True], dtype=bool) + + >>> ne.evaluate("sin(a) + arcsinh(a/b)") # you can also use functions + array([ NaN, 1.72284457, 1.79067101, ..., 1.09567006, + 0.17523598, -0.09597844]) + + >>> s = np.array([b'abba', b'abbb', b'abbcdef']) + >>> ne.evaluate("b'abba' == s") # string arrays are supported too + array([ True, False, False], dtype=bool) + + +Free-threading support +---------------------- +Starting on CPython 3.13 onwards there is a new distribution that disables the +Global Interpreter Lock (GIL) altogether, thus increasing the performance yields +under multi-threaded conditions on a single interpreter, as opposed to having to use +multiprocessing. + +Whilst numexpr has been demonstrated to work under free-threaded +CPython, considerations need to be taken when using numexpr native parallel +implementation vs using Python threads directly in order to prevent oversubscription, +we recommend either using the main CPython interpreter thread to spawn multiple C threads +using the parallel numexpr API, or spawning multiple CPython threads that do not use +the parallel API. + +For more information about free-threaded CPython, we recommend visiting the following +`community Wiki ` + + +Documentation +------------- + +Please see the official documentation at `numexpr.readthedocs.io `_. +Included is a user guide, benchmark results, and the reference API. + + +Authors +------- + +Please see `AUTHORS.txt `_. + + +License +------- + +NumExpr is distributed under the `MIT `_ license. + + +.. Local Variables: +.. mode: text +.. coding: utf-8 +.. fill-column: 70 +.. End: diff --git a/venv/lib/python3.10/site-packages/numexpr-2.11.0.dist-info/RECORD b/venv/lib/python3.10/site-packages/numexpr-2.11.0.dist-info/RECORD new file mode 100644 index 0000000000000000000000000000000000000000..2766dba4869b46f81093f80d849137defabd3446 --- /dev/null +++ b/venv/lib/python3.10/site-packages/numexpr-2.11.0.dist-info/RECORD @@ -0,0 +1,43 @@ +numexpr-2.11.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +numexpr-2.11.0.dist-info/METADATA,sha256=Y-Jc2hBPJ5kcsl00A8euyDUiNd1jWSJZkmQXZ1XJ8yc,8991 +numexpr-2.11.0.dist-info/RECORD,, +numexpr-2.11.0.dist-info/WHEEL,sha256=Obtqci3x5vy5ZivY2BiOH9GHO8-xQ0d4HFhTOtXMNhw,152 +numexpr-2.11.0.dist-info/licenses/AUTHORS.txt,sha256=hRcPsBOGO_kZ00euuf30KK3zg5bsa6wJ88Rl-WSg_DY,1052 +numexpr-2.11.0.dist-info/licenses/LICENSE.txt,sha256=A_3YAlpObXDK8ncg6Rp5rY2f5CLr4YIPXOxh3OrnCf8,1193 +numexpr-2.11.0.dist-info/top_level.txt,sha256=5R5OAhc7k6sUajqt4vp-368lWWhb23CoC6LltIMNqNA,8 +numexpr/__init__.py,sha256=2Ud-a2wLTXqU1NaxQOUobQ_PA9_aldAuLw44np5lVSA,2340 +numexpr/__pycache__/__init__.cpython-310.pyc,, +numexpr/__pycache__/cpuinfo.cpython-310.pyc,, +numexpr/__pycache__/expressions.cpython-310.pyc,, +numexpr/__pycache__/necompiler.cpython-310.pyc,, +numexpr/__pycache__/utils.cpython-310.pyc,, +numexpr/__pycache__/version.cpython-310.pyc,, +numexpr/complex_functions.hpp,sha256=r1chzJDf4JDzgVkCtSujVkY3RQ7GPMQnQSQH2g433dM,9665 +numexpr/cpuinfo.py,sha256=KxTMrTOWPeBwE4OUI0qlsVh7fwenpojUn1nBnEolWv4,25176 +numexpr/expressions.py,sha256=undv6hchoCS8xl2Ka9k07X2TTX47DfW7_pH7mTdN3YY,16134 +numexpr/functions.hpp,sha256=fQ9AV-PA9GxtsRFV2BnUw8kIUXbmMaoGvIfldFF1M_g,5723 +numexpr/interp_body.cpp,sha256=NnbZLzKumyhkSACFibD1PG_tDek3kbCQulhVs27Q2T8,21264 +numexpr/interpreter.cpp,sha256=AjLPGDwrIGD9P4hpV2Ju3Hz2HFTbIFvCAwliSsVE0rQ,48605 +numexpr/interpreter.cpython-310-x86_64-linux-gnu.so,sha256=-5yV2Gh-jkwcw-V4dBawsa4MTUVap9F8Y9M_D7eiDrQ,1034936 +numexpr/interpreter.hpp,sha256=momqy781Ty8YmNoZ_QcZQXmbXXQPLHDK6Zmnk40MtLs,2707 +numexpr/missing_posix_functions.hpp,sha256=WXoxONhxMSh8tbYhP_n4g2NdxOtZUiuCeF_e-J3aYFY,1950 +numexpr/module.cpp,sha256=ouvqiQeODCsNwh54Kj5J6-JndXyXhL9D-P8gY2v5ovE,16467 +numexpr/module.hpp,sha256=E6OXYHYhr-X_RVjDfBkRqY2CF8PSdQdrOOuVCOJrvrY,2259 +numexpr/msvc_function_stubs.hpp,sha256=pudOWD7OL3YySsZklJjh7EBrbXqOIpS9x32BJzbmHhA,3470 +numexpr/necompiler.py,sha256=EeBMgiwPMVREf2B-Tqao2pJnnhJoNbvT4-0rqOeME2I,34703 +numexpr/numexpr_config.hpp,sha256=W4H8DNPjjxGAYzEKUwIV5l1hwWKGgBLogasx_99DV1A,1379 +numexpr/numexpr_object.cpp,sha256=uhci43cDrzfG0oKjOlladrIyp7HPo-NxYTnnNdBoGQU,14632 +numexpr/numexpr_object.hpp,sha256=Hmxg9M1QDvaHHtjtK0KPlx1Tzm2ljWKpSlIAKbmgBUc,1069 +numexpr/opcodes.hpp,sha256=kRyOYa_teL9FQrEQ2M3Smn6KJ4T3cLWLv92jkOo2vqQ,7310 +numexpr/str-two-way.hpp,sha256=5Xx1tUeykTd5IcyTKU95XlpbGZS1qXIvlvJwjY6RZKM,14428 +numexpr/tests/__init__.py,sha256=kYHHISmkAW8b-mKjJUxPq40phcMNmABbdtIvyjOG6W4,447 +numexpr/tests/__pycache__/__init__.cpython-310.pyc,, +numexpr/tests/__pycache__/conftest.cpython-310.pyc,, +numexpr/tests/__pycache__/test_numexpr.cpython-310.pyc,, +numexpr/tests/conftest.py,sha256=Y5SlvN82FCf3g3xg-JpXG-0ub5HsED1vGr4og63mUvs,507 +numexpr/tests/test_numexpr.py,sha256=6jOm5hmWWqB2lwslKKM868NwGAkd6wslsG_t0BVy4mw,53865 +numexpr/utils.py,sha256=cDFybn0EjdxBR27i3gPvW323sp9gotP9QQsvmG2Umxg,9879 +numexpr/version.py,sha256=IU9-jzfd6_8_uBoBtF0ZGvLcE3frIk4TDGfGUe-oiaw,139 +numexpr/win32/pthread.c,sha256=SIgmoRef_zrFaEu636rnm8gChw5WtAf69AJ8osv3K-Y,7085 +numexpr/win32/pthread.h,sha256=cgim1vljQIIGZKjcszJKaPO5KkNGcl9l9-_1_GwaGDQ,4036 +numexpr/win32/stdint.h,sha256=HbEg0tvCzt9OdAjIq1aAfExftQ8SBlDqSDm59ddGhxc,7324 diff --git a/venv/lib/python3.10/site-packages/numexpr-2.11.0.dist-info/WHEEL b/venv/lib/python3.10/site-packages/numexpr-2.11.0.dist-info/WHEEL new file mode 100644 index 0000000000000000000000000000000000000000..12e67ca29ff180ca4133d9ec4769226edb266ce4 --- /dev/null +++ b/venv/lib/python3.10/site-packages/numexpr-2.11.0.dist-info/WHEEL @@ -0,0 +1,6 @@ +Wheel-Version: 1.0 +Generator: setuptools (80.9.0) +Root-Is-Purelib: false +Tag: cp310-cp310-manylinux_2_27_x86_64 +Tag: cp310-cp310-manylinux_2_28_x86_64 + diff --git a/venv/lib/python3.10/site-packages/numexpr-2.11.0.dist-info/licenses/AUTHORS.txt b/venv/lib/python3.10/site-packages/numexpr-2.11.0.dist-info/licenses/AUTHORS.txt new file mode 100644 index 0000000000000000000000000000000000000000..57410db9710b2ccfcea423408e2c90812ce99762 --- /dev/null +++ b/venv/lib/python3.10/site-packages/numexpr-2.11.0.dist-info/licenses/AUTHORS.txt @@ -0,0 +1,31 @@ +Numexpr was initially written by David Cooke, and extended to more +types by Tim Hochberg. + +Francesc Alted contributed support for booleans and simple-precision +floating point types, efficient strided and unaligned array operations +and multi-threading code. + +Ivan Vilata contributed support for strings. + +Gregor Thalhammer implemented the support for Intel VML (Vector Math +Library). + +Mark Wiebe added support for the new iterator in NumPy, which allows +for better performance in more scenarios (like broadcasting, +fortran-ordered or non-native byte orderings). + +Gaëtan de Menten contributed important bug fixes and speed +enhancements. + +Antonio Valentino contributed the port to Python 3. + +Google Inc. contributed bug fixes. + +David Cox improved readability of the Readme. + +Robert A. McLeod contributed bug fixes and ported the documentation to +numexpr.readthedocs.io. He has served as the maintainer of the package +since 2016 to 2023. + +Teng Liu fixed many bugs, and in particular, contributed valuable fixes +to the new regex sanitizer for expressions. diff --git a/venv/lib/python3.10/site-packages/numexpr-2.11.0.dist-info/licenses/LICENSE.txt b/venv/lib/python3.10/site-packages/numexpr-2.11.0.dist-info/licenses/LICENSE.txt new file mode 100644 index 0000000000000000000000000000000000000000..de9a582603ca6aa895136e2b118443e9397897da --- /dev/null +++ b/venv/lib/python3.10/site-packages/numexpr-2.11.0.dist-info/licenses/LICENSE.txt @@ -0,0 +1,21 @@ +Copyright (c) 2007,2008 David M. Cooke +Copyright (c) 2009,2010 Francesc Alted +Copyright (c) 2011- See AUTHORS.txt + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. diff --git a/venv/lib/python3.10/site-packages/numexpr-2.11.0.dist-info/top_level.txt b/venv/lib/python3.10/site-packages/numexpr-2.11.0.dist-info/top_level.txt new file mode 100644 index 0000000000000000000000000000000000000000..ba1904bf1533907788338997eb320918b2578528 --- /dev/null +++ b/venv/lib/python3.10/site-packages/numexpr-2.11.0.dist-info/top_level.txt @@ -0,0 +1 @@ +numexpr diff --git a/venv/lib/python3.10/site-packages/nvidia_nccl_cu12-2.21.5.dist-info/INSTALLER b/venv/lib/python3.10/site-packages/nvidia_nccl_cu12-2.21.5.dist-info/INSTALLER new file mode 100644 index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68 --- /dev/null +++ b/venv/lib/python3.10/site-packages/nvidia_nccl_cu12-2.21.5.dist-info/INSTALLER @@ -0,0 +1 @@ +pip diff --git a/venv/lib/python3.10/site-packages/nvidia_nccl_cu12-2.21.5.dist-info/License.txt b/venv/lib/python3.10/site-packages/nvidia_nccl_cu12-2.21.5.dist-info/License.txt new file mode 100644 index 0000000000000000000000000000000000000000..e318c666958b8bd82e56ef2c4314f67c3ba80b48 --- /dev/null +++ b/venv/lib/python3.10/site-packages/nvidia_nccl_cu12-2.21.5.dist-info/License.txt @@ -0,0 +1,31 @@ + + Copyright (c) 2015-2019, NVIDIA CORPORATION. All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions + are met: + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + * Neither the name of NVIDIA CORPORATION, Lawrence Berkeley National + Laboratory, the U.S. Department of Energy, nor the names of their + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY + EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + The U.S. Department of Energy funded the development of this software + under subcontract 7078610 with Lawrence Berkeley National Laboratory. + diff --git a/venv/lib/python3.10/site-packages/nvidia_nccl_cu12-2.21.5.dist-info/METADATA b/venv/lib/python3.10/site-packages/nvidia_nccl_cu12-2.21.5.dist-info/METADATA new file mode 100644 index 0000000000000000000000000000000000000000..2f3b7f31e80a2312665a165948f3e84ea943a978 --- /dev/null +++ b/venv/lib/python3.10/site-packages/nvidia_nccl_cu12-2.21.5.dist-info/METADATA @@ -0,0 +1,35 @@ +Metadata-Version: 2.1 +Name: nvidia-nccl-cu12 +Version: 2.21.5 +Summary: NVIDIA Collective Communication Library (NCCL) Runtime +Home-page: https://developer.nvidia.com/cuda-zone +Author: Nvidia CUDA Installer Team +Author-email: cuda_installer@nvidia.com +License: NVIDIA Proprietary Software +Keywords: cuda,nvidia,runtime,machine learning,deep learning +Classifier: Development Status :: 4 - Beta +Classifier: Intended Audience :: Developers +Classifier: Intended Audience :: Education +Classifier: Intended Audience :: Science/Research +Classifier: License :: Other/Proprietary License +Classifier: Natural Language :: English +Classifier: Programming Language :: Python :: 3 +Classifier: Programming Language :: Python :: 3.5 +Classifier: Programming Language :: Python :: 3.6 +Classifier: Programming Language :: Python :: 3.7 +Classifier: Programming Language :: Python :: 3.8 +Classifier: Programming Language :: Python :: 3.9 +Classifier: Programming Language :: Python :: 3.10 +Classifier: Programming Language :: Python :: 3.11 +Classifier: Programming Language :: Python :: 3 :: Only +Classifier: Topic :: Scientific/Engineering +Classifier: Topic :: Scientific/Engineering :: Mathematics +Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence +Classifier: Topic :: Software Development +Classifier: Topic :: Software Development :: Libraries +Classifier: Operating System :: Microsoft :: Windows +Classifier: Operating System :: POSIX :: Linux +Requires-Python: >=3 +License-File: License.txt + +NCCL (pronounced "Nickel") is a stand-alone library of standard collective communication routines for GPUs, implementing all-reduce, all-gather, reduce, broadcast, and reduce-scatter. It has been optimized to achieve high bandwidth on any platform using PCIe, NVLink, NVswitch, as well as networking using InfiniBand Verbs or TCP/IP sockets. diff --git a/venv/lib/python3.10/site-packages/nvidia_nccl_cu12-2.21.5.dist-info/RECORD b/venv/lib/python3.10/site-packages/nvidia_nccl_cu12-2.21.5.dist-info/RECORD new file mode 100644 index 0000000000000000000000000000000000000000..c53f9bf022b12ab1420e4903686e7f81e179af92 --- /dev/null +++ b/venv/lib/python3.10/site-packages/nvidia_nccl_cu12-2.21.5.dist-info/RECORD @@ -0,0 +1,17 @@ +nvidia/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +nvidia/__pycache__/__init__.cpython-310.pyc,, +nvidia/nccl/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +nvidia/nccl/__pycache__/__init__.cpython-310.pyc,, +nvidia/nccl/include/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +nvidia/nccl/include/__pycache__/__init__.cpython-310.pyc,, +nvidia/nccl/include/nccl.h,sha256=LOTwUlbIa2tBwr21EwJTDUUek6el_KQxau6MTCVkZZo,18589 +nvidia/nccl/include/nccl_net.h,sha256=Q2yMEZBE6uKkX_nduRb3TaU64hC1jjOMstCypTKGSdk,25896 +nvidia/nccl/lib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +nvidia/nccl/lib/__pycache__/__init__.cpython-310.pyc,, +nvidia/nccl/lib/libnccl.so.2,sha256=eN8vMfbbgULsVGoeWjHLBm94ktEtL2ZbRI-AaaCO-Ac,251616632 +nvidia_nccl_cu12-2.21.5.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +nvidia_nccl_cu12-2.21.5.dist-info/License.txt,sha256=92n6LTYyE_WZNm2kbiqNZQyG6q6EWuxNRLL1_QHU7Fk,1735 +nvidia_nccl_cu12-2.21.5.dist-info/METADATA,sha256=xTdJK3TpvqhmF4iFEMsBz3H7wjXhXKNGpIaS5fJRYEk,1834 +nvidia_nccl_cu12-2.21.5.dist-info/RECORD,, +nvidia_nccl_cu12-2.21.5.dist-info/WHEEL,sha256=XDTs3wIbcE-BcRO08VJlZpA6z9OaC1mOKPCGGGwuM2g,109 +nvidia_nccl_cu12-2.21.5.dist-info/top_level.txt,sha256=fTkAtiFuL16nUrB9ytDDtpytz2t0B4NvYTnRzwAhO14,7 diff --git a/venv/lib/python3.10/site-packages/nvidia_nccl_cu12-2.21.5.dist-info/WHEEL b/venv/lib/python3.10/site-packages/nvidia_nccl_cu12-2.21.5.dist-info/WHEEL new file mode 100644 index 0000000000000000000000000000000000000000..e6c30e957cfb045017a9fef3430bb8ee87c4a074 --- /dev/null +++ b/venv/lib/python3.10/site-packages/nvidia_nccl_cu12-2.21.5.dist-info/WHEEL @@ -0,0 +1,5 @@ +Wheel-Version: 1.0 +Generator: bdist_wheel (0.42.0) +Root-Is-Purelib: true +Tag: py3-none-manylinux2014_x86_64 + diff --git a/venv/lib/python3.10/site-packages/nvidia_nccl_cu12-2.21.5.dist-info/top_level.txt b/venv/lib/python3.10/site-packages/nvidia_nccl_cu12-2.21.5.dist-info/top_level.txt new file mode 100644 index 0000000000000000000000000000000000000000..862f7abf232cdfbb928609856247292e81c9decb --- /dev/null +++ b/venv/lib/python3.10/site-packages/nvidia_nccl_cu12-2.21.5.dist-info/top_level.txt @@ -0,0 +1 @@ +nvidia diff --git a/venv/lib/python3.10/site-packages/opentelemetry_api-1.26.0.dist-info/INSTALLER b/venv/lib/python3.10/site-packages/opentelemetry_api-1.26.0.dist-info/INSTALLER new file mode 100644 index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68 --- /dev/null +++ b/venv/lib/python3.10/site-packages/opentelemetry_api-1.26.0.dist-info/INSTALLER @@ -0,0 +1 @@ +pip diff --git a/venv/lib/python3.10/site-packages/opentelemetry_api-1.26.0.dist-info/METADATA b/venv/lib/python3.10/site-packages/opentelemetry_api-1.26.0.dist-info/METADATA new file mode 100644 index 0000000000000000000000000000000000000000..ba05c9ac3717b3c94bff6ff01c26e71933a6c485 --- /dev/null +++ b/venv/lib/python3.10/site-packages/opentelemetry_api-1.26.0.dist-info/METADATA @@ -0,0 +1,44 @@ +Metadata-Version: 2.3 +Name: opentelemetry-api +Version: 1.26.0 +Summary: OpenTelemetry Python API +Project-URL: Homepage, https://github.com/open-telemetry/opentelemetry-python/tree/main/opentelemetry-api +Author-email: OpenTelemetry Authors +License: Apache-2.0 +License-File: LICENSE +Classifier: Development Status :: 5 - Production/Stable +Classifier: Framework :: OpenTelemetry +Classifier: Intended Audience :: Developers +Classifier: License :: OSI Approved :: Apache Software License +Classifier: Programming Language :: Python +Classifier: Programming Language :: Python :: 3 +Classifier: Programming Language :: Python :: 3.8 +Classifier: Programming Language :: Python :: 3.9 +Classifier: Programming Language :: Python :: 3.10 +Classifier: Programming Language :: Python :: 3.11 +Classifier: Programming Language :: Python :: 3.12 +Classifier: Typing :: Typed +Requires-Python: >=3.8 +Requires-Dist: deprecated>=1.2.6 +Requires-Dist: importlib-metadata<=8.0.0,>=6.0 +Description-Content-Type: text/x-rst + +OpenTelemetry Python API +============================================================================ + +|pypi| + +.. |pypi| image:: https://badge.fury.io/py/opentelemetry-api.svg + :target: https://pypi.org/project/opentelemetry-api/ + +Installation +------------ + +:: + + pip install opentelemetry-api + +References +---------- + +* `OpenTelemetry Project `_ diff --git a/venv/lib/python3.10/site-packages/opentelemetry_api-1.26.0.dist-info/RECORD b/venv/lib/python3.10/site-packages/opentelemetry_api-1.26.0.dist-info/RECORD new file mode 100644 index 0000000000000000000000000000000000000000..906c51006aef78c848fafbeb6fa9c3f8b9ecfce4 --- /dev/null +++ b/venv/lib/python3.10/site-packages/opentelemetry_api-1.26.0.dist-info/RECORD @@ -0,0 +1,75 @@ +opentelemetry/_logs/__init__.py,sha256=3N1oc68Iuhy17DTnXrfh5xo_BonRD43t-xymZ8S1Vjk,1906 +opentelemetry/_logs/__pycache__/__init__.cpython-310.pyc,, +opentelemetry/_logs/_internal/__init__.py,sha256=xPdGWkQZksixgsw7l3mkv5JgT6JUU7uUN9qTuaTx_JI,9797 +opentelemetry/_logs/_internal/__pycache__/__init__.cpython-310.pyc,, +opentelemetry/_logs/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +opentelemetry/_logs/severity/__init__.py,sha256=GIZVyH_D2_D7YOfX66T0EZnBEFT7HZeioD8FlHUu0Rs,3374 +opentelemetry/_logs/severity/__pycache__/__init__.cpython-310.pyc,, +opentelemetry/attributes/__init__.py,sha256=kkkUh93lZCag0MVrsDdqz5tBsQhwVRBnsftB2J-SsAw,6810 +opentelemetry/attributes/__pycache__/__init__.cpython-310.pyc,, +opentelemetry/attributes/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +opentelemetry/baggage/__init__.py,sha256=SDIJxXMfBQPkDBz4i-6nFLWeNvYLIHyqNYNXRsNsJDE,3875 +opentelemetry/baggage/__pycache__/__init__.cpython-310.pyc,, +opentelemetry/baggage/propagation/__init__.py,sha256=FA2U9YyZ5IObWJVX31NUU7ouKYaM0JdUY3kdiRT6PH0,4687 +opentelemetry/baggage/propagation/__pycache__/__init__.cpython-310.pyc,, +opentelemetry/baggage/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +opentelemetry/context/__init__.py,sha256=4-JTgVyxPXnqcW8yfVQfqTqiff5mDWs0gdPOMHcFzzk,5512 +opentelemetry/context/__pycache__/__init__.cpython-310.pyc,, +opentelemetry/context/__pycache__/context.cpython-310.pyc,, +opentelemetry/context/__pycache__/contextvars_context.cpython-310.pyc,, +opentelemetry/context/context.py,sha256=NamBGlAlwMmplU4U8tgJXXIONfrGWdNunSJ99icHumA,1632 +opentelemetry/context/contextvars_context.py,sha256=gtLd8IBhpRk1L3BJJmeITiQzat2lWZTBwZmjT9PXvy8,1785 +opentelemetry/context/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +opentelemetry/environment_variables/__init__.py,sha256=yd2jBBYiUb6iLD6ErT3DRMD3_W5iRxWxN0LxD2UHgw0,2367 +opentelemetry/environment_variables/__pycache__/__init__.cpython-310.pyc,, +opentelemetry/environment_variables/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +opentelemetry/metrics/__init__.py,sha256=pFuGAnERjDAMZehw9nyzkwYqO12PbSzpDcRK77oVtvM,3694 +opentelemetry/metrics/__pycache__/__init__.cpython-310.pyc,, +opentelemetry/metrics/_internal/__init__.py,sha256=m4xeJyEo2JJrWY7SZZo8WKQIC-6By2nv2oUegkZSzTw,28579 +opentelemetry/metrics/_internal/__pycache__/__init__.cpython-310.pyc,, +opentelemetry/metrics/_internal/__pycache__/instrument.cpython-310.pyc,, +opentelemetry/metrics/_internal/__pycache__/observation.cpython-310.pyc,, +opentelemetry/metrics/_internal/instrument.py,sha256=eNiC1EmXIqAYZHXo9DkJ7oY0DZqhuPO8aLScGnDlVvE,12647 +opentelemetry/metrics/_internal/observation.py,sha256=WrzGscBXf_dboUhK3veiOUrJ9N7UUCvwqzJ0OIpXnuU,1600 +opentelemetry/metrics/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +opentelemetry/propagate/__init__.py,sha256=NNyEsHGS8i30_1ZY2hKUjzZuAU3QI1Ts32DPp0LLhzE,5702 +opentelemetry/propagate/__pycache__/__init__.cpython-310.pyc,, +opentelemetry/propagate/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +opentelemetry/propagators/__pycache__/composite.cpython-310.pyc,, +opentelemetry/propagators/__pycache__/textmap.cpython-310.pyc,, +opentelemetry/propagators/composite.py,sha256=EgdgEbaNEN7g-XNGXR9YEO8akBv7eOWzA4pKyhDXVxc,3255 +opentelemetry/propagators/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +opentelemetry/propagators/textmap.py,sha256=d9j28pychplbPs6bRjSDERzQJVf6IS6LpOrMtLP6Ibk,6642 +opentelemetry/trace/__init__.py,sha256=-fr2-qstFMozxCQnpJEH8Egui4dDhYmBEG2AKAbXktw,22539 +opentelemetry/trace/__pycache__/__init__.cpython-310.pyc,, +opentelemetry/trace/__pycache__/span.cpython-310.pyc,, +opentelemetry/trace/__pycache__/status.cpython-310.pyc,, +opentelemetry/trace/propagation/__init__.py,sha256=YZMj0p-IcgBkyBfcZN0xO-3iUxi65Z8_zaIZGXRu5Q4,1684 +opentelemetry/trace/propagation/__pycache__/__init__.cpython-310.pyc,, +opentelemetry/trace/propagation/__pycache__/tracecontext.cpython-310.pyc,, +opentelemetry/trace/propagation/tracecontext.py,sha256=enrv8I99529sQcvokscqfZyY_Z6GblgV3r2W-rjxLTA,4178 +opentelemetry/trace/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +opentelemetry/trace/span.py,sha256=rZFqBSqqIY4GCfJbLx6PTBhTUPZZ_AvIBY_3f3A0-a0,19562 +opentelemetry/trace/status.py,sha256=2K7fRLV7gDFAgpFA4AvMTjJfEUfyZjFa2PQ3VjjHBHE,2539 +opentelemetry/util/__pycache__/_decorator.cpython-310.pyc,, +opentelemetry/util/__pycache__/_importlib_metadata.cpython-310.pyc,, +opentelemetry/util/__pycache__/_once.cpython-310.pyc,, +opentelemetry/util/__pycache__/_providers.cpython-310.pyc,, +opentelemetry/util/__pycache__/re.cpython-310.pyc,, +opentelemetry/util/__pycache__/types.cpython-310.pyc,, +opentelemetry/util/_decorator.py,sha256=mCnpQKrq-WlzGHYkZWcMhk7kMp-pBYtMr3eganoFhgU,3221 +opentelemetry/util/_importlib_metadata.py,sha256=Q-z72Ffut5iY0jdxDjgQyBrb6NYpUFKMEma4DEVCuxM,1135 +opentelemetry/util/_once.py,sha256=qTsPYBYopTsAtVthY88gd8EQR6jNe-yWzZB353_REDY,1440 +opentelemetry/util/_providers.py,sha256=bG6rJlNAr-QMv6WHYCdMlEW4QqI9PkoIkWBzlxhok1I,1731 +opentelemetry/util/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +opentelemetry/util/re.py,sha256=JhahUT7wybSbuWpmpQajxwW0ANHxda4eAQ1-mML3sZc,3057 +opentelemetry/util/types.py,sha256=a9i0orW124UkS48cDIa0PDZOsjbx1weHHNJp3gGjlQc,1167 +opentelemetry/version/__init__.py,sha256=ANYEMcxW_7kp7m-QhNKZUKat8Jf1JBtQ3N9YJF-3SLU,608 +opentelemetry/version/__pycache__/__init__.cpython-310.pyc,, +opentelemetry/version/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +opentelemetry_api-1.26.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +opentelemetry_api-1.26.0.dist-info/METADATA,sha256=v_5MQW78-7iCufJdJemvmHVikTi3iZ8CtfWLA4QiHtU,1420 +opentelemetry_api-1.26.0.dist-info/RECORD,, +opentelemetry_api-1.26.0.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87 +opentelemetry_api-1.26.0.dist-info/entry_points.txt,sha256=dxPq0YRbQDSwl8QkR-I9A38rbbfKQG5h2uNFjpvU6V4,573 +opentelemetry_api-1.26.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357 diff --git a/venv/lib/python3.10/site-packages/opentelemetry_api-1.26.0.dist-info/WHEEL b/venv/lib/python3.10/site-packages/opentelemetry_api-1.26.0.dist-info/WHEEL new file mode 100644 index 0000000000000000000000000000000000000000..cdd68a497cdfa8d3f2b837225beacef711b85047 --- /dev/null +++ b/venv/lib/python3.10/site-packages/opentelemetry_api-1.26.0.dist-info/WHEEL @@ -0,0 +1,4 @@ +Wheel-Version: 1.0 +Generator: hatchling 1.25.0 +Root-Is-Purelib: true +Tag: py3-none-any diff --git a/venv/lib/python3.10/site-packages/opentelemetry_api-1.26.0.dist-info/entry_points.txt b/venv/lib/python3.10/site-packages/opentelemetry_api-1.26.0.dist-info/entry_points.txt new file mode 100644 index 0000000000000000000000000000000000000000..627961628b2a3b93ebf1469e89de97ccfffb7d94 --- /dev/null +++ b/venv/lib/python3.10/site-packages/opentelemetry_api-1.26.0.dist-info/entry_points.txt @@ -0,0 +1,15 @@ +[opentelemetry_context] +contextvars_context = opentelemetry.context.contextvars_context:ContextVarsRuntimeContext + +[opentelemetry_environment_variables] +api = opentelemetry.environment_variables + +[opentelemetry_meter_provider] +default_meter_provider = opentelemetry.metrics:NoOpMeterProvider + +[opentelemetry_propagator] +baggage = opentelemetry.baggage.propagation:W3CBaggagePropagator +tracecontext = opentelemetry.trace.propagation.tracecontext:TraceContextTextMapPropagator + +[opentelemetry_tracer_provider] +default_tracer_provider = opentelemetry.trace:NoOpTracerProvider diff --git a/venv/lib/python3.10/site-packages/opentelemetry_api-1.26.0.dist-info/licenses/LICENSE b/venv/lib/python3.10/site-packages/opentelemetry_api-1.26.0.dist-info/licenses/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64 --- /dev/null +++ b/venv/lib/python3.10/site-packages/opentelemetry_api-1.26.0.dist-info/licenses/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/venv/lib/python3.10/site-packages/opentelemetry_semantic_conventions_ai-0.4.12.dist-info/INSTALLER b/venv/lib/python3.10/site-packages/opentelemetry_semantic_conventions_ai-0.4.12.dist-info/INSTALLER new file mode 100644 index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68 --- /dev/null +++ b/venv/lib/python3.10/site-packages/opentelemetry_semantic_conventions_ai-0.4.12.dist-info/INSTALLER @@ -0,0 +1 @@ +pip diff --git a/venv/lib/python3.10/site-packages/opentelemetry_semantic_conventions_ai-0.4.12.dist-info/METADATA b/venv/lib/python3.10/site-packages/opentelemetry_semantic_conventions_ai-0.4.12.dist-info/METADATA new file mode 100644 index 0000000000000000000000000000000000000000..995bcf5838ebd5fe859b95f6e154ca926527dc5a --- /dev/null +++ b/venv/lib/python3.10/site-packages/opentelemetry_semantic_conventions_ai-0.4.12.dist-info/METADATA @@ -0,0 +1,25 @@ +Metadata-Version: 2.3 +Name: opentelemetry-semantic-conventions-ai +Version: 0.4.12 +Summary: OpenTelemetry Semantic Conventions Extension for Large Language Models +License: Apache-2.0 +Author: Gal Kleinman +Author-email: gal@traceloop.com +Requires-Python: >=3.9,<4 +Classifier: License :: OSI Approved :: Apache Software License +Classifier: Programming Language :: Python :: 3 +Classifier: Programming Language :: Python :: 3.9 +Classifier: Programming Language :: Python :: 3.10 +Classifier: Programming Language :: Python :: 3.11 +Classifier: Programming Language :: Python :: 3.12 +Classifier: Programming Language :: Python :: 3.13 +Description-Content-Type: text/markdown + +# OpenTelemetry Semantic Conventions extensions for gen-AI applications + + + + + +This is an extension of the standard [OpenTelemetry Semantic Conventions](https://github.com/open-telemetry/semantic-conventions) for gen AI applications. It defines additional attributes for spans that are useful for debugging and monitoring prompts, completions, token usage, etc. + diff --git a/venv/lib/python3.10/site-packages/opentelemetry_semantic_conventions_ai-0.4.12.dist-info/RECORD b/venv/lib/python3.10/site-packages/opentelemetry_semantic_conventions_ai-0.4.12.dist-info/RECORD new file mode 100644 index 0000000000000000000000000000000000000000..c1208958520dbb23d06a0de308768e180e97903d --- /dev/null +++ b/venv/lib/python3.10/site-packages/opentelemetry_semantic_conventions_ai-0.4.12.dist-info/RECORD @@ -0,0 +1,10 @@ +opentelemetry/semconv_ai/__init__.py,sha256=74pgKLgnsMZm-fm68sTjjf60-Ei3B7kWZ0V7skHk51E,13914 +opentelemetry/semconv_ai/__pycache__/__init__.cpython-310.pyc,, +opentelemetry/semconv_ai/__pycache__/utils.cpython-310.pyc,, +opentelemetry/semconv_ai/__pycache__/version.cpython-310.pyc,, +opentelemetry/semconv_ai/utils.py,sha256=nHbVWYXlzZvETznUMJmTI3TSkzdUYXUikRwqANXcUiY,728 +opentelemetry/semconv_ai/version.py,sha256=lYNcyjtUgDCdtQI4PJHV2HTSNhaeqv8synl2jjobziM,23 +opentelemetry_semantic_conventions_ai-0.4.12.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +opentelemetry_semantic_conventions_ai-0.4.12.dist-info/METADATA,sha256=vL2oDncioxVm48yg0QDyaz0B_qEU3Fwmtg-k65FmDUg,1188 +opentelemetry_semantic_conventions_ai-0.4.12.dist-info/RECORD,, +opentelemetry_semantic_conventions_ai-0.4.12.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88 diff --git a/venv/lib/python3.10/site-packages/opentelemetry_semantic_conventions_ai-0.4.12.dist-info/WHEEL b/venv/lib/python3.10/site-packages/opentelemetry_semantic_conventions_ai-0.4.12.dist-info/WHEEL new file mode 100644 index 0000000000000000000000000000000000000000..cafd7e15ace76facf4f1bcec42710b31e59c1ae3 --- /dev/null +++ b/venv/lib/python3.10/site-packages/opentelemetry_semantic_conventions_ai-0.4.12.dist-info/WHEEL @@ -0,0 +1,4 @@ +Wheel-Version: 1.0 +Generator: poetry-core 2.0.1 +Root-Is-Purelib: true +Tag: py3-none-any diff --git a/venv/lib/python3.10/site-packages/outlines-0.1.11.dist-info/INSTALLER b/venv/lib/python3.10/site-packages/outlines-0.1.11.dist-info/INSTALLER new file mode 100644 index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68 --- /dev/null +++ b/venv/lib/python3.10/site-packages/outlines-0.1.11.dist-info/INSTALLER @@ -0,0 +1 @@ +pip diff --git a/venv/lib/python3.10/site-packages/outlines-0.1.11.dist-info/LICENSE b/venv/lib/python3.10/site-packages/outlines-0.1.11.dist-info/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..cac50cdfa9f73d7329854bd5528c6c8c3c0eb5d4 --- /dev/null +++ b/venv/lib/python3.10/site-packages/outlines-0.1.11.dist-info/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright 2023- The Outlines developers + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/venv/lib/python3.10/site-packages/outlines-0.1.11.dist-info/METADATA b/venv/lib/python3.10/site-packages/outlines-0.1.11.dist-info/METADATA new file mode 100644 index 0000000000000000000000000000000000000000..da6d846fc4d7fa70f450086b539ead0b70588dfe --- /dev/null +++ b/venv/lib/python3.10/site-packages/outlines-0.1.11.dist-info/METADATA @@ -0,0 +1,503 @@ +Metadata-Version: 2.1 +Name: outlines +Version: 0.1.11 +Summary: Probabilistic Generative Model Programming +Author: Outlines Developers +License: Apache-2.0 +Project-URL: homepage, https://github.com/dottxt-ai/outlines +Project-URL: documentation, https://dottxt-ai.github.io/outlines/ +Project-URL: repository, https://github.com/dottxt-ai/outlines +Keywords: machine learning,deep learning,language models,structured generation +Classifier: Development Status :: 5 - Production/Stable +Classifier: Intended Audience :: Developers +Classifier: Intended Audience :: Information Technology +Classifier: Intended Audience :: Science/Research +Classifier: Operating System :: OS Independent +Classifier: Programming Language :: Python :: 3 +Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence +Requires-Python: >=3.9 +Description-Content-Type: text/markdown +License-File: LICENSE +Requires-Dist: interegular +Requires-Dist: jinja2 +Requires-Dist: lark +Requires-Dist: nest_asyncio +Requires-Dist: numpy +Requires-Dist: cloudpickle +Requires-Dist: diskcache +Requires-Dist: pydantic>=2.0 +Requires-Dist: referencing +Requires-Dist: jsonschema +Requires-Dist: requests +Requires-Dist: tqdm +Requires-Dist: typing_extensions +Requires-Dist: pycountry +Requires-Dist: airportsdata +Requires-Dist: torch +Requires-Dist: outlines_core==0.1.26 +Provides-Extra: vllm +Requires-Dist: vllm; extra == "vllm" +Requires-Dist: transformers; extra == "vllm" +Requires-Dist: numpy<2; extra == "vllm" +Provides-Extra: transformers +Requires-Dist: transformers; extra == "transformers" +Requires-Dist: accelerate; extra == "transformers" +Requires-Dist: datasets; extra == "transformers" +Requires-Dist: numpy<2; extra == "transformers" +Provides-Extra: mlxlm +Requires-Dist: mlx-lm; extra == "mlxlm" +Requires-Dist: datasets; extra == "mlxlm" +Provides-Extra: openai +Requires-Dist: openai; extra == "openai" +Provides-Extra: llamacpp +Requires-Dist: llama-cpp-python; extra == "llamacpp" +Requires-Dist: transformers; extra == "llamacpp" +Requires-Dist: datasets; extra == "llamacpp" +Requires-Dist: numpy<2; extra == "llamacpp" +Provides-Extra: exllamav2 +Requires-Dist: exllamav2; extra == "exllamav2" +Provides-Extra: test +Requires-Dist: pre-commit; extra == "test" +Requires-Dist: pytest; extra == "test" +Requires-Dist: pytest-benchmark; extra == "test" +Requires-Dist: pytest-cov; extra == "test" +Requires-Dist: pytest-mock; extra == "test" +Requires-Dist: coverage[toml]>=5.1; extra == "test" +Requires-Dist: diff-cover; extra == "test" +Requires-Dist: accelerate; extra == "test" +Requires-Dist: beartype<0.16.0; extra == "test" +Requires-Dist: responses; extra == "test" +Requires-Dist: llama-cpp-python; extra == "test" +Requires-Dist: mlx-lm>=0.19.2; (platform_machine == "arm64" and sys_platform == "darwin") and extra == "test" +Requires-Dist: huggingface_hub; extra == "test" +Requires-Dist: openai>=1.0.0; extra == "test" +Requires-Dist: datasets; extra == "test" +Requires-Dist: vllm; sys_platform != "darwin" and extra == "test" +Requires-Dist: transformers; extra == "test" +Requires-Dist: pillow; extra == "test" +Requires-Dist: exllamav2; extra == "test" +Requires-Dist: jax; extra == "test" +Provides-Extra: serve +Requires-Dist: vllm>=0.3.0; extra == "serve" +Requires-Dist: uvicorn; extra == "serve" +Requires-Dist: fastapi; extra == "serve" +Requires-Dist: pydantic>=2.0; extra == "serve" + +
+ +Outlines Logo + + + 🗒️ *Make LLMs speak the language of every application.* 🗒️ + +Made with ❤👷️ by the team at [.txt](https://dottxt.co). + +[![Documentation][documentation-badge]][documentation] +[![Contributors][contributors-badge]][contributors] +[![Downloads][downloads-badge]][pypistats] +[![Discord][discord-badge]][discord] + +[Youtube channel][youtube-dottxt] | [.txt blog][blog-dottxt] | [Twitter][dottxt-twitter] + + +
+ + +``` bash +pip install outlines +``` + +First time here? Go to our [setup guide](https://dottxt-ai.github.io/outlines/latest/welcome/) + +## Features + +- [x] 🤖 [Multiple model integrations](https://dottxt-ai.github.io/outlines/latest/installation): OpenAI, transformers, llama.cpp, exllama2, mamba +- [x] 🖍️ Simple and powerful prompting primitives based on the [Jinja templating engine](https://jinja.palletsprojects.com/) +- [x] 🚄 [Multiple choices](#multiple-choices), [type constraints](#type-constraint) and dynamic stopping +- [x] ⚡ Fast [regex-structured generation](#efficient-regex-structured-generation) +- [x] 🔥 Fast [JSON generation](#efficient-json-generation-following-a-pydantic-model) following a JSON schema or a Pydantic model +- [x] 📝 [Grammar-structured generation](#using-context-free-grammars-to-guide-generation) +- [x] 🐍 Interleave completions with loops, conditionals, and custom Python functions +- [x] 💾 Caching of generations +- [x] 🗂️ Batch inference +- [x] 🎲 Sample with the greedy, multinomial and beam search algorithms (and more to come!) +- [x] 🚀 [Serve with vLLM](https://dottxt-ai.github.io/outlines/latest/reference/serve/vllm), with official Docker image, [`outlinesdev/outlines`](https://hub.docker.com/r/outlinesdev/outlines)! + + +Outlines has new releases and features coming every week. Make sure to ⭐ star and 👀 watch this repository, follow [@dottxtai][dottxt-twitter] to stay up to date! + +## Why should I use structured generation? + +* It doesn't add any overhead during inference (cost-free) +* It allows Open Source models to beat closed source models ([Mistral](https://x.com/dottxtai/status/1797692104023363765), [GPT-4](https://x.com/dottxtai/status/1798443290913853770)) +* [It speeds up inference](http://blog.dottxt.co/coalescence.html) +* [It improves the performance of base models (GSM8K)](http://blog.dottxt.co/performance-gsm8k.html) +* [It improves the performance of finetuned models (CoNNL)](https://predibase.com/blog/lorax-outlines-better-json-extraction-with-structured-generation-and-lora) +* [It improves model efficiency (less examples needed)](https://huggingface.co/blog/evaluation-structured-outputs) + +## .txt company + +
+Outlines Logo +
+ +We started a company to keep pushing the boundaries of structured generation. Learn more about [.txt](https://twitter.com/dottxtai), and [give our .json API a try](https://h1xbpbfsf0w.typeform.com/to/ZgBCvJHF) if you need a hosted solution ✨ + +## Structured generation + +The first step towards reliability of systems that include large language models +is to ensure that there is a well-defined interface between their output and +user-defined code. **Outlines** provides ways to control the generation of +language models to make their output more predictable. + +### Multiple choices + +You can reduce the completion to a choice between multiple possibilities: + +``` python +import outlines + +model = outlines.models.transformers("microsoft/Phi-3-mini-4k-instruct") + +prompt = """You are a sentiment-labelling assistant. +Is the following review positive or negative? + +Review: This restaurant is just awesome! +""" + +generator = outlines.generate.choice(model, ["Positive", "Negative"]) +answer = generator(prompt) +``` + +You can also pass these choices through en enum: + +````python +from enum import Enum + +import outlines + +class Sentiment(str, Enum): + positive = "Positive" + negative = "Negative" + +model = outlines.models.transformers("microsoft/Phi-3-mini-4k-instruct") + +prompt = """You are a sentiment-labelling assistant. +Is the following review positive or negative? + +Review: This restaurant is just awesome! +""" + +generator = outlines.generate.choice(model, Sentiment) +answer = generator(prompt) +```` + +### Type constraint + +You can instruct the model to only return integers or floats: + + +``` python +import outlines + +model = outlines.models.transformers("WizardLM/WizardMath-7B-V1.1") + +prompt = "result of 9 + 9 = 18result of 1 + 2 = " +answer = outlines.generate.format(model, int)(prompt) +print(answer) +# 3 + +prompt = "sqrt(2)=" +generator = outlines.generate.format(model, float) +answer = generator(prompt, max_tokens=10) +print(answer) +# 1.41421356 +``` + +### Efficient regex-structured generation + +Outlines also comes with fast regex-structured generation. In fact, the `choice` and +`format` functions above all use regex-structured generation under the +hood: + +``` python +import outlines + +model = outlines.models.transformers("microsoft/Phi-3-mini-4k-instruct") + +prompt = "What is the IP address of the Google DNS servers? " + +generator = outlines.generate.text(model) +unstructured = generator(prompt, max_tokens=30) + +generator = outlines.generate.regex( + model, + r"((25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(25[0-5]|2[0-4]\d|[01]?\d\d?)", +) +structured = generator(prompt, max_tokens=30) + +print(unstructured) +# What is the IP address of the Google DNS servers? +# +# Passive DNS servers are at DNS servers that are private. +# In other words, both IP servers are private. The database +# does not contain Chelsea Manning + +print(structured) +# What is the IP address of the Google DNS servers? +# 2.2.6.1 +``` + +Unlike other libraries, regex-structured generation in Outlines is almost as fast +as non-structured generation. + +### Efficient JSON generation following a Pydantic model + +Outlines allows to guide the generation process so the output is *guaranteed* to follow a [JSON schema](https://json-schema.org/) or [Pydantic model](https://docs.pydantic.dev/latest/): + +```python +from enum import Enum +from pydantic import BaseModel, constr + +import outlines +import torch + + +class Weapon(str, Enum): + sword = "sword" + axe = "axe" + mace = "mace" + spear = "spear" + bow = "bow" + crossbow = "crossbow" + + +class Armor(str, Enum): + leather = "leather" + chainmail = "chainmail" + plate = "plate" + + +class Character(BaseModel): + name: constr(max_length=10) + age: int + armor: Armor + weapon: Weapon + strength: int + + +model = outlines.models.transformers("microsoft/Phi-3-mini-4k-instruct") + +# Construct structured sequence generator +generator = outlines.generate.json(model, Character) + +# Draw a sample +seed = 789001 + +character = generator("Give me a character description", seed=seed) + +print(repr(character)) +# Character(name='Anderson', age=28, armor=, weapon=, strength=8) + +character = generator("Give me an interesting character description") + +print(repr(character)) +# Character(name='Vivian Thr', age=44, armor=, weapon=, strength=125) +``` + +The method works with union types, optional types, arrays, nested schemas, etc. Some field constraints are [not supported yet](https://github.com/dottxt-ai/outlines/issues/215), but everything else should work. + +### Efficient JSON generation following a JSON Schema + +Sometimes you just want to be able to pass a JSON Schema instead of a Pydantic model. We've got you covered: + +``` python +import outlines + +schema = '''{ + "title": "Character", + "type": "object", + "properties": { + "name": { + "title": "Name", + "maxLength": 10, + "type": "string" + }, + "age": { + "title": "Age", + "type": "integer" + }, + "armor": {"$ref": "#/definitions/Armor"}, + "weapon": {"$ref": "#/definitions/Weapon"}, + "strength": { + "title": "Strength", + "type": "integer" + } + }, + "required": ["name", "age", "armor", "weapon", "strength"], + "definitions": { + "Armor": { + "title": "Armor", + "description": "An enumeration.", + "enum": ["leather", "chainmail", "plate"], + "type": "string" + }, + "Weapon": { + "title": "Weapon", + "description": "An enumeration.", + "enum": ["sword", "axe", "mace", "spear", "bow", "crossbow"], + "type": "string" + } + } +}''' + +model = outlines.models.transformers("microsoft/Phi-3-mini-4k-instruct") +generator = outlines.generate.json(model, schema) +character = generator("Give me a character description") +``` + +### Using context-free grammars to guide generation + +Formal grammars rule the world, and Outlines makes them rule LLMs too. You can pass any context-free grammar in the EBNF format and Outlines will generate an output that is valid to this grammar: + +``` python +import outlines + +arithmetic_grammar = """ + ?start: expression + + ?expression: term (("+" | "-") term)* + + ?term: factor (("*" | "/") factor)* + + ?factor: NUMBER + | "-" factor + | "(" expression ")" + + %import common.NUMBER +""" + +model = outlines.models.transformers("WizardLM/WizardMath-7B-V1.1") +generator = outlines.generate.cfg(model, arithmetic_grammar) +sequence = generator("Alice had 4 apples and Bob ate 2. Write an expression for Alice's apples:") + +print(sequence) +# (8-2) +``` + +This was a very simple grammar, and you can use `outlines.generate.cfg` to generate syntactically valid Python, SQL, and much more than this. Any kind of structured text, really. All you have to do is search for "X EBNF grammar" on the web, and take a look at the [Outlines `grammars` module](https://github.com/dottxt-ai/outlines/tree/main/outlines/grammars). + +### Open functions + +Outlines can infer the structure of the output from the signature of a function. The result is a dictionary, and can be passed directly to the function using the usual dictionary expansion syntax `**`: + +```python +import outlines + + +def add(a: int, b: int): + return a + b + +model = outlines.models.transformers("WizardLM/WizardMath-7B-V1.1") +generator = outlines.generate.json(model, add) +result = generator("Return json with two integers named a and b respectively. a is odd and b even.") + +print(add(**result)) +# 3 +``` + +A great advantage of passing functions directly to specify the structure is that the structure of the LLM will change with the function's definition. No need to change the code at several places! + +You can also embed various functions into an enum to generate params: + +```python +from enum import Enum +from functools import partial + +import outlines + + +def add(a: int, b: int) -> int: + return a + b + +def mul(c: float, d: float) -> float: + return c * d + +class Operation(Enum): + add = partial(add) + mul = partial(mul) + +model = outlines.models.transformers("WizardLM/WizardMath-7B-V1.1") +generator = outlines.generate.json(model, add) +result = generator("Return json with two float named c and d respectively. c is negative and d greater than 1.0.") + +print(result) +# {'c': -3.14, 'd': 1.5} +``` + +## Prompting + +Building prompts can get messy. **Outlines** makes it easier to write and manage +prompts by encapsulating templates inside "template functions". + +These functions make it possible to neatly separate the prompt logic from the +general program logic; they can be imported from other modules and libraries. + +Template functions require no superfluous abstraction, they use the Jinja2 +templating engine to help build complex prompts in a concise manner: + +``` python +import outlines + +examples = [ + ("The food was disgusting", "Negative"), + ("We had a fantastic night", "Positive"), + ("Recommended", "Positive"), + ("The waiter was rude", "Negative") +] + +@outlines.prompt +def labelling(to_label, examples): + """You are a sentiment-labelling assistant. + + {% for example in examples %} + {{ example[0] }} // {{ example[1] }} + {% endfor %} + {{ to_label }} // + """ + +model = outlines.models.transformers("microsoft/Phi-3-mini-4k-instruct") +prompt = labelling("Just awesome", examples) +answer = outlines.generate.text(model)(prompt, max_tokens=100) +``` + +## Join us + +- 💡 **Have an idea?** Come chat with us on [Discord][discord] +- 🔨 **Want to contribute?** Consult our [contribution guide](https://dottxt-ai.github.io/outlines/latest/community/contribute/). +- 🐞 **Found a bug?** Open an [issue](https://github.com/dottxt-ai/outlines/issues) + + +## Cite Outlines + +``` +@article{willard2023efficient, + title={Efficient Guided Generation for LLMs}, + author={Willard, Brandon T and Louf, R{\'e}mi}, + journal={arXiv preprint arXiv:2307.09702}, + year={2023} +} +``` + +[documentation]: https://dottxt-ai.github.io/outlines/latest/welcome/ +[documentation-badge]: https://img.shields.io/readthedocs/outlines +[contributors]: https://github.com/dottxt-ai/outlines/graphs/contributors +[contributors-badge]: https://img.shields.io/github/contributors/dottxt-ai/outlines?style=flat-square&logo=github&logoColor=white&color=ECEFF4 +[dottxt-twitter]: https://twitter.com/dottxtai +[discord]: https://discord.gg/R9DSu34mGd +[discord-badge]: https://img.shields.io/discord/1182316225284554793?color=81A1C1&logo=discord&logoColor=white&style=flat-square +[downloads-badge]: https://img.shields.io/pypi/dm/outlines?color=89AC6B&logo=python&logoColor=white&style=flat-square +[pypistats]: https://pypistats.org/packages/outlines +[dottxt-twitter-badge]: https://img.shields.io/twitter/follow/dottxtai?style=social +[youtube-dottxt]: https://www.youtube.com/@dottxt-ai +[blog-dottxt]: https://blog.dottxt.co/ diff --git a/venv/lib/python3.10/site-packages/outlines-0.1.11.dist-info/RECORD b/venv/lib/python3.10/site-packages/outlines-0.1.11.dist-info/RECORD new file mode 100644 index 0000000000000000000000000000000000000000..0bfc2ca8203f374b99277e7efd49158fd766ad72 --- /dev/null +++ b/venv/lib/python3.10/site-packages/outlines-0.1.11.dist-info/RECORD @@ -0,0 +1,100 @@ +outlines-0.1.11.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +outlines-0.1.11.dist-info/LICENSE,sha256=9xB47oqqPVZwSIdW8Zk7neOuZMlUagIy67vdWVxTddc,11354 +outlines-0.1.11.dist-info/METADATA,sha256=90I6ySed9yjWM_A0cZZ7kYaG6CSh1DiTnGq-Q1s_jeM,17137 +outlines-0.1.11.dist-info/RECORD,, +outlines-0.1.11.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91 +outlines-0.1.11.dist-info/top_level.txt,sha256=DRbCwvEBUKClPATvDaHzpX6gD7LgECM9WVYkEq0NHpY,9 +outlines/__init__.py,sha256=sYuMGn7xxyuPhwq-M3M2WKjwGqFwEXG0xyJw6lw31Ng,495 +outlines/__pycache__/__init__.cpython-310.pyc,, +outlines/__pycache__/_version.cpython-310.pyc,, +outlines/__pycache__/base.cpython-310.pyc,, +outlines/__pycache__/caching.cpython-310.pyc,, +outlines/__pycache__/function.cpython-310.pyc,, +outlines/__pycache__/grammars.cpython-310.pyc,, +outlines/__pycache__/prompts.cpython-310.pyc,, +outlines/__pycache__/samplers.cpython-310.pyc,, +outlines/_version.py,sha256=HreDwlLXV189L3kiBj3huM_kqWD1usijlC8LN1YXcCM,413 +outlines/base.py,sha256=InRqZU2VeNPjpkb3wfCDnYZ5xW1wxSYeCNXCHTLz_Vg,10501 +outlines/caching.py,sha256=WxfFldbINw0MBtsHhHI51nugsgH7dDpYyPf07A6Yv2E,5337 +outlines/fsm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +outlines/fsm/__pycache__/__init__.cpython-310.pyc,, +outlines/fsm/__pycache__/guide.cpython-310.pyc,, +outlines/fsm/__pycache__/json_schema.cpython-310.pyc,, +outlines/fsm/__pycache__/parsing.cpython-310.pyc,, +outlines/fsm/__pycache__/types.cpython-310.pyc,, +outlines/fsm/guide.py,sha256=0DZwVei2g-3kA9Cn5NECwDalWB2ufKTwxJVvdXOVGQ0,8953 +outlines/fsm/json_schema.py,sha256=eB0fMz3UKI-pHOsuYdVQZmsm2Jr1QIw_6DzkC83mB6Y,2535 +outlines/fsm/parsing.py,sha256=ypJ52to1umo2wItiUqhxXDGW4fQf731mq5cGLrQAOeI,39516 +outlines/fsm/types.py,sha256=XEhFaGaM6rrFKsXNXnGmvk1_5Jfht8nkqCcKBk2piDQ,2493 +outlines/function.py,sha256=kN22C9c5IBoQ3KR5GwCFR0gyPzG2Ke5k6ZAPb6pF55U,3707 +outlines/generate/__init__.py,sha256=aQs6Ga6r0n_KMzAY-d1NQhnGkQSWGdQXNCdJzMcbeGo,202 +outlines/generate/__pycache__/__init__.cpython-310.pyc,, +outlines/generate/__pycache__/api.cpython-310.pyc,, +outlines/generate/__pycache__/cfg.cpython-310.pyc,, +outlines/generate/__pycache__/choice.cpython-310.pyc,, +outlines/generate/__pycache__/format.cpython-310.pyc,, +outlines/generate/__pycache__/fsm.cpython-310.pyc,, +outlines/generate/__pycache__/generator.cpython-310.pyc,, +outlines/generate/__pycache__/json.cpython-310.pyc,, +outlines/generate/__pycache__/regex.cpython-310.pyc,, +outlines/generate/__pycache__/text.cpython-310.pyc,, +outlines/generate/api.py,sha256=54ww0C759h2A6COktBcJeLPDXPH1Nn4l0Iv2i-gLH84,20666 +outlines/generate/cfg.py,sha256=giAHsT-TAi4OnO_d3U15JJX1X194SKQrBqYgdxnFEw4,1686 +outlines/generate/choice.py,sha256=MNJZ0Ig-ZvW_Ci1IazrMqJNkuqnYU7H0R7cvic9YbPc,1752 +outlines/generate/format.py,sha256=d0tEbpdImunihJorf4cYc3KK3aeFrjuWI6G3KoO8Dqg,1435 +outlines/generate/fsm.py,sha256=N7M6BUmEoN02gcVijV3kPUa3Bk9S_sGfFGt1I-lvCeY,1111 +outlines/generate/generator.py,sha256=-EnFq8pb7fbfLPmqRFvMeXN-kA1l_mhwrGvDoRxKWx0,8811 +outlines/generate/json.py,sha256=cFHVogIC_ltTjoPURCP2WaQjuqslRuzcR7GLy3dlgjA,4309 +outlines/generate/regex.py,sha256=3PhYSiR2tpDLj3ty_fvjv7vMcU28Y9dgYiGsfRFOe8Q,1715 +outlines/generate/text.py,sha256=8-DcHDtV4imaqKfG_f4hhYQ_wbPwhhCdjuPmHG_HVo4,1409 +outlines/grammars.py,sha256=OXxQyKvthoQCfrwQuCHSSi4VYcb3GMAOYudC2DmvquU,396 +outlines/grammars/arithmetic.lark,sha256=4aWsZ_IkS9nP7NGihdgPf0wWaP2tn0xb_jhFNF5ws50,293 +outlines/grammars/common.lark,sha256=h6mPVV0vitrbCSVDUnL_GvQriCfwrN8EtWLFiss3K9Q,2243 +outlines/grammars/json.lark,sha256=6d6owpAzgVkAOUSsINg6MLu81VV_HQknRsMsSXHYB-k,373 +outlines/models/__init__.py,sha256=8vIXGlkrjOIeBYx21Uo0-3U6A4UyOBOMf9iK4Wswvcw,701 +outlines/models/__pycache__/__init__.cpython-310.pyc,, +outlines/models/__pycache__/exllamav2.cpython-310.pyc,, +outlines/models/__pycache__/llamacpp.cpython-310.pyc,, +outlines/models/__pycache__/mlxlm.cpython-310.pyc,, +outlines/models/__pycache__/openai.cpython-310.pyc,, +outlines/models/__pycache__/tokenizer.cpython-310.pyc,, +outlines/models/__pycache__/transformers.cpython-310.pyc,, +outlines/models/__pycache__/transformers_vision.cpython-310.pyc,, +outlines/models/__pycache__/vllm.cpython-310.pyc,, +outlines/models/exllamav2.py,sha256=Mo8gpuQI7KQe77T-BZHXHOV3Kkucgvkqo7-TjJcpzV0,13295 +outlines/models/llamacpp.py,sha256=mI_xD-DqfcADl9asF554qOKxpusekx65GEl1Ja-C-xY,14662 +outlines/models/mlxlm.py,sha256=ieim5QadwNQXM6311RBXOoYh52EnRcJZSvPiEfLpxbU,8588 +outlines/models/openai.py,sha256=Oa-HiCUf5tk8HL_UCMI9FJ4tz4F0gAnQgggE1EB28QU,9009 +outlines/models/tokenizer.py,sha256=x6228TFhbcGe-XssA4SAAjaOBEZoAvFciQUpK22Y28U,996 +outlines/models/transformers.py,sha256=xJblsZB8FoXfDxrhvJ7pW0Hj8HSLT9FndURPrZ7kO2M,15337 +outlines/models/transformers_vision.py,sha256=t77kgdRa5DIRiPis126AOfTnKl3PswL3klouUlFR9Jk,5069 +outlines/models/vllm.py,sha256=BRvkrYAC2gTMZ3vhcETXJYf_mlO1U49m3bMArGymyDU,7769 +outlines/processors/__init__.py,sha256=fDMQ-pyBPaDB7Eb8pgwJ16eTUbPAm-w2Wf-Vn8BuCGY,158 +outlines/processors/__pycache__/__init__.cpython-310.pyc,, +outlines/processors/__pycache__/base_logits_processor.cpython-310.pyc,, +outlines/processors/__pycache__/structured.cpython-310.pyc,, +outlines/processors/base_logits_processor.py,sha256=vFM2p65Mstk4YkO2ZC1xOON3YGj4KgWgjj_iFnROSQQ,5354 +outlines/processors/structured.py,sha256=XOZ3hq_B9BbD6nRuOjdZYQvXYRIYY1s6PJFYzdwtV-c,8240 +outlines/prompts.py,sha256=By6LodDBBDeh9xhCXqkxQqnD1pGNStK7JNJDmMylBMg,10071 +outlines/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +outlines/samplers.py,sha256=aQqVwEqgCoAVjr2qDkSk28hJXf4CQ8DT0LEJv73vQC4,10646 +outlines/serve/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +outlines/serve/__pycache__/__init__.cpython-310.pyc,, +outlines/serve/__pycache__/serve.cpython-310.pyc,, +outlines/serve/serve.py,sha256=xZnXnos-mB7xurY_y2zQIRkUi9508QNxZERZTfbxosw,4940 +outlines/types/__init__.py,sha256=0ZVfLELb_CZ6P9RTete561Uja8bgoGZ4S2shDy-iNhg,110 +outlines/types/__pycache__/__init__.cpython-310.pyc,, +outlines/types/__pycache__/airports.cpython-310.pyc,, +outlines/types/__pycache__/countries.cpython-310.pyc,, +outlines/types/__pycache__/email.cpython-310.pyc,, +outlines/types/__pycache__/isbn.cpython-310.pyc,, +outlines/types/__pycache__/locales.cpython-310.pyc,, +outlines/types/__pycache__/phone_numbers.cpython-310.pyc,, +outlines/types/__pycache__/zip_codes.cpython-310.pyc,, +outlines/types/airports.py,sha256=L2rBblU02mkiXrQfm35XS-r4h0L8OySZ-rEpJJvw75s,241 +outlines/types/countries.py,sha256=XWjvIEXkKNwHSdG4TILxfpSU3xHNJnTeMhvVLp1n_S4,748 +outlines/types/email.py,sha256=aOc004pbeIY4p_Ssj5kWBYXfwAukHxVVY10lTj77byY,739 +outlines/types/isbn.py,sha256=2HtRGX-eoOvGImOI0WL2LUAa7IuvJmGgr1Xb7JZOwi8,761 +outlines/types/locales.py,sha256=rKj2OfDIgY4akyjMWOCWF7jB93kv3NzdQcihM4ojh-s,530 +outlines/types/phone_numbers.py,sha256=l8MSwbzsQ2qjGzKN0vVH546IdaHTuT9OD9XzZE4zAp8,435 +outlines/types/zip_codes.py,sha256=lGj2OBwX3LwLk7agw396WK17Aky4a5fZpLeZsNPkjAg,300 diff --git a/venv/lib/python3.10/site-packages/outlines-0.1.11.dist-info/WHEEL b/venv/lib/python3.10/site-packages/outlines-0.1.11.dist-info/WHEEL new file mode 100644 index 0000000000000000000000000000000000000000..ae527e7d64811439e61b93aa375defb30e06edfe --- /dev/null +++ b/venv/lib/python3.10/site-packages/outlines-0.1.11.dist-info/WHEEL @@ -0,0 +1,5 @@ +Wheel-Version: 1.0 +Generator: setuptools (75.6.0) +Root-Is-Purelib: true +Tag: py3-none-any + diff --git a/venv/lib/python3.10/site-packages/outlines-0.1.11.dist-info/top_level.txt b/venv/lib/python3.10/site-packages/outlines-0.1.11.dist-info/top_level.txt new file mode 100644 index 0000000000000000000000000000000000000000..768b9f9d0fc65abf8ac73ed084432c7ad32c7183 --- /dev/null +++ b/venv/lib/python3.10/site-packages/outlines-0.1.11.dist-info/top_level.txt @@ -0,0 +1 @@ +outlines diff --git a/venv/lib/python3.10/site-packages/patsy-1.0.1.dist-info/INSTALLER b/venv/lib/python3.10/site-packages/patsy-1.0.1.dist-info/INSTALLER new file mode 100644 index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68 --- /dev/null +++ b/venv/lib/python3.10/site-packages/patsy-1.0.1.dist-info/INSTALLER @@ -0,0 +1 @@ +pip diff --git a/venv/lib/python3.10/site-packages/patsy-1.0.1.dist-info/LICENSE.txt b/venv/lib/python3.10/site-packages/patsy-1.0.1.dist-info/LICENSE.txt new file mode 100644 index 0000000000000000000000000000000000000000..624f740736c766fbeb815bf2272c2d333672aa28 --- /dev/null +++ b/venv/lib/python3.10/site-packages/patsy-1.0.1.dist-info/LICENSE.txt @@ -0,0 +1,81 @@ +The bulk of Patsy is distributed under a simple 2-clause BSD license: + + Copyright (C) 2011-2012, Patsy Developers. All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are + met: + + 1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +The module patsy.compat contains code derived from the Python +standard library, and is covered by the following license: + + PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2 + -------------------------------------------- + + 1. This LICENSE AGREEMENT is between the Python Software Foundation + ("PSF"), and the Individual or Organization ("Licensee") accessing and + otherwise using this software ("Python") in source or binary form and + its associated documentation. + + 2. Subject to the terms and conditions of this License Agreement, PSF hereby + grants Licensee a nonexclusive, royalty-free, world-wide license to reproduce, + analyze, test, perform and/or display publicly, prepare derivative works, + distribute, and otherwise use Python alone or in any derivative version, + provided, however, that PSF's License Agreement and PSF's notice of copyright, + i.e., "Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, + 2011, 2012 Python Software Foundation; All Rights Reserved" are retained in Python + alone or in any derivative version prepared by Licensee. + + 3. In the event Licensee prepares a derivative work that is based on + or incorporates Python or any part thereof, and wants to make + the derivative work available to others as provided herein, then + Licensee hereby agrees to include in any such work a brief summary of + the changes made to Python. + + 4. PSF is making Python available to Licensee on an "AS IS" + basis. PSF MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR + IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND + DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS + FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON WILL NOT + INFRINGE ANY THIRD PARTY RIGHTS. + + 5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON + FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS + A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON, + OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF. + + 6. This License Agreement will automatically terminate upon a material + breach of its terms and conditions. + + 7. Nothing in this License Agreement shall be deemed to create any + relationship of agency, partnership, or joint venture between PSF and + Licensee. This License Agreement does not grant permission to use PSF + trademarks or trade name in a trademark sense to endorse or promote + products or services of Licensee, or any third party. + + 8. By copying, installing or otherwise using Python, Licensee + agrees to be bound by the terms and conditions of this License + Agreement. + +As per item (3), we are required to provide a brief summary of +changes. For this, see comments in patsy/compat.py. diff --git a/venv/lib/python3.10/site-packages/patsy-1.0.1.dist-info/METADATA b/venv/lib/python3.10/site-packages/patsy-1.0.1.dist-info/METADATA new file mode 100644 index 0000000000000000000000000000000000000000..eddc4cce73a8b10a03ae86948b33c5afbca13d6d --- /dev/null +++ b/venv/lib/python3.10/site-packages/patsy-1.0.1.dist-info/METADATA @@ -0,0 +1,79 @@ +Metadata-Version: 2.1 +Name: patsy +Version: 1.0.1 +Summary: A Python package for describing statistical models and for building design matrices. +Home-page: https://github.com/pydata/patsy +Author: Nathaniel J. Smith +Author-email: njs@pobox.com +License: 2-clause BSD +Platform: UNKNOWN +Classifier: Development Status :: 6 - Mature +Classifier: Intended Audience :: Developers +Classifier: Intended Audience :: Science/Research +Classifier: Intended Audience :: Financial and Insurance Industry +Classifier: License :: OSI Approved :: BSD License +Classifier: Programming Language :: Python :: 3 +Classifier: Programming Language :: Python :: 3.6 +Classifier: Programming Language :: Python :: 3.7 +Classifier: Programming Language :: Python :: 3.8 +Classifier: Programming Language :: Python :: 3.9 +Classifier: Programming Language :: Python :: 3.10 +Classifier: Programming Language :: Python :: 3.11 +Classifier: Programming Language :: Python :: 3.12 +Classifier: Programming Language :: Python :: 3.13 +Classifier: Topic :: Scientific/Engineering +Requires-Python: >=3.6 +Description-Content-Type: text/markdown +Requires-Dist: numpy >=1.4 +Provides-Extra: test +Requires-Dist: pytest ; extra == 'test' +Requires-Dist: pytest-cov ; extra == 'test' +Requires-Dist: scipy ; extra == 'test' + +# Patsy + +**Notice:** `patsy` is no longer under active development. As of August 2021, +Matthew Wardrop (@matthewwardrop) and Tomás Capretto (@tomicapretto) have taken +on responsibility from Nathaniel Smith (@njsmith) for keeping the lights on, but +no new feature development is planned. The spiritual successor of this project +is [Formulaic](https://github.com/matthewwardrop/formulaic), and we +recommend that users [migrate](https://matthewwardrop.github.io/formulaic/migration/) +when possible. For the time being, until major software packages have successfully +transitioned, we will attempt to keep `patsy` working in its current state with +current releases in the Python ecosystem. + +--- + +Patsy is a Python library for describing statistical models +(especially linear models, or models that have a linear component) and +building design matrices. Patsy brings the convenience of [R](http://www.r-project.org/) "formulas" to Python. + +[![PyPI - Version](https://img.shields.io/pypi/v/patsy.svg)](https://pypi.org/project/spec-classes/) +![PyPI - Python Version](https://img.shields.io/pypi/pyversions/patsy.svg) +![https://patsy.readthedocs.io/](https://img.shields.io/badge/docs-read%20now-blue.svg) +![PyPI - Status](https://img.shields.io/pypi/status/patsy.svg) +![https://coveralls.io/r/pydata/patsy?branch=master](https://coveralls.io/repos/pydata/patsy/badge.png?branch=master) +![https://doi.org/10.5281/zenodo.592075](https://zenodo.org/badge/DOI/10.5281/zenodo.592075.svg) + +- **Documentation:** +- **Downloads:** +- **Code and issues:** +- **Mailing list:** () + + +## Dependencies + + * Python (3.6+) + * numpy + * Optional: + * pytest/pytest-cov: needed to run tests + * scipy: needed for spline-related functions like ``bs`` + +## Installation + ``pip install patsy`` (or, for traditionalists: ``python setup.py install``) + +## License + +2-clause BSD, see LICENSE.txt for details. + + diff --git a/venv/lib/python3.10/site-packages/patsy-1.0.1.dist-info/RECORD b/venv/lib/python3.10/site-packages/patsy-1.0.1.dist-info/RECORD new file mode 100644 index 0000000000000000000000000000000000000000..61dd5ebcbdee79c4763cc2e2386f3417921e28d8 --- /dev/null +++ b/venv/lib/python3.10/site-packages/patsy-1.0.1.dist-info/RECORD @@ -0,0 +1,66 @@ +patsy-1.0.1.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +patsy-1.0.1.dist-info/LICENSE.txt,sha256=PySjI5M9NnkQ8yir-yH40XiR7zhn2UEBXecpOluoTrw,4313 +patsy-1.0.1.dist-info/METADATA,sha256=ysEJvarQHM-gUqIZ9ZPOEeFcSjy00DUQzwYR9x09Dfs,3320 +patsy-1.0.1.dist-info/RECORD,, +patsy-1.0.1.dist-info/WHEEL,sha256=-G_t0oGuE7UD0DrSpVZnq1hHMBV9DD2XkS5v7XpmTnk,110 +patsy-1.0.1.dist-info/top_level.txt,sha256=twKfN4KbeHgauQL25IXZRyHkuO4js0wIeKSnzXzYB2o,6 +patsy/__init__.py,sha256=HYe3BrOSFypfnQ04GBWygF5A9k2xBsVJHt6kh0Vq9Hg,3645 +patsy/__pycache__/__init__.cpython-310.pyc,, +patsy/__pycache__/build.cpython-310.pyc,, +patsy/__pycache__/builtins.cpython-310.pyc,, +patsy/__pycache__/categorical.cpython-310.pyc,, +patsy/__pycache__/compat.cpython-310.pyc,, +patsy/__pycache__/compat_ordereddict.cpython-310.pyc,, +patsy/__pycache__/constraint.cpython-310.pyc,, +patsy/__pycache__/contrasts.cpython-310.pyc,, +patsy/__pycache__/desc.cpython-310.pyc,, +patsy/__pycache__/design_info.cpython-310.pyc,, +patsy/__pycache__/eval.cpython-310.pyc,, +patsy/__pycache__/highlevel.cpython-310.pyc,, +patsy/__pycache__/infix_parser.cpython-310.pyc,, +patsy/__pycache__/mgcv_cubic_splines.cpython-310.pyc,, +patsy/__pycache__/missing.cpython-310.pyc,, +patsy/__pycache__/origin.cpython-310.pyc,, +patsy/__pycache__/parse_formula.cpython-310.pyc,, +patsy/__pycache__/redundancy.cpython-310.pyc,, +patsy/__pycache__/splines.cpython-310.pyc,, +patsy/__pycache__/state.cpython-310.pyc,, +patsy/__pycache__/test_build.cpython-310.pyc,, +patsy/__pycache__/test_highlevel.cpython-310.pyc,, +patsy/__pycache__/test_regressions.cpython-310.pyc,, +patsy/__pycache__/test_splines_bs_data.cpython-310.pyc,, +patsy/__pycache__/test_splines_crs_data.cpython-310.pyc,, +patsy/__pycache__/test_state.cpython-310.pyc,, +patsy/__pycache__/tokens.cpython-310.pyc,, +patsy/__pycache__/user_util.cpython-310.pyc,, +patsy/__pycache__/util.cpython-310.pyc,, +patsy/__pycache__/version.cpython-310.pyc,, +patsy/build.py,sha256=2MW6HAzwGDCOHYIanP-oS-JHZnZLi_mUVtWOLT5ZCY8,40402 +patsy/builtins.py,sha256=Wt6ECIRaLldvZj5RvtkQNHyOIAes_Cis9YFwTL9f7xc,3141 +patsy/categorical.py,sha256=vXvgoC3l9-cxnKZe_-GMgFmgGfR3rbwaTP4Cb-vG19U,18981 +patsy/compat.py,sha256=MzTdXp4hw6JygZ5dsbSRN-_HQHbRKQh9OQuJQYVbHsc,1487 +patsy/compat_ordereddict.py,sha256=YiLUc0pFm1HdpkV4sUoiVkZBJiPFS9eGy6J7Rilfuxc,9178 +patsy/constraint.py,sha256=lzPxlLFD_9anZvSZezuISA3kdkLz75fL0EIvHLvwQKY,19857 +patsy/contrasts.py,sha256=Ur0HVW6PXNhauoBPB13iHH0FcR-6q-RiWVZk9ijEmp4,22987 +patsy/desc.py,sha256=wJjGfjietjmwixgeIQwuNXXtbfDWCYABgJzfsotpoh0,22149 +patsy/design_info.py,sha256=Adx-35b6Dwxh3biHuTqVFyD7xPiTcOOfwjTN5LZmNhM,49895 +patsy/eval.py,sha256=kO8x-pEcc3twWB2PpYVx_yE9dK1Xl7vSQAlHjQz-sZk,30877 +patsy/highlevel.py,sha256=--65iwNSSzEFXBcCeUMt5zVAnIf3yek5OXFJTib8C2g,13635 +patsy/infix_parser.py,sha256=8S1SHsOLdr3CFmjmcFe0BmH4MQiX2-KHn2HbXESv-xA,9515 +patsy/mgcv_cubic_splines.py,sha256=HWTSY8EMGlGIM06K2k4EKKIwZUhqxVc023rucA8-S8Y,45214 +patsy/missing.py,sha256=NRQiWEHoQfrfl2l7U6ttfEzEAG6zcUe5WixtlEO4asw,11351 +patsy/origin.py,sha256=T8vdAy3YMOWWHZPI4BsHKyy6Ntbi2VT9ar1sLfpfk7c,4598 +patsy/parse_formula.py,sha256=aTjBt_O-6w8wEdc4nJQprDxbxQK11xJAX_o9VhXSdik,9404 +patsy/redundancy.py,sha256=XEDe6Ym4v4w4MnK63oRfQmWV5PzQQI--2Tdulte__v4,10632 +patsy/splines.py,sha256=A8R163NvLlsbINZAYaWS3uJ2lnQIawFpF1qig7zxjsc,16972 +patsy/state.py,sha256=W8eSHxDr7F-AfpcdRpzqBxESJwG9cZFepSQ8sQr5EBU,6830 +patsy/test_build.py,sha256=2Yj0P8X0LdCRm1UrjoVD0_bOqoT_Hdv4bjZAgmd6T0w,27428 +patsy/test_highlevel.py,sha256=Rs8oh7OSH54OKLFWhHNq4teSZM0MOjZQhXl3cYb8nIw,28617 +patsy/test_regressions.py,sha256=4c_Gdg8KitwKzcPYs4RlFZdtezT7iitqLds7ALzgQBk,849 +patsy/test_splines_bs_data.py,sha256=ocC_FOzdkoLKcwElhw96csdBQBteZSjL7DZBAcTxXqY,144178 +patsy/test_splines_crs_data.py,sha256=9QigM3tZxXWgEwSJKyKer_ka1ccrpnHTI7spRUvsO8o,133390 +patsy/test_state.py,sha256=foA55_WQYoLJNN5N4u9yxhCpDRWOga8feTibONPLLUc,7855 +patsy/tokens.py,sha256=5ytXo9dczgyUm6KU1f40aJl7v1vuQx4lhSDO8iBGtk8,8141 +patsy/user_util.py,sha256=E53372TfMoGX2czUoaW4djN_TVRaIOu4pcYroC2P_p8,9308 +patsy/util.py,sha256=c5x_Ovc6FvwNbSbf2KZF_PawdAjda55bB-JmpuQAoyc,28499 +patsy/version.py,sha256=HVwo82WE9XD2KtPz4k4rFe2sVsaLA9kJt8n71fidUKg,823 diff --git a/venv/lib/python3.10/site-packages/patsy-1.0.1.dist-info/WHEEL b/venv/lib/python3.10/site-packages/patsy-1.0.1.dist-info/WHEEL new file mode 100644 index 0000000000000000000000000000000000000000..4724c45738f6ac125bb3a21787855562e6870440 --- /dev/null +++ b/venv/lib/python3.10/site-packages/patsy-1.0.1.dist-info/WHEEL @@ -0,0 +1,6 @@ +Wheel-Version: 1.0 +Generator: bdist_wheel (0.42.0) +Root-Is-Purelib: true +Tag: py2-none-any +Tag: py3-none-any + diff --git a/venv/lib/python3.10/site-packages/patsy-1.0.1.dist-info/top_level.txt b/venv/lib/python3.10/site-packages/patsy-1.0.1.dist-info/top_level.txt new file mode 100644 index 0000000000000000000000000000000000000000..c8990fe096a12e0d34d48731947c381079324049 --- /dev/null +++ b/venv/lib/python3.10/site-packages/patsy-1.0.1.dist-info/top_level.txt @@ -0,0 +1 @@ +patsy diff --git a/venv/lib/python3.10/site-packages/pip/__pycache__/__init__.cpython-310.pyc b/venv/lib/python3.10/site-packages/pip/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..963f19e588eb20621682bc4f094f17a5a535d4f9 Binary files /dev/null and b/venv/lib/python3.10/site-packages/pip/__pycache__/__init__.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pip/__pycache__/__main__.cpython-310.pyc b/venv/lib/python3.10/site-packages/pip/__pycache__/__main__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..846b4a9ea7696da318f6187f35bc70e4be00da9c Binary files /dev/null and b/venv/lib/python3.10/site-packages/pip/__pycache__/__main__.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pip/__pycache__/__pip-runner__.cpython-310.pyc b/venv/lib/python3.10/site-packages/pip/__pycache__/__pip-runner__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..bff52319f0b860164d673d0731044fe9fa9c4351 Binary files /dev/null and b/venv/lib/python3.10/site-packages/pip/__pycache__/__pip-runner__.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/__pycache__/__init__.cpython-310.pyc b/venv/lib/python3.10/site-packages/pip/_vendor/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6b370ef346f4cae9d8a1a5bdf162e653105a3148 Binary files /dev/null and b/venv/lib/python3.10/site-packages/pip/_vendor/__pycache__/__init__.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/pretty.cpython-310.pyc b/venv/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/pretty.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f74e1993c7ef4e4361e6568ff170d138fd8c7309 Binary files /dev/null and b/venv/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/pretty.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/progress.cpython-310.pyc b/venv/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/progress.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f47707d5ea8e576e427ad67ebda6036a0030eb72 Binary files /dev/null and b/venv/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/progress.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/prompt.cpython-310.pyc b/venv/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/prompt.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d203a701b0f5ef8541070ac15576b5466fedd19b Binary files /dev/null and b/venv/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/prompt.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/protocol.cpython-310.pyc b/venv/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/protocol.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ef252fb11fcd6da674f817bf0b3f8c024f75b02e Binary files /dev/null and b/venv/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/protocol.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/region.cpython-310.pyc b/venv/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/region.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b48f46525cb25fc982b593e4397ba9adbed9c773 Binary files /dev/null and b/venv/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/region.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/repr.cpython-310.pyc b/venv/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/repr.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..577ff5b0167ac5f0ebc96939b15f22ac8ba60e41 Binary files /dev/null and b/venv/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/repr.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/rule.cpython-310.pyc b/venv/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/rule.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9b3c02522048fc218d54a5733c34481664c554d9 Binary files /dev/null and b/venv/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/rule.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/scope.cpython-310.pyc b/venv/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/scope.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3d809a2f866ff2a70963af1c81b305ca343d5077 Binary files /dev/null and b/venv/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/scope.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/screen.cpython-310.pyc b/venv/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/screen.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3c097c3179825b7660741e591b80fac6c010e3f0 Binary files /dev/null and b/venv/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/screen.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/segment.cpython-310.pyc b/venv/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/segment.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2d41f2193b978815e0fb0ba4b37f6a828811b37d Binary files /dev/null and b/venv/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/segment.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/spinner.cpython-310.pyc b/venv/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/spinner.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3ed3e61bf8fa9abef18d44412f4f36a80222a6c4 Binary files /dev/null and b/venv/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/spinner.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/status.cpython-310.pyc b/venv/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/status.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..22cf4d084bcb75311167c7cd030176b73ac59fa1 Binary files /dev/null and b/venv/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/status.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/style.cpython-310.pyc b/venv/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/style.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..428a44fec39123cddaf169a54df1647b8ad854e1 Binary files /dev/null and b/venv/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/style.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/styled.cpython-310.pyc b/venv/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/styled.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..628f87a7e500e496358764814d9b621a1b44b7e5 Binary files /dev/null and b/venv/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/styled.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/syntax.cpython-310.pyc b/venv/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/syntax.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ebfc95d2910eba48f90a4358ab7fef0b1db303ec Binary files /dev/null and b/venv/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/syntax.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/table.cpython-310.pyc b/venv/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/table.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4825a5001532bafe34214bd8ab5c5afec1dc5523 Binary files /dev/null and b/venv/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/table.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/terminal_theme.cpython-310.pyc b/venv/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/terminal_theme.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..de399df2f7a32ca2d88c1a28610ccc105d09d07e Binary files /dev/null and b/venv/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/terminal_theme.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/text.cpython-310.pyc b/venv/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/text.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..35caa1ffc47d72c5668a2480dc22547a97820b14 Binary files /dev/null and b/venv/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/text.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/theme.cpython-310.pyc b/venv/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/theme.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..587c65ec8ea223c5f55456f81cc864dd4b66d0c1 Binary files /dev/null and b/venv/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/theme.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/themes.cpython-310.pyc b/venv/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/themes.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b66337bc3589e3785bae308ecd309db46dad5c15 Binary files /dev/null and b/venv/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/themes.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/traceback.cpython-310.pyc b/venv/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/traceback.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f12add8d1f0202c83c4100897c9930fa00a9ac1a Binary files /dev/null and b/venv/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/traceback.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/tree.cpython-310.pyc b/venv/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/tree.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9502590507588ecf7eaf5e7ad3cc52a6c95817ae Binary files /dev/null and b/venv/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/tree.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/truststore/__pycache__/__init__.cpython-310.pyc b/venv/lib/python3.10/site-packages/pip/_vendor/truststore/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..246767253922ed1584a885690e2398b91dc7602e Binary files /dev/null and b/venv/lib/python3.10/site-packages/pip/_vendor/truststore/__pycache__/__init__.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/truststore/__pycache__/_api.cpython-310.pyc b/venv/lib/python3.10/site-packages/pip/_vendor/truststore/__pycache__/_api.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a11a2c20f65d0cc5cfe11b4bf5d26b2ca8894bad Binary files /dev/null and b/venv/lib/python3.10/site-packages/pip/_vendor/truststore/__pycache__/_api.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/truststore/__pycache__/_macos.cpython-310.pyc b/venv/lib/python3.10/site-packages/pip/_vendor/truststore/__pycache__/_macos.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4b1b0f0923197a3ab320fbbf7a78129678a9da41 Binary files /dev/null and b/venv/lib/python3.10/site-packages/pip/_vendor/truststore/__pycache__/_macos.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/truststore/__pycache__/_openssl.cpython-310.pyc b/venv/lib/python3.10/site-packages/pip/_vendor/truststore/__pycache__/_openssl.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8060ee45c4ee94f98146433ac765d51ccb5ef7cb Binary files /dev/null and b/venv/lib/python3.10/site-packages/pip/_vendor/truststore/__pycache__/_openssl.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/truststore/__pycache__/_ssl_constants.cpython-310.pyc b/venv/lib/python3.10/site-packages/pip/_vendor/truststore/__pycache__/_ssl_constants.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..410f81296b1c8ec0379956cd81070b5e75297be9 Binary files /dev/null and b/venv/lib/python3.10/site-packages/pip/_vendor/truststore/__pycache__/_ssl_constants.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/truststore/__pycache__/_windows.cpython-310.pyc b/venv/lib/python3.10/site-packages/pip/_vendor/truststore/__pycache__/_windows.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2a41d420a2b681e878a2221c4389e448c4b840cc Binary files /dev/null and b/venv/lib/python3.10/site-packages/pip/_vendor/truststore/__pycache__/_windows.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/truststore/_ssl_constants.py b/venv/lib/python3.10/site-packages/pip/_vendor/truststore/_ssl_constants.py new file mode 100644 index 0000000000000000000000000000000000000000..b1ee7a3cb13a8a3482f2cb8cadef097087e3780b --- /dev/null +++ b/venv/lib/python3.10/site-packages/pip/_vendor/truststore/_ssl_constants.py @@ -0,0 +1,31 @@ +import ssl +import sys +import typing + +# Hold on to the original class so we can create it consistently +# even if we inject our own SSLContext into the ssl module. +_original_SSLContext = ssl.SSLContext +_original_super_SSLContext = super(_original_SSLContext, _original_SSLContext) + +# CPython is known to be good, but non-CPython implementations +# may implement SSLContext differently so to be safe we don't +# subclass the SSLContext. + +# This is returned by truststore.SSLContext.__class__() +_truststore_SSLContext_dunder_class: typing.Optional[type] + +# This value is the superclass of truststore.SSLContext. +_truststore_SSLContext_super_class: type + +if sys.implementation.name == "cpython": + _truststore_SSLContext_super_class = _original_SSLContext + _truststore_SSLContext_dunder_class = None +else: + _truststore_SSLContext_super_class = object + _truststore_SSLContext_dunder_class = _original_SSLContext + + +def _set_ssl_context_verify_mode( + ssl_context: ssl.SSLContext, verify_mode: ssl.VerifyMode +) -> None: + _original_super_SSLContext.verify_mode.__set__(ssl_context, verify_mode) # type: ignore[attr-defined] diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/truststore/_windows.py b/venv/lib/python3.10/site-packages/pip/_vendor/truststore/_windows.py new file mode 100644 index 0000000000000000000000000000000000000000..a9bf9abdfc8ed065a2253af17daa07cce4009022 --- /dev/null +++ b/venv/lib/python3.10/site-packages/pip/_vendor/truststore/_windows.py @@ -0,0 +1,567 @@ +import contextlib +import ssl +import typing +from ctypes import WinDLL # type: ignore +from ctypes import WinError # type: ignore +from ctypes import ( + POINTER, + Structure, + c_char_p, + c_ulong, + c_void_p, + c_wchar_p, + cast, + create_unicode_buffer, + pointer, + sizeof, +) +from ctypes.wintypes import ( + BOOL, + DWORD, + HANDLE, + LONG, + LPCSTR, + LPCVOID, + LPCWSTR, + LPFILETIME, + LPSTR, + LPWSTR, +) +from typing import TYPE_CHECKING, Any + +from ._ssl_constants import _set_ssl_context_verify_mode + +HCERTCHAINENGINE = HANDLE +HCERTSTORE = HANDLE +HCRYPTPROV_LEGACY = HANDLE + + +class CERT_CONTEXT(Structure): + _fields_ = ( + ("dwCertEncodingType", DWORD), + ("pbCertEncoded", c_void_p), + ("cbCertEncoded", DWORD), + ("pCertInfo", c_void_p), + ("hCertStore", HCERTSTORE), + ) + + +PCERT_CONTEXT = POINTER(CERT_CONTEXT) +PCCERT_CONTEXT = POINTER(PCERT_CONTEXT) + + +class CERT_ENHKEY_USAGE(Structure): + _fields_ = ( + ("cUsageIdentifier", DWORD), + ("rgpszUsageIdentifier", POINTER(LPSTR)), + ) + + +PCERT_ENHKEY_USAGE = POINTER(CERT_ENHKEY_USAGE) + + +class CERT_USAGE_MATCH(Structure): + _fields_ = ( + ("dwType", DWORD), + ("Usage", CERT_ENHKEY_USAGE), + ) + + +class CERT_CHAIN_PARA(Structure): + _fields_ = ( + ("cbSize", DWORD), + ("RequestedUsage", CERT_USAGE_MATCH), + ("RequestedIssuancePolicy", CERT_USAGE_MATCH), + ("dwUrlRetrievalTimeout", DWORD), + ("fCheckRevocationFreshnessTime", BOOL), + ("dwRevocationFreshnessTime", DWORD), + ("pftCacheResync", LPFILETIME), + ("pStrongSignPara", c_void_p), + ("dwStrongSignFlags", DWORD), + ) + + +if TYPE_CHECKING: + PCERT_CHAIN_PARA = pointer[CERT_CHAIN_PARA] # type: ignore[misc] +else: + PCERT_CHAIN_PARA = POINTER(CERT_CHAIN_PARA) + + +class CERT_TRUST_STATUS(Structure): + _fields_ = ( + ("dwErrorStatus", DWORD), + ("dwInfoStatus", DWORD), + ) + + +class CERT_CHAIN_ELEMENT(Structure): + _fields_ = ( + ("cbSize", DWORD), + ("pCertContext", PCERT_CONTEXT), + ("TrustStatus", CERT_TRUST_STATUS), + ("pRevocationInfo", c_void_p), + ("pIssuanceUsage", PCERT_ENHKEY_USAGE), + ("pApplicationUsage", PCERT_ENHKEY_USAGE), + ("pwszExtendedErrorInfo", LPCWSTR), + ) + + +PCERT_CHAIN_ELEMENT = POINTER(CERT_CHAIN_ELEMENT) + + +class CERT_SIMPLE_CHAIN(Structure): + _fields_ = ( + ("cbSize", DWORD), + ("TrustStatus", CERT_TRUST_STATUS), + ("cElement", DWORD), + ("rgpElement", POINTER(PCERT_CHAIN_ELEMENT)), + ("pTrustListInfo", c_void_p), + ("fHasRevocationFreshnessTime", BOOL), + ("dwRevocationFreshnessTime", DWORD), + ) + + +PCERT_SIMPLE_CHAIN = POINTER(CERT_SIMPLE_CHAIN) + + +class CERT_CHAIN_CONTEXT(Structure): + _fields_ = ( + ("cbSize", DWORD), + ("TrustStatus", CERT_TRUST_STATUS), + ("cChain", DWORD), + ("rgpChain", POINTER(PCERT_SIMPLE_CHAIN)), + ("cLowerQualityChainContext", DWORD), + ("rgpLowerQualityChainContext", c_void_p), + ("fHasRevocationFreshnessTime", BOOL), + ("dwRevocationFreshnessTime", DWORD), + ) + + +PCERT_CHAIN_CONTEXT = POINTER(CERT_CHAIN_CONTEXT) +PCCERT_CHAIN_CONTEXT = POINTER(PCERT_CHAIN_CONTEXT) + + +class SSL_EXTRA_CERT_CHAIN_POLICY_PARA(Structure): + _fields_ = ( + ("cbSize", DWORD), + ("dwAuthType", DWORD), + ("fdwChecks", DWORD), + ("pwszServerName", LPCWSTR), + ) + + +class CERT_CHAIN_POLICY_PARA(Structure): + _fields_ = ( + ("cbSize", DWORD), + ("dwFlags", DWORD), + ("pvExtraPolicyPara", c_void_p), + ) + + +PCERT_CHAIN_POLICY_PARA = POINTER(CERT_CHAIN_POLICY_PARA) + + +class CERT_CHAIN_POLICY_STATUS(Structure): + _fields_ = ( + ("cbSize", DWORD), + ("dwError", DWORD), + ("lChainIndex", LONG), + ("lElementIndex", LONG), + ("pvExtraPolicyStatus", c_void_p), + ) + + +PCERT_CHAIN_POLICY_STATUS = POINTER(CERT_CHAIN_POLICY_STATUS) + + +class CERT_CHAIN_ENGINE_CONFIG(Structure): + _fields_ = ( + ("cbSize", DWORD), + ("hRestrictedRoot", HCERTSTORE), + ("hRestrictedTrust", HCERTSTORE), + ("hRestrictedOther", HCERTSTORE), + ("cAdditionalStore", DWORD), + ("rghAdditionalStore", c_void_p), + ("dwFlags", DWORD), + ("dwUrlRetrievalTimeout", DWORD), + ("MaximumCachedCertificates", DWORD), + ("CycleDetectionModulus", DWORD), + ("hExclusiveRoot", HCERTSTORE), + ("hExclusiveTrustedPeople", HCERTSTORE), + ("dwExclusiveFlags", DWORD), + ) + + +PCERT_CHAIN_ENGINE_CONFIG = POINTER(CERT_CHAIN_ENGINE_CONFIG) +PHCERTCHAINENGINE = POINTER(HCERTCHAINENGINE) + +X509_ASN_ENCODING = 0x00000001 +PKCS_7_ASN_ENCODING = 0x00010000 +CERT_STORE_PROV_MEMORY = b"Memory" +CERT_STORE_ADD_USE_EXISTING = 2 +USAGE_MATCH_TYPE_OR = 1 +OID_PKIX_KP_SERVER_AUTH = c_char_p(b"1.3.6.1.5.5.7.3.1") +CERT_CHAIN_REVOCATION_CHECK_END_CERT = 0x10000000 +CERT_CHAIN_REVOCATION_CHECK_CHAIN = 0x20000000 +CERT_CHAIN_POLICY_IGNORE_ALL_NOT_TIME_VALID_FLAGS = 0x00000007 +CERT_CHAIN_POLICY_IGNORE_INVALID_BASIC_CONSTRAINTS_FLAG = 0x00000008 +CERT_CHAIN_POLICY_ALLOW_UNKNOWN_CA_FLAG = 0x00000010 +CERT_CHAIN_POLICY_IGNORE_INVALID_NAME_FLAG = 0x00000040 +CERT_CHAIN_POLICY_IGNORE_WRONG_USAGE_FLAG = 0x00000020 +CERT_CHAIN_POLICY_IGNORE_INVALID_POLICY_FLAG = 0x00000080 +CERT_CHAIN_POLICY_IGNORE_ALL_REV_UNKNOWN_FLAGS = 0x00000F00 +CERT_CHAIN_POLICY_ALLOW_TESTROOT_FLAG = 0x00008000 +CERT_CHAIN_POLICY_TRUST_TESTROOT_FLAG = 0x00004000 +SECURITY_FLAG_IGNORE_CERT_CN_INVALID = 0x00001000 +AUTHTYPE_SERVER = 2 +CERT_CHAIN_POLICY_SSL = 4 +FORMAT_MESSAGE_FROM_SYSTEM = 0x00001000 +FORMAT_MESSAGE_IGNORE_INSERTS = 0x00000200 + +# Flags to set for SSLContext.verify_mode=CERT_NONE +CERT_CHAIN_POLICY_VERIFY_MODE_NONE_FLAGS = ( + CERT_CHAIN_POLICY_IGNORE_ALL_NOT_TIME_VALID_FLAGS + | CERT_CHAIN_POLICY_IGNORE_INVALID_BASIC_CONSTRAINTS_FLAG + | CERT_CHAIN_POLICY_ALLOW_UNKNOWN_CA_FLAG + | CERT_CHAIN_POLICY_IGNORE_INVALID_NAME_FLAG + | CERT_CHAIN_POLICY_IGNORE_WRONG_USAGE_FLAG + | CERT_CHAIN_POLICY_IGNORE_INVALID_POLICY_FLAG + | CERT_CHAIN_POLICY_IGNORE_ALL_REV_UNKNOWN_FLAGS + | CERT_CHAIN_POLICY_ALLOW_TESTROOT_FLAG + | CERT_CHAIN_POLICY_TRUST_TESTROOT_FLAG +) + +wincrypt = WinDLL("crypt32.dll") +kernel32 = WinDLL("kernel32.dll") + + +def _handle_win_error(result: bool, _: Any, args: Any) -> Any: + if not result: + # Note, actually raises OSError after calling GetLastError and FormatMessage + raise WinError() + return args + + +CertCreateCertificateChainEngine = wincrypt.CertCreateCertificateChainEngine +CertCreateCertificateChainEngine.argtypes = ( + PCERT_CHAIN_ENGINE_CONFIG, + PHCERTCHAINENGINE, +) +CertCreateCertificateChainEngine.errcheck = _handle_win_error + +CertOpenStore = wincrypt.CertOpenStore +CertOpenStore.argtypes = (LPCSTR, DWORD, HCRYPTPROV_LEGACY, DWORD, c_void_p) +CertOpenStore.restype = HCERTSTORE +CertOpenStore.errcheck = _handle_win_error + +CertAddEncodedCertificateToStore = wincrypt.CertAddEncodedCertificateToStore +CertAddEncodedCertificateToStore.argtypes = ( + HCERTSTORE, + DWORD, + c_char_p, + DWORD, + DWORD, + PCCERT_CONTEXT, +) +CertAddEncodedCertificateToStore.restype = BOOL + +CertCreateCertificateContext = wincrypt.CertCreateCertificateContext +CertCreateCertificateContext.argtypes = (DWORD, c_char_p, DWORD) +CertCreateCertificateContext.restype = PCERT_CONTEXT +CertCreateCertificateContext.errcheck = _handle_win_error + +CertGetCertificateChain = wincrypt.CertGetCertificateChain +CertGetCertificateChain.argtypes = ( + HCERTCHAINENGINE, + PCERT_CONTEXT, + LPFILETIME, + HCERTSTORE, + PCERT_CHAIN_PARA, + DWORD, + c_void_p, + PCCERT_CHAIN_CONTEXT, +) +CertGetCertificateChain.restype = BOOL +CertGetCertificateChain.errcheck = _handle_win_error + +CertVerifyCertificateChainPolicy = wincrypt.CertVerifyCertificateChainPolicy +CertVerifyCertificateChainPolicy.argtypes = ( + c_ulong, + PCERT_CHAIN_CONTEXT, + PCERT_CHAIN_POLICY_PARA, + PCERT_CHAIN_POLICY_STATUS, +) +CertVerifyCertificateChainPolicy.restype = BOOL + +CertCloseStore = wincrypt.CertCloseStore +CertCloseStore.argtypes = (HCERTSTORE, DWORD) +CertCloseStore.restype = BOOL +CertCloseStore.errcheck = _handle_win_error + +CertFreeCertificateChain = wincrypt.CertFreeCertificateChain +CertFreeCertificateChain.argtypes = (PCERT_CHAIN_CONTEXT,) + +CertFreeCertificateContext = wincrypt.CertFreeCertificateContext +CertFreeCertificateContext.argtypes = (PCERT_CONTEXT,) + +CertFreeCertificateChainEngine = wincrypt.CertFreeCertificateChainEngine +CertFreeCertificateChainEngine.argtypes = (HCERTCHAINENGINE,) + +FormatMessageW = kernel32.FormatMessageW +FormatMessageW.argtypes = ( + DWORD, + LPCVOID, + DWORD, + DWORD, + LPWSTR, + DWORD, + c_void_p, +) +FormatMessageW.restype = DWORD + + +def _verify_peercerts_impl( + ssl_context: ssl.SSLContext, + cert_chain: list[bytes], + server_hostname: str | None = None, +) -> None: + """Verify the cert_chain from the server using Windows APIs.""" + + # If the peer didn't send any certificates then + # we can't do verification. Raise an error. + if not cert_chain: + raise ssl.SSLCertVerificationError("Peer sent no certificates to verify") + + pCertContext = None + hIntermediateCertStore = CertOpenStore(CERT_STORE_PROV_MEMORY, 0, None, 0, None) + try: + # Add intermediate certs to an in-memory cert store + for cert_bytes in cert_chain[1:]: + CertAddEncodedCertificateToStore( + hIntermediateCertStore, + X509_ASN_ENCODING | PKCS_7_ASN_ENCODING, + cert_bytes, + len(cert_bytes), + CERT_STORE_ADD_USE_EXISTING, + None, + ) + + # Cert context for leaf cert + leaf_cert = cert_chain[0] + pCertContext = CertCreateCertificateContext( + X509_ASN_ENCODING | PKCS_7_ASN_ENCODING, leaf_cert, len(leaf_cert) + ) + + # Chain params to match certs for serverAuth extended usage + cert_enhkey_usage = CERT_ENHKEY_USAGE() + cert_enhkey_usage.cUsageIdentifier = 1 + cert_enhkey_usage.rgpszUsageIdentifier = (c_char_p * 1)(OID_PKIX_KP_SERVER_AUTH) + cert_usage_match = CERT_USAGE_MATCH() + cert_usage_match.Usage = cert_enhkey_usage + chain_params = CERT_CHAIN_PARA() + chain_params.RequestedUsage = cert_usage_match + chain_params.cbSize = sizeof(chain_params) + pChainPara = pointer(chain_params) + + if ssl_context.verify_flags & ssl.VERIFY_CRL_CHECK_CHAIN: + chain_flags = CERT_CHAIN_REVOCATION_CHECK_CHAIN + elif ssl_context.verify_flags & ssl.VERIFY_CRL_CHECK_LEAF: + chain_flags = CERT_CHAIN_REVOCATION_CHECK_END_CERT + else: + chain_flags = 0 + + try: + # First attempt to verify using the default Windows system trust roots + # (default chain engine). + _get_and_verify_cert_chain( + ssl_context, + None, + hIntermediateCertStore, + pCertContext, + pChainPara, + server_hostname, + chain_flags=chain_flags, + ) + except ssl.SSLCertVerificationError as e: + # If that fails but custom CA certs have been added + # to the SSLContext using load_verify_locations, + # try verifying using a custom chain engine + # that trusts the custom CA certs. + custom_ca_certs: list[bytes] | None = ssl_context.get_ca_certs( + binary_form=True + ) + if custom_ca_certs: + try: + _verify_using_custom_ca_certs( + ssl_context, + custom_ca_certs, + hIntermediateCertStore, + pCertContext, + pChainPara, + server_hostname, + chain_flags=chain_flags, + ) + # Raise the original error, not the new error. + except ssl.SSLCertVerificationError: + raise e from None + else: + raise + finally: + CertCloseStore(hIntermediateCertStore, 0) + if pCertContext: + CertFreeCertificateContext(pCertContext) + + +def _get_and_verify_cert_chain( + ssl_context: ssl.SSLContext, + hChainEngine: HCERTCHAINENGINE | None, + hIntermediateCertStore: HCERTSTORE, + pPeerCertContext: c_void_p, + pChainPara: PCERT_CHAIN_PARA, # type: ignore[valid-type] + server_hostname: str | None, + chain_flags: int, +) -> None: + ppChainContext = None + try: + # Get cert chain + ppChainContext = pointer(PCERT_CHAIN_CONTEXT()) + CertGetCertificateChain( + hChainEngine, # chain engine + pPeerCertContext, # leaf cert context + None, # current system time + hIntermediateCertStore, # additional in-memory cert store + pChainPara, # chain-building parameters + chain_flags, + None, # reserved + ppChainContext, # the resulting chain context + ) + pChainContext = ppChainContext.contents + + # Verify cert chain + ssl_extra_cert_chain_policy_para = SSL_EXTRA_CERT_CHAIN_POLICY_PARA() + ssl_extra_cert_chain_policy_para.cbSize = sizeof( + ssl_extra_cert_chain_policy_para + ) + ssl_extra_cert_chain_policy_para.dwAuthType = AUTHTYPE_SERVER + ssl_extra_cert_chain_policy_para.fdwChecks = 0 + if ssl_context.check_hostname is False: + ssl_extra_cert_chain_policy_para.fdwChecks = ( + SECURITY_FLAG_IGNORE_CERT_CN_INVALID + ) + if server_hostname: + ssl_extra_cert_chain_policy_para.pwszServerName = c_wchar_p(server_hostname) + + chain_policy = CERT_CHAIN_POLICY_PARA() + chain_policy.pvExtraPolicyPara = cast( + pointer(ssl_extra_cert_chain_policy_para), c_void_p + ) + if ssl_context.verify_mode == ssl.CERT_NONE: + chain_policy.dwFlags |= CERT_CHAIN_POLICY_VERIFY_MODE_NONE_FLAGS + chain_policy.cbSize = sizeof(chain_policy) + + pPolicyPara = pointer(chain_policy) + policy_status = CERT_CHAIN_POLICY_STATUS() + policy_status.cbSize = sizeof(policy_status) + pPolicyStatus = pointer(policy_status) + CertVerifyCertificateChainPolicy( + CERT_CHAIN_POLICY_SSL, + pChainContext, + pPolicyPara, + pPolicyStatus, + ) + + # Check status + error_code = policy_status.dwError + if error_code: + # Try getting a human readable message for an error code. + error_message_buf = create_unicode_buffer(1024) + error_message_chars = FormatMessageW( + FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, + None, + error_code, + 0, + error_message_buf, + sizeof(error_message_buf), + None, + ) + + # See if we received a message for the error, + # otherwise we use a generic error with the + # error code and hope that it's search-able. + if error_message_chars <= 0: + error_message = f"Certificate chain policy error {error_code:#x} [{policy_status.lElementIndex}]" + else: + error_message = error_message_buf.value.strip() + + err = ssl.SSLCertVerificationError(error_message) + err.verify_message = error_message + err.verify_code = error_code + raise err from None + finally: + if ppChainContext: + CertFreeCertificateChain(ppChainContext.contents) + + +def _verify_using_custom_ca_certs( + ssl_context: ssl.SSLContext, + custom_ca_certs: list[bytes], + hIntermediateCertStore: HCERTSTORE, + pPeerCertContext: c_void_p, + pChainPara: PCERT_CHAIN_PARA, # type: ignore[valid-type] + server_hostname: str | None, + chain_flags: int, +) -> None: + hChainEngine = None + hRootCertStore = CertOpenStore(CERT_STORE_PROV_MEMORY, 0, None, 0, None) + try: + # Add custom CA certs to an in-memory cert store + for cert_bytes in custom_ca_certs: + CertAddEncodedCertificateToStore( + hRootCertStore, + X509_ASN_ENCODING | PKCS_7_ASN_ENCODING, + cert_bytes, + len(cert_bytes), + CERT_STORE_ADD_USE_EXISTING, + None, + ) + + # Create a custom cert chain engine which exclusively trusts + # certs from our hRootCertStore + cert_chain_engine_config = CERT_CHAIN_ENGINE_CONFIG() + cert_chain_engine_config.cbSize = sizeof(cert_chain_engine_config) + cert_chain_engine_config.hExclusiveRoot = hRootCertStore + pConfig = pointer(cert_chain_engine_config) + phChainEngine = pointer(HCERTCHAINENGINE()) + CertCreateCertificateChainEngine( + pConfig, + phChainEngine, + ) + hChainEngine = phChainEngine.contents + + # Get and verify a cert chain using the custom chain engine + _get_and_verify_cert_chain( + ssl_context, + hChainEngine, + hIntermediateCertStore, + pPeerCertContext, + pChainPara, + server_hostname, + chain_flags, + ) + finally: + if hChainEngine: + CertFreeCertificateChainEngine(hChainEngine) + CertCloseStore(hRootCertStore, 0) + + +@contextlib.contextmanager +def _configure_context(ctx: ssl.SSLContext) -> typing.Iterator[None]: + check_hostname = ctx.check_hostname + verify_mode = ctx.verify_mode + ctx.check_hostname = False + _set_ssl_context_verify_mode(ctx, ssl.CERT_NONE) + try: + yield + finally: + ctx.check_hostname = check_hostname + _set_ssl_context_verify_mode(ctx, verify_mode) diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/truststore/py.typed b/venv/lib/python3.10/site-packages/pip/_vendor/truststore/py.typed new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/__init__.py b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..c6fa38212fb559a9b51fe36b72892839efae63f5 --- /dev/null +++ b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/__init__.py @@ -0,0 +1,102 @@ +""" +Python HTTP library with thread-safe connection pooling, file post support, user friendly, and more +""" +from __future__ import absolute_import + +# Set default logging handler to avoid "No handler found" warnings. +import logging +import warnings +from logging import NullHandler + +from . import exceptions +from ._version import __version__ +from .connectionpool import HTTPConnectionPool, HTTPSConnectionPool, connection_from_url +from .filepost import encode_multipart_formdata +from .poolmanager import PoolManager, ProxyManager, proxy_from_url +from .response import HTTPResponse +from .util.request import make_headers +from .util.retry import Retry +from .util.timeout import Timeout +from .util.url import get_host + +# === NOTE TO REPACKAGERS AND VENDORS === +# Please delete this block, this logic is only +# for urllib3 being distributed via PyPI. +# See: https://github.com/urllib3/urllib3/issues/2680 +try: + import urllib3_secure_extra # type: ignore # noqa: F401 +except ImportError: + pass +else: + warnings.warn( + "'urllib3[secure]' extra is deprecated and will be removed " + "in a future release of urllib3 2.x. Read more in this issue: " + "https://github.com/urllib3/urllib3/issues/2680", + category=DeprecationWarning, + stacklevel=2, + ) + +__author__ = "Andrey Petrov (andrey.petrov@shazow.net)" +__license__ = "MIT" +__version__ = __version__ + +__all__ = ( + "HTTPConnectionPool", + "HTTPSConnectionPool", + "PoolManager", + "ProxyManager", + "HTTPResponse", + "Retry", + "Timeout", + "add_stderr_logger", + "connection_from_url", + "disable_warnings", + "encode_multipart_formdata", + "get_host", + "make_headers", + "proxy_from_url", +) + +logging.getLogger(__name__).addHandler(NullHandler()) + + +def add_stderr_logger(level=logging.DEBUG): + """ + Helper for quickly adding a StreamHandler to the logger. Useful for + debugging. + + Returns the handler after adding it. + """ + # This method needs to be in this __init__.py to get the __name__ correct + # even if urllib3 is vendored within another package. + logger = logging.getLogger(__name__) + handler = logging.StreamHandler() + handler.setFormatter(logging.Formatter("%(asctime)s %(levelname)s %(message)s")) + logger.addHandler(handler) + logger.setLevel(level) + logger.debug("Added a stderr logging handler to logger: %s", __name__) + return handler + + +# ... Clean up. +del NullHandler + + +# All warning filters *must* be appended unless you're really certain that they +# shouldn't be: otherwise, it's very hard for users to use most Python +# mechanisms to silence them. +# SecurityWarning's always go off by default. +warnings.simplefilter("always", exceptions.SecurityWarning, append=True) +# SubjectAltNameWarning's should go off once per host +warnings.simplefilter("default", exceptions.SubjectAltNameWarning, append=True) +# InsecurePlatformWarning's don't vary between requests, so we keep it default. +warnings.simplefilter("default", exceptions.InsecurePlatformWarning, append=True) +# SNIMissingWarnings should go off only once. +warnings.simplefilter("default", exceptions.SNIMissingWarning, append=True) + + +def disable_warnings(category=exceptions.HTTPWarning): + """ + Helper for quickly disabling all urllib3 warnings. + """ + warnings.simplefilter("ignore", category) diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/__pycache__/__init__.cpython-310.pyc b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8c99eea30ebd0f25c1b881cb121afffedc403d0f Binary files /dev/null and b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/__pycache__/__init__.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/__pycache__/_collections.cpython-310.pyc b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/__pycache__/_collections.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5f649f8a75d1f5abfb25867e06820649d1e74fcb Binary files /dev/null and b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/__pycache__/_collections.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/__pycache__/_version.cpython-310.pyc b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/__pycache__/_version.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..86a7887f6b66f21166e4cd6573e1bf74053e58ea Binary files /dev/null and b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/__pycache__/_version.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/__pycache__/connection.cpython-310.pyc b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/__pycache__/connection.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..15b04f035301d7b88c05ed3decd1a4e70ad57759 Binary files /dev/null and b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/__pycache__/connection.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/__pycache__/connectionpool.cpython-310.pyc b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/__pycache__/connectionpool.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1ba12683008a11b2ec0d4431fc70fe972a9e66a6 Binary files /dev/null and b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/__pycache__/connectionpool.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/__pycache__/exceptions.cpython-310.pyc b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/__pycache__/exceptions.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..962586b9ad4e1ef39efb93b21a574d0715a6f23d Binary files /dev/null and b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/__pycache__/exceptions.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/__pycache__/fields.cpython-310.pyc b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/__pycache__/fields.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..77254f0e4eb304d5dc9e04b7dd8fa6a3ed66b130 Binary files /dev/null and b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/__pycache__/fields.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/__pycache__/filepost.cpython-310.pyc b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/__pycache__/filepost.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0667136498531e6a30254b5c00a51ed449dff51d Binary files /dev/null and b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/__pycache__/filepost.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/__pycache__/poolmanager.cpython-310.pyc b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/__pycache__/poolmanager.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4ccb7cabf09314cd80b18c7258936b569606158e Binary files /dev/null and b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/__pycache__/poolmanager.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/__pycache__/request.cpython-310.pyc b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/__pycache__/request.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f00b1c35f3cf76914004b5f206d7ef3bfdb62475 Binary files /dev/null and b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/__pycache__/request.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/__pycache__/response.cpython-310.pyc b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/__pycache__/response.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..522633f3dd687dff853c10034dcbf76e1749a007 Binary files /dev/null and b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/__pycache__/response.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/_collections.py b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/_collections.py new file mode 100644 index 0000000000000000000000000000000000000000..bceb8451f0e761f623b88c9b4d5341630d05f9ce --- /dev/null +++ b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/_collections.py @@ -0,0 +1,355 @@ +from __future__ import absolute_import + +try: + from collections.abc import Mapping, MutableMapping +except ImportError: + from collections import Mapping, MutableMapping +try: + from threading import RLock +except ImportError: # Platform-specific: No threads available + + class RLock: + def __enter__(self): + pass + + def __exit__(self, exc_type, exc_value, traceback): + pass + + +from collections import OrderedDict + +from .exceptions import InvalidHeader +from .packages import six +from .packages.six import iterkeys, itervalues + +__all__ = ["RecentlyUsedContainer", "HTTPHeaderDict"] + + +_Null = object() + + +class RecentlyUsedContainer(MutableMapping): + """ + Provides a thread-safe dict-like container which maintains up to + ``maxsize`` keys while throwing away the least-recently-used keys beyond + ``maxsize``. + + :param maxsize: + Maximum number of recent elements to retain. + + :param dispose_func: + Every time an item is evicted from the container, + ``dispose_func(value)`` is called. Callback which will get called + """ + + ContainerCls = OrderedDict + + def __init__(self, maxsize=10, dispose_func=None): + self._maxsize = maxsize + self.dispose_func = dispose_func + + self._container = self.ContainerCls() + self.lock = RLock() + + def __getitem__(self, key): + # Re-insert the item, moving it to the end of the eviction line. + with self.lock: + item = self._container.pop(key) + self._container[key] = item + return item + + def __setitem__(self, key, value): + evicted_value = _Null + with self.lock: + # Possibly evict the existing value of 'key' + evicted_value = self._container.get(key, _Null) + self._container[key] = value + + # If we didn't evict an existing value, we might have to evict the + # least recently used item from the beginning of the container. + if len(self._container) > self._maxsize: + _key, evicted_value = self._container.popitem(last=False) + + if self.dispose_func and evicted_value is not _Null: + self.dispose_func(evicted_value) + + def __delitem__(self, key): + with self.lock: + value = self._container.pop(key) + + if self.dispose_func: + self.dispose_func(value) + + def __len__(self): + with self.lock: + return len(self._container) + + def __iter__(self): + raise NotImplementedError( + "Iteration over this class is unlikely to be threadsafe." + ) + + def clear(self): + with self.lock: + # Copy pointers to all values, then wipe the mapping + values = list(itervalues(self._container)) + self._container.clear() + + if self.dispose_func: + for value in values: + self.dispose_func(value) + + def keys(self): + with self.lock: + return list(iterkeys(self._container)) + + +class HTTPHeaderDict(MutableMapping): + """ + :param headers: + An iterable of field-value pairs. Must not contain multiple field names + when compared case-insensitively. + + :param kwargs: + Additional field-value pairs to pass in to ``dict.update``. + + A ``dict`` like container for storing HTTP Headers. + + Field names are stored and compared case-insensitively in compliance with + RFC 7230. Iteration provides the first case-sensitive key seen for each + case-insensitive pair. + + Using ``__setitem__`` syntax overwrites fields that compare equal + case-insensitively in order to maintain ``dict``'s api. For fields that + compare equal, instead create a new ``HTTPHeaderDict`` and use ``.add`` + in a loop. + + If multiple fields that are equal case-insensitively are passed to the + constructor or ``.update``, the behavior is undefined and some will be + lost. + + >>> headers = HTTPHeaderDict() + >>> headers.add('Set-Cookie', 'foo=bar') + >>> headers.add('set-cookie', 'baz=quxx') + >>> headers['content-length'] = '7' + >>> headers['SET-cookie'] + 'foo=bar, baz=quxx' + >>> headers['Content-Length'] + '7' + """ + + def __init__(self, headers=None, **kwargs): + super(HTTPHeaderDict, self).__init__() + self._container = OrderedDict() + if headers is not None: + if isinstance(headers, HTTPHeaderDict): + self._copy_from(headers) + else: + self.extend(headers) + if kwargs: + self.extend(kwargs) + + def __setitem__(self, key, val): + self._container[key.lower()] = [key, val] + return self._container[key.lower()] + + def __getitem__(self, key): + val = self._container[key.lower()] + return ", ".join(val[1:]) + + def __delitem__(self, key): + del self._container[key.lower()] + + def __contains__(self, key): + return key.lower() in self._container + + def __eq__(self, other): + if not isinstance(other, Mapping) and not hasattr(other, "keys"): + return False + if not isinstance(other, type(self)): + other = type(self)(other) + return dict((k.lower(), v) for k, v in self.itermerged()) == dict( + (k.lower(), v) for k, v in other.itermerged() + ) + + def __ne__(self, other): + return not self.__eq__(other) + + if six.PY2: # Python 2 + iterkeys = MutableMapping.iterkeys + itervalues = MutableMapping.itervalues + + __marker = object() + + def __len__(self): + return len(self._container) + + def __iter__(self): + # Only provide the originally cased names + for vals in self._container.values(): + yield vals[0] + + def pop(self, key, default=__marker): + """D.pop(k[,d]) -> v, remove specified key and return the corresponding value. + If key is not found, d is returned if given, otherwise KeyError is raised. + """ + # Using the MutableMapping function directly fails due to the private marker. + # Using ordinary dict.pop would expose the internal structures. + # So let's reinvent the wheel. + try: + value = self[key] + except KeyError: + if default is self.__marker: + raise + return default + else: + del self[key] + return value + + def discard(self, key): + try: + del self[key] + except KeyError: + pass + + def add(self, key, val): + """Adds a (name, value) pair, doesn't overwrite the value if it already + exists. + + >>> headers = HTTPHeaderDict(foo='bar') + >>> headers.add('Foo', 'baz') + >>> headers['foo'] + 'bar, baz' + """ + key_lower = key.lower() + new_vals = [key, val] + # Keep the common case aka no item present as fast as possible + vals = self._container.setdefault(key_lower, new_vals) + if new_vals is not vals: + vals.append(val) + + def extend(self, *args, **kwargs): + """Generic import function for any type of header-like object. + Adapted version of MutableMapping.update in order to insert items + with self.add instead of self.__setitem__ + """ + if len(args) > 1: + raise TypeError( + "extend() takes at most 1 positional " + "arguments ({0} given)".format(len(args)) + ) + other = args[0] if len(args) >= 1 else () + + if isinstance(other, HTTPHeaderDict): + for key, val in other.iteritems(): + self.add(key, val) + elif isinstance(other, Mapping): + for key in other: + self.add(key, other[key]) + elif hasattr(other, "keys"): + for key in other.keys(): + self.add(key, other[key]) + else: + for key, value in other: + self.add(key, value) + + for key, value in kwargs.items(): + self.add(key, value) + + def getlist(self, key, default=__marker): + """Returns a list of all the values for the named field. Returns an + empty list if the key doesn't exist.""" + try: + vals = self._container[key.lower()] + except KeyError: + if default is self.__marker: + return [] + return default + else: + return vals[1:] + + def _prepare_for_method_change(self): + """ + Remove content-specific header fields before changing the request + method to GET or HEAD according to RFC 9110, Section 15.4. + """ + content_specific_headers = [ + "Content-Encoding", + "Content-Language", + "Content-Location", + "Content-Type", + "Content-Length", + "Digest", + "Last-Modified", + ] + for header in content_specific_headers: + self.discard(header) + return self + + # Backwards compatibility for httplib + getheaders = getlist + getallmatchingheaders = getlist + iget = getlist + + # Backwards compatibility for http.cookiejar + get_all = getlist + + def __repr__(self): + return "%s(%s)" % (type(self).__name__, dict(self.itermerged())) + + def _copy_from(self, other): + for key in other: + val = other.getlist(key) + if isinstance(val, list): + # Don't need to convert tuples + val = list(val) + self._container[key.lower()] = [key] + val + + def copy(self): + clone = type(self)() + clone._copy_from(self) + return clone + + def iteritems(self): + """Iterate over all header lines, including duplicate ones.""" + for key in self: + vals = self._container[key.lower()] + for val in vals[1:]: + yield vals[0], val + + def itermerged(self): + """Iterate over all headers, merging duplicate ones together.""" + for key in self: + val = self._container[key.lower()] + yield val[0], ", ".join(val[1:]) + + def items(self): + return list(self.iteritems()) + + @classmethod + def from_httplib(cls, message): # Python 2 + """Read headers from a Python 2 httplib message object.""" + # python2.7 does not expose a proper API for exporting multiheaders + # efficiently. This function re-reads raw lines from the message + # object and extracts the multiheaders properly. + obs_fold_continued_leaders = (" ", "\t") + headers = [] + + for line in message.headers: + if line.startswith(obs_fold_continued_leaders): + if not headers: + # We received a header line that starts with OWS as described + # in RFC-7230 S3.2.4. This indicates a multiline header, but + # there exists no previous header to which we can attach it. + raise InvalidHeader( + "Header continuation with no previous header: %s" % line + ) + else: + key, value = headers[-1] + headers[-1] = (key, value + " " + line.strip()) + continue + + key, value = line.split(":", 1) + headers.append((key, value.strip())) + + return cls(headers) diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/_version.py b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/_version.py new file mode 100644 index 0000000000000000000000000000000000000000..d49df2a0c543623b5568c3a2f9b3cc12f1023ecb --- /dev/null +++ b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/_version.py @@ -0,0 +1,2 @@ +# This file is protected via CODEOWNERS +__version__ = "1.26.20" diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/connection.py b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/connection.py new file mode 100644 index 0000000000000000000000000000000000000000..de35b63d670d8be799ba60d3ac0a5da4742562ac --- /dev/null +++ b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/connection.py @@ -0,0 +1,572 @@ +from __future__ import absolute_import + +import datetime +import logging +import os +import re +import socket +import warnings +from socket import error as SocketError +from socket import timeout as SocketTimeout + +from .packages import six +from .packages.six.moves.http_client import HTTPConnection as _HTTPConnection +from .packages.six.moves.http_client import HTTPException # noqa: F401 +from .util.proxy import create_proxy_ssl_context + +try: # Compiled with SSL? + import ssl + + BaseSSLError = ssl.SSLError +except (ImportError, AttributeError): # Platform-specific: No SSL. + ssl = None + + class BaseSSLError(BaseException): + pass + + +try: + # Python 3: not a no-op, we're adding this to the namespace so it can be imported. + ConnectionError = ConnectionError +except NameError: + # Python 2 + class ConnectionError(Exception): + pass + + +try: # Python 3: + # Not a no-op, we're adding this to the namespace so it can be imported. + BrokenPipeError = BrokenPipeError +except NameError: # Python 2: + + class BrokenPipeError(Exception): + pass + + +from ._collections import HTTPHeaderDict # noqa (historical, removed in v2) +from ._version import __version__ +from .exceptions import ( + ConnectTimeoutError, + NewConnectionError, + SubjectAltNameWarning, + SystemTimeWarning, +) +from .util import SKIP_HEADER, SKIPPABLE_HEADERS, connection +from .util.ssl_ import ( + assert_fingerprint, + create_urllib3_context, + is_ipaddress, + resolve_cert_reqs, + resolve_ssl_version, + ssl_wrap_socket, +) +from .util.ssl_match_hostname import CertificateError, match_hostname + +log = logging.getLogger(__name__) + +port_by_scheme = {"http": 80, "https": 443} + +# When it comes time to update this value as a part of regular maintenance +# (ie test_recent_date is failing) update it to ~6 months before the current date. +RECENT_DATE = datetime.date(2024, 1, 1) + +_CONTAINS_CONTROL_CHAR_RE = re.compile(r"[^-!#$%&'*+.^_`|~0-9a-zA-Z]") + + +class HTTPConnection(_HTTPConnection, object): + """ + Based on :class:`http.client.HTTPConnection` but provides an extra constructor + backwards-compatibility layer between older and newer Pythons. + + Additional keyword parameters are used to configure attributes of the connection. + Accepted parameters include: + + - ``strict``: See the documentation on :class:`urllib3.connectionpool.HTTPConnectionPool` + - ``source_address``: Set the source address for the current connection. + - ``socket_options``: Set specific options on the underlying socket. If not specified, then + defaults are loaded from ``HTTPConnection.default_socket_options`` which includes disabling + Nagle's algorithm (sets TCP_NODELAY to 1) unless the connection is behind a proxy. + + For example, if you wish to enable TCP Keep Alive in addition to the defaults, + you might pass: + + .. code-block:: python + + HTTPConnection.default_socket_options + [ + (socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1), + ] + + Or you may want to disable the defaults by passing an empty list (e.g., ``[]``). + """ + + default_port = port_by_scheme["http"] + + #: Disable Nagle's algorithm by default. + #: ``[(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)]`` + default_socket_options = [(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)] + + #: Whether this connection verifies the host's certificate. + is_verified = False + + #: Whether this proxy connection (if used) verifies the proxy host's + #: certificate. + proxy_is_verified = None + + def __init__(self, *args, **kw): + if not six.PY2: + kw.pop("strict", None) + + # Pre-set source_address. + self.source_address = kw.get("source_address") + + #: The socket options provided by the user. If no options are + #: provided, we use the default options. + self.socket_options = kw.pop("socket_options", self.default_socket_options) + + # Proxy options provided by the user. + self.proxy = kw.pop("proxy", None) + self.proxy_config = kw.pop("proxy_config", None) + + _HTTPConnection.__init__(self, *args, **kw) + + @property + def host(self): + """ + Getter method to remove any trailing dots that indicate the hostname is an FQDN. + + In general, SSL certificates don't include the trailing dot indicating a + fully-qualified domain name, and thus, they don't validate properly when + checked against a domain name that includes the dot. In addition, some + servers may not expect to receive the trailing dot when provided. + + However, the hostname with trailing dot is critical to DNS resolution; doing a + lookup with the trailing dot will properly only resolve the appropriate FQDN, + whereas a lookup without a trailing dot will search the system's search domain + list. Thus, it's important to keep the original host around for use only in + those cases where it's appropriate (i.e., when doing DNS lookup to establish the + actual TCP connection across which we're going to send HTTP requests). + """ + return self._dns_host.rstrip(".") + + @host.setter + def host(self, value): + """ + Setter for the `host` property. + + We assume that only urllib3 uses the _dns_host attribute; httplib itself + only uses `host`, and it seems reasonable that other libraries follow suit. + """ + self._dns_host = value + + def _new_conn(self): + """Establish a socket connection and set nodelay settings on it. + + :return: New socket connection. + """ + extra_kw = {} + if self.source_address: + extra_kw["source_address"] = self.source_address + + if self.socket_options: + extra_kw["socket_options"] = self.socket_options + + try: + conn = connection.create_connection( + (self._dns_host, self.port), self.timeout, **extra_kw + ) + + except SocketTimeout: + raise ConnectTimeoutError( + self, + "Connection to %s timed out. (connect timeout=%s)" + % (self.host, self.timeout), + ) + + except SocketError as e: + raise NewConnectionError( + self, "Failed to establish a new connection: %s" % e + ) + + return conn + + def _is_using_tunnel(self): + # Google App Engine's httplib does not define _tunnel_host + return getattr(self, "_tunnel_host", None) + + def _prepare_conn(self, conn): + self.sock = conn + if self._is_using_tunnel(): + # TODO: Fix tunnel so it doesn't depend on self.sock state. + self._tunnel() + # Mark this connection as not reusable + self.auto_open = 0 + + def connect(self): + conn = self._new_conn() + self._prepare_conn(conn) + + def putrequest(self, method, url, *args, **kwargs): + """ """ + # Empty docstring because the indentation of CPython's implementation + # is broken but we don't want this method in our documentation. + match = _CONTAINS_CONTROL_CHAR_RE.search(method) + if match: + raise ValueError( + "Method cannot contain non-token characters %r (found at least %r)" + % (method, match.group()) + ) + + return _HTTPConnection.putrequest(self, method, url, *args, **kwargs) + + def putheader(self, header, *values): + """ """ + if not any(isinstance(v, str) and v == SKIP_HEADER for v in values): + _HTTPConnection.putheader(self, header, *values) + elif six.ensure_str(header.lower()) not in SKIPPABLE_HEADERS: + raise ValueError( + "urllib3.util.SKIP_HEADER only supports '%s'" + % ("', '".join(map(str.title, sorted(SKIPPABLE_HEADERS))),) + ) + + def request(self, method, url, body=None, headers=None): + # Update the inner socket's timeout value to send the request. + # This only triggers if the connection is re-used. + if getattr(self, "sock", None) is not None: + self.sock.settimeout(self.timeout) + + if headers is None: + headers = {} + else: + # Avoid modifying the headers passed into .request() + headers = headers.copy() + if "user-agent" not in (six.ensure_str(k.lower()) for k in headers): + headers["User-Agent"] = _get_default_user_agent() + super(HTTPConnection, self).request(method, url, body=body, headers=headers) + + def request_chunked(self, method, url, body=None, headers=None): + """ + Alternative to the common request method, which sends the + body with chunked encoding and not as one block + """ + headers = headers or {} + header_keys = set([six.ensure_str(k.lower()) for k in headers]) + skip_accept_encoding = "accept-encoding" in header_keys + skip_host = "host" in header_keys + self.putrequest( + method, url, skip_accept_encoding=skip_accept_encoding, skip_host=skip_host + ) + if "user-agent" not in header_keys: + self.putheader("User-Agent", _get_default_user_agent()) + for header, value in headers.items(): + self.putheader(header, value) + if "transfer-encoding" not in header_keys: + self.putheader("Transfer-Encoding", "chunked") + self.endheaders() + + if body is not None: + stringish_types = six.string_types + (bytes,) + if isinstance(body, stringish_types): + body = (body,) + for chunk in body: + if not chunk: + continue + if not isinstance(chunk, bytes): + chunk = chunk.encode("utf8") + len_str = hex(len(chunk))[2:] + to_send = bytearray(len_str.encode()) + to_send += b"\r\n" + to_send += chunk + to_send += b"\r\n" + self.send(to_send) + + # After the if clause, to always have a closed body + self.send(b"0\r\n\r\n") + + +class HTTPSConnection(HTTPConnection): + """ + Many of the parameters to this constructor are passed to the underlying SSL + socket by means of :py:func:`urllib3.util.ssl_wrap_socket`. + """ + + default_port = port_by_scheme["https"] + + cert_reqs = None + ca_certs = None + ca_cert_dir = None + ca_cert_data = None + ssl_version = None + assert_fingerprint = None + tls_in_tls_required = False + + def __init__( + self, + host, + port=None, + key_file=None, + cert_file=None, + key_password=None, + strict=None, + timeout=socket._GLOBAL_DEFAULT_TIMEOUT, + ssl_context=None, + server_hostname=None, + **kw + ): + + HTTPConnection.__init__(self, host, port, strict=strict, timeout=timeout, **kw) + + self.key_file = key_file + self.cert_file = cert_file + self.key_password = key_password + self.ssl_context = ssl_context + self.server_hostname = server_hostname + + # Required property for Google AppEngine 1.9.0 which otherwise causes + # HTTPS requests to go out as HTTP. (See Issue #356) + self._protocol = "https" + + def set_cert( + self, + key_file=None, + cert_file=None, + cert_reqs=None, + key_password=None, + ca_certs=None, + assert_hostname=None, + assert_fingerprint=None, + ca_cert_dir=None, + ca_cert_data=None, + ): + """ + This method should only be called once, before the connection is used. + """ + # If cert_reqs is not provided we'll assume CERT_REQUIRED unless we also + # have an SSLContext object in which case we'll use its verify_mode. + if cert_reqs is None: + if self.ssl_context is not None: + cert_reqs = self.ssl_context.verify_mode + else: + cert_reqs = resolve_cert_reqs(None) + + self.key_file = key_file + self.cert_file = cert_file + self.cert_reqs = cert_reqs + self.key_password = key_password + self.assert_hostname = assert_hostname + self.assert_fingerprint = assert_fingerprint + self.ca_certs = ca_certs and os.path.expanduser(ca_certs) + self.ca_cert_dir = ca_cert_dir and os.path.expanduser(ca_cert_dir) + self.ca_cert_data = ca_cert_data + + def connect(self): + # Add certificate verification + self.sock = conn = self._new_conn() + hostname = self.host + tls_in_tls = False + + if self._is_using_tunnel(): + if self.tls_in_tls_required: + self.sock = conn = self._connect_tls_proxy(hostname, conn) + tls_in_tls = True + + # Calls self._set_hostport(), so self.host is + # self._tunnel_host below. + self._tunnel() + # Mark this connection as not reusable + self.auto_open = 0 + + # Override the host with the one we're requesting data from. + hostname = self._tunnel_host + + server_hostname = hostname + if self.server_hostname is not None: + server_hostname = self.server_hostname + + is_time_off = datetime.date.today() < RECENT_DATE + if is_time_off: + warnings.warn( + ( + "System time is way off (before {0}). This will probably " + "lead to SSL verification errors" + ).format(RECENT_DATE), + SystemTimeWarning, + ) + + # Wrap socket using verification with the root certs in + # trusted_root_certs + default_ssl_context = False + if self.ssl_context is None: + default_ssl_context = True + self.ssl_context = create_urllib3_context( + ssl_version=resolve_ssl_version(self.ssl_version), + cert_reqs=resolve_cert_reqs(self.cert_reqs), + ) + + context = self.ssl_context + context.verify_mode = resolve_cert_reqs(self.cert_reqs) + + # Try to load OS default certs if none are given. + # Works well on Windows (requires Python3.4+) + if ( + not self.ca_certs + and not self.ca_cert_dir + and not self.ca_cert_data + and default_ssl_context + and hasattr(context, "load_default_certs") + ): + context.load_default_certs() + + self.sock = ssl_wrap_socket( + sock=conn, + keyfile=self.key_file, + certfile=self.cert_file, + key_password=self.key_password, + ca_certs=self.ca_certs, + ca_cert_dir=self.ca_cert_dir, + ca_cert_data=self.ca_cert_data, + server_hostname=server_hostname, + ssl_context=context, + tls_in_tls=tls_in_tls, + ) + + # If we're using all defaults and the connection + # is TLSv1 or TLSv1.1 we throw a DeprecationWarning + # for the host. + if ( + default_ssl_context + and self.ssl_version is None + and hasattr(self.sock, "version") + and self.sock.version() in {"TLSv1", "TLSv1.1"} + ): # Defensive: + warnings.warn( + "Negotiating TLSv1/TLSv1.1 by default is deprecated " + "and will be disabled in urllib3 v2.0.0. Connecting to " + "'%s' with '%s' can be enabled by explicitly opting-in " + "with 'ssl_version'" % (self.host, self.sock.version()), + DeprecationWarning, + ) + + if self.assert_fingerprint: + assert_fingerprint( + self.sock.getpeercert(binary_form=True), self.assert_fingerprint + ) + elif ( + context.verify_mode != ssl.CERT_NONE + and not getattr(context, "check_hostname", False) + and self.assert_hostname is not False + ): + # While urllib3 attempts to always turn off hostname matching from + # the TLS library, this cannot always be done. So we check whether + # the TLS Library still thinks it's matching hostnames. + cert = self.sock.getpeercert() + if not cert.get("subjectAltName", ()): + warnings.warn( + ( + "Certificate for {0} has no `subjectAltName`, falling back to check for a " + "`commonName` for now. This feature is being removed by major browsers and " + "deprecated by RFC 2818. (See https://github.com/urllib3/urllib3/issues/497 " + "for details.)".format(hostname) + ), + SubjectAltNameWarning, + ) + _match_hostname(cert, self.assert_hostname or server_hostname) + + self.is_verified = ( + context.verify_mode == ssl.CERT_REQUIRED + or self.assert_fingerprint is not None + ) + + def _connect_tls_proxy(self, hostname, conn): + """ + Establish a TLS connection to the proxy using the provided SSL context. + """ + proxy_config = self.proxy_config + ssl_context = proxy_config.ssl_context + if ssl_context: + # If the user provided a proxy context, we assume CA and client + # certificates have already been set + return ssl_wrap_socket( + sock=conn, + server_hostname=hostname, + ssl_context=ssl_context, + ) + + ssl_context = create_proxy_ssl_context( + self.ssl_version, + self.cert_reqs, + self.ca_certs, + self.ca_cert_dir, + self.ca_cert_data, + ) + + # If no cert was provided, use only the default options for server + # certificate validation + socket = ssl_wrap_socket( + sock=conn, + ca_certs=self.ca_certs, + ca_cert_dir=self.ca_cert_dir, + ca_cert_data=self.ca_cert_data, + server_hostname=hostname, + ssl_context=ssl_context, + ) + + if ssl_context.verify_mode != ssl.CERT_NONE and not getattr( + ssl_context, "check_hostname", False + ): + # While urllib3 attempts to always turn off hostname matching from + # the TLS library, this cannot always be done. So we check whether + # the TLS Library still thinks it's matching hostnames. + cert = socket.getpeercert() + if not cert.get("subjectAltName", ()): + warnings.warn( + ( + "Certificate for {0} has no `subjectAltName`, falling back to check for a " + "`commonName` for now. This feature is being removed by major browsers and " + "deprecated by RFC 2818. (See https://github.com/urllib3/urllib3/issues/497 " + "for details.)".format(hostname) + ), + SubjectAltNameWarning, + ) + _match_hostname(cert, hostname) + + self.proxy_is_verified = ssl_context.verify_mode == ssl.CERT_REQUIRED + return socket + + +def _match_hostname(cert, asserted_hostname): + # Our upstream implementation of ssl.match_hostname() + # only applies this normalization to IP addresses so it doesn't + # match DNS SANs so we do the same thing! + stripped_hostname = asserted_hostname.strip("u[]") + if is_ipaddress(stripped_hostname): + asserted_hostname = stripped_hostname + + try: + match_hostname(cert, asserted_hostname) + except CertificateError as e: + log.warning( + "Certificate did not match expected hostname: %s. Certificate: %s", + asserted_hostname, + cert, + ) + # Add cert to exception and reraise so client code can inspect + # the cert when catching the exception, if they want to + e._peer_cert = cert + raise + + +def _get_default_user_agent(): + return "python-urllib3/%s" % __version__ + + +class DummyConnection(object): + """Used to detect a failed ConnectionCls import.""" + + pass + + +if not ssl: + HTTPSConnection = DummyConnection # noqa: F811 + + +VerifiedHTTPSConnection = HTTPSConnection diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/connectionpool.py b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/connectionpool.py new file mode 100644 index 0000000000000000000000000000000000000000..0872ed770117096a8decf02e099a5c4148e018f3 --- /dev/null +++ b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/connectionpool.py @@ -0,0 +1,1140 @@ +from __future__ import absolute_import + +import errno +import logging +import re +import socket +import sys +import warnings +from socket import error as SocketError +from socket import timeout as SocketTimeout + +from ._collections import HTTPHeaderDict +from .connection import ( + BaseSSLError, + BrokenPipeError, + DummyConnection, + HTTPConnection, + HTTPException, + HTTPSConnection, + VerifiedHTTPSConnection, + port_by_scheme, +) +from .exceptions import ( + ClosedPoolError, + EmptyPoolError, + HeaderParsingError, + HostChangedError, + InsecureRequestWarning, + LocationValueError, + MaxRetryError, + NewConnectionError, + ProtocolError, + ProxyError, + ReadTimeoutError, + SSLError, + TimeoutError, +) +from .packages import six +from .packages.six.moves import queue +from .request import RequestMethods +from .response import HTTPResponse +from .util.connection import is_connection_dropped +from .util.proxy import connection_requires_http_tunnel +from .util.queue import LifoQueue +from .util.request import set_file_position +from .util.response import assert_header_parsing +from .util.retry import Retry +from .util.ssl_match_hostname import CertificateError +from .util.timeout import Timeout +from .util.url import Url, _encode_target +from .util.url import _normalize_host as normalize_host +from .util.url import get_host, parse_url + +try: # Platform-specific: Python 3 + import weakref + + weakref_finalize = weakref.finalize +except AttributeError: # Platform-specific: Python 2 + from .packages.backports.weakref_finalize import weakref_finalize + +xrange = six.moves.xrange + +log = logging.getLogger(__name__) + +_Default = object() + + +# Pool objects +class ConnectionPool(object): + """ + Base class for all connection pools, such as + :class:`.HTTPConnectionPool` and :class:`.HTTPSConnectionPool`. + + .. note:: + ConnectionPool.urlopen() does not normalize or percent-encode target URIs + which is useful if your target server doesn't support percent-encoded + target URIs. + """ + + scheme = None + QueueCls = LifoQueue + + def __init__(self, host, port=None): + if not host: + raise LocationValueError("No host specified.") + + self.host = _normalize_host(host, scheme=self.scheme) + self._proxy_host = host.lower() + self.port = port + + def __str__(self): + return "%s(host=%r, port=%r)" % (type(self).__name__, self.host, self.port) + + def __enter__(self): + return self + + def __exit__(self, exc_type, exc_val, exc_tb): + self.close() + # Return False to re-raise any potential exceptions + return False + + def close(self): + """ + Close all pooled connections and disable the pool. + """ + pass + + +# This is taken from http://hg.python.org/cpython/file/7aaba721ebc0/Lib/socket.py#l252 +_blocking_errnos = {errno.EAGAIN, errno.EWOULDBLOCK} + + +class HTTPConnectionPool(ConnectionPool, RequestMethods): + """ + Thread-safe connection pool for one host. + + :param host: + Host used for this HTTP Connection (e.g. "localhost"), passed into + :class:`http.client.HTTPConnection`. + + :param port: + Port used for this HTTP Connection (None is equivalent to 80), passed + into :class:`http.client.HTTPConnection`. + + :param strict: + Causes BadStatusLine to be raised if the status line can't be parsed + as a valid HTTP/1.0 or 1.1 status line, passed into + :class:`http.client.HTTPConnection`. + + .. note:: + Only works in Python 2. This parameter is ignored in Python 3. + + :param timeout: + Socket timeout in seconds for each individual connection. This can + be a float or integer, which sets the timeout for the HTTP request, + or an instance of :class:`urllib3.util.Timeout` which gives you more + fine-grained control over request timeouts. After the constructor has + been parsed, this is always a `urllib3.util.Timeout` object. + + :param maxsize: + Number of connections to save that can be reused. More than 1 is useful + in multithreaded situations. If ``block`` is set to False, more + connections will be created but they will not be saved once they've + been used. + + :param block: + If set to True, no more than ``maxsize`` connections will be used at + a time. When no free connections are available, the call will block + until a connection has been released. This is a useful side effect for + particular multithreaded situations where one does not want to use more + than maxsize connections per host to prevent flooding. + + :param headers: + Headers to include with all requests, unless other headers are given + explicitly. + + :param retries: + Retry configuration to use by default with requests in this pool. + + :param _proxy: + Parsed proxy URL, should not be used directly, instead, see + :class:`urllib3.ProxyManager` + + :param _proxy_headers: + A dictionary with proxy headers, should not be used directly, + instead, see :class:`urllib3.ProxyManager` + + :param \\**conn_kw: + Additional parameters are used to create fresh :class:`urllib3.connection.HTTPConnection`, + :class:`urllib3.connection.HTTPSConnection` instances. + """ + + scheme = "http" + ConnectionCls = HTTPConnection + ResponseCls = HTTPResponse + + def __init__( + self, + host, + port=None, + strict=False, + timeout=Timeout.DEFAULT_TIMEOUT, + maxsize=1, + block=False, + headers=None, + retries=None, + _proxy=None, + _proxy_headers=None, + _proxy_config=None, + **conn_kw + ): + ConnectionPool.__init__(self, host, port) + RequestMethods.__init__(self, headers) + + self.strict = strict + + if not isinstance(timeout, Timeout): + timeout = Timeout.from_float(timeout) + + if retries is None: + retries = Retry.DEFAULT + + self.timeout = timeout + self.retries = retries + + self.pool = self.QueueCls(maxsize) + self.block = block + + self.proxy = _proxy + self.proxy_headers = _proxy_headers or {} + self.proxy_config = _proxy_config + + # Fill the queue up so that doing get() on it will block properly + for _ in xrange(maxsize): + self.pool.put(None) + + # These are mostly for testing and debugging purposes. + self.num_connections = 0 + self.num_requests = 0 + self.conn_kw = conn_kw + + if self.proxy: + # Enable Nagle's algorithm for proxies, to avoid packet fragmentation. + # We cannot know if the user has added default socket options, so we cannot replace the + # list. + self.conn_kw.setdefault("socket_options", []) + + self.conn_kw["proxy"] = self.proxy + self.conn_kw["proxy_config"] = self.proxy_config + + # Do not pass 'self' as callback to 'finalize'. + # Then the 'finalize' would keep an endless living (leak) to self. + # By just passing a reference to the pool allows the garbage collector + # to free self if nobody else has a reference to it. + pool = self.pool + + # Close all the HTTPConnections in the pool before the + # HTTPConnectionPool object is garbage collected. + weakref_finalize(self, _close_pool_connections, pool) + + def _new_conn(self): + """ + Return a fresh :class:`HTTPConnection`. + """ + self.num_connections += 1 + log.debug( + "Starting new HTTP connection (%d): %s:%s", + self.num_connections, + self.host, + self.port or "80", + ) + + conn = self.ConnectionCls( + host=self.host, + port=self.port, + timeout=self.timeout.connect_timeout, + strict=self.strict, + **self.conn_kw + ) + return conn + + def _get_conn(self, timeout=None): + """ + Get a connection. Will return a pooled connection if one is available. + + If no connections are available and :prop:`.block` is ``False``, then a + fresh connection is returned. + + :param timeout: + Seconds to wait before giving up and raising + :class:`urllib3.exceptions.EmptyPoolError` if the pool is empty and + :prop:`.block` is ``True``. + """ + conn = None + try: + conn = self.pool.get(block=self.block, timeout=timeout) + + except AttributeError: # self.pool is None + raise ClosedPoolError(self, "Pool is closed.") + + except queue.Empty: + if self.block: + raise EmptyPoolError( + self, + "Pool reached maximum size and no more connections are allowed.", + ) + pass # Oh well, we'll create a new connection then + + # If this is a persistent connection, check if it got disconnected + if conn and is_connection_dropped(conn): + log.debug("Resetting dropped connection: %s", self.host) + conn.close() + if getattr(conn, "auto_open", 1) == 0: + # This is a proxied connection that has been mutated by + # http.client._tunnel() and cannot be reused (since it would + # attempt to bypass the proxy) + conn = None + + return conn or self._new_conn() + + def _put_conn(self, conn): + """ + Put a connection back into the pool. + + :param conn: + Connection object for the current host and port as returned by + :meth:`._new_conn` or :meth:`._get_conn`. + + If the pool is already full, the connection is closed and discarded + because we exceeded maxsize. If connections are discarded frequently, + then maxsize should be increased. + + If the pool is closed, then the connection will be closed and discarded. + """ + try: + self.pool.put(conn, block=False) + return # Everything is dandy, done. + except AttributeError: + # self.pool is None. + pass + except queue.Full: + # This should never happen if self.block == True + log.warning( + "Connection pool is full, discarding connection: %s. Connection pool size: %s", + self.host, + self.pool.qsize(), + ) + # Connection never got put back into the pool, close it. + if conn: + conn.close() + + def _validate_conn(self, conn): + """ + Called right before a request is made, after the socket is created. + """ + pass + + def _prepare_proxy(self, conn): + # Nothing to do for HTTP connections. + pass + + def _get_timeout(self, timeout): + """Helper that always returns a :class:`urllib3.util.Timeout`""" + if timeout is _Default: + return self.timeout.clone() + + if isinstance(timeout, Timeout): + return timeout.clone() + else: + # User passed us an int/float. This is for backwards compatibility, + # can be removed later + return Timeout.from_float(timeout) + + def _raise_timeout(self, err, url, timeout_value): + """Is the error actually a timeout? Will raise a ReadTimeout or pass""" + + if isinstance(err, SocketTimeout): + raise ReadTimeoutError( + self, url, "Read timed out. (read timeout=%s)" % timeout_value + ) + + # See the above comment about EAGAIN in Python 3. In Python 2 we have + # to specifically catch it and throw the timeout error + if hasattr(err, "errno") and err.errno in _blocking_errnos: + raise ReadTimeoutError( + self, url, "Read timed out. (read timeout=%s)" % timeout_value + ) + + # Catch possible read timeouts thrown as SSL errors. If not the + # case, rethrow the original. We need to do this because of: + # http://bugs.python.org/issue10272 + if "timed out" in str(err) or "did not complete (read)" in str( + err + ): # Python < 2.7.4 + raise ReadTimeoutError( + self, url, "Read timed out. (read timeout=%s)" % timeout_value + ) + + def _make_request( + self, conn, method, url, timeout=_Default, chunked=False, **httplib_request_kw + ): + """ + Perform a request on a given urllib connection object taken from our + pool. + + :param conn: + a connection from one of our connection pools + + :param timeout: + Socket timeout in seconds for the request. This can be a + float or integer, which will set the same timeout value for + the socket connect and the socket read, or an instance of + :class:`urllib3.util.Timeout`, which gives you more fine-grained + control over your timeouts. + """ + self.num_requests += 1 + + timeout_obj = self._get_timeout(timeout) + timeout_obj.start_connect() + conn.timeout = Timeout.resolve_default_timeout(timeout_obj.connect_timeout) + + # Trigger any extra validation we need to do. + try: + self._validate_conn(conn) + except (SocketTimeout, BaseSSLError) as e: + # Py2 raises this as a BaseSSLError, Py3 raises it as socket timeout. + self._raise_timeout(err=e, url=url, timeout_value=conn.timeout) + raise + + # conn.request() calls http.client.*.request, not the method in + # urllib3.request. It also calls makefile (recv) on the socket. + try: + if chunked: + conn.request_chunked(method, url, **httplib_request_kw) + else: + conn.request(method, url, **httplib_request_kw) + + # We are swallowing BrokenPipeError (errno.EPIPE) since the server is + # legitimately able to close the connection after sending a valid response. + # With this behaviour, the received response is still readable. + except BrokenPipeError: + # Python 3 + pass + except IOError as e: + # Python 2 and macOS/Linux + # EPIPE and ESHUTDOWN are BrokenPipeError on Python 2, and EPROTOTYPE/ECONNRESET are needed on macOS + # https://erickt.github.io/blog/2014/11/19/adventures-in-debugging-a-potential-osx-kernel-bug/ + if e.errno not in { + errno.EPIPE, + errno.ESHUTDOWN, + errno.EPROTOTYPE, + errno.ECONNRESET, + }: + raise + + # Reset the timeout for the recv() on the socket + read_timeout = timeout_obj.read_timeout + + # App Engine doesn't have a sock attr + if getattr(conn, "sock", None): + # In Python 3 socket.py will catch EAGAIN and return None when you + # try and read into the file pointer created by http.client, which + # instead raises a BadStatusLine exception. Instead of catching + # the exception and assuming all BadStatusLine exceptions are read + # timeouts, check for a zero timeout before making the request. + if read_timeout == 0: + raise ReadTimeoutError( + self, url, "Read timed out. (read timeout=%s)" % read_timeout + ) + if read_timeout is Timeout.DEFAULT_TIMEOUT: + conn.sock.settimeout(socket.getdefaulttimeout()) + else: # None or a value + conn.sock.settimeout(read_timeout) + + # Receive the response from the server + try: + try: + # Python 2.7, use buffering of HTTP responses + httplib_response = conn.getresponse(buffering=True) + except TypeError: + # Python 3 + try: + httplib_response = conn.getresponse() + except BaseException as e: + # Remove the TypeError from the exception chain in + # Python 3 (including for exceptions like SystemExit). + # Otherwise it looks like a bug in the code. + six.raise_from(e, None) + except (SocketTimeout, BaseSSLError, SocketError) as e: + self._raise_timeout(err=e, url=url, timeout_value=read_timeout) + raise + + # AppEngine doesn't have a version attr. + http_version = getattr(conn, "_http_vsn_str", "HTTP/?") + log.debug( + '%s://%s:%s "%s %s %s" %s %s', + self.scheme, + self.host, + self.port, + method, + url, + http_version, + httplib_response.status, + httplib_response.length, + ) + + try: + assert_header_parsing(httplib_response.msg) + except (HeaderParsingError, TypeError) as hpe: # Platform-specific: Python 3 + log.warning( + "Failed to parse headers (url=%s): %s", + self._absolute_url(url), + hpe, + exc_info=True, + ) + + return httplib_response + + def _absolute_url(self, path): + return Url(scheme=self.scheme, host=self.host, port=self.port, path=path).url + + def close(self): + """ + Close all pooled connections and disable the pool. + """ + if self.pool is None: + return + # Disable access to the pool + old_pool, self.pool = self.pool, None + + # Close all the HTTPConnections in the pool. + _close_pool_connections(old_pool) + + def is_same_host(self, url): + """ + Check if the given ``url`` is a member of the same host as this + connection pool. + """ + if url.startswith("/"): + return True + + # TODO: Add optional support for socket.gethostbyname checking. + scheme, host, port = get_host(url) + if host is not None: + host = _normalize_host(host, scheme=scheme) + + # Use explicit default port for comparison when none is given + if self.port and not port: + port = port_by_scheme.get(scheme) + elif not self.port and port == port_by_scheme.get(scheme): + port = None + + return (scheme, host, port) == (self.scheme, self.host, self.port) + + def urlopen( + self, + method, + url, + body=None, + headers=None, + retries=None, + redirect=True, + assert_same_host=True, + timeout=_Default, + pool_timeout=None, + release_conn=None, + chunked=False, + body_pos=None, + **response_kw + ): + """ + Get a connection from the pool and perform an HTTP request. This is the + lowest level call for making a request, so you'll need to specify all + the raw details. + + .. note:: + + More commonly, it's appropriate to use a convenience method provided + by :class:`.RequestMethods`, such as :meth:`request`. + + .. note:: + + `release_conn` will only behave as expected if + `preload_content=False` because we want to make + `preload_content=False` the default behaviour someday soon without + breaking backwards compatibility. + + :param method: + HTTP request method (such as GET, POST, PUT, etc.) + + :param url: + The URL to perform the request on. + + :param body: + Data to send in the request body, either :class:`str`, :class:`bytes`, + an iterable of :class:`str`/:class:`bytes`, or a file-like object. + + :param headers: + Dictionary of custom headers to send, such as User-Agent, + If-None-Match, etc. If None, pool headers are used. If provided, + these headers completely replace any pool-specific headers. + + :param retries: + Configure the number of retries to allow before raising a + :class:`~urllib3.exceptions.MaxRetryError` exception. + + Pass ``None`` to retry until you receive a response. Pass a + :class:`~urllib3.util.retry.Retry` object for fine-grained control + over different types of retries. + Pass an integer number to retry connection errors that many times, + but no other types of errors. Pass zero to never retry. + + If ``False``, then retries are disabled and any exception is raised + immediately. Also, instead of raising a MaxRetryError on redirects, + the redirect response will be returned. + + :type retries: :class:`~urllib3.util.retry.Retry`, False, or an int. + + :param redirect: + If True, automatically handle redirects (status codes 301, 302, + 303, 307, 308). Each redirect counts as a retry. Disabling retries + will disable redirect, too. + + :param assert_same_host: + If ``True``, will make sure that the host of the pool requests is + consistent else will raise HostChangedError. When ``False``, you can + use the pool on an HTTP proxy and request foreign hosts. + + :param timeout: + If specified, overrides the default timeout for this one + request. It may be a float (in seconds) or an instance of + :class:`urllib3.util.Timeout`. + + :param pool_timeout: + If set and the pool is set to block=True, then this method will + block for ``pool_timeout`` seconds and raise EmptyPoolError if no + connection is available within the time period. + + :param release_conn: + If False, then the urlopen call will not release the connection + back into the pool once a response is received (but will release if + you read the entire contents of the response such as when + `preload_content=True`). This is useful if you're not preloading + the response's content immediately. You will need to call + ``r.release_conn()`` on the response ``r`` to return the connection + back into the pool. If None, it takes the value of + ``response_kw.get('preload_content', True)``. + + :param chunked: + If True, urllib3 will send the body using chunked transfer + encoding. Otherwise, urllib3 will send the body using the standard + content-length form. Defaults to False. + + :param int body_pos: + Position to seek to in file-like body in the event of a retry or + redirect. Typically this won't need to be set because urllib3 will + auto-populate the value when needed. + + :param \\**response_kw: + Additional parameters are passed to + :meth:`urllib3.response.HTTPResponse.from_httplib` + """ + + parsed_url = parse_url(url) + destination_scheme = parsed_url.scheme + + if headers is None: + headers = self.headers + + if not isinstance(retries, Retry): + retries = Retry.from_int(retries, redirect=redirect, default=self.retries) + + if release_conn is None: + release_conn = response_kw.get("preload_content", True) + + # Check host + if assert_same_host and not self.is_same_host(url): + raise HostChangedError(self, url, retries) + + # Ensure that the URL we're connecting to is properly encoded + if url.startswith("/"): + url = six.ensure_str(_encode_target(url)) + else: + url = six.ensure_str(parsed_url.url) + + conn = None + + # Track whether `conn` needs to be released before + # returning/raising/recursing. Update this variable if necessary, and + # leave `release_conn` constant throughout the function. That way, if + # the function recurses, the original value of `release_conn` will be + # passed down into the recursive call, and its value will be respected. + # + # See issue #651 [1] for details. + # + # [1] + release_this_conn = release_conn + + http_tunnel_required = connection_requires_http_tunnel( + self.proxy, self.proxy_config, destination_scheme + ) + + # Merge the proxy headers. Only done when not using HTTP CONNECT. We + # have to copy the headers dict so we can safely change it without those + # changes being reflected in anyone else's copy. + if not http_tunnel_required: + headers = headers.copy() + headers.update(self.proxy_headers) + + # Must keep the exception bound to a separate variable or else Python 3 + # complains about UnboundLocalError. + err = None + + # Keep track of whether we cleanly exited the except block. This + # ensures we do proper cleanup in finally. + clean_exit = False + + # Rewind body position, if needed. Record current position + # for future rewinds in the event of a redirect/retry. + body_pos = set_file_position(body, body_pos) + + try: + # Request a connection from the queue. + timeout_obj = self._get_timeout(timeout) + conn = self._get_conn(timeout=pool_timeout) + + conn.timeout = timeout_obj.connect_timeout + + is_new_proxy_conn = self.proxy is not None and not getattr( + conn, "sock", None + ) + if is_new_proxy_conn and http_tunnel_required: + self._prepare_proxy(conn) + + # Make the request on the httplib connection object. + httplib_response = self._make_request( + conn, + method, + url, + timeout=timeout_obj, + body=body, + headers=headers, + chunked=chunked, + ) + + # If we're going to release the connection in ``finally:``, then + # the response doesn't need to know about the connection. Otherwise + # it will also try to release it and we'll have a double-release + # mess. + response_conn = conn if not release_conn else None + + # Pass method to Response for length checking + response_kw["request_method"] = method + + # Import httplib's response into our own wrapper object + response = self.ResponseCls.from_httplib( + httplib_response, + pool=self, + connection=response_conn, + retries=retries, + **response_kw + ) + + # Everything went great! + clean_exit = True + + except EmptyPoolError: + # Didn't get a connection from the pool, no need to clean up + clean_exit = True + release_this_conn = False + raise + + except ( + TimeoutError, + HTTPException, + SocketError, + ProtocolError, + BaseSSLError, + SSLError, + CertificateError, + ) as e: + # Discard the connection for these exceptions. It will be + # replaced during the next _get_conn() call. + clean_exit = False + + def _is_ssl_error_message_from_http_proxy(ssl_error): + # We're trying to detect the message 'WRONG_VERSION_NUMBER' but + # SSLErrors are kinda all over the place when it comes to the message, + # so we try to cover our bases here! + message = " ".join(re.split("[^a-z]", str(ssl_error).lower())) + return ( + "wrong version number" in message + or "unknown protocol" in message + or "record layer failure" in message + ) + + # Try to detect a common user error with proxies which is to + # set an HTTP proxy to be HTTPS when it should be 'http://' + # (ie {'http': 'http://proxy', 'https': 'https://proxy'}) + # Instead we add a nice error message and point to a URL. + if ( + isinstance(e, BaseSSLError) + and self.proxy + and _is_ssl_error_message_from_http_proxy(e) + and conn.proxy + and conn.proxy.scheme == "https" + ): + e = ProxyError( + "Your proxy appears to only use HTTP and not HTTPS, " + "try changing your proxy URL to be HTTP. See: " + "https://urllib3.readthedocs.io/en/1.26.x/advanced-usage.html" + "#https-proxy-error-http-proxy", + SSLError(e), + ) + elif isinstance(e, (BaseSSLError, CertificateError)): + e = SSLError(e) + elif isinstance(e, (SocketError, NewConnectionError)) and self.proxy: + e = ProxyError("Cannot connect to proxy.", e) + elif isinstance(e, (SocketError, HTTPException)): + e = ProtocolError("Connection aborted.", e) + + retries = retries.increment( + method, url, error=e, _pool=self, _stacktrace=sys.exc_info()[2] + ) + retries.sleep() + + # Keep track of the error for the retry warning. + err = e + + finally: + if not clean_exit: + # We hit some kind of exception, handled or otherwise. We need + # to throw the connection away unless explicitly told not to. + # Close the connection, set the variable to None, and make sure + # we put the None back in the pool to avoid leaking it. + conn = conn and conn.close() + release_this_conn = True + + if release_this_conn: + # Put the connection back to be reused. If the connection is + # expired then it will be None, which will get replaced with a + # fresh connection during _get_conn. + self._put_conn(conn) + + if not conn: + # Try again + log.warning( + "Retrying (%r) after connection broken by '%r': %s", retries, err, url + ) + return self.urlopen( + method, + url, + body, + headers, + retries, + redirect, + assert_same_host, + timeout=timeout, + pool_timeout=pool_timeout, + release_conn=release_conn, + chunked=chunked, + body_pos=body_pos, + **response_kw + ) + + # Handle redirect? + redirect_location = redirect and response.get_redirect_location() + if redirect_location: + if response.status == 303: + # Change the method according to RFC 9110, Section 15.4.4. + method = "GET" + # And lose the body not to transfer anything sensitive. + body = None + headers = HTTPHeaderDict(headers)._prepare_for_method_change() + + try: + retries = retries.increment(method, url, response=response, _pool=self) + except MaxRetryError: + if retries.raise_on_redirect: + response.drain_conn() + raise + return response + + response.drain_conn() + retries.sleep_for_retry(response) + log.debug("Redirecting %s -> %s", url, redirect_location) + return self.urlopen( + method, + redirect_location, + body, + headers, + retries=retries, + redirect=redirect, + assert_same_host=assert_same_host, + timeout=timeout, + pool_timeout=pool_timeout, + release_conn=release_conn, + chunked=chunked, + body_pos=body_pos, + **response_kw + ) + + # Check if we should retry the HTTP response. + has_retry_after = bool(response.headers.get("Retry-After")) + if retries.is_retry(method, response.status, has_retry_after): + try: + retries = retries.increment(method, url, response=response, _pool=self) + except MaxRetryError: + if retries.raise_on_status: + response.drain_conn() + raise + return response + + response.drain_conn() + retries.sleep(response) + log.debug("Retry: %s", url) + return self.urlopen( + method, + url, + body, + headers, + retries=retries, + redirect=redirect, + assert_same_host=assert_same_host, + timeout=timeout, + pool_timeout=pool_timeout, + release_conn=release_conn, + chunked=chunked, + body_pos=body_pos, + **response_kw + ) + + return response + + +class HTTPSConnectionPool(HTTPConnectionPool): + """ + Same as :class:`.HTTPConnectionPool`, but HTTPS. + + :class:`.HTTPSConnection` uses one of ``assert_fingerprint``, + ``assert_hostname`` and ``host`` in this order to verify connections. + If ``assert_hostname`` is False, no verification is done. + + The ``key_file``, ``cert_file``, ``cert_reqs``, ``ca_certs``, + ``ca_cert_dir``, ``ssl_version``, ``key_password`` are only used if :mod:`ssl` + is available and are fed into :meth:`urllib3.util.ssl_wrap_socket` to upgrade + the connection socket into an SSL socket. + """ + + scheme = "https" + ConnectionCls = HTTPSConnection + + def __init__( + self, + host, + port=None, + strict=False, + timeout=Timeout.DEFAULT_TIMEOUT, + maxsize=1, + block=False, + headers=None, + retries=None, + _proxy=None, + _proxy_headers=None, + key_file=None, + cert_file=None, + cert_reqs=None, + key_password=None, + ca_certs=None, + ssl_version=None, + assert_hostname=None, + assert_fingerprint=None, + ca_cert_dir=None, + **conn_kw + ): + + HTTPConnectionPool.__init__( + self, + host, + port, + strict, + timeout, + maxsize, + block, + headers, + retries, + _proxy, + _proxy_headers, + **conn_kw + ) + + self.key_file = key_file + self.cert_file = cert_file + self.cert_reqs = cert_reqs + self.key_password = key_password + self.ca_certs = ca_certs + self.ca_cert_dir = ca_cert_dir + self.ssl_version = ssl_version + self.assert_hostname = assert_hostname + self.assert_fingerprint = assert_fingerprint + + def _prepare_conn(self, conn): + """ + Prepare the ``connection`` for :meth:`urllib3.util.ssl_wrap_socket` + and establish the tunnel if proxy is used. + """ + + if isinstance(conn, VerifiedHTTPSConnection): + conn.set_cert( + key_file=self.key_file, + key_password=self.key_password, + cert_file=self.cert_file, + cert_reqs=self.cert_reqs, + ca_certs=self.ca_certs, + ca_cert_dir=self.ca_cert_dir, + assert_hostname=self.assert_hostname, + assert_fingerprint=self.assert_fingerprint, + ) + conn.ssl_version = self.ssl_version + return conn + + def _prepare_proxy(self, conn): + """ + Establishes a tunnel connection through HTTP CONNECT. + + Tunnel connection is established early because otherwise httplib would + improperly set Host: header to proxy's IP:port. + """ + + conn.set_tunnel(self._proxy_host, self.port, self.proxy_headers) + + if self.proxy.scheme == "https": + conn.tls_in_tls_required = True + + conn.connect() + + def _new_conn(self): + """ + Return a fresh :class:`http.client.HTTPSConnection`. + """ + self.num_connections += 1 + log.debug( + "Starting new HTTPS connection (%d): %s:%s", + self.num_connections, + self.host, + self.port or "443", + ) + + if not self.ConnectionCls or self.ConnectionCls is DummyConnection: + raise SSLError( + "Can't connect to HTTPS URL because the SSL module is not available." + ) + + actual_host = self.host + actual_port = self.port + if self.proxy is not None: + actual_host = self.proxy.host + actual_port = self.proxy.port + + conn = self.ConnectionCls( + host=actual_host, + port=actual_port, + timeout=self.timeout.connect_timeout, + strict=self.strict, + cert_file=self.cert_file, + key_file=self.key_file, + key_password=self.key_password, + **self.conn_kw + ) + + return self._prepare_conn(conn) + + def _validate_conn(self, conn): + """ + Called right before a request is made, after the socket is created. + """ + super(HTTPSConnectionPool, self)._validate_conn(conn) + + # Force connect early to allow us to validate the connection. + if not getattr(conn, "sock", None): # AppEngine might not have `.sock` + conn.connect() + + if not conn.is_verified: + warnings.warn( + ( + "Unverified HTTPS request is being made to host '%s'. " + "Adding certificate verification is strongly advised. See: " + "https://urllib3.readthedocs.io/en/1.26.x/advanced-usage.html" + "#ssl-warnings" % conn.host + ), + InsecureRequestWarning, + ) + + if getattr(conn, "proxy_is_verified", None) is False: + warnings.warn( + ( + "Unverified HTTPS connection done to an HTTPS proxy. " + "Adding certificate verification is strongly advised. See: " + "https://urllib3.readthedocs.io/en/1.26.x/advanced-usage.html" + "#ssl-warnings" + ), + InsecureRequestWarning, + ) + + +def connection_from_url(url, **kw): + """ + Given a url, return an :class:`.ConnectionPool` instance of its host. + + This is a shortcut for not having to parse out the scheme, host, and port + of the url before creating an :class:`.ConnectionPool` instance. + + :param url: + Absolute URL string that must include the scheme. Port is optional. + + :param \\**kw: + Passes additional parameters to the constructor of the appropriate + :class:`.ConnectionPool`. Useful for specifying things like + timeout, maxsize, headers, etc. + + Example:: + + >>> conn = connection_from_url('http://google.com/') + >>> r = conn.request('GET', '/') + """ + scheme, host, port = get_host(url) + port = port or port_by_scheme.get(scheme, 80) + if scheme == "https": + return HTTPSConnectionPool(host, port=port, **kw) + else: + return HTTPConnectionPool(host, port=port, **kw) + + +def _normalize_host(host, scheme): + """ + Normalize hosts for comparisons and use with sockets. + """ + + host = normalize_host(host, scheme) + + # httplib doesn't like it when we include brackets in IPv6 addresses + # Specifically, if we include brackets but also pass the port then + # httplib crazily doubles up the square brackets on the Host header. + # Instead, we need to make sure we never pass ``None`` as the port. + # However, for backward compatibility reasons we can't actually + # *assert* that. See http://bugs.python.org/issue28539 + if host.startswith("[") and host.endswith("]"): + host = host[1:-1] + return host + + +def _close_pool_connections(pool): + """Drains a queue of connections and closes each one.""" + try: + while True: + conn = pool.get(block=False) + if conn: + conn.close() + except queue.Empty: + pass # Done. diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/__init__.py b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/__pycache__/__init__.cpython-310.pyc b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b6bfc46ad26134d73c2edb121d0276a3529f1a28 Binary files /dev/null and b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/__pycache__/__init__.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/__pycache__/_appengine_environ.cpython-310.pyc b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/__pycache__/_appengine_environ.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..408f590ba007f5edd69591e0f7af6a76eb2ce31b Binary files /dev/null and b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/__pycache__/_appengine_environ.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/__pycache__/appengine.cpython-310.pyc b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/__pycache__/appengine.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d8496a1ce98e61db946ca4364789f34f99f0cefe Binary files /dev/null and b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/__pycache__/appengine.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/__pycache__/ntlmpool.cpython-310.pyc b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/__pycache__/ntlmpool.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..19a439e9b445ddec3398b22dfea027a463aaee34 Binary files /dev/null and b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/__pycache__/ntlmpool.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/__pycache__/pyopenssl.cpython-310.pyc b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/__pycache__/pyopenssl.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ece354dbeb664a9fdad8b25aa80d72a44672fcc7 Binary files /dev/null and b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/__pycache__/pyopenssl.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/__pycache__/securetransport.cpython-310.pyc b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/__pycache__/securetransport.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..64db17c1425e41f49f64f1e77b56d67fa1bcebf7 Binary files /dev/null and b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/__pycache__/securetransport.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/__pycache__/socks.cpython-310.pyc b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/__pycache__/socks.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..962d0c0a5441757aeac118606e9065253f5e081e Binary files /dev/null and b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/__pycache__/socks.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/_appengine_environ.py b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/_appengine_environ.py new file mode 100644 index 0000000000000000000000000000000000000000..8765b907d70c4a530bc90dc88f24b3df73473b01 --- /dev/null +++ b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/_appengine_environ.py @@ -0,0 +1,36 @@ +""" +This module provides means to detect the App Engine environment. +""" + +import os + + +def is_appengine(): + return is_local_appengine() or is_prod_appengine() + + +def is_appengine_sandbox(): + """Reports if the app is running in the first generation sandbox. + + The second generation runtimes are technically still in a sandbox, but it + is much less restrictive, so generally you shouldn't need to check for it. + see https://cloud.google.com/appengine/docs/standard/runtimes + """ + return is_appengine() and os.environ["APPENGINE_RUNTIME"] == "python27" + + +def is_local_appengine(): + return "APPENGINE_RUNTIME" in os.environ and os.environ.get( + "SERVER_SOFTWARE", "" + ).startswith("Development/") + + +def is_prod_appengine(): + return "APPENGINE_RUNTIME" in os.environ and os.environ.get( + "SERVER_SOFTWARE", "" + ).startswith("Google App Engine/") + + +def is_prod_appengine_mvms(): + """Deprecated.""" + return False diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/_securetransport/__init__.py b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/_securetransport/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/_securetransport/__pycache__/__init__.cpython-310.pyc b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/_securetransport/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7ffef04fdacec56d84809c3f74ec7b4e5594cd27 Binary files /dev/null and b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/_securetransport/__pycache__/__init__.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/_securetransport/__pycache__/bindings.cpython-310.pyc b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/_securetransport/__pycache__/bindings.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..76c114789cffa56a89215208f036fe90a9fa8cfe Binary files /dev/null and b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/_securetransport/__pycache__/bindings.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/_securetransport/__pycache__/low_level.cpython-310.pyc b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/_securetransport/__pycache__/low_level.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6c166e955b76d0c4f09fb7f469b99b4416176ce2 Binary files /dev/null and b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/_securetransport/__pycache__/low_level.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/_securetransport/bindings.py b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/_securetransport/bindings.py new file mode 100644 index 0000000000000000000000000000000000000000..264d564dbda676b52f446c0d25433a15939a78a3 --- /dev/null +++ b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/_securetransport/bindings.py @@ -0,0 +1,519 @@ +""" +This module uses ctypes to bind a whole bunch of functions and constants from +SecureTransport. The goal here is to provide the low-level API to +SecureTransport. These are essentially the C-level functions and constants, and +they're pretty gross to work with. + +This code is a bastardised version of the code found in Will Bond's oscrypto +library. An enormous debt is owed to him for blazing this trail for us. For +that reason, this code should be considered to be covered both by urllib3's +license and by oscrypto's: + + Copyright (c) 2015-2016 Will Bond + + Permission is hereby granted, free of charge, to any person obtaining a + copy of this software and associated documentation files (the "Software"), + to deal in the Software without restriction, including without limitation + the rights to use, copy, modify, merge, publish, distribute, sublicense, + and/or sell copies of the Software, and to permit persons to whom the + Software is furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in + all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + DEALINGS IN THE SOFTWARE. +""" +from __future__ import absolute_import + +import platform +from ctypes import ( + CDLL, + CFUNCTYPE, + POINTER, + c_bool, + c_byte, + c_char_p, + c_int32, + c_long, + c_size_t, + c_uint32, + c_ulong, + c_void_p, +) +from ctypes.util import find_library + +from ...packages.six import raise_from + +if platform.system() != "Darwin": + raise ImportError("Only macOS is supported") + +version = platform.mac_ver()[0] +version_info = tuple(map(int, version.split("."))) +if version_info < (10, 8): + raise OSError( + "Only OS X 10.8 and newer are supported, not %s.%s" + % (version_info[0], version_info[1]) + ) + + +def load_cdll(name, macos10_16_path): + """Loads a CDLL by name, falling back to known path on 10.16+""" + try: + # Big Sur is technically 11 but we use 10.16 due to the Big Sur + # beta being labeled as 10.16. + if version_info >= (10, 16): + path = macos10_16_path + else: + path = find_library(name) + if not path: + raise OSError # Caught and reraised as 'ImportError' + return CDLL(path, use_errno=True) + except OSError: + raise_from(ImportError("The library %s failed to load" % name), None) + + +Security = load_cdll( + "Security", "/System/Library/Frameworks/Security.framework/Security" +) +CoreFoundation = load_cdll( + "CoreFoundation", + "/System/Library/Frameworks/CoreFoundation.framework/CoreFoundation", +) + + +Boolean = c_bool +CFIndex = c_long +CFStringEncoding = c_uint32 +CFData = c_void_p +CFString = c_void_p +CFArray = c_void_p +CFMutableArray = c_void_p +CFDictionary = c_void_p +CFError = c_void_p +CFType = c_void_p +CFTypeID = c_ulong + +CFTypeRef = POINTER(CFType) +CFAllocatorRef = c_void_p + +OSStatus = c_int32 + +CFDataRef = POINTER(CFData) +CFStringRef = POINTER(CFString) +CFArrayRef = POINTER(CFArray) +CFMutableArrayRef = POINTER(CFMutableArray) +CFDictionaryRef = POINTER(CFDictionary) +CFArrayCallBacks = c_void_p +CFDictionaryKeyCallBacks = c_void_p +CFDictionaryValueCallBacks = c_void_p + +SecCertificateRef = POINTER(c_void_p) +SecExternalFormat = c_uint32 +SecExternalItemType = c_uint32 +SecIdentityRef = POINTER(c_void_p) +SecItemImportExportFlags = c_uint32 +SecItemImportExportKeyParameters = c_void_p +SecKeychainRef = POINTER(c_void_p) +SSLProtocol = c_uint32 +SSLCipherSuite = c_uint32 +SSLContextRef = POINTER(c_void_p) +SecTrustRef = POINTER(c_void_p) +SSLConnectionRef = c_uint32 +SecTrustResultType = c_uint32 +SecTrustOptionFlags = c_uint32 +SSLProtocolSide = c_uint32 +SSLConnectionType = c_uint32 +SSLSessionOption = c_uint32 + + +try: + Security.SecItemImport.argtypes = [ + CFDataRef, + CFStringRef, + POINTER(SecExternalFormat), + POINTER(SecExternalItemType), + SecItemImportExportFlags, + POINTER(SecItemImportExportKeyParameters), + SecKeychainRef, + POINTER(CFArrayRef), + ] + Security.SecItemImport.restype = OSStatus + + Security.SecCertificateGetTypeID.argtypes = [] + Security.SecCertificateGetTypeID.restype = CFTypeID + + Security.SecIdentityGetTypeID.argtypes = [] + Security.SecIdentityGetTypeID.restype = CFTypeID + + Security.SecKeyGetTypeID.argtypes = [] + Security.SecKeyGetTypeID.restype = CFTypeID + + Security.SecCertificateCreateWithData.argtypes = [CFAllocatorRef, CFDataRef] + Security.SecCertificateCreateWithData.restype = SecCertificateRef + + Security.SecCertificateCopyData.argtypes = [SecCertificateRef] + Security.SecCertificateCopyData.restype = CFDataRef + + Security.SecCopyErrorMessageString.argtypes = [OSStatus, c_void_p] + Security.SecCopyErrorMessageString.restype = CFStringRef + + Security.SecIdentityCreateWithCertificate.argtypes = [ + CFTypeRef, + SecCertificateRef, + POINTER(SecIdentityRef), + ] + Security.SecIdentityCreateWithCertificate.restype = OSStatus + + Security.SecKeychainCreate.argtypes = [ + c_char_p, + c_uint32, + c_void_p, + Boolean, + c_void_p, + POINTER(SecKeychainRef), + ] + Security.SecKeychainCreate.restype = OSStatus + + Security.SecKeychainDelete.argtypes = [SecKeychainRef] + Security.SecKeychainDelete.restype = OSStatus + + Security.SecPKCS12Import.argtypes = [ + CFDataRef, + CFDictionaryRef, + POINTER(CFArrayRef), + ] + Security.SecPKCS12Import.restype = OSStatus + + SSLReadFunc = CFUNCTYPE(OSStatus, SSLConnectionRef, c_void_p, POINTER(c_size_t)) + SSLWriteFunc = CFUNCTYPE( + OSStatus, SSLConnectionRef, POINTER(c_byte), POINTER(c_size_t) + ) + + Security.SSLSetIOFuncs.argtypes = [SSLContextRef, SSLReadFunc, SSLWriteFunc] + Security.SSLSetIOFuncs.restype = OSStatus + + Security.SSLSetPeerID.argtypes = [SSLContextRef, c_char_p, c_size_t] + Security.SSLSetPeerID.restype = OSStatus + + Security.SSLSetCertificate.argtypes = [SSLContextRef, CFArrayRef] + Security.SSLSetCertificate.restype = OSStatus + + Security.SSLSetCertificateAuthorities.argtypes = [SSLContextRef, CFTypeRef, Boolean] + Security.SSLSetCertificateAuthorities.restype = OSStatus + + Security.SSLSetConnection.argtypes = [SSLContextRef, SSLConnectionRef] + Security.SSLSetConnection.restype = OSStatus + + Security.SSLSetPeerDomainName.argtypes = [SSLContextRef, c_char_p, c_size_t] + Security.SSLSetPeerDomainName.restype = OSStatus + + Security.SSLHandshake.argtypes = [SSLContextRef] + Security.SSLHandshake.restype = OSStatus + + Security.SSLRead.argtypes = [SSLContextRef, c_char_p, c_size_t, POINTER(c_size_t)] + Security.SSLRead.restype = OSStatus + + Security.SSLWrite.argtypes = [SSLContextRef, c_char_p, c_size_t, POINTER(c_size_t)] + Security.SSLWrite.restype = OSStatus + + Security.SSLClose.argtypes = [SSLContextRef] + Security.SSLClose.restype = OSStatus + + Security.SSLGetNumberSupportedCiphers.argtypes = [SSLContextRef, POINTER(c_size_t)] + Security.SSLGetNumberSupportedCiphers.restype = OSStatus + + Security.SSLGetSupportedCiphers.argtypes = [ + SSLContextRef, + POINTER(SSLCipherSuite), + POINTER(c_size_t), + ] + Security.SSLGetSupportedCiphers.restype = OSStatus + + Security.SSLSetEnabledCiphers.argtypes = [ + SSLContextRef, + POINTER(SSLCipherSuite), + c_size_t, + ] + Security.SSLSetEnabledCiphers.restype = OSStatus + + Security.SSLGetNumberEnabledCiphers.argtype = [SSLContextRef, POINTER(c_size_t)] + Security.SSLGetNumberEnabledCiphers.restype = OSStatus + + Security.SSLGetEnabledCiphers.argtypes = [ + SSLContextRef, + POINTER(SSLCipherSuite), + POINTER(c_size_t), + ] + Security.SSLGetEnabledCiphers.restype = OSStatus + + Security.SSLGetNegotiatedCipher.argtypes = [SSLContextRef, POINTER(SSLCipherSuite)] + Security.SSLGetNegotiatedCipher.restype = OSStatus + + Security.SSLGetNegotiatedProtocolVersion.argtypes = [ + SSLContextRef, + POINTER(SSLProtocol), + ] + Security.SSLGetNegotiatedProtocolVersion.restype = OSStatus + + Security.SSLCopyPeerTrust.argtypes = [SSLContextRef, POINTER(SecTrustRef)] + Security.SSLCopyPeerTrust.restype = OSStatus + + Security.SecTrustSetAnchorCertificates.argtypes = [SecTrustRef, CFArrayRef] + Security.SecTrustSetAnchorCertificates.restype = OSStatus + + Security.SecTrustSetAnchorCertificatesOnly.argstypes = [SecTrustRef, Boolean] + Security.SecTrustSetAnchorCertificatesOnly.restype = OSStatus + + Security.SecTrustEvaluate.argtypes = [SecTrustRef, POINTER(SecTrustResultType)] + Security.SecTrustEvaluate.restype = OSStatus + + Security.SecTrustGetCertificateCount.argtypes = [SecTrustRef] + Security.SecTrustGetCertificateCount.restype = CFIndex + + Security.SecTrustGetCertificateAtIndex.argtypes = [SecTrustRef, CFIndex] + Security.SecTrustGetCertificateAtIndex.restype = SecCertificateRef + + Security.SSLCreateContext.argtypes = [ + CFAllocatorRef, + SSLProtocolSide, + SSLConnectionType, + ] + Security.SSLCreateContext.restype = SSLContextRef + + Security.SSLSetSessionOption.argtypes = [SSLContextRef, SSLSessionOption, Boolean] + Security.SSLSetSessionOption.restype = OSStatus + + Security.SSLSetProtocolVersionMin.argtypes = [SSLContextRef, SSLProtocol] + Security.SSLSetProtocolVersionMin.restype = OSStatus + + Security.SSLSetProtocolVersionMax.argtypes = [SSLContextRef, SSLProtocol] + Security.SSLSetProtocolVersionMax.restype = OSStatus + + try: + Security.SSLSetALPNProtocols.argtypes = [SSLContextRef, CFArrayRef] + Security.SSLSetALPNProtocols.restype = OSStatus + except AttributeError: + # Supported only in 10.12+ + pass + + Security.SecCopyErrorMessageString.argtypes = [OSStatus, c_void_p] + Security.SecCopyErrorMessageString.restype = CFStringRef + + Security.SSLReadFunc = SSLReadFunc + Security.SSLWriteFunc = SSLWriteFunc + Security.SSLContextRef = SSLContextRef + Security.SSLProtocol = SSLProtocol + Security.SSLCipherSuite = SSLCipherSuite + Security.SecIdentityRef = SecIdentityRef + Security.SecKeychainRef = SecKeychainRef + Security.SecTrustRef = SecTrustRef + Security.SecTrustResultType = SecTrustResultType + Security.SecExternalFormat = SecExternalFormat + Security.OSStatus = OSStatus + + Security.kSecImportExportPassphrase = CFStringRef.in_dll( + Security, "kSecImportExportPassphrase" + ) + Security.kSecImportItemIdentity = CFStringRef.in_dll( + Security, "kSecImportItemIdentity" + ) + + # CoreFoundation time! + CoreFoundation.CFRetain.argtypes = [CFTypeRef] + CoreFoundation.CFRetain.restype = CFTypeRef + + CoreFoundation.CFRelease.argtypes = [CFTypeRef] + CoreFoundation.CFRelease.restype = None + + CoreFoundation.CFGetTypeID.argtypes = [CFTypeRef] + CoreFoundation.CFGetTypeID.restype = CFTypeID + + CoreFoundation.CFStringCreateWithCString.argtypes = [ + CFAllocatorRef, + c_char_p, + CFStringEncoding, + ] + CoreFoundation.CFStringCreateWithCString.restype = CFStringRef + + CoreFoundation.CFStringGetCStringPtr.argtypes = [CFStringRef, CFStringEncoding] + CoreFoundation.CFStringGetCStringPtr.restype = c_char_p + + CoreFoundation.CFStringGetCString.argtypes = [ + CFStringRef, + c_char_p, + CFIndex, + CFStringEncoding, + ] + CoreFoundation.CFStringGetCString.restype = c_bool + + CoreFoundation.CFDataCreate.argtypes = [CFAllocatorRef, c_char_p, CFIndex] + CoreFoundation.CFDataCreate.restype = CFDataRef + + CoreFoundation.CFDataGetLength.argtypes = [CFDataRef] + CoreFoundation.CFDataGetLength.restype = CFIndex + + CoreFoundation.CFDataGetBytePtr.argtypes = [CFDataRef] + CoreFoundation.CFDataGetBytePtr.restype = c_void_p + + CoreFoundation.CFDictionaryCreate.argtypes = [ + CFAllocatorRef, + POINTER(CFTypeRef), + POINTER(CFTypeRef), + CFIndex, + CFDictionaryKeyCallBacks, + CFDictionaryValueCallBacks, + ] + CoreFoundation.CFDictionaryCreate.restype = CFDictionaryRef + + CoreFoundation.CFDictionaryGetValue.argtypes = [CFDictionaryRef, CFTypeRef] + CoreFoundation.CFDictionaryGetValue.restype = CFTypeRef + + CoreFoundation.CFArrayCreate.argtypes = [ + CFAllocatorRef, + POINTER(CFTypeRef), + CFIndex, + CFArrayCallBacks, + ] + CoreFoundation.CFArrayCreate.restype = CFArrayRef + + CoreFoundation.CFArrayCreateMutable.argtypes = [ + CFAllocatorRef, + CFIndex, + CFArrayCallBacks, + ] + CoreFoundation.CFArrayCreateMutable.restype = CFMutableArrayRef + + CoreFoundation.CFArrayAppendValue.argtypes = [CFMutableArrayRef, c_void_p] + CoreFoundation.CFArrayAppendValue.restype = None + + CoreFoundation.CFArrayGetCount.argtypes = [CFArrayRef] + CoreFoundation.CFArrayGetCount.restype = CFIndex + + CoreFoundation.CFArrayGetValueAtIndex.argtypes = [CFArrayRef, CFIndex] + CoreFoundation.CFArrayGetValueAtIndex.restype = c_void_p + + CoreFoundation.kCFAllocatorDefault = CFAllocatorRef.in_dll( + CoreFoundation, "kCFAllocatorDefault" + ) + CoreFoundation.kCFTypeArrayCallBacks = c_void_p.in_dll( + CoreFoundation, "kCFTypeArrayCallBacks" + ) + CoreFoundation.kCFTypeDictionaryKeyCallBacks = c_void_p.in_dll( + CoreFoundation, "kCFTypeDictionaryKeyCallBacks" + ) + CoreFoundation.kCFTypeDictionaryValueCallBacks = c_void_p.in_dll( + CoreFoundation, "kCFTypeDictionaryValueCallBacks" + ) + + CoreFoundation.CFTypeRef = CFTypeRef + CoreFoundation.CFArrayRef = CFArrayRef + CoreFoundation.CFStringRef = CFStringRef + CoreFoundation.CFDictionaryRef = CFDictionaryRef + +except (AttributeError): + raise ImportError("Error initializing ctypes") + + +class CFConst(object): + """ + A class object that acts as essentially a namespace for CoreFoundation + constants. + """ + + kCFStringEncodingUTF8 = CFStringEncoding(0x08000100) + + +class SecurityConst(object): + """ + A class object that acts as essentially a namespace for Security constants. + """ + + kSSLSessionOptionBreakOnServerAuth = 0 + + kSSLProtocol2 = 1 + kSSLProtocol3 = 2 + kTLSProtocol1 = 4 + kTLSProtocol11 = 7 + kTLSProtocol12 = 8 + # SecureTransport does not support TLS 1.3 even if there's a constant for it + kTLSProtocol13 = 10 + kTLSProtocolMaxSupported = 999 + + kSSLClientSide = 1 + kSSLStreamType = 0 + + kSecFormatPEMSequence = 10 + + kSecTrustResultInvalid = 0 + kSecTrustResultProceed = 1 + # This gap is present on purpose: this was kSecTrustResultConfirm, which + # is deprecated. + kSecTrustResultDeny = 3 + kSecTrustResultUnspecified = 4 + kSecTrustResultRecoverableTrustFailure = 5 + kSecTrustResultFatalTrustFailure = 6 + kSecTrustResultOtherError = 7 + + errSSLProtocol = -9800 + errSSLWouldBlock = -9803 + errSSLClosedGraceful = -9805 + errSSLClosedNoNotify = -9816 + errSSLClosedAbort = -9806 + + errSSLXCertChainInvalid = -9807 + errSSLCrypto = -9809 + errSSLInternal = -9810 + errSSLCertExpired = -9814 + errSSLCertNotYetValid = -9815 + errSSLUnknownRootCert = -9812 + errSSLNoRootCert = -9813 + errSSLHostNameMismatch = -9843 + errSSLPeerHandshakeFail = -9824 + errSSLPeerUserCancelled = -9839 + errSSLWeakPeerEphemeralDHKey = -9850 + errSSLServerAuthCompleted = -9841 + errSSLRecordOverflow = -9847 + + errSecVerifyFailed = -67808 + errSecNoTrustSettings = -25263 + errSecItemNotFound = -25300 + errSecInvalidTrustSettings = -25262 + + # Cipher suites. We only pick the ones our default cipher string allows. + # Source: https://developer.apple.com/documentation/security/1550981-ssl_cipher_suite_values + TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384 = 0xC02C + TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 = 0xC030 + TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256 = 0xC02B + TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 = 0xC02F + TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256 = 0xCCA9 + TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256 = 0xCCA8 + TLS_DHE_RSA_WITH_AES_256_GCM_SHA384 = 0x009F + TLS_DHE_RSA_WITH_AES_128_GCM_SHA256 = 0x009E + TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384 = 0xC024 + TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384 = 0xC028 + TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA = 0xC00A + TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA = 0xC014 + TLS_DHE_RSA_WITH_AES_256_CBC_SHA256 = 0x006B + TLS_DHE_RSA_WITH_AES_256_CBC_SHA = 0x0039 + TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256 = 0xC023 + TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256 = 0xC027 + TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA = 0xC009 + TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA = 0xC013 + TLS_DHE_RSA_WITH_AES_128_CBC_SHA256 = 0x0067 + TLS_DHE_RSA_WITH_AES_128_CBC_SHA = 0x0033 + TLS_RSA_WITH_AES_256_GCM_SHA384 = 0x009D + TLS_RSA_WITH_AES_128_GCM_SHA256 = 0x009C + TLS_RSA_WITH_AES_256_CBC_SHA256 = 0x003D + TLS_RSA_WITH_AES_128_CBC_SHA256 = 0x003C + TLS_RSA_WITH_AES_256_CBC_SHA = 0x0035 + TLS_RSA_WITH_AES_128_CBC_SHA = 0x002F + TLS_AES_128_GCM_SHA256 = 0x1301 + TLS_AES_256_GCM_SHA384 = 0x1302 + TLS_AES_128_CCM_8_SHA256 = 0x1305 + TLS_AES_128_CCM_SHA256 = 0x1304 diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/_securetransport/low_level.py b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/_securetransport/low_level.py new file mode 100644 index 0000000000000000000000000000000000000000..fa0b245d279e96724d5610f93bc3b3c8c22ca032 --- /dev/null +++ b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/_securetransport/low_level.py @@ -0,0 +1,397 @@ +""" +Low-level helpers for the SecureTransport bindings. + +These are Python functions that are not directly related to the high-level APIs +but are necessary to get them to work. They include a whole bunch of low-level +CoreFoundation messing about and memory management. The concerns in this module +are almost entirely about trying to avoid memory leaks and providing +appropriate and useful assistance to the higher-level code. +""" +import base64 +import ctypes +import itertools +import os +import re +import ssl +import struct +import tempfile + +from .bindings import CFConst, CoreFoundation, Security + +# This regular expression is used to grab PEM data out of a PEM bundle. +_PEM_CERTS_RE = re.compile( + b"-----BEGIN CERTIFICATE-----\n(.*?)\n-----END CERTIFICATE-----", re.DOTALL +) + + +def _cf_data_from_bytes(bytestring): + """ + Given a bytestring, create a CFData object from it. This CFData object must + be CFReleased by the caller. + """ + return CoreFoundation.CFDataCreate( + CoreFoundation.kCFAllocatorDefault, bytestring, len(bytestring) + ) + + +def _cf_dictionary_from_tuples(tuples): + """ + Given a list of Python tuples, create an associated CFDictionary. + """ + dictionary_size = len(tuples) + + # We need to get the dictionary keys and values out in the same order. + keys = (t[0] for t in tuples) + values = (t[1] for t in tuples) + cf_keys = (CoreFoundation.CFTypeRef * dictionary_size)(*keys) + cf_values = (CoreFoundation.CFTypeRef * dictionary_size)(*values) + + return CoreFoundation.CFDictionaryCreate( + CoreFoundation.kCFAllocatorDefault, + cf_keys, + cf_values, + dictionary_size, + CoreFoundation.kCFTypeDictionaryKeyCallBacks, + CoreFoundation.kCFTypeDictionaryValueCallBacks, + ) + + +def _cfstr(py_bstr): + """ + Given a Python binary data, create a CFString. + The string must be CFReleased by the caller. + """ + c_str = ctypes.c_char_p(py_bstr) + cf_str = CoreFoundation.CFStringCreateWithCString( + CoreFoundation.kCFAllocatorDefault, + c_str, + CFConst.kCFStringEncodingUTF8, + ) + return cf_str + + +def _create_cfstring_array(lst): + """ + Given a list of Python binary data, create an associated CFMutableArray. + The array must be CFReleased by the caller. + + Raises an ssl.SSLError on failure. + """ + cf_arr = None + try: + cf_arr = CoreFoundation.CFArrayCreateMutable( + CoreFoundation.kCFAllocatorDefault, + 0, + ctypes.byref(CoreFoundation.kCFTypeArrayCallBacks), + ) + if not cf_arr: + raise MemoryError("Unable to allocate memory!") + for item in lst: + cf_str = _cfstr(item) + if not cf_str: + raise MemoryError("Unable to allocate memory!") + try: + CoreFoundation.CFArrayAppendValue(cf_arr, cf_str) + finally: + CoreFoundation.CFRelease(cf_str) + except BaseException as e: + if cf_arr: + CoreFoundation.CFRelease(cf_arr) + raise ssl.SSLError("Unable to allocate array: %s" % (e,)) + return cf_arr + + +def _cf_string_to_unicode(value): + """ + Creates a Unicode string from a CFString object. Used entirely for error + reporting. + + Yes, it annoys me quite a lot that this function is this complex. + """ + value_as_void_p = ctypes.cast(value, ctypes.POINTER(ctypes.c_void_p)) + + string = CoreFoundation.CFStringGetCStringPtr( + value_as_void_p, CFConst.kCFStringEncodingUTF8 + ) + if string is None: + buffer = ctypes.create_string_buffer(1024) + result = CoreFoundation.CFStringGetCString( + value_as_void_p, buffer, 1024, CFConst.kCFStringEncodingUTF8 + ) + if not result: + raise OSError("Error copying C string from CFStringRef") + string = buffer.value + if string is not None: + string = string.decode("utf-8") + return string + + +def _assert_no_error(error, exception_class=None): + """ + Checks the return code and throws an exception if there is an error to + report + """ + if error == 0: + return + + cf_error_string = Security.SecCopyErrorMessageString(error, None) + output = _cf_string_to_unicode(cf_error_string) + CoreFoundation.CFRelease(cf_error_string) + + if output is None or output == u"": + output = u"OSStatus %s" % error + + if exception_class is None: + exception_class = ssl.SSLError + + raise exception_class(output) + + +def _cert_array_from_pem(pem_bundle): + """ + Given a bundle of certs in PEM format, turns them into a CFArray of certs + that can be used to validate a cert chain. + """ + # Normalize the PEM bundle's line endings. + pem_bundle = pem_bundle.replace(b"\r\n", b"\n") + + der_certs = [ + base64.b64decode(match.group(1)) for match in _PEM_CERTS_RE.finditer(pem_bundle) + ] + if not der_certs: + raise ssl.SSLError("No root certificates specified") + + cert_array = CoreFoundation.CFArrayCreateMutable( + CoreFoundation.kCFAllocatorDefault, + 0, + ctypes.byref(CoreFoundation.kCFTypeArrayCallBacks), + ) + if not cert_array: + raise ssl.SSLError("Unable to allocate memory!") + + try: + for der_bytes in der_certs: + certdata = _cf_data_from_bytes(der_bytes) + if not certdata: + raise ssl.SSLError("Unable to allocate memory!") + cert = Security.SecCertificateCreateWithData( + CoreFoundation.kCFAllocatorDefault, certdata + ) + CoreFoundation.CFRelease(certdata) + if not cert: + raise ssl.SSLError("Unable to build cert object!") + + CoreFoundation.CFArrayAppendValue(cert_array, cert) + CoreFoundation.CFRelease(cert) + except Exception: + # We need to free the array before the exception bubbles further. + # We only want to do that if an error occurs: otherwise, the caller + # should free. + CoreFoundation.CFRelease(cert_array) + raise + + return cert_array + + +def _is_cert(item): + """ + Returns True if a given CFTypeRef is a certificate. + """ + expected = Security.SecCertificateGetTypeID() + return CoreFoundation.CFGetTypeID(item) == expected + + +def _is_identity(item): + """ + Returns True if a given CFTypeRef is an identity. + """ + expected = Security.SecIdentityGetTypeID() + return CoreFoundation.CFGetTypeID(item) == expected + + +def _temporary_keychain(): + """ + This function creates a temporary Mac keychain that we can use to work with + credentials. This keychain uses a one-time password and a temporary file to + store the data. We expect to have one keychain per socket. The returned + SecKeychainRef must be freed by the caller, including calling + SecKeychainDelete. + + Returns a tuple of the SecKeychainRef and the path to the temporary + directory that contains it. + """ + # Unfortunately, SecKeychainCreate requires a path to a keychain. This + # means we cannot use mkstemp to use a generic temporary file. Instead, + # we're going to create a temporary directory and a filename to use there. + # This filename will be 8 random bytes expanded into base64. We also need + # some random bytes to password-protect the keychain we're creating, so we + # ask for 40 random bytes. + random_bytes = os.urandom(40) + filename = base64.b16encode(random_bytes[:8]).decode("utf-8") + password = base64.b16encode(random_bytes[8:]) # Must be valid UTF-8 + tempdirectory = tempfile.mkdtemp() + + keychain_path = os.path.join(tempdirectory, filename).encode("utf-8") + + # We now want to create the keychain itself. + keychain = Security.SecKeychainRef() + status = Security.SecKeychainCreate( + keychain_path, len(password), password, False, None, ctypes.byref(keychain) + ) + _assert_no_error(status) + + # Having created the keychain, we want to pass it off to the caller. + return keychain, tempdirectory + + +def _load_items_from_file(keychain, path): + """ + Given a single file, loads all the trust objects from it into arrays and + the keychain. + Returns a tuple of lists: the first list is a list of identities, the + second a list of certs. + """ + certificates = [] + identities = [] + result_array = None + + with open(path, "rb") as f: + raw_filedata = f.read() + + try: + filedata = CoreFoundation.CFDataCreate( + CoreFoundation.kCFAllocatorDefault, raw_filedata, len(raw_filedata) + ) + result_array = CoreFoundation.CFArrayRef() + result = Security.SecItemImport( + filedata, # cert data + None, # Filename, leaving it out for now + None, # What the type of the file is, we don't care + None, # what's in the file, we don't care + 0, # import flags + None, # key params, can include passphrase in the future + keychain, # The keychain to insert into + ctypes.byref(result_array), # Results + ) + _assert_no_error(result) + + # A CFArray is not very useful to us as an intermediary + # representation, so we are going to extract the objects we want + # and then free the array. We don't need to keep hold of keys: the + # keychain already has them! + result_count = CoreFoundation.CFArrayGetCount(result_array) + for index in range(result_count): + item = CoreFoundation.CFArrayGetValueAtIndex(result_array, index) + item = ctypes.cast(item, CoreFoundation.CFTypeRef) + + if _is_cert(item): + CoreFoundation.CFRetain(item) + certificates.append(item) + elif _is_identity(item): + CoreFoundation.CFRetain(item) + identities.append(item) + finally: + if result_array: + CoreFoundation.CFRelease(result_array) + + CoreFoundation.CFRelease(filedata) + + return (identities, certificates) + + +def _load_client_cert_chain(keychain, *paths): + """ + Load certificates and maybe keys from a number of files. Has the end goal + of returning a CFArray containing one SecIdentityRef, and then zero or more + SecCertificateRef objects, suitable for use as a client certificate trust + chain. + """ + # Ok, the strategy. + # + # This relies on knowing that macOS will not give you a SecIdentityRef + # unless you have imported a key into a keychain. This is a somewhat + # artificial limitation of macOS (for example, it doesn't necessarily + # affect iOS), but there is nothing inside Security.framework that lets you + # get a SecIdentityRef without having a key in a keychain. + # + # So the policy here is we take all the files and iterate them in order. + # Each one will use SecItemImport to have one or more objects loaded from + # it. We will also point at a keychain that macOS can use to work with the + # private key. + # + # Once we have all the objects, we'll check what we actually have. If we + # already have a SecIdentityRef in hand, fab: we'll use that. Otherwise, + # we'll take the first certificate (which we assume to be our leaf) and + # ask the keychain to give us a SecIdentityRef with that cert's associated + # key. + # + # We'll then return a CFArray containing the trust chain: one + # SecIdentityRef and then zero-or-more SecCertificateRef objects. The + # responsibility for freeing this CFArray will be with the caller. This + # CFArray must remain alive for the entire connection, so in practice it + # will be stored with a single SSLSocket, along with the reference to the + # keychain. + certificates = [] + identities = [] + + # Filter out bad paths. + paths = (path for path in paths if path) + + try: + for file_path in paths: + new_identities, new_certs = _load_items_from_file(keychain, file_path) + identities.extend(new_identities) + certificates.extend(new_certs) + + # Ok, we have everything. The question is: do we have an identity? If + # not, we want to grab one from the first cert we have. + if not identities: + new_identity = Security.SecIdentityRef() + status = Security.SecIdentityCreateWithCertificate( + keychain, certificates[0], ctypes.byref(new_identity) + ) + _assert_no_error(status) + identities.append(new_identity) + + # We now want to release the original certificate, as we no longer + # need it. + CoreFoundation.CFRelease(certificates.pop(0)) + + # We now need to build a new CFArray that holds the trust chain. + trust_chain = CoreFoundation.CFArrayCreateMutable( + CoreFoundation.kCFAllocatorDefault, + 0, + ctypes.byref(CoreFoundation.kCFTypeArrayCallBacks), + ) + for item in itertools.chain(identities, certificates): + # ArrayAppendValue does a CFRetain on the item. That's fine, + # because the finally block will release our other refs to them. + CoreFoundation.CFArrayAppendValue(trust_chain, item) + + return trust_chain + finally: + for obj in itertools.chain(identities, certificates): + CoreFoundation.CFRelease(obj) + + +TLS_PROTOCOL_VERSIONS = { + "SSLv2": (0, 2), + "SSLv3": (3, 0), + "TLSv1": (3, 1), + "TLSv1.1": (3, 2), + "TLSv1.2": (3, 3), +} + + +def _build_tls_unknown_ca_alert(version): + """ + Builds a TLS alert record for an unknown CA. + """ + ver_maj, ver_min = TLS_PROTOCOL_VERSIONS[version] + severity_fatal = 0x02 + description_unknown_ca = 0x30 + msg = struct.pack(">BB", severity_fatal, description_unknown_ca) + msg_len = len(msg) + record_type_alert = 0x15 + record = struct.pack(">BBBH", record_type_alert, ver_maj, ver_min, msg_len) + msg + return record diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/appengine.py b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/appengine.py new file mode 100644 index 0000000000000000000000000000000000000000..1717ee22cdf77849e2e273566c877f95311e691b --- /dev/null +++ b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/appengine.py @@ -0,0 +1,314 @@ +""" +This module provides a pool manager that uses Google App Engine's +`URLFetch Service `_. + +Example usage:: + + from pip._vendor.urllib3 import PoolManager + from pip._vendor.urllib3.contrib.appengine import AppEngineManager, is_appengine_sandbox + + if is_appengine_sandbox(): + # AppEngineManager uses AppEngine's URLFetch API behind the scenes + http = AppEngineManager() + else: + # PoolManager uses a socket-level API behind the scenes + http = PoolManager() + + r = http.request('GET', 'https://google.com/') + +There are `limitations `_ to the URLFetch service and it may not be +the best choice for your application. There are three options for using +urllib3 on Google App Engine: + +1. You can use :class:`AppEngineManager` with URLFetch. URLFetch is + cost-effective in many circumstances as long as your usage is within the + limitations. +2. You can use a normal :class:`~urllib3.PoolManager` by enabling sockets. + Sockets also have `limitations and restrictions + `_ and have a lower free quota than URLFetch. + To use sockets, be sure to specify the following in your ``app.yaml``:: + + env_variables: + GAE_USE_SOCKETS_HTTPLIB : 'true' + +3. If you are using `App Engine Flexible +`_, you can use the standard +:class:`PoolManager` without any configuration or special environment variables. +""" + +from __future__ import absolute_import + +import io +import logging +import warnings + +from ..exceptions import ( + HTTPError, + HTTPWarning, + MaxRetryError, + ProtocolError, + SSLError, + TimeoutError, +) +from ..packages.six.moves.urllib.parse import urljoin +from ..request import RequestMethods +from ..response import HTTPResponse +from ..util.retry import Retry +from ..util.timeout import Timeout +from . import _appengine_environ + +try: + from google.appengine.api import urlfetch +except ImportError: + urlfetch = None + + +log = logging.getLogger(__name__) + + +class AppEnginePlatformWarning(HTTPWarning): + pass + + +class AppEnginePlatformError(HTTPError): + pass + + +class AppEngineManager(RequestMethods): + """ + Connection manager for Google App Engine sandbox applications. + + This manager uses the URLFetch service directly instead of using the + emulated httplib, and is subject to URLFetch limitations as described in + the App Engine documentation `here + `_. + + Notably it will raise an :class:`AppEnginePlatformError` if: + * URLFetch is not available. + * If you attempt to use this on App Engine Flexible, as full socket + support is available. + * If a request size is more than 10 megabytes. + * If a response size is more than 32 megabytes. + * If you use an unsupported request method such as OPTIONS. + + Beyond those cases, it will raise normal urllib3 errors. + """ + + def __init__( + self, + headers=None, + retries=None, + validate_certificate=True, + urlfetch_retries=True, + ): + if not urlfetch: + raise AppEnginePlatformError( + "URLFetch is not available in this environment." + ) + + warnings.warn( + "urllib3 is using URLFetch on Google App Engine sandbox instead " + "of sockets. To use sockets directly instead of URLFetch see " + "https://urllib3.readthedocs.io/en/1.26.x/reference/urllib3.contrib.html.", + AppEnginePlatformWarning, + ) + + RequestMethods.__init__(self, headers) + self.validate_certificate = validate_certificate + self.urlfetch_retries = urlfetch_retries + + self.retries = retries or Retry.DEFAULT + + def __enter__(self): + return self + + def __exit__(self, exc_type, exc_val, exc_tb): + # Return False to re-raise any potential exceptions + return False + + def urlopen( + self, + method, + url, + body=None, + headers=None, + retries=None, + redirect=True, + timeout=Timeout.DEFAULT_TIMEOUT, + **response_kw + ): + + retries = self._get_retries(retries, redirect) + + try: + follow_redirects = redirect and retries.redirect != 0 and retries.total + response = urlfetch.fetch( + url, + payload=body, + method=method, + headers=headers or {}, + allow_truncated=False, + follow_redirects=self.urlfetch_retries and follow_redirects, + deadline=self._get_absolute_timeout(timeout), + validate_certificate=self.validate_certificate, + ) + except urlfetch.DeadlineExceededError as e: + raise TimeoutError(self, e) + + except urlfetch.InvalidURLError as e: + if "too large" in str(e): + raise AppEnginePlatformError( + "URLFetch request too large, URLFetch only " + "supports requests up to 10mb in size.", + e, + ) + raise ProtocolError(e) + + except urlfetch.DownloadError as e: + if "Too many redirects" in str(e): + raise MaxRetryError(self, url, reason=e) + raise ProtocolError(e) + + except urlfetch.ResponseTooLargeError as e: + raise AppEnginePlatformError( + "URLFetch response too large, URLFetch only supports" + "responses up to 32mb in size.", + e, + ) + + except urlfetch.SSLCertificateError as e: + raise SSLError(e) + + except urlfetch.InvalidMethodError as e: + raise AppEnginePlatformError( + "URLFetch does not support method: %s" % method, e + ) + + http_response = self._urlfetch_response_to_http_response( + response, retries=retries, **response_kw + ) + + # Handle redirect? + redirect_location = redirect and http_response.get_redirect_location() + if redirect_location: + # Check for redirect response + if self.urlfetch_retries and retries.raise_on_redirect: + raise MaxRetryError(self, url, "too many redirects") + else: + if http_response.status == 303: + method = "GET" + + try: + retries = retries.increment( + method, url, response=http_response, _pool=self + ) + except MaxRetryError: + if retries.raise_on_redirect: + raise MaxRetryError(self, url, "too many redirects") + return http_response + + retries.sleep_for_retry(http_response) + log.debug("Redirecting %s -> %s", url, redirect_location) + redirect_url = urljoin(url, redirect_location) + return self.urlopen( + method, + redirect_url, + body, + headers, + retries=retries, + redirect=redirect, + timeout=timeout, + **response_kw + ) + + # Check if we should retry the HTTP response. + has_retry_after = bool(http_response.headers.get("Retry-After")) + if retries.is_retry(method, http_response.status, has_retry_after): + retries = retries.increment(method, url, response=http_response, _pool=self) + log.debug("Retry: %s", url) + retries.sleep(http_response) + return self.urlopen( + method, + url, + body=body, + headers=headers, + retries=retries, + redirect=redirect, + timeout=timeout, + **response_kw + ) + + return http_response + + def _urlfetch_response_to_http_response(self, urlfetch_resp, **response_kw): + + if is_prod_appengine(): + # Production GAE handles deflate encoding automatically, but does + # not remove the encoding header. + content_encoding = urlfetch_resp.headers.get("content-encoding") + + if content_encoding == "deflate": + del urlfetch_resp.headers["content-encoding"] + + transfer_encoding = urlfetch_resp.headers.get("transfer-encoding") + # We have a full response's content, + # so let's make sure we don't report ourselves as chunked data. + if transfer_encoding == "chunked": + encodings = transfer_encoding.split(",") + encodings.remove("chunked") + urlfetch_resp.headers["transfer-encoding"] = ",".join(encodings) + + original_response = HTTPResponse( + # In order for decoding to work, we must present the content as + # a file-like object. + body=io.BytesIO(urlfetch_resp.content), + msg=urlfetch_resp.header_msg, + headers=urlfetch_resp.headers, + status=urlfetch_resp.status_code, + **response_kw + ) + + return HTTPResponse( + body=io.BytesIO(urlfetch_resp.content), + headers=urlfetch_resp.headers, + status=urlfetch_resp.status_code, + original_response=original_response, + **response_kw + ) + + def _get_absolute_timeout(self, timeout): + if timeout is Timeout.DEFAULT_TIMEOUT: + return None # Defer to URLFetch's default. + if isinstance(timeout, Timeout): + if timeout._read is not None or timeout._connect is not None: + warnings.warn( + "URLFetch does not support granular timeout settings, " + "reverting to total or default URLFetch timeout.", + AppEnginePlatformWarning, + ) + return timeout.total + return timeout + + def _get_retries(self, retries, redirect): + if not isinstance(retries, Retry): + retries = Retry.from_int(retries, redirect=redirect, default=self.retries) + + if retries.connect or retries.read or retries.redirect: + warnings.warn( + "URLFetch only supports total retries and does not " + "recognize connect, read, or redirect retry parameters.", + AppEnginePlatformWarning, + ) + + return retries + + +# Alias methods from _appengine_environ to maintain public API interface. + +is_appengine = _appengine_environ.is_appengine +is_appengine_sandbox = _appengine_environ.is_appengine_sandbox +is_local_appengine = _appengine_environ.is_local_appengine +is_prod_appengine = _appengine_environ.is_prod_appengine +is_prod_appengine_mvms = _appengine_environ.is_prod_appengine_mvms diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/ntlmpool.py b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/ntlmpool.py new file mode 100644 index 0000000000000000000000000000000000000000..471665754e9f199f07f90107ebb350c38b378100 --- /dev/null +++ b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/ntlmpool.py @@ -0,0 +1,130 @@ +""" +NTLM authenticating pool, contributed by erikcederstran + +Issue #10, see: http://code.google.com/p/urllib3/issues/detail?id=10 +""" +from __future__ import absolute_import + +import warnings +from logging import getLogger + +from ntlm import ntlm + +from .. import HTTPSConnectionPool +from ..packages.six.moves.http_client import HTTPSConnection + +warnings.warn( + "The 'urllib3.contrib.ntlmpool' module is deprecated and will be removed " + "in urllib3 v2.0 release, urllib3 is not able to support it properly due " + "to reasons listed in issue: https://github.com/urllib3/urllib3/issues/2282. " + "If you are a user of this module please comment in the mentioned issue.", + DeprecationWarning, +) + +log = getLogger(__name__) + + +class NTLMConnectionPool(HTTPSConnectionPool): + """ + Implements an NTLM authentication version of an urllib3 connection pool + """ + + scheme = "https" + + def __init__(self, user, pw, authurl, *args, **kwargs): + """ + authurl is a random URL on the server that is protected by NTLM. + user is the Windows user, probably in the DOMAIN\\username format. + pw is the password for the user. + """ + super(NTLMConnectionPool, self).__init__(*args, **kwargs) + self.authurl = authurl + self.rawuser = user + user_parts = user.split("\\", 1) + self.domain = user_parts[0].upper() + self.user = user_parts[1] + self.pw = pw + + def _new_conn(self): + # Performs the NTLM handshake that secures the connection. The socket + # must be kept open while requests are performed. + self.num_connections += 1 + log.debug( + "Starting NTLM HTTPS connection no. %d: https://%s%s", + self.num_connections, + self.host, + self.authurl, + ) + + headers = {"Connection": "Keep-Alive"} + req_header = "Authorization" + resp_header = "www-authenticate" + + conn = HTTPSConnection(host=self.host, port=self.port) + + # Send negotiation message + headers[req_header] = "NTLM %s" % ntlm.create_NTLM_NEGOTIATE_MESSAGE( + self.rawuser + ) + log.debug("Request headers: %s", headers) + conn.request("GET", self.authurl, None, headers) + res = conn.getresponse() + reshdr = dict(res.headers) + log.debug("Response status: %s %s", res.status, res.reason) + log.debug("Response headers: %s", reshdr) + log.debug("Response data: %s [...]", res.read(100)) + + # Remove the reference to the socket, so that it can not be closed by + # the response object (we want to keep the socket open) + res.fp = None + + # Server should respond with a challenge message + auth_header_values = reshdr[resp_header].split(", ") + auth_header_value = None + for s in auth_header_values: + if s[:5] == "NTLM ": + auth_header_value = s[5:] + if auth_header_value is None: + raise Exception( + "Unexpected %s response header: %s" % (resp_header, reshdr[resp_header]) + ) + + # Send authentication message + ServerChallenge, NegotiateFlags = ntlm.parse_NTLM_CHALLENGE_MESSAGE( + auth_header_value + ) + auth_msg = ntlm.create_NTLM_AUTHENTICATE_MESSAGE( + ServerChallenge, self.user, self.domain, self.pw, NegotiateFlags + ) + headers[req_header] = "NTLM %s" % auth_msg + log.debug("Request headers: %s", headers) + conn.request("GET", self.authurl, None, headers) + res = conn.getresponse() + log.debug("Response status: %s %s", res.status, res.reason) + log.debug("Response headers: %s", dict(res.headers)) + log.debug("Response data: %s [...]", res.read()[:100]) + if res.status != 200: + if res.status == 401: + raise Exception("Server rejected request: wrong username or password") + raise Exception("Wrong server response: %s %s" % (res.status, res.reason)) + + res.fp = None + log.debug("Connection established") + return conn + + def urlopen( + self, + method, + url, + body=None, + headers=None, + retries=3, + redirect=True, + assert_same_host=True, + ): + if headers is None: + headers = {} + headers["Connection"] = "Keep-Alive" + return super(NTLMConnectionPool, self).urlopen( + method, url, body, headers, retries, redirect, assert_same_host + ) diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/pyopenssl.py b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/pyopenssl.py new file mode 100644 index 0000000000000000000000000000000000000000..19e4aa97cc138e4bd39bebf6c49ff1955cb00437 --- /dev/null +++ b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/pyopenssl.py @@ -0,0 +1,518 @@ +""" +TLS with SNI_-support for Python 2. Follow these instructions if you would +like to verify TLS certificates in Python 2. Note, the default libraries do +*not* do certificate checking; you need to do additional work to validate +certificates yourself. + +This needs the following packages installed: + +* `pyOpenSSL`_ (tested with 16.0.0) +* `cryptography`_ (minimum 1.3.4, from pyopenssl) +* `idna`_ (minimum 2.0, from cryptography) + +However, pyopenssl depends on cryptography, which depends on idna, so while we +use all three directly here we end up having relatively few packages required. + +You can install them with the following command: + +.. code-block:: bash + + $ python -m pip install pyopenssl cryptography idna + +To activate certificate checking, call +:func:`~urllib3.contrib.pyopenssl.inject_into_urllib3` from your Python code +before you begin making HTTP requests. This can be done in a ``sitecustomize`` +module, or at any other time before your application begins using ``urllib3``, +like this: + +.. code-block:: python + + try: + import pip._vendor.urllib3.contrib.pyopenssl as pyopenssl + pyopenssl.inject_into_urllib3() + except ImportError: + pass + +Now you can use :mod:`urllib3` as you normally would, and it will support SNI +when the required modules are installed. + +Activating this module also has the positive side effect of disabling SSL/TLS +compression in Python 2 (see `CRIME attack`_). + +.. _sni: https://en.wikipedia.org/wiki/Server_Name_Indication +.. _crime attack: https://en.wikipedia.org/wiki/CRIME_(security_exploit) +.. _pyopenssl: https://www.pyopenssl.org +.. _cryptography: https://cryptography.io +.. _idna: https://github.com/kjd/idna +""" +from __future__ import absolute_import + +import OpenSSL.crypto +import OpenSSL.SSL +from cryptography import x509 +from cryptography.hazmat.backends.openssl import backend as openssl_backend + +try: + from cryptography.x509 import UnsupportedExtension +except ImportError: + # UnsupportedExtension is gone in cryptography >= 2.1.0 + class UnsupportedExtension(Exception): + pass + + +from io import BytesIO +from socket import error as SocketError +from socket import timeout + +try: # Platform-specific: Python 2 + from socket import _fileobject +except ImportError: # Platform-specific: Python 3 + _fileobject = None + from ..packages.backports.makefile import backport_makefile + +import logging +import ssl +import sys +import warnings + +from .. import util +from ..packages import six +from ..util.ssl_ import PROTOCOL_TLS_CLIENT + +warnings.warn( + "'urllib3.contrib.pyopenssl' module is deprecated and will be removed " + "in a future release of urllib3 2.x. Read more in this issue: " + "https://github.com/urllib3/urllib3/issues/2680", + category=DeprecationWarning, + stacklevel=2, +) + +__all__ = ["inject_into_urllib3", "extract_from_urllib3"] + +# SNI always works. +HAS_SNI = True + +# Map from urllib3 to PyOpenSSL compatible parameter-values. +_openssl_versions = { + util.PROTOCOL_TLS: OpenSSL.SSL.SSLv23_METHOD, + PROTOCOL_TLS_CLIENT: OpenSSL.SSL.SSLv23_METHOD, + ssl.PROTOCOL_TLSv1: OpenSSL.SSL.TLSv1_METHOD, +} + +if hasattr(ssl, "PROTOCOL_SSLv3") and hasattr(OpenSSL.SSL, "SSLv3_METHOD"): + _openssl_versions[ssl.PROTOCOL_SSLv3] = OpenSSL.SSL.SSLv3_METHOD + +if hasattr(ssl, "PROTOCOL_TLSv1_1") and hasattr(OpenSSL.SSL, "TLSv1_1_METHOD"): + _openssl_versions[ssl.PROTOCOL_TLSv1_1] = OpenSSL.SSL.TLSv1_1_METHOD + +if hasattr(ssl, "PROTOCOL_TLSv1_2") and hasattr(OpenSSL.SSL, "TLSv1_2_METHOD"): + _openssl_versions[ssl.PROTOCOL_TLSv1_2] = OpenSSL.SSL.TLSv1_2_METHOD + + +_stdlib_to_openssl_verify = { + ssl.CERT_NONE: OpenSSL.SSL.VERIFY_NONE, + ssl.CERT_OPTIONAL: OpenSSL.SSL.VERIFY_PEER, + ssl.CERT_REQUIRED: OpenSSL.SSL.VERIFY_PEER + + OpenSSL.SSL.VERIFY_FAIL_IF_NO_PEER_CERT, +} +_openssl_to_stdlib_verify = dict((v, k) for k, v in _stdlib_to_openssl_verify.items()) + +# OpenSSL will only write 16K at a time +SSL_WRITE_BLOCKSIZE = 16384 + +orig_util_HAS_SNI = util.HAS_SNI +orig_util_SSLContext = util.ssl_.SSLContext + + +log = logging.getLogger(__name__) + + +def inject_into_urllib3(): + "Monkey-patch urllib3 with PyOpenSSL-backed SSL-support." + + _validate_dependencies_met() + + util.SSLContext = PyOpenSSLContext + util.ssl_.SSLContext = PyOpenSSLContext + util.HAS_SNI = HAS_SNI + util.ssl_.HAS_SNI = HAS_SNI + util.IS_PYOPENSSL = True + util.ssl_.IS_PYOPENSSL = True + + +def extract_from_urllib3(): + "Undo monkey-patching by :func:`inject_into_urllib3`." + + util.SSLContext = orig_util_SSLContext + util.ssl_.SSLContext = orig_util_SSLContext + util.HAS_SNI = orig_util_HAS_SNI + util.ssl_.HAS_SNI = orig_util_HAS_SNI + util.IS_PYOPENSSL = False + util.ssl_.IS_PYOPENSSL = False + + +def _validate_dependencies_met(): + """ + Verifies that PyOpenSSL's package-level dependencies have been met. + Throws `ImportError` if they are not met. + """ + # Method added in `cryptography==1.1`; not available in older versions + from cryptography.x509.extensions import Extensions + + if getattr(Extensions, "get_extension_for_class", None) is None: + raise ImportError( + "'cryptography' module missing required functionality. " + "Try upgrading to v1.3.4 or newer." + ) + + # pyOpenSSL 0.14 and above use cryptography for OpenSSL bindings. The _x509 + # attribute is only present on those versions. + from OpenSSL.crypto import X509 + + x509 = X509() + if getattr(x509, "_x509", None) is None: + raise ImportError( + "'pyOpenSSL' module missing required functionality. " + "Try upgrading to v0.14 or newer." + ) + + +def _dnsname_to_stdlib(name): + """ + Converts a dNSName SubjectAlternativeName field to the form used by the + standard library on the given Python version. + + Cryptography produces a dNSName as a unicode string that was idna-decoded + from ASCII bytes. We need to idna-encode that string to get it back, and + then on Python 3 we also need to convert to unicode via UTF-8 (the stdlib + uses PyUnicode_FromStringAndSize on it, which decodes via UTF-8). + + If the name cannot be idna-encoded then we return None signalling that + the name given should be skipped. + """ + + def idna_encode(name): + """ + Borrowed wholesale from the Python Cryptography Project. It turns out + that we can't just safely call `idna.encode`: it can explode for + wildcard names. This avoids that problem. + """ + from pip._vendor import idna + + try: + for prefix in [u"*.", u"."]: + if name.startswith(prefix): + name = name[len(prefix) :] + return prefix.encode("ascii") + idna.encode(name) + return idna.encode(name) + except idna.core.IDNAError: + return None + + # Don't send IPv6 addresses through the IDNA encoder. + if ":" in name: + return name + + name = idna_encode(name) + if name is None: + return None + elif sys.version_info >= (3, 0): + name = name.decode("utf-8") + return name + + +def get_subj_alt_name(peer_cert): + """ + Given an PyOpenSSL certificate, provides all the subject alternative names. + """ + # Pass the cert to cryptography, which has much better APIs for this. + if hasattr(peer_cert, "to_cryptography"): + cert = peer_cert.to_cryptography() + else: + der = OpenSSL.crypto.dump_certificate(OpenSSL.crypto.FILETYPE_ASN1, peer_cert) + cert = x509.load_der_x509_certificate(der, openssl_backend) + + # We want to find the SAN extension. Ask Cryptography to locate it (it's + # faster than looping in Python) + try: + ext = cert.extensions.get_extension_for_class(x509.SubjectAlternativeName).value + except x509.ExtensionNotFound: + # No such extension, return the empty list. + return [] + except ( + x509.DuplicateExtension, + UnsupportedExtension, + x509.UnsupportedGeneralNameType, + UnicodeError, + ) as e: + # A problem has been found with the quality of the certificate. Assume + # no SAN field is present. + log.warning( + "A problem was encountered with the certificate that prevented " + "urllib3 from finding the SubjectAlternativeName field. This can " + "affect certificate validation. The error was %s", + e, + ) + return [] + + # We want to return dNSName and iPAddress fields. We need to cast the IPs + # back to strings because the match_hostname function wants them as + # strings. + # Sadly the DNS names need to be idna encoded and then, on Python 3, UTF-8 + # decoded. This is pretty frustrating, but that's what the standard library + # does with certificates, and so we need to attempt to do the same. + # We also want to skip over names which cannot be idna encoded. + names = [ + ("DNS", name) + for name in map(_dnsname_to_stdlib, ext.get_values_for_type(x509.DNSName)) + if name is not None + ] + names.extend( + ("IP Address", str(name)) for name in ext.get_values_for_type(x509.IPAddress) + ) + + return names + + +class WrappedSocket(object): + """API-compatibility wrapper for Python OpenSSL's Connection-class. + + Note: _makefile_refs, _drop() and _reuse() are needed for the garbage + collector of pypy. + """ + + def __init__(self, connection, socket, suppress_ragged_eofs=True): + self.connection = connection + self.socket = socket + self.suppress_ragged_eofs = suppress_ragged_eofs + self._makefile_refs = 0 + self._closed = False + + def fileno(self): + return self.socket.fileno() + + # Copy-pasted from Python 3.5 source code + def _decref_socketios(self): + if self._makefile_refs > 0: + self._makefile_refs -= 1 + if self._closed: + self.close() + + def recv(self, *args, **kwargs): + try: + data = self.connection.recv(*args, **kwargs) + except OpenSSL.SSL.SysCallError as e: + if self.suppress_ragged_eofs and e.args == (-1, "Unexpected EOF"): + return b"" + else: + raise SocketError(str(e)) + except OpenSSL.SSL.ZeroReturnError: + if self.connection.get_shutdown() == OpenSSL.SSL.RECEIVED_SHUTDOWN: + return b"" + else: + raise + except OpenSSL.SSL.WantReadError: + if not util.wait_for_read(self.socket, self.socket.gettimeout()): + raise timeout("The read operation timed out") + else: + return self.recv(*args, **kwargs) + + # TLS 1.3 post-handshake authentication + except OpenSSL.SSL.Error as e: + raise ssl.SSLError("read error: %r" % e) + else: + return data + + def recv_into(self, *args, **kwargs): + try: + return self.connection.recv_into(*args, **kwargs) + except OpenSSL.SSL.SysCallError as e: + if self.suppress_ragged_eofs and e.args == (-1, "Unexpected EOF"): + return 0 + else: + raise SocketError(str(e)) + except OpenSSL.SSL.ZeroReturnError: + if self.connection.get_shutdown() == OpenSSL.SSL.RECEIVED_SHUTDOWN: + return 0 + else: + raise + except OpenSSL.SSL.WantReadError: + if not util.wait_for_read(self.socket, self.socket.gettimeout()): + raise timeout("The read operation timed out") + else: + return self.recv_into(*args, **kwargs) + + # TLS 1.3 post-handshake authentication + except OpenSSL.SSL.Error as e: + raise ssl.SSLError("read error: %r" % e) + + def settimeout(self, timeout): + return self.socket.settimeout(timeout) + + def _send_until_done(self, data): + while True: + try: + return self.connection.send(data) + except OpenSSL.SSL.WantWriteError: + if not util.wait_for_write(self.socket, self.socket.gettimeout()): + raise timeout() + continue + except OpenSSL.SSL.SysCallError as e: + raise SocketError(str(e)) + + def sendall(self, data): + total_sent = 0 + while total_sent < len(data): + sent = self._send_until_done( + data[total_sent : total_sent + SSL_WRITE_BLOCKSIZE] + ) + total_sent += sent + + def shutdown(self): + # FIXME rethrow compatible exceptions should we ever use this + self.connection.shutdown() + + def close(self): + if self._makefile_refs < 1: + try: + self._closed = True + return self.connection.close() + except OpenSSL.SSL.Error: + return + else: + self._makefile_refs -= 1 + + def getpeercert(self, binary_form=False): + x509 = self.connection.get_peer_certificate() + + if not x509: + return x509 + + if binary_form: + return OpenSSL.crypto.dump_certificate(OpenSSL.crypto.FILETYPE_ASN1, x509) + + return { + "subject": ((("commonName", x509.get_subject().CN),),), + "subjectAltName": get_subj_alt_name(x509), + } + + def version(self): + return self.connection.get_protocol_version_name() + + def _reuse(self): + self._makefile_refs += 1 + + def _drop(self): + if self._makefile_refs < 1: + self.close() + else: + self._makefile_refs -= 1 + + +if _fileobject: # Platform-specific: Python 2 + + def makefile(self, mode, bufsize=-1): + self._makefile_refs += 1 + return _fileobject(self, mode, bufsize, close=True) + +else: # Platform-specific: Python 3 + makefile = backport_makefile + +WrappedSocket.makefile = makefile + + +class PyOpenSSLContext(object): + """ + I am a wrapper class for the PyOpenSSL ``Context`` object. I am responsible + for translating the interface of the standard library ``SSLContext`` object + to calls into PyOpenSSL. + """ + + def __init__(self, protocol): + self.protocol = _openssl_versions[protocol] + self._ctx = OpenSSL.SSL.Context(self.protocol) + self._options = 0 + self.check_hostname = False + + @property + def options(self): + return self._options + + @options.setter + def options(self, value): + self._options = value + self._ctx.set_options(value) + + @property + def verify_mode(self): + return _openssl_to_stdlib_verify[self._ctx.get_verify_mode()] + + @verify_mode.setter + def verify_mode(self, value): + self._ctx.set_verify(_stdlib_to_openssl_verify[value], _verify_callback) + + def set_default_verify_paths(self): + self._ctx.set_default_verify_paths() + + def set_ciphers(self, ciphers): + if isinstance(ciphers, six.text_type): + ciphers = ciphers.encode("utf-8") + self._ctx.set_cipher_list(ciphers) + + def load_verify_locations(self, cafile=None, capath=None, cadata=None): + if cafile is not None: + cafile = cafile.encode("utf-8") + if capath is not None: + capath = capath.encode("utf-8") + try: + self._ctx.load_verify_locations(cafile, capath) + if cadata is not None: + self._ctx.load_verify_locations(BytesIO(cadata)) + except OpenSSL.SSL.Error as e: + raise ssl.SSLError("unable to load trusted certificates: %r" % e) + + def load_cert_chain(self, certfile, keyfile=None, password=None): + self._ctx.use_certificate_chain_file(certfile) + if password is not None: + if not isinstance(password, six.binary_type): + password = password.encode("utf-8") + self._ctx.set_passwd_cb(lambda *_: password) + self._ctx.use_privatekey_file(keyfile or certfile) + + def set_alpn_protocols(self, protocols): + protocols = [six.ensure_binary(p) for p in protocols] + return self._ctx.set_alpn_protos(protocols) + + def wrap_socket( + self, + sock, + server_side=False, + do_handshake_on_connect=True, + suppress_ragged_eofs=True, + server_hostname=None, + ): + cnx = OpenSSL.SSL.Connection(self._ctx, sock) + + if isinstance(server_hostname, six.text_type): # Platform-specific: Python 3 + server_hostname = server_hostname.encode("utf-8") + + if server_hostname is not None: + cnx.set_tlsext_host_name(server_hostname) + + cnx.set_connect_state() + + while True: + try: + cnx.do_handshake() + except OpenSSL.SSL.WantReadError: + if not util.wait_for_read(sock, sock.gettimeout()): + raise timeout("select timed out") + continue + except OpenSSL.SSL.Error as e: + raise ssl.SSLError("bad handshake: %r" % e) + break + + return WrappedSocket(cnx, sock) + + +def _verify_callback(cnx, x509, err_no, err_depth, return_code): + return err_no == 0 diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/securetransport.py b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/securetransport.py new file mode 100644 index 0000000000000000000000000000000000000000..722ee4e12420f4c70af101ed9c749606157b67ef --- /dev/null +++ b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/securetransport.py @@ -0,0 +1,920 @@ +""" +SecureTranport support for urllib3 via ctypes. + +This makes platform-native TLS available to urllib3 users on macOS without the +use of a compiler. This is an important feature because the Python Package +Index is moving to become a TLSv1.2-or-higher server, and the default OpenSSL +that ships with macOS is not capable of doing TLSv1.2. The only way to resolve +this is to give macOS users an alternative solution to the problem, and that +solution is to use SecureTransport. + +We use ctypes here because this solution must not require a compiler. That's +because pip is not allowed to require a compiler either. + +This is not intended to be a seriously long-term solution to this problem. +The hope is that PEP 543 will eventually solve this issue for us, at which +point we can retire this contrib module. But in the short term, we need to +solve the impending tire fire that is Python on Mac without this kind of +contrib module. So...here we are. + +To use this module, simply import and inject it:: + + import pip._vendor.urllib3.contrib.securetransport as securetransport + securetransport.inject_into_urllib3() + +Happy TLSing! + +This code is a bastardised version of the code found in Will Bond's oscrypto +library. An enormous debt is owed to him for blazing this trail for us. For +that reason, this code should be considered to be covered both by urllib3's +license and by oscrypto's: + +.. code-block:: + + Copyright (c) 2015-2016 Will Bond + + Permission is hereby granted, free of charge, to any person obtaining a + copy of this software and associated documentation files (the "Software"), + to deal in the Software without restriction, including without limitation + the rights to use, copy, modify, merge, publish, distribute, sublicense, + and/or sell copies of the Software, and to permit persons to whom the + Software is furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in + all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + DEALINGS IN THE SOFTWARE. +""" +from __future__ import absolute_import + +import contextlib +import ctypes +import errno +import os.path +import shutil +import socket +import ssl +import struct +import threading +import weakref + +from .. import util +from ..packages import six +from ..util.ssl_ import PROTOCOL_TLS_CLIENT +from ._securetransport.bindings import CoreFoundation, Security, SecurityConst +from ._securetransport.low_level import ( + _assert_no_error, + _build_tls_unknown_ca_alert, + _cert_array_from_pem, + _create_cfstring_array, + _load_client_cert_chain, + _temporary_keychain, +) + +try: # Platform-specific: Python 2 + from socket import _fileobject +except ImportError: # Platform-specific: Python 3 + _fileobject = None + from ..packages.backports.makefile import backport_makefile + +__all__ = ["inject_into_urllib3", "extract_from_urllib3"] + +# SNI always works +HAS_SNI = True + +orig_util_HAS_SNI = util.HAS_SNI +orig_util_SSLContext = util.ssl_.SSLContext + +# This dictionary is used by the read callback to obtain a handle to the +# calling wrapped socket. This is a pretty silly approach, but for now it'll +# do. I feel like I should be able to smuggle a handle to the wrapped socket +# directly in the SSLConnectionRef, but for now this approach will work I +# guess. +# +# We need to lock around this structure for inserts, but we don't do it for +# reads/writes in the callbacks. The reasoning here goes as follows: +# +# 1. It is not possible to call into the callbacks before the dictionary is +# populated, so once in the callback the id must be in the dictionary. +# 2. The callbacks don't mutate the dictionary, they only read from it, and +# so cannot conflict with any of the insertions. +# +# This is good: if we had to lock in the callbacks we'd drastically slow down +# the performance of this code. +_connection_refs = weakref.WeakValueDictionary() +_connection_ref_lock = threading.Lock() + +# Limit writes to 16kB. This is OpenSSL's limit, but we'll cargo-cult it over +# for no better reason than we need *a* limit, and this one is right there. +SSL_WRITE_BLOCKSIZE = 16384 + +# This is our equivalent of util.ssl_.DEFAULT_CIPHERS, but expanded out to +# individual cipher suites. We need to do this because this is how +# SecureTransport wants them. +CIPHER_SUITES = [ + SecurityConst.TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384, + SecurityConst.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256, + SecurityConst.TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384, + SecurityConst.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256, + SecurityConst.TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256, + SecurityConst.TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256, + SecurityConst.TLS_DHE_RSA_WITH_AES_256_GCM_SHA384, + SecurityConst.TLS_DHE_RSA_WITH_AES_128_GCM_SHA256, + SecurityConst.TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384, + SecurityConst.TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA, + SecurityConst.TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256, + SecurityConst.TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA, + SecurityConst.TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384, + SecurityConst.TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA, + SecurityConst.TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256, + SecurityConst.TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA, + SecurityConst.TLS_DHE_RSA_WITH_AES_256_CBC_SHA256, + SecurityConst.TLS_DHE_RSA_WITH_AES_256_CBC_SHA, + SecurityConst.TLS_DHE_RSA_WITH_AES_128_CBC_SHA256, + SecurityConst.TLS_DHE_RSA_WITH_AES_128_CBC_SHA, + SecurityConst.TLS_AES_256_GCM_SHA384, + SecurityConst.TLS_AES_128_GCM_SHA256, + SecurityConst.TLS_RSA_WITH_AES_256_GCM_SHA384, + SecurityConst.TLS_RSA_WITH_AES_128_GCM_SHA256, + SecurityConst.TLS_AES_128_CCM_8_SHA256, + SecurityConst.TLS_AES_128_CCM_SHA256, + SecurityConst.TLS_RSA_WITH_AES_256_CBC_SHA256, + SecurityConst.TLS_RSA_WITH_AES_128_CBC_SHA256, + SecurityConst.TLS_RSA_WITH_AES_256_CBC_SHA, + SecurityConst.TLS_RSA_WITH_AES_128_CBC_SHA, +] + +# Basically this is simple: for PROTOCOL_SSLv23 we turn it into a low of +# TLSv1 and a high of TLSv1.2. For everything else, we pin to that version. +# TLSv1 to 1.2 are supported on macOS 10.8+ +_protocol_to_min_max = { + util.PROTOCOL_TLS: (SecurityConst.kTLSProtocol1, SecurityConst.kTLSProtocol12), + PROTOCOL_TLS_CLIENT: (SecurityConst.kTLSProtocol1, SecurityConst.kTLSProtocol12), +} + +if hasattr(ssl, "PROTOCOL_SSLv2"): + _protocol_to_min_max[ssl.PROTOCOL_SSLv2] = ( + SecurityConst.kSSLProtocol2, + SecurityConst.kSSLProtocol2, + ) +if hasattr(ssl, "PROTOCOL_SSLv3"): + _protocol_to_min_max[ssl.PROTOCOL_SSLv3] = ( + SecurityConst.kSSLProtocol3, + SecurityConst.kSSLProtocol3, + ) +if hasattr(ssl, "PROTOCOL_TLSv1"): + _protocol_to_min_max[ssl.PROTOCOL_TLSv1] = ( + SecurityConst.kTLSProtocol1, + SecurityConst.kTLSProtocol1, + ) +if hasattr(ssl, "PROTOCOL_TLSv1_1"): + _protocol_to_min_max[ssl.PROTOCOL_TLSv1_1] = ( + SecurityConst.kTLSProtocol11, + SecurityConst.kTLSProtocol11, + ) +if hasattr(ssl, "PROTOCOL_TLSv1_2"): + _protocol_to_min_max[ssl.PROTOCOL_TLSv1_2] = ( + SecurityConst.kTLSProtocol12, + SecurityConst.kTLSProtocol12, + ) + + +def inject_into_urllib3(): + """ + Monkey-patch urllib3 with SecureTransport-backed SSL-support. + """ + util.SSLContext = SecureTransportContext + util.ssl_.SSLContext = SecureTransportContext + util.HAS_SNI = HAS_SNI + util.ssl_.HAS_SNI = HAS_SNI + util.IS_SECURETRANSPORT = True + util.ssl_.IS_SECURETRANSPORT = True + + +def extract_from_urllib3(): + """ + Undo monkey-patching by :func:`inject_into_urllib3`. + """ + util.SSLContext = orig_util_SSLContext + util.ssl_.SSLContext = orig_util_SSLContext + util.HAS_SNI = orig_util_HAS_SNI + util.ssl_.HAS_SNI = orig_util_HAS_SNI + util.IS_SECURETRANSPORT = False + util.ssl_.IS_SECURETRANSPORT = False + + +def _read_callback(connection_id, data_buffer, data_length_pointer): + """ + SecureTransport read callback. This is called by ST to request that data + be returned from the socket. + """ + wrapped_socket = None + try: + wrapped_socket = _connection_refs.get(connection_id) + if wrapped_socket is None: + return SecurityConst.errSSLInternal + base_socket = wrapped_socket.socket + + requested_length = data_length_pointer[0] + + timeout = wrapped_socket.gettimeout() + error = None + read_count = 0 + + try: + while read_count < requested_length: + if timeout is None or timeout >= 0: + if not util.wait_for_read(base_socket, timeout): + raise socket.error(errno.EAGAIN, "timed out") + + remaining = requested_length - read_count + buffer = (ctypes.c_char * remaining).from_address( + data_buffer + read_count + ) + chunk_size = base_socket.recv_into(buffer, remaining) + read_count += chunk_size + if not chunk_size: + if not read_count: + return SecurityConst.errSSLClosedGraceful + break + except (socket.error) as e: + error = e.errno + + if error is not None and error != errno.EAGAIN: + data_length_pointer[0] = read_count + if error == errno.ECONNRESET or error == errno.EPIPE: + return SecurityConst.errSSLClosedAbort + raise + + data_length_pointer[0] = read_count + + if read_count != requested_length: + return SecurityConst.errSSLWouldBlock + + return 0 + except Exception as e: + if wrapped_socket is not None: + wrapped_socket._exception = e + return SecurityConst.errSSLInternal + + +def _write_callback(connection_id, data_buffer, data_length_pointer): + """ + SecureTransport write callback. This is called by ST to request that data + actually be sent on the network. + """ + wrapped_socket = None + try: + wrapped_socket = _connection_refs.get(connection_id) + if wrapped_socket is None: + return SecurityConst.errSSLInternal + base_socket = wrapped_socket.socket + + bytes_to_write = data_length_pointer[0] + data = ctypes.string_at(data_buffer, bytes_to_write) + + timeout = wrapped_socket.gettimeout() + error = None + sent = 0 + + try: + while sent < bytes_to_write: + if timeout is None or timeout >= 0: + if not util.wait_for_write(base_socket, timeout): + raise socket.error(errno.EAGAIN, "timed out") + chunk_sent = base_socket.send(data) + sent += chunk_sent + + # This has some needless copying here, but I'm not sure there's + # much value in optimising this data path. + data = data[chunk_sent:] + except (socket.error) as e: + error = e.errno + + if error is not None and error != errno.EAGAIN: + data_length_pointer[0] = sent + if error == errno.ECONNRESET or error == errno.EPIPE: + return SecurityConst.errSSLClosedAbort + raise + + data_length_pointer[0] = sent + + if sent != bytes_to_write: + return SecurityConst.errSSLWouldBlock + + return 0 + except Exception as e: + if wrapped_socket is not None: + wrapped_socket._exception = e + return SecurityConst.errSSLInternal + + +# We need to keep these two objects references alive: if they get GC'd while +# in use then SecureTransport could attempt to call a function that is in freed +# memory. That would be...uh...bad. Yeah, that's the word. Bad. +_read_callback_pointer = Security.SSLReadFunc(_read_callback) +_write_callback_pointer = Security.SSLWriteFunc(_write_callback) + + +class WrappedSocket(object): + """ + API-compatibility wrapper for Python's OpenSSL wrapped socket object. + + Note: _makefile_refs, _drop(), and _reuse() are needed for the garbage + collector of PyPy. + """ + + def __init__(self, socket): + self.socket = socket + self.context = None + self._makefile_refs = 0 + self._closed = False + self._exception = None + self._keychain = None + self._keychain_dir = None + self._client_cert_chain = None + + # We save off the previously-configured timeout and then set it to + # zero. This is done because we use select and friends to handle the + # timeouts, but if we leave the timeout set on the lower socket then + # Python will "kindly" call select on that socket again for us. Avoid + # that by forcing the timeout to zero. + self._timeout = self.socket.gettimeout() + self.socket.settimeout(0) + + @contextlib.contextmanager + def _raise_on_error(self): + """ + A context manager that can be used to wrap calls that do I/O from + SecureTransport. If any of the I/O callbacks hit an exception, this + context manager will correctly propagate the exception after the fact. + This avoids silently swallowing those exceptions. + + It also correctly forces the socket closed. + """ + self._exception = None + + # We explicitly don't catch around this yield because in the unlikely + # event that an exception was hit in the block we don't want to swallow + # it. + yield + if self._exception is not None: + exception, self._exception = self._exception, None + self.close() + raise exception + + def _set_ciphers(self): + """ + Sets up the allowed ciphers. By default this matches the set in + util.ssl_.DEFAULT_CIPHERS, at least as supported by macOS. This is done + custom and doesn't allow changing at this time, mostly because parsing + OpenSSL cipher strings is going to be a freaking nightmare. + """ + ciphers = (Security.SSLCipherSuite * len(CIPHER_SUITES))(*CIPHER_SUITES) + result = Security.SSLSetEnabledCiphers( + self.context, ciphers, len(CIPHER_SUITES) + ) + _assert_no_error(result) + + def _set_alpn_protocols(self, protocols): + """ + Sets up the ALPN protocols on the context. + """ + if not protocols: + return + protocols_arr = _create_cfstring_array(protocols) + try: + result = Security.SSLSetALPNProtocols(self.context, protocols_arr) + _assert_no_error(result) + finally: + CoreFoundation.CFRelease(protocols_arr) + + def _custom_validate(self, verify, trust_bundle): + """ + Called when we have set custom validation. We do this in two cases: + first, when cert validation is entirely disabled; and second, when + using a custom trust DB. + Raises an SSLError if the connection is not trusted. + """ + # If we disabled cert validation, just say: cool. + if not verify: + return + + successes = ( + SecurityConst.kSecTrustResultUnspecified, + SecurityConst.kSecTrustResultProceed, + ) + try: + trust_result = self._evaluate_trust(trust_bundle) + if trust_result in successes: + return + reason = "error code: %d" % (trust_result,) + except Exception as e: + # Do not trust on error + reason = "exception: %r" % (e,) + + # SecureTransport does not send an alert nor shuts down the connection. + rec = _build_tls_unknown_ca_alert(self.version()) + self.socket.sendall(rec) + # close the connection immediately + # l_onoff = 1, activate linger + # l_linger = 0, linger for 0 seoncds + opts = struct.pack("ii", 1, 0) + self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_LINGER, opts) + self.close() + raise ssl.SSLError("certificate verify failed, %s" % reason) + + def _evaluate_trust(self, trust_bundle): + # We want data in memory, so load it up. + if os.path.isfile(trust_bundle): + with open(trust_bundle, "rb") as f: + trust_bundle = f.read() + + cert_array = None + trust = Security.SecTrustRef() + + try: + # Get a CFArray that contains the certs we want. + cert_array = _cert_array_from_pem(trust_bundle) + + # Ok, now the hard part. We want to get the SecTrustRef that ST has + # created for this connection, shove our CAs into it, tell ST to + # ignore everything else it knows, and then ask if it can build a + # chain. This is a buuuunch of code. + result = Security.SSLCopyPeerTrust(self.context, ctypes.byref(trust)) + _assert_no_error(result) + if not trust: + raise ssl.SSLError("Failed to copy trust reference") + + result = Security.SecTrustSetAnchorCertificates(trust, cert_array) + _assert_no_error(result) + + result = Security.SecTrustSetAnchorCertificatesOnly(trust, True) + _assert_no_error(result) + + trust_result = Security.SecTrustResultType() + result = Security.SecTrustEvaluate(trust, ctypes.byref(trust_result)) + _assert_no_error(result) + finally: + if trust: + CoreFoundation.CFRelease(trust) + + if cert_array is not None: + CoreFoundation.CFRelease(cert_array) + + return trust_result.value + + def handshake( + self, + server_hostname, + verify, + trust_bundle, + min_version, + max_version, + client_cert, + client_key, + client_key_passphrase, + alpn_protocols, + ): + """ + Actually performs the TLS handshake. This is run automatically by + wrapped socket, and shouldn't be needed in user code. + """ + # First, we do the initial bits of connection setup. We need to create + # a context, set its I/O funcs, and set the connection reference. + self.context = Security.SSLCreateContext( + None, SecurityConst.kSSLClientSide, SecurityConst.kSSLStreamType + ) + result = Security.SSLSetIOFuncs( + self.context, _read_callback_pointer, _write_callback_pointer + ) + _assert_no_error(result) + + # Here we need to compute the handle to use. We do this by taking the + # id of self modulo 2**31 - 1. If this is already in the dictionary, we + # just keep incrementing by one until we find a free space. + with _connection_ref_lock: + handle = id(self) % 2147483647 + while handle in _connection_refs: + handle = (handle + 1) % 2147483647 + _connection_refs[handle] = self + + result = Security.SSLSetConnection(self.context, handle) + _assert_no_error(result) + + # If we have a server hostname, we should set that too. + if server_hostname: + if not isinstance(server_hostname, bytes): + server_hostname = server_hostname.encode("utf-8") + + result = Security.SSLSetPeerDomainName( + self.context, server_hostname, len(server_hostname) + ) + _assert_no_error(result) + + # Setup the ciphers. + self._set_ciphers() + + # Setup the ALPN protocols. + self._set_alpn_protocols(alpn_protocols) + + # Set the minimum and maximum TLS versions. + result = Security.SSLSetProtocolVersionMin(self.context, min_version) + _assert_no_error(result) + + result = Security.SSLSetProtocolVersionMax(self.context, max_version) + _assert_no_error(result) + + # If there's a trust DB, we need to use it. We do that by telling + # SecureTransport to break on server auth. We also do that if we don't + # want to validate the certs at all: we just won't actually do any + # authing in that case. + if not verify or trust_bundle is not None: + result = Security.SSLSetSessionOption( + self.context, SecurityConst.kSSLSessionOptionBreakOnServerAuth, True + ) + _assert_no_error(result) + + # If there's a client cert, we need to use it. + if client_cert: + self._keychain, self._keychain_dir = _temporary_keychain() + self._client_cert_chain = _load_client_cert_chain( + self._keychain, client_cert, client_key + ) + result = Security.SSLSetCertificate(self.context, self._client_cert_chain) + _assert_no_error(result) + + while True: + with self._raise_on_error(): + result = Security.SSLHandshake(self.context) + + if result == SecurityConst.errSSLWouldBlock: + raise socket.timeout("handshake timed out") + elif result == SecurityConst.errSSLServerAuthCompleted: + self._custom_validate(verify, trust_bundle) + continue + else: + _assert_no_error(result) + break + + def fileno(self): + return self.socket.fileno() + + # Copy-pasted from Python 3.5 source code + def _decref_socketios(self): + if self._makefile_refs > 0: + self._makefile_refs -= 1 + if self._closed: + self.close() + + def recv(self, bufsiz): + buffer = ctypes.create_string_buffer(bufsiz) + bytes_read = self.recv_into(buffer, bufsiz) + data = buffer[:bytes_read] + return data + + def recv_into(self, buffer, nbytes=None): + # Read short on EOF. + if self._closed: + return 0 + + if nbytes is None: + nbytes = len(buffer) + + buffer = (ctypes.c_char * nbytes).from_buffer(buffer) + processed_bytes = ctypes.c_size_t(0) + + with self._raise_on_error(): + result = Security.SSLRead( + self.context, buffer, nbytes, ctypes.byref(processed_bytes) + ) + + # There are some result codes that we want to treat as "not always + # errors". Specifically, those are errSSLWouldBlock, + # errSSLClosedGraceful, and errSSLClosedNoNotify. + if result == SecurityConst.errSSLWouldBlock: + # If we didn't process any bytes, then this was just a time out. + # However, we can get errSSLWouldBlock in situations when we *did* + # read some data, and in those cases we should just read "short" + # and return. + if processed_bytes.value == 0: + # Timed out, no data read. + raise socket.timeout("recv timed out") + elif result in ( + SecurityConst.errSSLClosedGraceful, + SecurityConst.errSSLClosedNoNotify, + ): + # The remote peer has closed this connection. We should do so as + # well. Note that we don't actually return here because in + # principle this could actually be fired along with return data. + # It's unlikely though. + self.close() + else: + _assert_no_error(result) + + # Ok, we read and probably succeeded. We should return whatever data + # was actually read. + return processed_bytes.value + + def settimeout(self, timeout): + self._timeout = timeout + + def gettimeout(self): + return self._timeout + + def send(self, data): + processed_bytes = ctypes.c_size_t(0) + + with self._raise_on_error(): + result = Security.SSLWrite( + self.context, data, len(data), ctypes.byref(processed_bytes) + ) + + if result == SecurityConst.errSSLWouldBlock and processed_bytes.value == 0: + # Timed out + raise socket.timeout("send timed out") + else: + _assert_no_error(result) + + # We sent, and probably succeeded. Tell them how much we sent. + return processed_bytes.value + + def sendall(self, data): + total_sent = 0 + while total_sent < len(data): + sent = self.send(data[total_sent : total_sent + SSL_WRITE_BLOCKSIZE]) + total_sent += sent + + def shutdown(self): + with self._raise_on_error(): + Security.SSLClose(self.context) + + def close(self): + # TODO: should I do clean shutdown here? Do I have to? + if self._makefile_refs < 1: + self._closed = True + if self.context: + CoreFoundation.CFRelease(self.context) + self.context = None + if self._client_cert_chain: + CoreFoundation.CFRelease(self._client_cert_chain) + self._client_cert_chain = None + if self._keychain: + Security.SecKeychainDelete(self._keychain) + CoreFoundation.CFRelease(self._keychain) + shutil.rmtree(self._keychain_dir) + self._keychain = self._keychain_dir = None + return self.socket.close() + else: + self._makefile_refs -= 1 + + def getpeercert(self, binary_form=False): + # Urgh, annoying. + # + # Here's how we do this: + # + # 1. Call SSLCopyPeerTrust to get hold of the trust object for this + # connection. + # 2. Call SecTrustGetCertificateAtIndex for index 0 to get the leaf. + # 3. To get the CN, call SecCertificateCopyCommonName and process that + # string so that it's of the appropriate type. + # 4. To get the SAN, we need to do something a bit more complex: + # a. Call SecCertificateCopyValues to get the data, requesting + # kSecOIDSubjectAltName. + # b. Mess about with this dictionary to try to get the SANs out. + # + # This is gross. Really gross. It's going to be a few hundred LoC extra + # just to repeat something that SecureTransport can *already do*. So my + # operating assumption at this time is that what we want to do is + # instead to just flag to urllib3 that it shouldn't do its own hostname + # validation when using SecureTransport. + if not binary_form: + raise ValueError("SecureTransport only supports dumping binary certs") + trust = Security.SecTrustRef() + certdata = None + der_bytes = None + + try: + # Grab the trust store. + result = Security.SSLCopyPeerTrust(self.context, ctypes.byref(trust)) + _assert_no_error(result) + if not trust: + # Probably we haven't done the handshake yet. No biggie. + return None + + cert_count = Security.SecTrustGetCertificateCount(trust) + if not cert_count: + # Also a case that might happen if we haven't handshaked. + # Handshook? Handshaken? + return None + + leaf = Security.SecTrustGetCertificateAtIndex(trust, 0) + assert leaf + + # Ok, now we want the DER bytes. + certdata = Security.SecCertificateCopyData(leaf) + assert certdata + + data_length = CoreFoundation.CFDataGetLength(certdata) + data_buffer = CoreFoundation.CFDataGetBytePtr(certdata) + der_bytes = ctypes.string_at(data_buffer, data_length) + finally: + if certdata: + CoreFoundation.CFRelease(certdata) + if trust: + CoreFoundation.CFRelease(trust) + + return der_bytes + + def version(self): + protocol = Security.SSLProtocol() + result = Security.SSLGetNegotiatedProtocolVersion( + self.context, ctypes.byref(protocol) + ) + _assert_no_error(result) + if protocol.value == SecurityConst.kTLSProtocol13: + raise ssl.SSLError("SecureTransport does not support TLS 1.3") + elif protocol.value == SecurityConst.kTLSProtocol12: + return "TLSv1.2" + elif protocol.value == SecurityConst.kTLSProtocol11: + return "TLSv1.1" + elif protocol.value == SecurityConst.kTLSProtocol1: + return "TLSv1" + elif protocol.value == SecurityConst.kSSLProtocol3: + return "SSLv3" + elif protocol.value == SecurityConst.kSSLProtocol2: + return "SSLv2" + else: + raise ssl.SSLError("Unknown TLS version: %r" % protocol) + + def _reuse(self): + self._makefile_refs += 1 + + def _drop(self): + if self._makefile_refs < 1: + self.close() + else: + self._makefile_refs -= 1 + + +if _fileobject: # Platform-specific: Python 2 + + def makefile(self, mode, bufsize=-1): + self._makefile_refs += 1 + return _fileobject(self, mode, bufsize, close=True) + +else: # Platform-specific: Python 3 + + def makefile(self, mode="r", buffering=None, *args, **kwargs): + # We disable buffering with SecureTransport because it conflicts with + # the buffering that ST does internally (see issue #1153 for more). + buffering = 0 + return backport_makefile(self, mode, buffering, *args, **kwargs) + + +WrappedSocket.makefile = makefile + + +class SecureTransportContext(object): + """ + I am a wrapper class for the SecureTransport library, to translate the + interface of the standard library ``SSLContext`` object to calls into + SecureTransport. + """ + + def __init__(self, protocol): + self._min_version, self._max_version = _protocol_to_min_max[protocol] + self._options = 0 + self._verify = False + self._trust_bundle = None + self._client_cert = None + self._client_key = None + self._client_key_passphrase = None + self._alpn_protocols = None + + @property + def check_hostname(self): + """ + SecureTransport cannot have its hostname checking disabled. For more, + see the comment on getpeercert() in this file. + """ + return True + + @check_hostname.setter + def check_hostname(self, value): + """ + SecureTransport cannot have its hostname checking disabled. For more, + see the comment on getpeercert() in this file. + """ + pass + + @property + def options(self): + # TODO: Well, crap. + # + # So this is the bit of the code that is the most likely to cause us + # trouble. Essentially we need to enumerate all of the SSL options that + # users might want to use and try to see if we can sensibly translate + # them, or whether we should just ignore them. + return self._options + + @options.setter + def options(self, value): + # TODO: Update in line with above. + self._options = value + + @property + def verify_mode(self): + return ssl.CERT_REQUIRED if self._verify else ssl.CERT_NONE + + @verify_mode.setter + def verify_mode(self, value): + self._verify = True if value == ssl.CERT_REQUIRED else False + + def set_default_verify_paths(self): + # So, this has to do something a bit weird. Specifically, what it does + # is nothing. + # + # This means that, if we had previously had load_verify_locations + # called, this does not undo that. We need to do that because it turns + # out that the rest of the urllib3 code will attempt to load the + # default verify paths if it hasn't been told about any paths, even if + # the context itself was sometime earlier. We resolve that by just + # ignoring it. + pass + + def load_default_certs(self): + return self.set_default_verify_paths() + + def set_ciphers(self, ciphers): + # For now, we just require the default cipher string. + if ciphers != util.ssl_.DEFAULT_CIPHERS: + raise ValueError("SecureTransport doesn't support custom cipher strings") + + def load_verify_locations(self, cafile=None, capath=None, cadata=None): + # OK, we only really support cadata and cafile. + if capath is not None: + raise ValueError("SecureTransport does not support cert directories") + + # Raise if cafile does not exist. + if cafile is not None: + with open(cafile): + pass + + self._trust_bundle = cafile or cadata + + def load_cert_chain(self, certfile, keyfile=None, password=None): + self._client_cert = certfile + self._client_key = keyfile + self._client_cert_passphrase = password + + def set_alpn_protocols(self, protocols): + """ + Sets the ALPN protocols that will later be set on the context. + + Raises a NotImplementedError if ALPN is not supported. + """ + if not hasattr(Security, "SSLSetALPNProtocols"): + raise NotImplementedError( + "SecureTransport supports ALPN only in macOS 10.12+" + ) + self._alpn_protocols = [six.ensure_binary(p) for p in protocols] + + def wrap_socket( + self, + sock, + server_side=False, + do_handshake_on_connect=True, + suppress_ragged_eofs=True, + server_hostname=None, + ): + # So, what do we do here? Firstly, we assert some properties. This is a + # stripped down shim, so there is some functionality we don't support. + # See PEP 543 for the real deal. + assert not server_side + assert do_handshake_on_connect + assert suppress_ragged_eofs + + # Ok, we're good to go. Now we want to create the wrapped socket object + # and store it in the appropriate place. + wrapped_socket = WrappedSocket(sock) + + # Now we can handshake + wrapped_socket.handshake( + server_hostname, + self._verify, + self._trust_bundle, + self._min_version, + self._max_version, + self._client_cert, + self._client_key, + self._client_key_passphrase, + self._alpn_protocols, + ) + return wrapped_socket diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/socks.py b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/socks.py new file mode 100644 index 0000000000000000000000000000000000000000..c326e80dd117458ff6e71741ca57359629b05ae4 --- /dev/null +++ b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/contrib/socks.py @@ -0,0 +1,216 @@ +# -*- coding: utf-8 -*- +""" +This module contains provisional support for SOCKS proxies from within +urllib3. This module supports SOCKS4, SOCKS4A (an extension of SOCKS4), and +SOCKS5. To enable its functionality, either install PySocks or install this +module with the ``socks`` extra. + +The SOCKS implementation supports the full range of urllib3 features. It also +supports the following SOCKS features: + +- SOCKS4A (``proxy_url='socks4a://...``) +- SOCKS4 (``proxy_url='socks4://...``) +- SOCKS5 with remote DNS (``proxy_url='socks5h://...``) +- SOCKS5 with local DNS (``proxy_url='socks5://...``) +- Usernames and passwords for the SOCKS proxy + +.. note:: + It is recommended to use ``socks5h://`` or ``socks4a://`` schemes in + your ``proxy_url`` to ensure that DNS resolution is done from the remote + server instead of client-side when connecting to a domain name. + +SOCKS4 supports IPv4 and domain names with the SOCKS4A extension. SOCKS5 +supports IPv4, IPv6, and domain names. + +When connecting to a SOCKS4 proxy the ``username`` portion of the ``proxy_url`` +will be sent as the ``userid`` section of the SOCKS request: + +.. code-block:: python + + proxy_url="socks4a://@proxy-host" + +When connecting to a SOCKS5 proxy the ``username`` and ``password`` portion +of the ``proxy_url`` will be sent as the username/password to authenticate +with the proxy: + +.. code-block:: python + + proxy_url="socks5h://:@proxy-host" + +""" +from __future__ import absolute_import + +try: + import socks +except ImportError: + import warnings + + from ..exceptions import DependencyWarning + + warnings.warn( + ( + "SOCKS support in urllib3 requires the installation of optional " + "dependencies: specifically, PySocks. For more information, see " + "https://urllib3.readthedocs.io/en/1.26.x/contrib.html#socks-proxies" + ), + DependencyWarning, + ) + raise + +from socket import error as SocketError +from socket import timeout as SocketTimeout + +from ..connection import HTTPConnection, HTTPSConnection +from ..connectionpool import HTTPConnectionPool, HTTPSConnectionPool +from ..exceptions import ConnectTimeoutError, NewConnectionError +from ..poolmanager import PoolManager +from ..util.url import parse_url + +try: + import ssl +except ImportError: + ssl = None + + +class SOCKSConnection(HTTPConnection): + """ + A plain-text HTTP connection that connects via a SOCKS proxy. + """ + + def __init__(self, *args, **kwargs): + self._socks_options = kwargs.pop("_socks_options") + super(SOCKSConnection, self).__init__(*args, **kwargs) + + def _new_conn(self): + """ + Establish a new connection via the SOCKS proxy. + """ + extra_kw = {} + if self.source_address: + extra_kw["source_address"] = self.source_address + + if self.socket_options: + extra_kw["socket_options"] = self.socket_options + + try: + conn = socks.create_connection( + (self.host, self.port), + proxy_type=self._socks_options["socks_version"], + proxy_addr=self._socks_options["proxy_host"], + proxy_port=self._socks_options["proxy_port"], + proxy_username=self._socks_options["username"], + proxy_password=self._socks_options["password"], + proxy_rdns=self._socks_options["rdns"], + timeout=self.timeout, + **extra_kw + ) + + except SocketTimeout: + raise ConnectTimeoutError( + self, + "Connection to %s timed out. (connect timeout=%s)" + % (self.host, self.timeout), + ) + + except socks.ProxyError as e: + # This is fragile as hell, but it seems to be the only way to raise + # useful errors here. + if e.socket_err: + error = e.socket_err + if isinstance(error, SocketTimeout): + raise ConnectTimeoutError( + self, + "Connection to %s timed out. (connect timeout=%s)" + % (self.host, self.timeout), + ) + else: + raise NewConnectionError( + self, "Failed to establish a new connection: %s" % error + ) + else: + raise NewConnectionError( + self, "Failed to establish a new connection: %s" % e + ) + + except SocketError as e: # Defensive: PySocks should catch all these. + raise NewConnectionError( + self, "Failed to establish a new connection: %s" % e + ) + + return conn + + +# We don't need to duplicate the Verified/Unverified distinction from +# urllib3/connection.py here because the HTTPSConnection will already have been +# correctly set to either the Verified or Unverified form by that module. This +# means the SOCKSHTTPSConnection will automatically be the correct type. +class SOCKSHTTPSConnection(SOCKSConnection, HTTPSConnection): + pass + + +class SOCKSHTTPConnectionPool(HTTPConnectionPool): + ConnectionCls = SOCKSConnection + + +class SOCKSHTTPSConnectionPool(HTTPSConnectionPool): + ConnectionCls = SOCKSHTTPSConnection + + +class SOCKSProxyManager(PoolManager): + """ + A version of the urllib3 ProxyManager that routes connections via the + defined SOCKS proxy. + """ + + pool_classes_by_scheme = { + "http": SOCKSHTTPConnectionPool, + "https": SOCKSHTTPSConnectionPool, + } + + def __init__( + self, + proxy_url, + username=None, + password=None, + num_pools=10, + headers=None, + **connection_pool_kw + ): + parsed = parse_url(proxy_url) + + if username is None and password is None and parsed.auth is not None: + split = parsed.auth.split(":") + if len(split) == 2: + username, password = split + if parsed.scheme == "socks5": + socks_version = socks.PROXY_TYPE_SOCKS5 + rdns = False + elif parsed.scheme == "socks5h": + socks_version = socks.PROXY_TYPE_SOCKS5 + rdns = True + elif parsed.scheme == "socks4": + socks_version = socks.PROXY_TYPE_SOCKS4 + rdns = False + elif parsed.scheme == "socks4a": + socks_version = socks.PROXY_TYPE_SOCKS4 + rdns = True + else: + raise ValueError("Unable to determine SOCKS version from %s" % proxy_url) + + self.proxy_url = proxy_url + + socks_options = { + "socks_version": socks_version, + "proxy_host": parsed.host, + "proxy_port": parsed.port, + "username": username, + "password": password, + "rdns": rdns, + } + connection_pool_kw["_socks_options"] = socks_options + + super(SOCKSProxyManager, self).__init__( + num_pools, headers, **connection_pool_kw + ) + + self.pool_classes_by_scheme = SOCKSProxyManager.pool_classes_by_scheme diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/exceptions.py b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/exceptions.py new file mode 100644 index 0000000000000000000000000000000000000000..cba6f3f560f71b3b15ab6aaf21dde4f1bba1bd00 --- /dev/null +++ b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/exceptions.py @@ -0,0 +1,323 @@ +from __future__ import absolute_import + +from .packages.six.moves.http_client import IncompleteRead as httplib_IncompleteRead + +# Base Exceptions + + +class HTTPError(Exception): + """Base exception used by this module.""" + + pass + + +class HTTPWarning(Warning): + """Base warning used by this module.""" + + pass + + +class PoolError(HTTPError): + """Base exception for errors caused within a pool.""" + + def __init__(self, pool, message): + self.pool = pool + HTTPError.__init__(self, "%s: %s" % (pool, message)) + + def __reduce__(self): + # For pickling purposes. + return self.__class__, (None, None) + + +class RequestError(PoolError): + """Base exception for PoolErrors that have associated URLs.""" + + def __init__(self, pool, url, message): + self.url = url + PoolError.__init__(self, pool, message) + + def __reduce__(self): + # For pickling purposes. + return self.__class__, (None, self.url, None) + + +class SSLError(HTTPError): + """Raised when SSL certificate fails in an HTTPS connection.""" + + pass + + +class ProxyError(HTTPError): + """Raised when the connection to a proxy fails.""" + + def __init__(self, message, error, *args): + super(ProxyError, self).__init__(message, error, *args) + self.original_error = error + + +class DecodeError(HTTPError): + """Raised when automatic decoding based on Content-Type fails.""" + + pass + + +class ProtocolError(HTTPError): + """Raised when something unexpected happens mid-request/response.""" + + pass + + +#: Renamed to ProtocolError but aliased for backwards compatibility. +ConnectionError = ProtocolError + + +# Leaf Exceptions + + +class MaxRetryError(RequestError): + """Raised when the maximum number of retries is exceeded. + + :param pool: The connection pool + :type pool: :class:`~urllib3.connectionpool.HTTPConnectionPool` + :param string url: The requested Url + :param exceptions.Exception reason: The underlying error + + """ + + def __init__(self, pool, url, reason=None): + self.reason = reason + + message = "Max retries exceeded with url: %s (Caused by %r)" % (url, reason) + + RequestError.__init__(self, pool, url, message) + + +class HostChangedError(RequestError): + """Raised when an existing pool gets a request for a foreign host.""" + + def __init__(self, pool, url, retries=3): + message = "Tried to open a foreign host with url: %s" % url + RequestError.__init__(self, pool, url, message) + self.retries = retries + + +class TimeoutStateError(HTTPError): + """Raised when passing an invalid state to a timeout""" + + pass + + +class TimeoutError(HTTPError): + """Raised when a socket timeout error occurs. + + Catching this error will catch both :exc:`ReadTimeoutErrors + ` and :exc:`ConnectTimeoutErrors `. + """ + + pass + + +class ReadTimeoutError(TimeoutError, RequestError): + """Raised when a socket timeout occurs while receiving data from a server""" + + pass + + +# This timeout error does not have a URL attached and needs to inherit from the +# base HTTPError +class ConnectTimeoutError(TimeoutError): + """Raised when a socket timeout occurs while connecting to a server""" + + pass + + +class NewConnectionError(ConnectTimeoutError, PoolError): + """Raised when we fail to establish a new connection. Usually ECONNREFUSED.""" + + pass + + +class EmptyPoolError(PoolError): + """Raised when a pool runs out of connections and no more are allowed.""" + + pass + + +class ClosedPoolError(PoolError): + """Raised when a request enters a pool after the pool has been closed.""" + + pass + + +class LocationValueError(ValueError, HTTPError): + """Raised when there is something wrong with a given URL input.""" + + pass + + +class LocationParseError(LocationValueError): + """Raised when get_host or similar fails to parse the URL input.""" + + def __init__(self, location): + message = "Failed to parse: %s" % location + HTTPError.__init__(self, message) + + self.location = location + + +class URLSchemeUnknown(LocationValueError): + """Raised when a URL input has an unsupported scheme.""" + + def __init__(self, scheme): + message = "Not supported URL scheme %s" % scheme + super(URLSchemeUnknown, self).__init__(message) + + self.scheme = scheme + + +class ResponseError(HTTPError): + """Used as a container for an error reason supplied in a MaxRetryError.""" + + GENERIC_ERROR = "too many error responses" + SPECIFIC_ERROR = "too many {status_code} error responses" + + +class SecurityWarning(HTTPWarning): + """Warned when performing security reducing actions""" + + pass + + +class SubjectAltNameWarning(SecurityWarning): + """Warned when connecting to a host with a certificate missing a SAN.""" + + pass + + +class InsecureRequestWarning(SecurityWarning): + """Warned when making an unverified HTTPS request.""" + + pass + + +class SystemTimeWarning(SecurityWarning): + """Warned when system time is suspected to be wrong""" + + pass + + +class InsecurePlatformWarning(SecurityWarning): + """Warned when certain TLS/SSL configuration is not available on a platform.""" + + pass + + +class SNIMissingWarning(HTTPWarning): + """Warned when making a HTTPS request without SNI available.""" + + pass + + +class DependencyWarning(HTTPWarning): + """ + Warned when an attempt is made to import a module with missing optional + dependencies. + """ + + pass + + +class ResponseNotChunked(ProtocolError, ValueError): + """Response needs to be chunked in order to read it as chunks.""" + + pass + + +class BodyNotHttplibCompatible(HTTPError): + """ + Body should be :class:`http.client.HTTPResponse` like + (have an fp attribute which returns raw chunks) for read_chunked(). + """ + + pass + + +class IncompleteRead(HTTPError, httplib_IncompleteRead): + """ + Response length doesn't match expected Content-Length + + Subclass of :class:`http.client.IncompleteRead` to allow int value + for ``partial`` to avoid creating large objects on streamed reads. + """ + + def __init__(self, partial, expected): + super(IncompleteRead, self).__init__(partial, expected) + + def __repr__(self): + return "IncompleteRead(%i bytes read, %i more expected)" % ( + self.partial, + self.expected, + ) + + +class InvalidChunkLength(HTTPError, httplib_IncompleteRead): + """Invalid chunk length in a chunked response.""" + + def __init__(self, response, length): + super(InvalidChunkLength, self).__init__( + response.tell(), response.length_remaining + ) + self.response = response + self.length = length + + def __repr__(self): + return "InvalidChunkLength(got length %r, %i bytes read)" % ( + self.length, + self.partial, + ) + + +class InvalidHeader(HTTPError): + """The header provided was somehow invalid.""" + + pass + + +class ProxySchemeUnknown(AssertionError, URLSchemeUnknown): + """ProxyManager does not support the supplied scheme""" + + # TODO(t-8ch): Stop inheriting from AssertionError in v2.0. + + def __init__(self, scheme): + # 'localhost' is here because our URL parser parses + # localhost:8080 -> scheme=localhost, remove if we fix this. + if scheme == "localhost": + scheme = None + if scheme is None: + message = "Proxy URL had no scheme, should start with http:// or https://" + else: + message = ( + "Proxy URL had unsupported scheme %s, should use http:// or https://" + % scheme + ) + super(ProxySchemeUnknown, self).__init__(message) + + +class ProxySchemeUnsupported(ValueError): + """Fetching HTTPS resources through HTTPS proxies is unsupported""" + + pass + + +class HeaderParsingError(HTTPError): + """Raised by assert_header_parsing, but we convert it to a log.warning statement.""" + + def __init__(self, defects, unparsed_data): + message = "%s, unparsed data: %r" % (defects or "Unknown", unparsed_data) + super(HeaderParsingError, self).__init__(message) + + +class UnrewindableBodyError(HTTPError): + """urllib3 encountered an error when trying to rewind a body""" + + pass diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/fields.py b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/fields.py new file mode 100644 index 0000000000000000000000000000000000000000..9d630f491d9a39644ae65564dac88eb51f0bbe78 --- /dev/null +++ b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/fields.py @@ -0,0 +1,274 @@ +from __future__ import absolute_import + +import email.utils +import mimetypes +import re + +from .packages import six + + +def guess_content_type(filename, default="application/octet-stream"): + """ + Guess the "Content-Type" of a file. + + :param filename: + The filename to guess the "Content-Type" of using :mod:`mimetypes`. + :param default: + If no "Content-Type" can be guessed, default to `default`. + """ + if filename: + return mimetypes.guess_type(filename)[0] or default + return default + + +def format_header_param_rfc2231(name, value): + """ + Helper function to format and quote a single header parameter using the + strategy defined in RFC 2231. + + Particularly useful for header parameters which might contain + non-ASCII values, like file names. This follows + `RFC 2388 Section 4.4 `_. + + :param name: + The name of the parameter, a string expected to be ASCII only. + :param value: + The value of the parameter, provided as ``bytes`` or `str``. + :ret: + An RFC-2231-formatted unicode string. + """ + if isinstance(value, six.binary_type): + value = value.decode("utf-8") + + if not any(ch in value for ch in '"\\\r\n'): + result = u'%s="%s"' % (name, value) + try: + result.encode("ascii") + except (UnicodeEncodeError, UnicodeDecodeError): + pass + else: + return result + + if six.PY2: # Python 2: + value = value.encode("utf-8") + + # encode_rfc2231 accepts an encoded string and returns an ascii-encoded + # string in Python 2 but accepts and returns unicode strings in Python 3 + value = email.utils.encode_rfc2231(value, "utf-8") + value = "%s*=%s" % (name, value) + + if six.PY2: # Python 2: + value = value.decode("utf-8") + + return value + + +_HTML5_REPLACEMENTS = { + u"\u0022": u"%22", + # Replace "\" with "\\". + u"\u005C": u"\u005C\u005C", +} + +# All control characters from 0x00 to 0x1F *except* 0x1B. +_HTML5_REPLACEMENTS.update( + { + six.unichr(cc): u"%{:02X}".format(cc) + for cc in range(0x00, 0x1F + 1) + if cc not in (0x1B,) + } +) + + +def _replace_multiple(value, needles_and_replacements): + def replacer(match): + return needles_and_replacements[match.group(0)] + + pattern = re.compile( + r"|".join([re.escape(needle) for needle in needles_and_replacements.keys()]) + ) + + result = pattern.sub(replacer, value) + + return result + + +def format_header_param_html5(name, value): + """ + Helper function to format and quote a single header parameter using the + HTML5 strategy. + + Particularly useful for header parameters which might contain + non-ASCII values, like file names. This follows the `HTML5 Working Draft + Section 4.10.22.7`_ and matches the behavior of curl and modern browsers. + + .. _HTML5 Working Draft Section 4.10.22.7: + https://w3c.github.io/html/sec-forms.html#multipart-form-data + + :param name: + The name of the parameter, a string expected to be ASCII only. + :param value: + The value of the parameter, provided as ``bytes`` or `str``. + :ret: + A unicode string, stripped of troublesome characters. + """ + if isinstance(value, six.binary_type): + value = value.decode("utf-8") + + value = _replace_multiple(value, _HTML5_REPLACEMENTS) + + return u'%s="%s"' % (name, value) + + +# For backwards-compatibility. +format_header_param = format_header_param_html5 + + +class RequestField(object): + """ + A data container for request body parameters. + + :param name: + The name of this request field. Must be unicode. + :param data: + The data/value body. + :param filename: + An optional filename of the request field. Must be unicode. + :param headers: + An optional dict-like object of headers to initially use for the field. + :param header_formatter: + An optional callable that is used to encode and format the headers. By + default, this is :func:`format_header_param_html5`. + """ + + def __init__( + self, + name, + data, + filename=None, + headers=None, + header_formatter=format_header_param_html5, + ): + self._name = name + self._filename = filename + self.data = data + self.headers = {} + if headers: + self.headers = dict(headers) + self.header_formatter = header_formatter + + @classmethod + def from_tuples(cls, fieldname, value, header_formatter=format_header_param_html5): + """ + A :class:`~urllib3.fields.RequestField` factory from old-style tuple parameters. + + Supports constructing :class:`~urllib3.fields.RequestField` from + parameter of key/value strings AND key/filetuple. A filetuple is a + (filename, data, MIME type) tuple where the MIME type is optional. + For example:: + + 'foo': 'bar', + 'fakefile': ('foofile.txt', 'contents of foofile'), + 'realfile': ('barfile.txt', open('realfile').read()), + 'typedfile': ('bazfile.bin', open('bazfile').read(), 'image/jpeg'), + 'nonamefile': 'contents of nonamefile field', + + Field names and filenames must be unicode. + """ + if isinstance(value, tuple): + if len(value) == 3: + filename, data, content_type = value + else: + filename, data = value + content_type = guess_content_type(filename) + else: + filename = None + content_type = None + data = value + + request_param = cls( + fieldname, data, filename=filename, header_formatter=header_formatter + ) + request_param.make_multipart(content_type=content_type) + + return request_param + + def _render_part(self, name, value): + """ + Overridable helper function to format a single header parameter. By + default, this calls ``self.header_formatter``. + + :param name: + The name of the parameter, a string expected to be ASCII only. + :param value: + The value of the parameter, provided as a unicode string. + """ + + return self.header_formatter(name, value) + + def _render_parts(self, header_parts): + """ + Helper function to format and quote a single header. + + Useful for single headers that are composed of multiple items. E.g., + 'Content-Disposition' fields. + + :param header_parts: + A sequence of (k, v) tuples or a :class:`dict` of (k, v) to format + as `k1="v1"; k2="v2"; ...`. + """ + parts = [] + iterable = header_parts + if isinstance(header_parts, dict): + iterable = header_parts.items() + + for name, value in iterable: + if value is not None: + parts.append(self._render_part(name, value)) + + return u"; ".join(parts) + + def render_headers(self): + """ + Renders the headers for this request field. + """ + lines = [] + + sort_keys = ["Content-Disposition", "Content-Type", "Content-Location"] + for sort_key in sort_keys: + if self.headers.get(sort_key, False): + lines.append(u"%s: %s" % (sort_key, self.headers[sort_key])) + + for header_name, header_value in self.headers.items(): + if header_name not in sort_keys: + if header_value: + lines.append(u"%s: %s" % (header_name, header_value)) + + lines.append(u"\r\n") + return u"\r\n".join(lines) + + def make_multipart( + self, content_disposition=None, content_type=None, content_location=None + ): + """ + Makes this request field into a multipart request field. + + This method overrides "Content-Disposition", "Content-Type" and + "Content-Location" headers to the request parameter. + + :param content_type: + The 'Content-Type' of the request body. + :param content_location: + The 'Content-Location' of the request body. + + """ + self.headers["Content-Disposition"] = content_disposition or u"form-data" + self.headers["Content-Disposition"] += u"; ".join( + [ + u"", + self._render_parts( + ((u"name", self._name), (u"filename", self._filename)) + ), + ] + ) + self.headers["Content-Type"] = content_type + self.headers["Content-Location"] = content_location diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/filepost.py b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/filepost.py new file mode 100644 index 0000000000000000000000000000000000000000..36c9252c647e67bc7353c523152568b993c1331f --- /dev/null +++ b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/filepost.py @@ -0,0 +1,98 @@ +from __future__ import absolute_import + +import binascii +import codecs +import os +from io import BytesIO + +from .fields import RequestField +from .packages import six +from .packages.six import b + +writer = codecs.lookup("utf-8")[3] + + +def choose_boundary(): + """ + Our embarrassingly-simple replacement for mimetools.choose_boundary. + """ + boundary = binascii.hexlify(os.urandom(16)) + if not six.PY2: + boundary = boundary.decode("ascii") + return boundary + + +def iter_field_objects(fields): + """ + Iterate over fields. + + Supports list of (k, v) tuples and dicts, and lists of + :class:`~urllib3.fields.RequestField`. + + """ + if isinstance(fields, dict): + i = six.iteritems(fields) + else: + i = iter(fields) + + for field in i: + if isinstance(field, RequestField): + yield field + else: + yield RequestField.from_tuples(*field) + + +def iter_fields(fields): + """ + .. deprecated:: 1.6 + + Iterate over fields. + + The addition of :class:`~urllib3.fields.RequestField` makes this function + obsolete. Instead, use :func:`iter_field_objects`, which returns + :class:`~urllib3.fields.RequestField` objects. + + Supports list of (k, v) tuples and dicts. + """ + if isinstance(fields, dict): + return ((k, v) for k, v in six.iteritems(fields)) + + return ((k, v) for k, v in fields) + + +def encode_multipart_formdata(fields, boundary=None): + """ + Encode a dictionary of ``fields`` using the multipart/form-data MIME format. + + :param fields: + Dictionary of fields or list of (key, :class:`~urllib3.fields.RequestField`). + + :param boundary: + If not specified, then a random boundary will be generated using + :func:`urllib3.filepost.choose_boundary`. + """ + body = BytesIO() + if boundary is None: + boundary = choose_boundary() + + for field in iter_field_objects(fields): + body.write(b("--%s\r\n" % (boundary))) + + writer(body).write(field.render_headers()) + data = field.data + + if isinstance(data, int): + data = str(data) # Backwards compatibility + + if isinstance(data, six.text_type): + writer(body).write(data) + else: + body.write(data) + + body.write(b"\r\n") + + body.write(b("--%s--\r\n" % (boundary))) + + content_type = str("multipart/form-data; boundary=%s" % boundary) + + return body.getvalue(), content_type diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/packages/__init__.py b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/packages/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/packages/__pycache__/__init__.cpython-310.pyc b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/packages/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d904f10ccd65996c026f4509b9fd32510f339fc2 Binary files /dev/null and b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/packages/__pycache__/__init__.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/packages/__pycache__/six.cpython-310.pyc b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/packages/__pycache__/six.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..cf68499fc1d64e31528d766a67f4bbadcdf392fd Binary files /dev/null and b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/packages/__pycache__/six.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/packages/backports/__init__.py b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/packages/backports/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/packages/backports/__pycache__/__init__.cpython-310.pyc b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/packages/backports/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..da7b54519ecd120ab9eb567849c67332e1569d66 Binary files /dev/null and b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/packages/backports/__pycache__/__init__.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/packages/backports/__pycache__/makefile.cpython-310.pyc b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/packages/backports/__pycache__/makefile.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8e83a60c0da92504ede0f90c912000884c6ba75e Binary files /dev/null and b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/packages/backports/__pycache__/makefile.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/packages/backports/__pycache__/weakref_finalize.cpython-310.pyc b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/packages/backports/__pycache__/weakref_finalize.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..19f5c8740fd23550c3a35e2d8eb2ca300cf27fa7 Binary files /dev/null and b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/packages/backports/__pycache__/weakref_finalize.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/packages/backports/makefile.py b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/packages/backports/makefile.py new file mode 100644 index 0000000000000000000000000000000000000000..b8fb2154b6d0618b62281578e5e947bca487cee4 --- /dev/null +++ b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/packages/backports/makefile.py @@ -0,0 +1,51 @@ +# -*- coding: utf-8 -*- +""" +backports.makefile +~~~~~~~~~~~~~~~~~~ + +Backports the Python 3 ``socket.makefile`` method for use with anything that +wants to create a "fake" socket object. +""" +import io +from socket import SocketIO + + +def backport_makefile( + self, mode="r", buffering=None, encoding=None, errors=None, newline=None +): + """ + Backport of ``socket.makefile`` from Python 3.5. + """ + if not set(mode) <= {"r", "w", "b"}: + raise ValueError("invalid mode %r (only r, w, b allowed)" % (mode,)) + writing = "w" in mode + reading = "r" in mode or not writing + assert reading or writing + binary = "b" in mode + rawmode = "" + if reading: + rawmode += "r" + if writing: + rawmode += "w" + raw = SocketIO(self, rawmode) + self._makefile_refs += 1 + if buffering is None: + buffering = -1 + if buffering < 0: + buffering = io.DEFAULT_BUFFER_SIZE + if buffering == 0: + if not binary: + raise ValueError("unbuffered streams must be binary") + return raw + if reading and writing: + buffer = io.BufferedRWPair(raw, raw, buffering) + elif reading: + buffer = io.BufferedReader(raw, buffering) + else: + assert writing + buffer = io.BufferedWriter(raw, buffering) + if binary: + return buffer + text = io.TextIOWrapper(buffer, encoding, errors, newline) + text.mode = mode + return text diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/packages/backports/weakref_finalize.py b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/packages/backports/weakref_finalize.py new file mode 100644 index 0000000000000000000000000000000000000000..a2f2966e5496601787d138e9004fbb3d2ce9b64c --- /dev/null +++ b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/packages/backports/weakref_finalize.py @@ -0,0 +1,155 @@ +# -*- coding: utf-8 -*- +""" +backports.weakref_finalize +~~~~~~~~~~~~~~~~~~ + +Backports the Python 3 ``weakref.finalize`` method. +""" +from __future__ import absolute_import + +import itertools +import sys +from weakref import ref + +__all__ = ["weakref_finalize"] + + +class weakref_finalize(object): + """Class for finalization of weakrefable objects + finalize(obj, func, *args, **kwargs) returns a callable finalizer + object which will be called when obj is garbage collected. The + first time the finalizer is called it evaluates func(*arg, **kwargs) + and returns the result. After this the finalizer is dead, and + calling it just returns None. + When the program exits any remaining finalizers for which the + atexit attribute is true will be run in reverse order of creation. + By default atexit is true. + """ + + # Finalizer objects don't have any state of their own. They are + # just used as keys to lookup _Info objects in the registry. This + # ensures that they cannot be part of a ref-cycle. + + __slots__ = () + _registry = {} + _shutdown = False + _index_iter = itertools.count() + _dirty = False + _registered_with_atexit = False + + class _Info(object): + __slots__ = ("weakref", "func", "args", "kwargs", "atexit", "index") + + def __init__(self, obj, func, *args, **kwargs): + if not self._registered_with_atexit: + # We may register the exit function more than once because + # of a thread race, but that is harmless + import atexit + + atexit.register(self._exitfunc) + weakref_finalize._registered_with_atexit = True + info = self._Info() + info.weakref = ref(obj, self) + info.func = func + info.args = args + info.kwargs = kwargs or None + info.atexit = True + info.index = next(self._index_iter) + self._registry[self] = info + weakref_finalize._dirty = True + + def __call__(self, _=None): + """If alive then mark as dead and return func(*args, **kwargs); + otherwise return None""" + info = self._registry.pop(self, None) + if info and not self._shutdown: + return info.func(*info.args, **(info.kwargs or {})) + + def detach(self): + """If alive then mark as dead and return (obj, func, args, kwargs); + otherwise return None""" + info = self._registry.get(self) + obj = info and info.weakref() + if obj is not None and self._registry.pop(self, None): + return (obj, info.func, info.args, info.kwargs or {}) + + def peek(self): + """If alive then return (obj, func, args, kwargs); + otherwise return None""" + info = self._registry.get(self) + obj = info and info.weakref() + if obj is not None: + return (obj, info.func, info.args, info.kwargs or {}) + + @property + def alive(self): + """Whether finalizer is alive""" + return self in self._registry + + @property + def atexit(self): + """Whether finalizer should be called at exit""" + info = self._registry.get(self) + return bool(info) and info.atexit + + @atexit.setter + def atexit(self, value): + info = self._registry.get(self) + if info: + info.atexit = bool(value) + + def __repr__(self): + info = self._registry.get(self) + obj = info and info.weakref() + if obj is None: + return "<%s object at %#x; dead>" % (type(self).__name__, id(self)) + else: + return "<%s object at %#x; for %r at %#x>" % ( + type(self).__name__, + id(self), + type(obj).__name__, + id(obj), + ) + + @classmethod + def _select_for_exit(cls): + # Return live finalizers marked for exit, oldest first + L = [(f, i) for (f, i) in cls._registry.items() if i.atexit] + L.sort(key=lambda item: item[1].index) + return [f for (f, i) in L] + + @classmethod + def _exitfunc(cls): + # At shutdown invoke finalizers for which atexit is true. + # This is called once all other non-daemonic threads have been + # joined. + reenable_gc = False + try: + if cls._registry: + import gc + + if gc.isenabled(): + reenable_gc = True + gc.disable() + pending = None + while True: + if pending is None or weakref_finalize._dirty: + pending = cls._select_for_exit() + weakref_finalize._dirty = False + if not pending: + break + f = pending.pop() + try: + # gc is disabled, so (assuming no daemonic + # threads) the following is the only line in + # this function which might trigger creation + # of a new finalizer + f() + except Exception: + sys.excepthook(*sys.exc_info()) + assert f not in cls._registry + finally: + # prevent any more finalizers from executing during shutdown + weakref_finalize._shutdown = True + if reenable_gc: + gc.enable() diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/packages/six.py b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/packages/six.py new file mode 100644 index 0000000000000000000000000000000000000000..f099a3dcd28d2fec21457c9b6c01ded4e3e9ddee --- /dev/null +++ b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/packages/six.py @@ -0,0 +1,1076 @@ +# Copyright (c) 2010-2020 Benjamin Peterson +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +"""Utilities for writing code that runs on Python 2 and 3""" + +from __future__ import absolute_import + +import functools +import itertools +import operator +import sys +import types + +__author__ = "Benjamin Peterson " +__version__ = "1.16.0" + + +# Useful for very coarse version differentiation. +PY2 = sys.version_info[0] == 2 +PY3 = sys.version_info[0] == 3 +PY34 = sys.version_info[0:2] >= (3, 4) + +if PY3: + string_types = (str,) + integer_types = (int,) + class_types = (type,) + text_type = str + binary_type = bytes + + MAXSIZE = sys.maxsize +else: + string_types = (basestring,) + integer_types = (int, long) + class_types = (type, types.ClassType) + text_type = unicode + binary_type = str + + if sys.platform.startswith("java"): + # Jython always uses 32 bits. + MAXSIZE = int((1 << 31) - 1) + else: + # It's possible to have sizeof(long) != sizeof(Py_ssize_t). + class X(object): + def __len__(self): + return 1 << 31 + + try: + len(X()) + except OverflowError: + # 32-bit + MAXSIZE = int((1 << 31) - 1) + else: + # 64-bit + MAXSIZE = int((1 << 63) - 1) + del X + +if PY34: + from importlib.util import spec_from_loader +else: + spec_from_loader = None + + +def _add_doc(func, doc): + """Add documentation to a function.""" + func.__doc__ = doc + + +def _import_module(name): + """Import module, returning the module after the last dot.""" + __import__(name) + return sys.modules[name] + + +class _LazyDescr(object): + def __init__(self, name): + self.name = name + + def __get__(self, obj, tp): + result = self._resolve() + setattr(obj, self.name, result) # Invokes __set__. + try: + # This is a bit ugly, but it avoids running this again by + # removing this descriptor. + delattr(obj.__class__, self.name) + except AttributeError: + pass + return result + + +class MovedModule(_LazyDescr): + def __init__(self, name, old, new=None): + super(MovedModule, self).__init__(name) + if PY3: + if new is None: + new = name + self.mod = new + else: + self.mod = old + + def _resolve(self): + return _import_module(self.mod) + + def __getattr__(self, attr): + _module = self._resolve() + value = getattr(_module, attr) + setattr(self, attr, value) + return value + + +class _LazyModule(types.ModuleType): + def __init__(self, name): + super(_LazyModule, self).__init__(name) + self.__doc__ = self.__class__.__doc__ + + def __dir__(self): + attrs = ["__doc__", "__name__"] + attrs += [attr.name for attr in self._moved_attributes] + return attrs + + # Subclasses should override this + _moved_attributes = [] + + +class MovedAttribute(_LazyDescr): + def __init__(self, name, old_mod, new_mod, old_attr=None, new_attr=None): + super(MovedAttribute, self).__init__(name) + if PY3: + if new_mod is None: + new_mod = name + self.mod = new_mod + if new_attr is None: + if old_attr is None: + new_attr = name + else: + new_attr = old_attr + self.attr = new_attr + else: + self.mod = old_mod + if old_attr is None: + old_attr = name + self.attr = old_attr + + def _resolve(self): + module = _import_module(self.mod) + return getattr(module, self.attr) + + +class _SixMetaPathImporter(object): + + """ + A meta path importer to import six.moves and its submodules. + + This class implements a PEP302 finder and loader. It should be compatible + with Python 2.5 and all existing versions of Python3 + """ + + def __init__(self, six_module_name): + self.name = six_module_name + self.known_modules = {} + + def _add_module(self, mod, *fullnames): + for fullname in fullnames: + self.known_modules[self.name + "." + fullname] = mod + + def _get_module(self, fullname): + return self.known_modules[self.name + "." + fullname] + + def find_module(self, fullname, path=None): + if fullname in self.known_modules: + return self + return None + + def find_spec(self, fullname, path, target=None): + if fullname in self.known_modules: + return spec_from_loader(fullname, self) + return None + + def __get_module(self, fullname): + try: + return self.known_modules[fullname] + except KeyError: + raise ImportError("This loader does not know module " + fullname) + + def load_module(self, fullname): + try: + # in case of a reload + return sys.modules[fullname] + except KeyError: + pass + mod = self.__get_module(fullname) + if isinstance(mod, MovedModule): + mod = mod._resolve() + else: + mod.__loader__ = self + sys.modules[fullname] = mod + return mod + + def is_package(self, fullname): + """ + Return true, if the named module is a package. + + We need this method to get correct spec objects with + Python 3.4 (see PEP451) + """ + return hasattr(self.__get_module(fullname), "__path__") + + def get_code(self, fullname): + """Return None + + Required, if is_package is implemented""" + self.__get_module(fullname) # eventually raises ImportError + return None + + get_source = get_code # same as get_code + + def create_module(self, spec): + return self.load_module(spec.name) + + def exec_module(self, module): + pass + + +_importer = _SixMetaPathImporter(__name__) + + +class _MovedItems(_LazyModule): + + """Lazy loading of moved objects""" + + __path__ = [] # mark as package + + +_moved_attributes = [ + MovedAttribute("cStringIO", "cStringIO", "io", "StringIO"), + MovedAttribute("filter", "itertools", "builtins", "ifilter", "filter"), + MovedAttribute( + "filterfalse", "itertools", "itertools", "ifilterfalse", "filterfalse" + ), + MovedAttribute("input", "__builtin__", "builtins", "raw_input", "input"), + MovedAttribute("intern", "__builtin__", "sys"), + MovedAttribute("map", "itertools", "builtins", "imap", "map"), + MovedAttribute("getcwd", "os", "os", "getcwdu", "getcwd"), + MovedAttribute("getcwdb", "os", "os", "getcwd", "getcwdb"), + MovedAttribute("getoutput", "commands", "subprocess"), + MovedAttribute("range", "__builtin__", "builtins", "xrange", "range"), + MovedAttribute( + "reload_module", "__builtin__", "importlib" if PY34 else "imp", "reload" + ), + MovedAttribute("reduce", "__builtin__", "functools"), + MovedAttribute("shlex_quote", "pipes", "shlex", "quote"), + MovedAttribute("StringIO", "StringIO", "io"), + MovedAttribute("UserDict", "UserDict", "collections"), + MovedAttribute("UserList", "UserList", "collections"), + MovedAttribute("UserString", "UserString", "collections"), + MovedAttribute("xrange", "__builtin__", "builtins", "xrange", "range"), + MovedAttribute("zip", "itertools", "builtins", "izip", "zip"), + MovedAttribute( + "zip_longest", "itertools", "itertools", "izip_longest", "zip_longest" + ), + MovedModule("builtins", "__builtin__"), + MovedModule("configparser", "ConfigParser"), + MovedModule( + "collections_abc", + "collections", + "collections.abc" if sys.version_info >= (3, 3) else "collections", + ), + MovedModule("copyreg", "copy_reg"), + MovedModule("dbm_gnu", "gdbm", "dbm.gnu"), + MovedModule("dbm_ndbm", "dbm", "dbm.ndbm"), + MovedModule( + "_dummy_thread", + "dummy_thread", + "_dummy_thread" if sys.version_info < (3, 9) else "_thread", + ), + MovedModule("http_cookiejar", "cookielib", "http.cookiejar"), + MovedModule("http_cookies", "Cookie", "http.cookies"), + MovedModule("html_entities", "htmlentitydefs", "html.entities"), + MovedModule("html_parser", "HTMLParser", "html.parser"), + MovedModule("http_client", "httplib", "http.client"), + MovedModule("email_mime_base", "email.MIMEBase", "email.mime.base"), + MovedModule("email_mime_image", "email.MIMEImage", "email.mime.image"), + MovedModule("email_mime_multipart", "email.MIMEMultipart", "email.mime.multipart"), + MovedModule( + "email_mime_nonmultipart", "email.MIMENonMultipart", "email.mime.nonmultipart" + ), + MovedModule("email_mime_text", "email.MIMEText", "email.mime.text"), + MovedModule("BaseHTTPServer", "BaseHTTPServer", "http.server"), + MovedModule("CGIHTTPServer", "CGIHTTPServer", "http.server"), + MovedModule("SimpleHTTPServer", "SimpleHTTPServer", "http.server"), + MovedModule("cPickle", "cPickle", "pickle"), + MovedModule("queue", "Queue"), + MovedModule("reprlib", "repr"), + MovedModule("socketserver", "SocketServer"), + MovedModule("_thread", "thread", "_thread"), + MovedModule("tkinter", "Tkinter"), + MovedModule("tkinter_dialog", "Dialog", "tkinter.dialog"), + MovedModule("tkinter_filedialog", "FileDialog", "tkinter.filedialog"), + MovedModule("tkinter_scrolledtext", "ScrolledText", "tkinter.scrolledtext"), + MovedModule("tkinter_simpledialog", "SimpleDialog", "tkinter.simpledialog"), + MovedModule("tkinter_tix", "Tix", "tkinter.tix"), + MovedModule("tkinter_ttk", "ttk", "tkinter.ttk"), + MovedModule("tkinter_constants", "Tkconstants", "tkinter.constants"), + MovedModule("tkinter_dnd", "Tkdnd", "tkinter.dnd"), + MovedModule("tkinter_colorchooser", "tkColorChooser", "tkinter.colorchooser"), + MovedModule("tkinter_commondialog", "tkCommonDialog", "tkinter.commondialog"), + MovedModule("tkinter_tkfiledialog", "tkFileDialog", "tkinter.filedialog"), + MovedModule("tkinter_font", "tkFont", "tkinter.font"), + MovedModule("tkinter_messagebox", "tkMessageBox", "tkinter.messagebox"), + MovedModule("tkinter_tksimpledialog", "tkSimpleDialog", "tkinter.simpledialog"), + MovedModule("urllib_parse", __name__ + ".moves.urllib_parse", "urllib.parse"), + MovedModule("urllib_error", __name__ + ".moves.urllib_error", "urllib.error"), + MovedModule("urllib", __name__ + ".moves.urllib", __name__ + ".moves.urllib"), + MovedModule("urllib_robotparser", "robotparser", "urllib.robotparser"), + MovedModule("xmlrpc_client", "xmlrpclib", "xmlrpc.client"), + MovedModule("xmlrpc_server", "SimpleXMLRPCServer", "xmlrpc.server"), +] +# Add windows specific modules. +if sys.platform == "win32": + _moved_attributes += [ + MovedModule("winreg", "_winreg"), + ] + +for attr in _moved_attributes: + setattr(_MovedItems, attr.name, attr) + if isinstance(attr, MovedModule): + _importer._add_module(attr, "moves." + attr.name) +del attr + +_MovedItems._moved_attributes = _moved_attributes + +moves = _MovedItems(__name__ + ".moves") +_importer._add_module(moves, "moves") + + +class Module_six_moves_urllib_parse(_LazyModule): + + """Lazy loading of moved objects in six.moves.urllib_parse""" + + +_urllib_parse_moved_attributes = [ + MovedAttribute("ParseResult", "urlparse", "urllib.parse"), + MovedAttribute("SplitResult", "urlparse", "urllib.parse"), + MovedAttribute("parse_qs", "urlparse", "urllib.parse"), + MovedAttribute("parse_qsl", "urlparse", "urllib.parse"), + MovedAttribute("urldefrag", "urlparse", "urllib.parse"), + MovedAttribute("urljoin", "urlparse", "urllib.parse"), + MovedAttribute("urlparse", "urlparse", "urllib.parse"), + MovedAttribute("urlsplit", "urlparse", "urllib.parse"), + MovedAttribute("urlunparse", "urlparse", "urllib.parse"), + MovedAttribute("urlunsplit", "urlparse", "urllib.parse"), + MovedAttribute("quote", "urllib", "urllib.parse"), + MovedAttribute("quote_plus", "urllib", "urllib.parse"), + MovedAttribute("unquote", "urllib", "urllib.parse"), + MovedAttribute("unquote_plus", "urllib", "urllib.parse"), + MovedAttribute( + "unquote_to_bytes", "urllib", "urllib.parse", "unquote", "unquote_to_bytes" + ), + MovedAttribute("urlencode", "urllib", "urllib.parse"), + MovedAttribute("splitquery", "urllib", "urllib.parse"), + MovedAttribute("splittag", "urllib", "urllib.parse"), + MovedAttribute("splituser", "urllib", "urllib.parse"), + MovedAttribute("splitvalue", "urllib", "urllib.parse"), + MovedAttribute("uses_fragment", "urlparse", "urllib.parse"), + MovedAttribute("uses_netloc", "urlparse", "urllib.parse"), + MovedAttribute("uses_params", "urlparse", "urllib.parse"), + MovedAttribute("uses_query", "urlparse", "urllib.parse"), + MovedAttribute("uses_relative", "urlparse", "urllib.parse"), +] +for attr in _urllib_parse_moved_attributes: + setattr(Module_six_moves_urllib_parse, attr.name, attr) +del attr + +Module_six_moves_urllib_parse._moved_attributes = _urllib_parse_moved_attributes + +_importer._add_module( + Module_six_moves_urllib_parse(__name__ + ".moves.urllib_parse"), + "moves.urllib_parse", + "moves.urllib.parse", +) + + +class Module_six_moves_urllib_error(_LazyModule): + + """Lazy loading of moved objects in six.moves.urllib_error""" + + +_urllib_error_moved_attributes = [ + MovedAttribute("URLError", "urllib2", "urllib.error"), + MovedAttribute("HTTPError", "urllib2", "urllib.error"), + MovedAttribute("ContentTooShortError", "urllib", "urllib.error"), +] +for attr in _urllib_error_moved_attributes: + setattr(Module_six_moves_urllib_error, attr.name, attr) +del attr + +Module_six_moves_urllib_error._moved_attributes = _urllib_error_moved_attributes + +_importer._add_module( + Module_six_moves_urllib_error(__name__ + ".moves.urllib.error"), + "moves.urllib_error", + "moves.urllib.error", +) + + +class Module_six_moves_urllib_request(_LazyModule): + + """Lazy loading of moved objects in six.moves.urllib_request""" + + +_urllib_request_moved_attributes = [ + MovedAttribute("urlopen", "urllib2", "urllib.request"), + MovedAttribute("install_opener", "urllib2", "urllib.request"), + MovedAttribute("build_opener", "urllib2", "urllib.request"), + MovedAttribute("pathname2url", "urllib", "urllib.request"), + MovedAttribute("url2pathname", "urllib", "urllib.request"), + MovedAttribute("getproxies", "urllib", "urllib.request"), + MovedAttribute("Request", "urllib2", "urllib.request"), + MovedAttribute("OpenerDirector", "urllib2", "urllib.request"), + MovedAttribute("HTTPDefaultErrorHandler", "urllib2", "urllib.request"), + MovedAttribute("HTTPRedirectHandler", "urllib2", "urllib.request"), + MovedAttribute("HTTPCookieProcessor", "urllib2", "urllib.request"), + MovedAttribute("ProxyHandler", "urllib2", "urllib.request"), + MovedAttribute("BaseHandler", "urllib2", "urllib.request"), + MovedAttribute("HTTPPasswordMgr", "urllib2", "urllib.request"), + MovedAttribute("HTTPPasswordMgrWithDefaultRealm", "urllib2", "urllib.request"), + MovedAttribute("AbstractBasicAuthHandler", "urllib2", "urllib.request"), + MovedAttribute("HTTPBasicAuthHandler", "urllib2", "urllib.request"), + MovedAttribute("ProxyBasicAuthHandler", "urllib2", "urllib.request"), + MovedAttribute("AbstractDigestAuthHandler", "urllib2", "urllib.request"), + MovedAttribute("HTTPDigestAuthHandler", "urllib2", "urllib.request"), + MovedAttribute("ProxyDigestAuthHandler", "urllib2", "urllib.request"), + MovedAttribute("HTTPHandler", "urllib2", "urllib.request"), + MovedAttribute("HTTPSHandler", "urllib2", "urllib.request"), + MovedAttribute("FileHandler", "urllib2", "urllib.request"), + MovedAttribute("FTPHandler", "urllib2", "urllib.request"), + MovedAttribute("CacheFTPHandler", "urllib2", "urllib.request"), + MovedAttribute("UnknownHandler", "urllib2", "urllib.request"), + MovedAttribute("HTTPErrorProcessor", "urllib2", "urllib.request"), + MovedAttribute("urlretrieve", "urllib", "urllib.request"), + MovedAttribute("urlcleanup", "urllib", "urllib.request"), + MovedAttribute("URLopener", "urllib", "urllib.request"), + MovedAttribute("FancyURLopener", "urllib", "urllib.request"), + MovedAttribute("proxy_bypass", "urllib", "urllib.request"), + MovedAttribute("parse_http_list", "urllib2", "urllib.request"), + MovedAttribute("parse_keqv_list", "urllib2", "urllib.request"), +] +for attr in _urllib_request_moved_attributes: + setattr(Module_six_moves_urllib_request, attr.name, attr) +del attr + +Module_six_moves_urllib_request._moved_attributes = _urllib_request_moved_attributes + +_importer._add_module( + Module_six_moves_urllib_request(__name__ + ".moves.urllib.request"), + "moves.urllib_request", + "moves.urllib.request", +) + + +class Module_six_moves_urllib_response(_LazyModule): + + """Lazy loading of moved objects in six.moves.urllib_response""" + + +_urllib_response_moved_attributes = [ + MovedAttribute("addbase", "urllib", "urllib.response"), + MovedAttribute("addclosehook", "urllib", "urllib.response"), + MovedAttribute("addinfo", "urllib", "urllib.response"), + MovedAttribute("addinfourl", "urllib", "urllib.response"), +] +for attr in _urllib_response_moved_attributes: + setattr(Module_six_moves_urllib_response, attr.name, attr) +del attr + +Module_six_moves_urllib_response._moved_attributes = _urllib_response_moved_attributes + +_importer._add_module( + Module_six_moves_urllib_response(__name__ + ".moves.urllib.response"), + "moves.urllib_response", + "moves.urllib.response", +) + + +class Module_six_moves_urllib_robotparser(_LazyModule): + + """Lazy loading of moved objects in six.moves.urllib_robotparser""" + + +_urllib_robotparser_moved_attributes = [ + MovedAttribute("RobotFileParser", "robotparser", "urllib.robotparser"), +] +for attr in _urllib_robotparser_moved_attributes: + setattr(Module_six_moves_urllib_robotparser, attr.name, attr) +del attr + +Module_six_moves_urllib_robotparser._moved_attributes = ( + _urllib_robotparser_moved_attributes +) + +_importer._add_module( + Module_six_moves_urllib_robotparser(__name__ + ".moves.urllib.robotparser"), + "moves.urllib_robotparser", + "moves.urllib.robotparser", +) + + +class Module_six_moves_urllib(types.ModuleType): + + """Create a six.moves.urllib namespace that resembles the Python 3 namespace""" + + __path__ = [] # mark as package + parse = _importer._get_module("moves.urllib_parse") + error = _importer._get_module("moves.urllib_error") + request = _importer._get_module("moves.urllib_request") + response = _importer._get_module("moves.urllib_response") + robotparser = _importer._get_module("moves.urllib_robotparser") + + def __dir__(self): + return ["parse", "error", "request", "response", "robotparser"] + + +_importer._add_module( + Module_six_moves_urllib(__name__ + ".moves.urllib"), "moves.urllib" +) + + +def add_move(move): + """Add an item to six.moves.""" + setattr(_MovedItems, move.name, move) + + +def remove_move(name): + """Remove item from six.moves.""" + try: + delattr(_MovedItems, name) + except AttributeError: + try: + del moves.__dict__[name] + except KeyError: + raise AttributeError("no such move, %r" % (name,)) + + +if PY3: + _meth_func = "__func__" + _meth_self = "__self__" + + _func_closure = "__closure__" + _func_code = "__code__" + _func_defaults = "__defaults__" + _func_globals = "__globals__" +else: + _meth_func = "im_func" + _meth_self = "im_self" + + _func_closure = "func_closure" + _func_code = "func_code" + _func_defaults = "func_defaults" + _func_globals = "func_globals" + + +try: + advance_iterator = next +except NameError: + + def advance_iterator(it): + return it.next() + + +next = advance_iterator + + +try: + callable = callable +except NameError: + + def callable(obj): + return any("__call__" in klass.__dict__ for klass in type(obj).__mro__) + + +if PY3: + + def get_unbound_function(unbound): + return unbound + + create_bound_method = types.MethodType + + def create_unbound_method(func, cls): + return func + + Iterator = object +else: + + def get_unbound_function(unbound): + return unbound.im_func + + def create_bound_method(func, obj): + return types.MethodType(func, obj, obj.__class__) + + def create_unbound_method(func, cls): + return types.MethodType(func, None, cls) + + class Iterator(object): + def next(self): + return type(self).__next__(self) + + callable = callable +_add_doc( + get_unbound_function, """Get the function out of a possibly unbound function""" +) + + +get_method_function = operator.attrgetter(_meth_func) +get_method_self = operator.attrgetter(_meth_self) +get_function_closure = operator.attrgetter(_func_closure) +get_function_code = operator.attrgetter(_func_code) +get_function_defaults = operator.attrgetter(_func_defaults) +get_function_globals = operator.attrgetter(_func_globals) + + +if PY3: + + def iterkeys(d, **kw): + return iter(d.keys(**kw)) + + def itervalues(d, **kw): + return iter(d.values(**kw)) + + def iteritems(d, **kw): + return iter(d.items(**kw)) + + def iterlists(d, **kw): + return iter(d.lists(**kw)) + + viewkeys = operator.methodcaller("keys") + + viewvalues = operator.methodcaller("values") + + viewitems = operator.methodcaller("items") +else: + + def iterkeys(d, **kw): + return d.iterkeys(**kw) + + def itervalues(d, **kw): + return d.itervalues(**kw) + + def iteritems(d, **kw): + return d.iteritems(**kw) + + def iterlists(d, **kw): + return d.iterlists(**kw) + + viewkeys = operator.methodcaller("viewkeys") + + viewvalues = operator.methodcaller("viewvalues") + + viewitems = operator.methodcaller("viewitems") + +_add_doc(iterkeys, "Return an iterator over the keys of a dictionary.") +_add_doc(itervalues, "Return an iterator over the values of a dictionary.") +_add_doc(iteritems, "Return an iterator over the (key, value) pairs of a dictionary.") +_add_doc( + iterlists, "Return an iterator over the (key, [values]) pairs of a dictionary." +) + + +if PY3: + + def b(s): + return s.encode("latin-1") + + def u(s): + return s + + unichr = chr + import struct + + int2byte = struct.Struct(">B").pack + del struct + byte2int = operator.itemgetter(0) + indexbytes = operator.getitem + iterbytes = iter + import io + + StringIO = io.StringIO + BytesIO = io.BytesIO + del io + _assertCountEqual = "assertCountEqual" + if sys.version_info[1] <= 1: + _assertRaisesRegex = "assertRaisesRegexp" + _assertRegex = "assertRegexpMatches" + _assertNotRegex = "assertNotRegexpMatches" + else: + _assertRaisesRegex = "assertRaisesRegex" + _assertRegex = "assertRegex" + _assertNotRegex = "assertNotRegex" +else: + + def b(s): + return s + + # Workaround for standalone backslash + + def u(s): + return unicode(s.replace(r"\\", r"\\\\"), "unicode_escape") + + unichr = unichr + int2byte = chr + + def byte2int(bs): + return ord(bs[0]) + + def indexbytes(buf, i): + return ord(buf[i]) + + iterbytes = functools.partial(itertools.imap, ord) + import StringIO + + StringIO = BytesIO = StringIO.StringIO + _assertCountEqual = "assertItemsEqual" + _assertRaisesRegex = "assertRaisesRegexp" + _assertRegex = "assertRegexpMatches" + _assertNotRegex = "assertNotRegexpMatches" +_add_doc(b, """Byte literal""") +_add_doc(u, """Text literal""") + + +def assertCountEqual(self, *args, **kwargs): + return getattr(self, _assertCountEqual)(*args, **kwargs) + + +def assertRaisesRegex(self, *args, **kwargs): + return getattr(self, _assertRaisesRegex)(*args, **kwargs) + + +def assertRegex(self, *args, **kwargs): + return getattr(self, _assertRegex)(*args, **kwargs) + + +def assertNotRegex(self, *args, **kwargs): + return getattr(self, _assertNotRegex)(*args, **kwargs) + + +if PY3: + exec_ = getattr(moves.builtins, "exec") + + def reraise(tp, value, tb=None): + try: + if value is None: + value = tp() + if value.__traceback__ is not tb: + raise value.with_traceback(tb) + raise value + finally: + value = None + tb = None + +else: + + def exec_(_code_, _globs_=None, _locs_=None): + """Execute code in a namespace.""" + if _globs_ is None: + frame = sys._getframe(1) + _globs_ = frame.f_globals + if _locs_ is None: + _locs_ = frame.f_locals + del frame + elif _locs_ is None: + _locs_ = _globs_ + exec ("""exec _code_ in _globs_, _locs_""") + + exec_( + """def reraise(tp, value, tb=None): + try: + raise tp, value, tb + finally: + tb = None +""" + ) + + +if sys.version_info[:2] > (3,): + exec_( + """def raise_from(value, from_value): + try: + raise value from from_value + finally: + value = None +""" + ) +else: + + def raise_from(value, from_value): + raise value + + +print_ = getattr(moves.builtins, "print", None) +if print_ is None: + + def print_(*args, **kwargs): + """The new-style print function for Python 2.4 and 2.5.""" + fp = kwargs.pop("file", sys.stdout) + if fp is None: + return + + def write(data): + if not isinstance(data, basestring): + data = str(data) + # If the file has an encoding, encode unicode with it. + if ( + isinstance(fp, file) + and isinstance(data, unicode) + and fp.encoding is not None + ): + errors = getattr(fp, "errors", None) + if errors is None: + errors = "strict" + data = data.encode(fp.encoding, errors) + fp.write(data) + + want_unicode = False + sep = kwargs.pop("sep", None) + if sep is not None: + if isinstance(sep, unicode): + want_unicode = True + elif not isinstance(sep, str): + raise TypeError("sep must be None or a string") + end = kwargs.pop("end", None) + if end is not None: + if isinstance(end, unicode): + want_unicode = True + elif not isinstance(end, str): + raise TypeError("end must be None or a string") + if kwargs: + raise TypeError("invalid keyword arguments to print()") + if not want_unicode: + for arg in args: + if isinstance(arg, unicode): + want_unicode = True + break + if want_unicode: + newline = unicode("\n") + space = unicode(" ") + else: + newline = "\n" + space = " " + if sep is None: + sep = space + if end is None: + end = newline + for i, arg in enumerate(args): + if i: + write(sep) + write(arg) + write(end) + + +if sys.version_info[:2] < (3, 3): + _print = print_ + + def print_(*args, **kwargs): + fp = kwargs.get("file", sys.stdout) + flush = kwargs.pop("flush", False) + _print(*args, **kwargs) + if flush and fp is not None: + fp.flush() + + +_add_doc(reraise, """Reraise an exception.""") + +if sys.version_info[0:2] < (3, 4): + # This does exactly the same what the :func:`py3:functools.update_wrapper` + # function does on Python versions after 3.2. It sets the ``__wrapped__`` + # attribute on ``wrapper`` object and it doesn't raise an error if any of + # the attributes mentioned in ``assigned`` and ``updated`` are missing on + # ``wrapped`` object. + def _update_wrapper( + wrapper, + wrapped, + assigned=functools.WRAPPER_ASSIGNMENTS, + updated=functools.WRAPPER_UPDATES, + ): + for attr in assigned: + try: + value = getattr(wrapped, attr) + except AttributeError: + continue + else: + setattr(wrapper, attr, value) + for attr in updated: + getattr(wrapper, attr).update(getattr(wrapped, attr, {})) + wrapper.__wrapped__ = wrapped + return wrapper + + _update_wrapper.__doc__ = functools.update_wrapper.__doc__ + + def wraps( + wrapped, + assigned=functools.WRAPPER_ASSIGNMENTS, + updated=functools.WRAPPER_UPDATES, + ): + return functools.partial( + _update_wrapper, wrapped=wrapped, assigned=assigned, updated=updated + ) + + wraps.__doc__ = functools.wraps.__doc__ + +else: + wraps = functools.wraps + + +def with_metaclass(meta, *bases): + """Create a base class with a metaclass.""" + # This requires a bit of explanation: the basic idea is to make a dummy + # metaclass for one level of class instantiation that replaces itself with + # the actual metaclass. + class metaclass(type): + def __new__(cls, name, this_bases, d): + if sys.version_info[:2] >= (3, 7): + # This version introduced PEP 560 that requires a bit + # of extra care (we mimic what is done by __build_class__). + resolved_bases = types.resolve_bases(bases) + if resolved_bases is not bases: + d["__orig_bases__"] = bases + else: + resolved_bases = bases + return meta(name, resolved_bases, d) + + @classmethod + def __prepare__(cls, name, this_bases): + return meta.__prepare__(name, bases) + + return type.__new__(metaclass, "temporary_class", (), {}) + + +def add_metaclass(metaclass): + """Class decorator for creating a class with a metaclass.""" + + def wrapper(cls): + orig_vars = cls.__dict__.copy() + slots = orig_vars.get("__slots__") + if slots is not None: + if isinstance(slots, str): + slots = [slots] + for slots_var in slots: + orig_vars.pop(slots_var) + orig_vars.pop("__dict__", None) + orig_vars.pop("__weakref__", None) + if hasattr(cls, "__qualname__"): + orig_vars["__qualname__"] = cls.__qualname__ + return metaclass(cls.__name__, cls.__bases__, orig_vars) + + return wrapper + + +def ensure_binary(s, encoding="utf-8", errors="strict"): + """Coerce **s** to six.binary_type. + + For Python 2: + - `unicode` -> encoded to `str` + - `str` -> `str` + + For Python 3: + - `str` -> encoded to `bytes` + - `bytes` -> `bytes` + """ + if isinstance(s, binary_type): + return s + if isinstance(s, text_type): + return s.encode(encoding, errors) + raise TypeError("not expecting type '%s'" % type(s)) + + +def ensure_str(s, encoding="utf-8", errors="strict"): + """Coerce *s* to `str`. + + For Python 2: + - `unicode` -> encoded to `str` + - `str` -> `str` + + For Python 3: + - `str` -> `str` + - `bytes` -> decoded to `str` + """ + # Optimization: Fast return for the common case. + if type(s) is str: + return s + if PY2 and isinstance(s, text_type): + return s.encode(encoding, errors) + elif PY3 and isinstance(s, binary_type): + return s.decode(encoding, errors) + elif not isinstance(s, (text_type, binary_type)): + raise TypeError("not expecting type '%s'" % type(s)) + return s + + +def ensure_text(s, encoding="utf-8", errors="strict"): + """Coerce *s* to six.text_type. + + For Python 2: + - `unicode` -> `unicode` + - `str` -> `unicode` + + For Python 3: + - `str` -> `str` + - `bytes` -> decoded to `str` + """ + if isinstance(s, binary_type): + return s.decode(encoding, errors) + elif isinstance(s, text_type): + return s + else: + raise TypeError("not expecting type '%s'" % type(s)) + + +def python_2_unicode_compatible(klass): + """ + A class decorator that defines __unicode__ and __str__ methods under Python 2. + Under Python 3 it does nothing. + + To support Python 2 and 3 with a single code base, define a __str__ method + returning text and apply this decorator to the class. + """ + if PY2: + if "__str__" not in klass.__dict__: + raise ValueError( + "@python_2_unicode_compatible cannot be applied " + "to %s because it doesn't define __str__()." % klass.__name__ + ) + klass.__unicode__ = klass.__str__ + klass.__str__ = lambda self: self.__unicode__().encode("utf-8") + return klass + + +# Complete the moves implementation. +# This code is at the end of this module to speed up module loading. +# Turn this module into a package. +__path__ = [] # required for PEP 302 and PEP 451 +__package__ = __name__ # see PEP 366 @ReservedAssignment +if globals().get("__spec__") is not None: + __spec__.submodule_search_locations = [] # PEP 451 @UndefinedVariable +# Remove other six meta path importers, since they cause problems. This can +# happen if six is removed from sys.modules and then reloaded. (Setuptools does +# this for some reason.) +if sys.meta_path: + for i, importer in enumerate(sys.meta_path): + # Here's some real nastiness: Another "instance" of the six module might + # be floating around. Therefore, we can't use isinstance() to check for + # the six meta path importer, since the other six instance will have + # inserted an importer with different class. + if ( + type(importer).__name__ == "_SixMetaPathImporter" + and importer.name == __name__ + ): + del sys.meta_path[i] + break + del i, importer +# Finally, add the importer to the meta path import hook. +sys.meta_path.append(_importer) diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/poolmanager.py b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/poolmanager.py new file mode 100644 index 0000000000000000000000000000000000000000..fb51bf7d96b6f530d5ec847abd3da67d1a052ff0 --- /dev/null +++ b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/poolmanager.py @@ -0,0 +1,540 @@ +from __future__ import absolute_import + +import collections +import functools +import logging + +from ._collections import HTTPHeaderDict, RecentlyUsedContainer +from .connectionpool import HTTPConnectionPool, HTTPSConnectionPool, port_by_scheme +from .exceptions import ( + LocationValueError, + MaxRetryError, + ProxySchemeUnknown, + ProxySchemeUnsupported, + URLSchemeUnknown, +) +from .packages import six +from .packages.six.moves.urllib.parse import urljoin +from .request import RequestMethods +from .util.proxy import connection_requires_http_tunnel +from .util.retry import Retry +from .util.url import parse_url + +__all__ = ["PoolManager", "ProxyManager", "proxy_from_url"] + + +log = logging.getLogger(__name__) + +SSL_KEYWORDS = ( + "key_file", + "cert_file", + "cert_reqs", + "ca_certs", + "ssl_version", + "ca_cert_dir", + "ssl_context", + "key_password", + "server_hostname", +) + +# All known keyword arguments that could be provided to the pool manager, its +# pools, or the underlying connections. This is used to construct a pool key. +_key_fields = ( + "key_scheme", # str + "key_host", # str + "key_port", # int + "key_timeout", # int or float or Timeout + "key_retries", # int or Retry + "key_strict", # bool + "key_block", # bool + "key_source_address", # str + "key_key_file", # str + "key_key_password", # str + "key_cert_file", # str + "key_cert_reqs", # str + "key_ca_certs", # str + "key_ssl_version", # str + "key_ca_cert_dir", # str + "key_ssl_context", # instance of ssl.SSLContext or urllib3.util.ssl_.SSLContext + "key_maxsize", # int + "key_headers", # dict + "key__proxy", # parsed proxy url + "key__proxy_headers", # dict + "key__proxy_config", # class + "key_socket_options", # list of (level (int), optname (int), value (int or str)) tuples + "key__socks_options", # dict + "key_assert_hostname", # bool or string + "key_assert_fingerprint", # str + "key_server_hostname", # str +) + +#: The namedtuple class used to construct keys for the connection pool. +#: All custom key schemes should include the fields in this key at a minimum. +PoolKey = collections.namedtuple("PoolKey", _key_fields) + +_proxy_config_fields = ("ssl_context", "use_forwarding_for_https") +ProxyConfig = collections.namedtuple("ProxyConfig", _proxy_config_fields) + + +def _default_key_normalizer(key_class, request_context): + """ + Create a pool key out of a request context dictionary. + + According to RFC 3986, both the scheme and host are case-insensitive. + Therefore, this function normalizes both before constructing the pool + key for an HTTPS request. If you wish to change this behaviour, provide + alternate callables to ``key_fn_by_scheme``. + + :param key_class: + The class to use when constructing the key. This should be a namedtuple + with the ``scheme`` and ``host`` keys at a minimum. + :type key_class: namedtuple + :param request_context: + A dictionary-like object that contain the context for a request. + :type request_context: dict + + :return: A namedtuple that can be used as a connection pool key. + :rtype: PoolKey + """ + # Since we mutate the dictionary, make a copy first + context = request_context.copy() + context["scheme"] = context["scheme"].lower() + context["host"] = context["host"].lower() + + # These are both dictionaries and need to be transformed into frozensets + for key in ("headers", "_proxy_headers", "_socks_options"): + if key in context and context[key] is not None: + context[key] = frozenset(context[key].items()) + + # The socket_options key may be a list and needs to be transformed into a + # tuple. + socket_opts = context.get("socket_options") + if socket_opts is not None: + context["socket_options"] = tuple(socket_opts) + + # Map the kwargs to the names in the namedtuple - this is necessary since + # namedtuples can't have fields starting with '_'. + for key in list(context.keys()): + context["key_" + key] = context.pop(key) + + # Default to ``None`` for keys missing from the context + for field in key_class._fields: + if field not in context: + context[field] = None + + return key_class(**context) + + +#: A dictionary that maps a scheme to a callable that creates a pool key. +#: This can be used to alter the way pool keys are constructed, if desired. +#: Each PoolManager makes a copy of this dictionary so they can be configured +#: globally here, or individually on the instance. +key_fn_by_scheme = { + "http": functools.partial(_default_key_normalizer, PoolKey), + "https": functools.partial(_default_key_normalizer, PoolKey), +} + +pool_classes_by_scheme = {"http": HTTPConnectionPool, "https": HTTPSConnectionPool} + + +class PoolManager(RequestMethods): + """ + Allows for arbitrary requests while transparently keeping track of + necessary connection pools for you. + + :param num_pools: + Number of connection pools to cache before discarding the least + recently used pool. + + :param headers: + Headers to include with all requests, unless other headers are given + explicitly. + + :param \\**connection_pool_kw: + Additional parameters are used to create fresh + :class:`urllib3.connectionpool.ConnectionPool` instances. + + Example:: + + >>> manager = PoolManager(num_pools=2) + >>> r = manager.request('GET', 'http://google.com/') + >>> r = manager.request('GET', 'http://google.com/mail') + >>> r = manager.request('GET', 'http://yahoo.com/') + >>> len(manager.pools) + 2 + + """ + + proxy = None + proxy_config = None + + def __init__(self, num_pools=10, headers=None, **connection_pool_kw): + RequestMethods.__init__(self, headers) + self.connection_pool_kw = connection_pool_kw + self.pools = RecentlyUsedContainer(num_pools) + + # Locally set the pool classes and keys so other PoolManagers can + # override them. + self.pool_classes_by_scheme = pool_classes_by_scheme + self.key_fn_by_scheme = key_fn_by_scheme.copy() + + def __enter__(self): + return self + + def __exit__(self, exc_type, exc_val, exc_tb): + self.clear() + # Return False to re-raise any potential exceptions + return False + + def _new_pool(self, scheme, host, port, request_context=None): + """ + Create a new :class:`urllib3.connectionpool.ConnectionPool` based on host, port, scheme, and + any additional pool keyword arguments. + + If ``request_context`` is provided, it is provided as keyword arguments + to the pool class used. This method is used to actually create the + connection pools handed out by :meth:`connection_from_url` and + companion methods. It is intended to be overridden for customization. + """ + pool_cls = self.pool_classes_by_scheme[scheme] + if request_context is None: + request_context = self.connection_pool_kw.copy() + + # Although the context has everything necessary to create the pool, + # this function has historically only used the scheme, host, and port + # in the positional args. When an API change is acceptable these can + # be removed. + for key in ("scheme", "host", "port"): + request_context.pop(key, None) + + if scheme == "http": + for kw in SSL_KEYWORDS: + request_context.pop(kw, None) + + return pool_cls(host, port, **request_context) + + def clear(self): + """ + Empty our store of pools and direct them all to close. + + This will not affect in-flight connections, but they will not be + re-used after completion. + """ + self.pools.clear() + + def connection_from_host(self, host, port=None, scheme="http", pool_kwargs=None): + """ + Get a :class:`urllib3.connectionpool.ConnectionPool` based on the host, port, and scheme. + + If ``port`` isn't given, it will be derived from the ``scheme`` using + ``urllib3.connectionpool.port_by_scheme``. If ``pool_kwargs`` is + provided, it is merged with the instance's ``connection_pool_kw`` + variable and used to create the new connection pool, if one is + needed. + """ + + if not host: + raise LocationValueError("No host specified.") + + request_context = self._merge_pool_kwargs(pool_kwargs) + request_context["scheme"] = scheme or "http" + if not port: + port = port_by_scheme.get(request_context["scheme"].lower(), 80) + request_context["port"] = port + request_context["host"] = host + + return self.connection_from_context(request_context) + + def connection_from_context(self, request_context): + """ + Get a :class:`urllib3.connectionpool.ConnectionPool` based on the request context. + + ``request_context`` must at least contain the ``scheme`` key and its + value must be a key in ``key_fn_by_scheme`` instance variable. + """ + scheme = request_context["scheme"].lower() + pool_key_constructor = self.key_fn_by_scheme.get(scheme) + if not pool_key_constructor: + raise URLSchemeUnknown(scheme) + pool_key = pool_key_constructor(request_context) + + return self.connection_from_pool_key(pool_key, request_context=request_context) + + def connection_from_pool_key(self, pool_key, request_context=None): + """ + Get a :class:`urllib3.connectionpool.ConnectionPool` based on the provided pool key. + + ``pool_key`` should be a namedtuple that only contains immutable + objects. At a minimum it must have the ``scheme``, ``host``, and + ``port`` fields. + """ + with self.pools.lock: + # If the scheme, host, or port doesn't match existing open + # connections, open a new ConnectionPool. + pool = self.pools.get(pool_key) + if pool: + return pool + + # Make a fresh ConnectionPool of the desired type + scheme = request_context["scheme"] + host = request_context["host"] + port = request_context["port"] + pool = self._new_pool(scheme, host, port, request_context=request_context) + self.pools[pool_key] = pool + + return pool + + def connection_from_url(self, url, pool_kwargs=None): + """ + Similar to :func:`urllib3.connectionpool.connection_from_url`. + + If ``pool_kwargs`` is not provided and a new pool needs to be + constructed, ``self.connection_pool_kw`` is used to initialize + the :class:`urllib3.connectionpool.ConnectionPool`. If ``pool_kwargs`` + is provided, it is used instead. Note that if a new pool does not + need to be created for the request, the provided ``pool_kwargs`` are + not used. + """ + u = parse_url(url) + return self.connection_from_host( + u.host, port=u.port, scheme=u.scheme, pool_kwargs=pool_kwargs + ) + + def _merge_pool_kwargs(self, override): + """ + Merge a dictionary of override values for self.connection_pool_kw. + + This does not modify self.connection_pool_kw and returns a new dict. + Any keys in the override dictionary with a value of ``None`` are + removed from the merged dictionary. + """ + base_pool_kwargs = self.connection_pool_kw.copy() + if override: + for key, value in override.items(): + if value is None: + try: + del base_pool_kwargs[key] + except KeyError: + pass + else: + base_pool_kwargs[key] = value + return base_pool_kwargs + + def _proxy_requires_url_absolute_form(self, parsed_url): + """ + Indicates if the proxy requires the complete destination URL in the + request. Normally this is only needed when not using an HTTP CONNECT + tunnel. + """ + if self.proxy is None: + return False + + return not connection_requires_http_tunnel( + self.proxy, self.proxy_config, parsed_url.scheme + ) + + def _validate_proxy_scheme_url_selection(self, url_scheme): + """ + Validates that were not attempting to do TLS in TLS connections on + Python2 or with unsupported SSL implementations. + """ + if self.proxy is None or url_scheme != "https": + return + + if self.proxy.scheme != "https": + return + + if six.PY2 and not self.proxy_config.use_forwarding_for_https: + raise ProxySchemeUnsupported( + "Contacting HTTPS destinations through HTTPS proxies " + "'via CONNECT tunnels' is not supported in Python 2" + ) + + def urlopen(self, method, url, redirect=True, **kw): + """ + Same as :meth:`urllib3.HTTPConnectionPool.urlopen` + with custom cross-host redirect logic and only sends the request-uri + portion of the ``url``. + + The given ``url`` parameter must be absolute, such that an appropriate + :class:`urllib3.connectionpool.ConnectionPool` can be chosen for it. + """ + u = parse_url(url) + self._validate_proxy_scheme_url_selection(u.scheme) + + conn = self.connection_from_host(u.host, port=u.port, scheme=u.scheme) + + kw["assert_same_host"] = False + kw["redirect"] = False + + if "headers" not in kw: + kw["headers"] = self.headers.copy() + + if self._proxy_requires_url_absolute_form(u): + response = conn.urlopen(method, url, **kw) + else: + response = conn.urlopen(method, u.request_uri, **kw) + + redirect_location = redirect and response.get_redirect_location() + if not redirect_location: + return response + + # Support relative URLs for redirecting. + redirect_location = urljoin(url, redirect_location) + + if response.status == 303: + # Change the method according to RFC 9110, Section 15.4.4. + method = "GET" + # And lose the body not to transfer anything sensitive. + kw["body"] = None + kw["headers"] = HTTPHeaderDict(kw["headers"])._prepare_for_method_change() + + retries = kw.get("retries") + if not isinstance(retries, Retry): + retries = Retry.from_int(retries, redirect=redirect) + + # Strip headers marked as unsafe to forward to the redirected location. + # Check remove_headers_on_redirect to avoid a potential network call within + # conn.is_same_host() which may use socket.gethostbyname() in the future. + if retries.remove_headers_on_redirect and not conn.is_same_host( + redirect_location + ): + headers = list(six.iterkeys(kw["headers"])) + for header in headers: + if header.lower() in retries.remove_headers_on_redirect: + kw["headers"].pop(header, None) + + try: + retries = retries.increment(method, url, response=response, _pool=conn) + except MaxRetryError: + if retries.raise_on_redirect: + response.drain_conn() + raise + return response + + kw["retries"] = retries + kw["redirect"] = redirect + + log.info("Redirecting %s -> %s", url, redirect_location) + + response.drain_conn() + return self.urlopen(method, redirect_location, **kw) + + +class ProxyManager(PoolManager): + """ + Behaves just like :class:`PoolManager`, but sends all requests through + the defined proxy, using the CONNECT method for HTTPS URLs. + + :param proxy_url: + The URL of the proxy to be used. + + :param proxy_headers: + A dictionary containing headers that will be sent to the proxy. In case + of HTTP they are being sent with each request, while in the + HTTPS/CONNECT case they are sent only once. Could be used for proxy + authentication. + + :param proxy_ssl_context: + The proxy SSL context is used to establish the TLS connection to the + proxy when using HTTPS proxies. + + :param use_forwarding_for_https: + (Defaults to False) If set to True will forward requests to the HTTPS + proxy to be made on behalf of the client instead of creating a TLS + tunnel via the CONNECT method. **Enabling this flag means that request + and response headers and content will be visible from the HTTPS proxy** + whereas tunneling keeps request and response headers and content + private. IP address, target hostname, SNI, and port are always visible + to an HTTPS proxy even when this flag is disabled. + + Example: + >>> proxy = urllib3.ProxyManager('http://localhost:3128/') + >>> r1 = proxy.request('GET', 'http://google.com/') + >>> r2 = proxy.request('GET', 'http://httpbin.org/') + >>> len(proxy.pools) + 1 + >>> r3 = proxy.request('GET', 'https://httpbin.org/') + >>> r4 = proxy.request('GET', 'https://twitter.com/') + >>> len(proxy.pools) + 3 + + """ + + def __init__( + self, + proxy_url, + num_pools=10, + headers=None, + proxy_headers=None, + proxy_ssl_context=None, + use_forwarding_for_https=False, + **connection_pool_kw + ): + + if isinstance(proxy_url, HTTPConnectionPool): + proxy_url = "%s://%s:%i" % ( + proxy_url.scheme, + proxy_url.host, + proxy_url.port, + ) + proxy = parse_url(proxy_url) + + if proxy.scheme not in ("http", "https"): + raise ProxySchemeUnknown(proxy.scheme) + + if not proxy.port: + port = port_by_scheme.get(proxy.scheme, 80) + proxy = proxy._replace(port=port) + + self.proxy = proxy + self.proxy_headers = proxy_headers or {} + self.proxy_ssl_context = proxy_ssl_context + self.proxy_config = ProxyConfig(proxy_ssl_context, use_forwarding_for_https) + + connection_pool_kw["_proxy"] = self.proxy + connection_pool_kw["_proxy_headers"] = self.proxy_headers + connection_pool_kw["_proxy_config"] = self.proxy_config + + super(ProxyManager, self).__init__(num_pools, headers, **connection_pool_kw) + + def connection_from_host(self, host, port=None, scheme="http", pool_kwargs=None): + if scheme == "https": + return super(ProxyManager, self).connection_from_host( + host, port, scheme, pool_kwargs=pool_kwargs + ) + + return super(ProxyManager, self).connection_from_host( + self.proxy.host, self.proxy.port, self.proxy.scheme, pool_kwargs=pool_kwargs + ) + + def _set_proxy_headers(self, url, headers=None): + """ + Sets headers needed by proxies: specifically, the Accept and Host + headers. Only sets headers not provided by the user. + """ + headers_ = {"Accept": "*/*"} + + netloc = parse_url(url).netloc + if netloc: + headers_["Host"] = netloc + + if headers: + headers_.update(headers) + return headers_ + + def urlopen(self, method, url, redirect=True, **kw): + "Same as HTTP(S)ConnectionPool.urlopen, ``url`` must be absolute." + u = parse_url(url) + if not connection_requires_http_tunnel(self.proxy, self.proxy_config, u.scheme): + # For connections using HTTP CONNECT, httplib sets the necessary + # headers on the CONNECT to the proxy. If we're not using CONNECT, + # we'll definitely need to set 'Host' at the very least. + headers = kw.get("headers", self.headers) + kw["headers"] = self._set_proxy_headers(url, headers) + + return super(ProxyManager, self).urlopen(method, url, redirect=redirect, **kw) + + +def proxy_from_url(url, **kw): + return ProxyManager(proxy_url=url, **kw) diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/request.py b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/request.py new file mode 100644 index 0000000000000000000000000000000000000000..3b4cf999225b83c46b930f1fe7cdc63e6ce57129 --- /dev/null +++ b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/request.py @@ -0,0 +1,191 @@ +from __future__ import absolute_import + +import sys + +from .filepost import encode_multipart_formdata +from .packages import six +from .packages.six.moves.urllib.parse import urlencode + +__all__ = ["RequestMethods"] + + +class RequestMethods(object): + """ + Convenience mixin for classes who implement a :meth:`urlopen` method, such + as :class:`urllib3.HTTPConnectionPool` and + :class:`urllib3.PoolManager`. + + Provides behavior for making common types of HTTP request methods and + decides which type of request field encoding to use. + + Specifically, + + :meth:`.request_encode_url` is for sending requests whose fields are + encoded in the URL (such as GET, HEAD, DELETE). + + :meth:`.request_encode_body` is for sending requests whose fields are + encoded in the *body* of the request using multipart or www-form-urlencoded + (such as for POST, PUT, PATCH). + + :meth:`.request` is for making any kind of request, it will look up the + appropriate encoding format and use one of the above two methods to make + the request. + + Initializer parameters: + + :param headers: + Headers to include with all requests, unless other headers are given + explicitly. + """ + + _encode_url_methods = {"DELETE", "GET", "HEAD", "OPTIONS"} + + def __init__(self, headers=None): + self.headers = headers or {} + + def urlopen( + self, + method, + url, + body=None, + headers=None, + encode_multipart=True, + multipart_boundary=None, + **kw + ): # Abstract + raise NotImplementedError( + "Classes extending RequestMethods must implement " + "their own ``urlopen`` method." + ) + + def request(self, method, url, fields=None, headers=None, **urlopen_kw): + """ + Make a request using :meth:`urlopen` with the appropriate encoding of + ``fields`` based on the ``method`` used. + + This is a convenience method that requires the least amount of manual + effort. It can be used in most situations, while still having the + option to drop down to more specific methods when necessary, such as + :meth:`request_encode_url`, :meth:`request_encode_body`, + or even the lowest level :meth:`urlopen`. + """ + method = method.upper() + + urlopen_kw["request_url"] = url + + if method in self._encode_url_methods: + return self.request_encode_url( + method, url, fields=fields, headers=headers, **urlopen_kw + ) + else: + return self.request_encode_body( + method, url, fields=fields, headers=headers, **urlopen_kw + ) + + def request_encode_url(self, method, url, fields=None, headers=None, **urlopen_kw): + """ + Make a request using :meth:`urlopen` with the ``fields`` encoded in + the url. This is useful for request methods like GET, HEAD, DELETE, etc. + """ + if headers is None: + headers = self.headers + + extra_kw = {"headers": headers} + extra_kw.update(urlopen_kw) + + if fields: + url += "?" + urlencode(fields) + + return self.urlopen(method, url, **extra_kw) + + def request_encode_body( + self, + method, + url, + fields=None, + headers=None, + encode_multipart=True, + multipart_boundary=None, + **urlopen_kw + ): + """ + Make a request using :meth:`urlopen` with the ``fields`` encoded in + the body. This is useful for request methods like POST, PUT, PATCH, etc. + + When ``encode_multipart=True`` (default), then + :func:`urllib3.encode_multipart_formdata` is used to encode + the payload with the appropriate content type. Otherwise + :func:`urllib.parse.urlencode` is used with the + 'application/x-www-form-urlencoded' content type. + + Multipart encoding must be used when posting files, and it's reasonably + safe to use it in other times too. However, it may break request + signing, such as with OAuth. + + Supports an optional ``fields`` parameter of key/value strings AND + key/filetuple. A filetuple is a (filename, data, MIME type) tuple where + the MIME type is optional. For example:: + + fields = { + 'foo': 'bar', + 'fakefile': ('foofile.txt', 'contents of foofile'), + 'realfile': ('barfile.txt', open('realfile').read()), + 'typedfile': ('bazfile.bin', open('bazfile').read(), + 'image/jpeg'), + 'nonamefile': 'contents of nonamefile field', + } + + When uploading a file, providing a filename (the first parameter of the + tuple) is optional but recommended to best mimic behavior of browsers. + + Note that if ``headers`` are supplied, the 'Content-Type' header will + be overwritten because it depends on the dynamic random boundary string + which is used to compose the body of the request. The random boundary + string can be explicitly set with the ``multipart_boundary`` parameter. + """ + if headers is None: + headers = self.headers + + extra_kw = {"headers": {}} + + if fields: + if "body" in urlopen_kw: + raise TypeError( + "request got values for both 'fields' and 'body', can only specify one." + ) + + if encode_multipart: + body, content_type = encode_multipart_formdata( + fields, boundary=multipart_boundary + ) + else: + body, content_type = ( + urlencode(fields), + "application/x-www-form-urlencoded", + ) + + extra_kw["body"] = body + extra_kw["headers"] = {"Content-Type": content_type} + + extra_kw["headers"].update(headers) + extra_kw.update(urlopen_kw) + + return self.urlopen(method, url, **extra_kw) + + +if not six.PY2: + + class RequestModule(sys.modules[__name__].__class__): + def __call__(self, *args, **kwargs): + """ + If user tries to call this module directly urllib3 v2.x style raise an error to the user + suggesting they may need urllib3 v2 + """ + raise TypeError( + "'module' object is not callable\n" + "urllib3.request() method is not supported in this release, " + "upgrade to urllib3 v2 to use it\n" + "see https://urllib3.readthedocs.io/en/stable/v2-migration-guide.html" + ) + + sys.modules[__name__].__class__ = RequestModule diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/response.py b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/response.py new file mode 100644 index 0000000000000000000000000000000000000000..8909f8454e94752d188ed13cf36c35f93fc6c3f2 --- /dev/null +++ b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/response.py @@ -0,0 +1,879 @@ +from __future__ import absolute_import + +import io +import logging +import sys +import warnings +import zlib +from contextlib import contextmanager +from socket import error as SocketError +from socket import timeout as SocketTimeout + +brotli = None + +from . import util +from ._collections import HTTPHeaderDict +from .connection import BaseSSLError, HTTPException +from .exceptions import ( + BodyNotHttplibCompatible, + DecodeError, + HTTPError, + IncompleteRead, + InvalidChunkLength, + InvalidHeader, + ProtocolError, + ReadTimeoutError, + ResponseNotChunked, + SSLError, +) +from .packages import six +from .util.response import is_fp_closed, is_response_to_head + +log = logging.getLogger(__name__) + + +class DeflateDecoder(object): + def __init__(self): + self._first_try = True + self._data = b"" + self._obj = zlib.decompressobj() + + def __getattr__(self, name): + return getattr(self._obj, name) + + def decompress(self, data): + if not data: + return data + + if not self._first_try: + return self._obj.decompress(data) + + self._data += data + try: + decompressed = self._obj.decompress(data) + if decompressed: + self._first_try = False + self._data = None + return decompressed + except zlib.error: + self._first_try = False + self._obj = zlib.decompressobj(-zlib.MAX_WBITS) + try: + return self.decompress(self._data) + finally: + self._data = None + + +class GzipDecoderState(object): + + FIRST_MEMBER = 0 + OTHER_MEMBERS = 1 + SWALLOW_DATA = 2 + + +class GzipDecoder(object): + def __init__(self): + self._obj = zlib.decompressobj(16 + zlib.MAX_WBITS) + self._state = GzipDecoderState.FIRST_MEMBER + + def __getattr__(self, name): + return getattr(self._obj, name) + + def decompress(self, data): + ret = bytearray() + if self._state == GzipDecoderState.SWALLOW_DATA or not data: + return bytes(ret) + while True: + try: + ret += self._obj.decompress(data) + except zlib.error: + previous_state = self._state + # Ignore data after the first error + self._state = GzipDecoderState.SWALLOW_DATA + if previous_state == GzipDecoderState.OTHER_MEMBERS: + # Allow trailing garbage acceptable in other gzip clients + return bytes(ret) + raise + data = self._obj.unused_data + if not data: + return bytes(ret) + self._state = GzipDecoderState.OTHER_MEMBERS + self._obj = zlib.decompressobj(16 + zlib.MAX_WBITS) + + +if brotli is not None: + + class BrotliDecoder(object): + # Supports both 'brotlipy' and 'Brotli' packages + # since they share an import name. The top branches + # are for 'brotlipy' and bottom branches for 'Brotli' + def __init__(self): + self._obj = brotli.Decompressor() + if hasattr(self._obj, "decompress"): + self.decompress = self._obj.decompress + else: + self.decompress = self._obj.process + + def flush(self): + if hasattr(self._obj, "flush"): + return self._obj.flush() + return b"" + + +class MultiDecoder(object): + """ + From RFC7231: + If one or more encodings have been applied to a representation, the + sender that applied the encodings MUST generate a Content-Encoding + header field that lists the content codings in the order in which + they were applied. + """ + + def __init__(self, modes): + self._decoders = [_get_decoder(m.strip()) for m in modes.split(",")] + + def flush(self): + return self._decoders[0].flush() + + def decompress(self, data): + for d in reversed(self._decoders): + data = d.decompress(data) + return data + + +def _get_decoder(mode): + if "," in mode: + return MultiDecoder(mode) + + if mode == "gzip": + return GzipDecoder() + + if brotli is not None and mode == "br": + return BrotliDecoder() + + return DeflateDecoder() + + +class HTTPResponse(io.IOBase): + """ + HTTP Response container. + + Backwards-compatible with :class:`http.client.HTTPResponse` but the response ``body`` is + loaded and decoded on-demand when the ``data`` property is accessed. This + class is also compatible with the Python standard library's :mod:`io` + module, and can hence be treated as a readable object in the context of that + framework. + + Extra parameters for behaviour not present in :class:`http.client.HTTPResponse`: + + :param preload_content: + If True, the response's body will be preloaded during construction. + + :param decode_content: + If True, will attempt to decode the body based on the + 'content-encoding' header. + + :param original_response: + When this HTTPResponse wrapper is generated from an :class:`http.client.HTTPResponse` + object, it's convenient to include the original for debug purposes. It's + otherwise unused. + + :param retries: + The retries contains the last :class:`~urllib3.util.retry.Retry` that + was used during the request. + + :param enforce_content_length: + Enforce content length checking. Body returned by server must match + value of Content-Length header, if present. Otherwise, raise error. + """ + + CONTENT_DECODERS = ["gzip", "deflate"] + if brotli is not None: + CONTENT_DECODERS += ["br"] + REDIRECT_STATUSES = [301, 302, 303, 307, 308] + + def __init__( + self, + body="", + headers=None, + status=0, + version=0, + reason=None, + strict=0, + preload_content=True, + decode_content=True, + original_response=None, + pool=None, + connection=None, + msg=None, + retries=None, + enforce_content_length=False, + request_method=None, + request_url=None, + auto_close=True, + ): + + if isinstance(headers, HTTPHeaderDict): + self.headers = headers + else: + self.headers = HTTPHeaderDict(headers) + self.status = status + self.version = version + self.reason = reason + self.strict = strict + self.decode_content = decode_content + self.retries = retries + self.enforce_content_length = enforce_content_length + self.auto_close = auto_close + + self._decoder = None + self._body = None + self._fp = None + self._original_response = original_response + self._fp_bytes_read = 0 + self.msg = msg + self._request_url = request_url + + if body and isinstance(body, (six.string_types, bytes)): + self._body = body + + self._pool = pool + self._connection = connection + + if hasattr(body, "read"): + self._fp = body + + # Are we using the chunked-style of transfer encoding? + self.chunked = False + self.chunk_left = None + tr_enc = self.headers.get("transfer-encoding", "").lower() + # Don't incur the penalty of creating a list and then discarding it + encodings = (enc.strip() for enc in tr_enc.split(",")) + if "chunked" in encodings: + self.chunked = True + + # Determine length of response + self.length_remaining = self._init_length(request_method) + + # If requested, preload the body. + if preload_content and not self._body: + self._body = self.read(decode_content=decode_content) + + def get_redirect_location(self): + """ + Should we redirect and where to? + + :returns: Truthy redirect location string if we got a redirect status + code and valid location. ``None`` if redirect status and no + location. ``False`` if not a redirect status code. + """ + if self.status in self.REDIRECT_STATUSES: + return self.headers.get("location") + + return False + + def release_conn(self): + if not self._pool or not self._connection: + return + + self._pool._put_conn(self._connection) + self._connection = None + + def drain_conn(self): + """ + Read and discard any remaining HTTP response data in the response connection. + + Unread data in the HTTPResponse connection blocks the connection from being released back to the pool. + """ + try: + self.read() + except (HTTPError, SocketError, BaseSSLError, HTTPException): + pass + + @property + def data(self): + # For backwards-compat with earlier urllib3 0.4 and earlier. + if self._body: + return self._body + + if self._fp: + return self.read(cache_content=True) + + @property + def connection(self): + return self._connection + + def isclosed(self): + return is_fp_closed(self._fp) + + def tell(self): + """ + Obtain the number of bytes pulled over the wire so far. May differ from + the amount of content returned by :meth:``urllib3.response.HTTPResponse.read`` + if bytes are encoded on the wire (e.g, compressed). + """ + return self._fp_bytes_read + + def _init_length(self, request_method): + """ + Set initial length value for Response content if available. + """ + length = self.headers.get("content-length") + + if length is not None: + if self.chunked: + # This Response will fail with an IncompleteRead if it can't be + # received as chunked. This method falls back to attempt reading + # the response before raising an exception. + log.warning( + "Received response with both Content-Length and " + "Transfer-Encoding set. This is expressly forbidden " + "by RFC 7230 sec 3.3.2. Ignoring Content-Length and " + "attempting to process response as Transfer-Encoding: " + "chunked." + ) + return None + + try: + # RFC 7230 section 3.3.2 specifies multiple content lengths can + # be sent in a single Content-Length header + # (e.g. Content-Length: 42, 42). This line ensures the values + # are all valid ints and that as long as the `set` length is 1, + # all values are the same. Otherwise, the header is invalid. + lengths = set([int(val) for val in length.split(",")]) + if len(lengths) > 1: + raise InvalidHeader( + "Content-Length contained multiple " + "unmatching values (%s)" % length + ) + length = lengths.pop() + except ValueError: + length = None + else: + if length < 0: + length = None + + # Convert status to int for comparison + # In some cases, httplib returns a status of "_UNKNOWN" + try: + status = int(self.status) + except ValueError: + status = 0 + + # Check for responses that shouldn't include a body + if status in (204, 304) or 100 <= status < 200 or request_method == "HEAD": + length = 0 + + return length + + def _init_decoder(self): + """ + Set-up the _decoder attribute if necessary. + """ + # Note: content-encoding value should be case-insensitive, per RFC 7230 + # Section 3.2 + content_encoding = self.headers.get("content-encoding", "").lower() + if self._decoder is None: + if content_encoding in self.CONTENT_DECODERS: + self._decoder = _get_decoder(content_encoding) + elif "," in content_encoding: + encodings = [ + e.strip() + for e in content_encoding.split(",") + if e.strip() in self.CONTENT_DECODERS + ] + if len(encodings): + self._decoder = _get_decoder(content_encoding) + + DECODER_ERROR_CLASSES = (IOError, zlib.error) + if brotli is not None: + DECODER_ERROR_CLASSES += (brotli.error,) + + def _decode(self, data, decode_content, flush_decoder): + """ + Decode the data passed in and potentially flush the decoder. + """ + if not decode_content: + return data + + try: + if self._decoder: + data = self._decoder.decompress(data) + except self.DECODER_ERROR_CLASSES as e: + content_encoding = self.headers.get("content-encoding", "").lower() + raise DecodeError( + "Received response with content-encoding: %s, but " + "failed to decode it." % content_encoding, + e, + ) + if flush_decoder: + data += self._flush_decoder() + + return data + + def _flush_decoder(self): + """ + Flushes the decoder. Should only be called if the decoder is actually + being used. + """ + if self._decoder: + buf = self._decoder.decompress(b"") + return buf + self._decoder.flush() + + return b"" + + @contextmanager + def _error_catcher(self): + """ + Catch low-level python exceptions, instead re-raising urllib3 + variants, so that low-level exceptions are not leaked in the + high-level api. + + On exit, release the connection back to the pool. + """ + clean_exit = False + + try: + try: + yield + + except SocketTimeout: + # FIXME: Ideally we'd like to include the url in the ReadTimeoutError but + # there is yet no clean way to get at it from this context. + raise ReadTimeoutError(self._pool, None, "Read timed out.") + + except BaseSSLError as e: + # FIXME: Is there a better way to differentiate between SSLErrors? + if "read operation timed out" not in str(e): + # SSL errors related to framing/MAC get wrapped and reraised here + raise SSLError(e) + + raise ReadTimeoutError(self._pool, None, "Read timed out.") + + except (HTTPException, SocketError) as e: + # This includes IncompleteRead. + raise ProtocolError("Connection broken: %r" % e, e) + + # If no exception is thrown, we should avoid cleaning up + # unnecessarily. + clean_exit = True + finally: + # If we didn't terminate cleanly, we need to throw away our + # connection. + if not clean_exit: + # The response may not be closed but we're not going to use it + # anymore so close it now to ensure that the connection is + # released back to the pool. + if self._original_response: + self._original_response.close() + + # Closing the response may not actually be sufficient to close + # everything, so if we have a hold of the connection close that + # too. + if self._connection: + self._connection.close() + + # If we hold the original response but it's closed now, we should + # return the connection back to the pool. + if self._original_response and self._original_response.isclosed(): + self.release_conn() + + def _fp_read(self, amt): + """ + Read a response with the thought that reading the number of bytes + larger than can fit in a 32-bit int at a time via SSL in some + known cases leads to an overflow error that has to be prevented + if `amt` or `self.length_remaining` indicate that a problem may + happen. + + The known cases: + * 3.8 <= CPython < 3.9.7 because of a bug + https://github.com/urllib3/urllib3/issues/2513#issuecomment-1152559900. + * urllib3 injected with pyOpenSSL-backed SSL-support. + * CPython < 3.10 only when `amt` does not fit 32-bit int. + """ + assert self._fp + c_int_max = 2 ** 31 - 1 + if ( + ( + (amt and amt > c_int_max) + or (self.length_remaining and self.length_remaining > c_int_max) + ) + and not util.IS_SECURETRANSPORT + and (util.IS_PYOPENSSL or sys.version_info < (3, 10)) + ): + buffer = io.BytesIO() + # Besides `max_chunk_amt` being a maximum chunk size, it + # affects memory overhead of reading a response by this + # method in CPython. + # `c_int_max` equal to 2 GiB - 1 byte is the actual maximum + # chunk size that does not lead to an overflow error, but + # 256 MiB is a compromise. + max_chunk_amt = 2 ** 28 + while amt is None or amt != 0: + if amt is not None: + chunk_amt = min(amt, max_chunk_amt) + amt -= chunk_amt + else: + chunk_amt = max_chunk_amt + data = self._fp.read(chunk_amt) + if not data: + break + buffer.write(data) + del data # to reduce peak memory usage by `max_chunk_amt`. + return buffer.getvalue() + else: + # StringIO doesn't like amt=None + return self._fp.read(amt) if amt is not None else self._fp.read() + + def read(self, amt=None, decode_content=None, cache_content=False): + """ + Similar to :meth:`http.client.HTTPResponse.read`, but with two additional + parameters: ``decode_content`` and ``cache_content``. + + :param amt: + How much of the content to read. If specified, caching is skipped + because it doesn't make sense to cache partial content as the full + response. + + :param decode_content: + If True, will attempt to decode the body based on the + 'content-encoding' header. + + :param cache_content: + If True, will save the returned data such that the same result is + returned despite of the state of the underlying file object. This + is useful if you want the ``.data`` property to continue working + after having ``.read()`` the file object. (Overridden if ``amt`` is + set.) + """ + self._init_decoder() + if decode_content is None: + decode_content = self.decode_content + + if self._fp is None: + return + + flush_decoder = False + fp_closed = getattr(self._fp, "closed", False) + + with self._error_catcher(): + data = self._fp_read(amt) if not fp_closed else b"" + if amt is None: + flush_decoder = True + else: + cache_content = False + if ( + amt != 0 and not data + ): # Platform-specific: Buggy versions of Python. + # Close the connection when no data is returned + # + # This is redundant to what httplib/http.client _should_ + # already do. However, versions of python released before + # December 15, 2012 (http://bugs.python.org/issue16298) do + # not properly close the connection in all cases. There is + # no harm in redundantly calling close. + self._fp.close() + flush_decoder = True + if self.enforce_content_length and self.length_remaining not in ( + 0, + None, + ): + # This is an edge case that httplib failed to cover due + # to concerns of backward compatibility. We're + # addressing it here to make sure IncompleteRead is + # raised during streaming, so all calls with incorrect + # Content-Length are caught. + raise IncompleteRead(self._fp_bytes_read, self.length_remaining) + + if data: + self._fp_bytes_read += len(data) + if self.length_remaining is not None: + self.length_remaining -= len(data) + + data = self._decode(data, decode_content, flush_decoder) + + if cache_content: + self._body = data + + return data + + def stream(self, amt=2 ** 16, decode_content=None): + """ + A generator wrapper for the read() method. A call will block until + ``amt`` bytes have been read from the connection or until the + connection is closed. + + :param amt: + How much of the content to read. The generator will return up to + much data per iteration, but may return less. This is particularly + likely when using compressed data. However, the empty string will + never be returned. + + :param decode_content: + If True, will attempt to decode the body based on the + 'content-encoding' header. + """ + if self.chunked and self.supports_chunked_reads(): + for line in self.read_chunked(amt, decode_content=decode_content): + yield line + else: + while not is_fp_closed(self._fp): + data = self.read(amt=amt, decode_content=decode_content) + + if data: + yield data + + @classmethod + def from_httplib(ResponseCls, r, **response_kw): + """ + Given an :class:`http.client.HTTPResponse` instance ``r``, return a + corresponding :class:`urllib3.response.HTTPResponse` object. + + Remaining parameters are passed to the HTTPResponse constructor, along + with ``original_response=r``. + """ + headers = r.msg + + if not isinstance(headers, HTTPHeaderDict): + if six.PY2: + # Python 2.7 + headers = HTTPHeaderDict.from_httplib(headers) + else: + headers = HTTPHeaderDict(headers.items()) + + # HTTPResponse objects in Python 3 don't have a .strict attribute + strict = getattr(r, "strict", 0) + resp = ResponseCls( + body=r, + headers=headers, + status=r.status, + version=r.version, + reason=r.reason, + strict=strict, + original_response=r, + **response_kw + ) + return resp + + # Backwards-compatibility methods for http.client.HTTPResponse + def getheaders(self): + warnings.warn( + "HTTPResponse.getheaders() is deprecated and will be removed " + "in urllib3 v2.1.0. Instead access HTTPResponse.headers directly.", + category=DeprecationWarning, + stacklevel=2, + ) + return self.headers + + def getheader(self, name, default=None): + warnings.warn( + "HTTPResponse.getheader() is deprecated and will be removed " + "in urllib3 v2.1.0. Instead use HTTPResponse.headers.get(name, default).", + category=DeprecationWarning, + stacklevel=2, + ) + return self.headers.get(name, default) + + # Backwards compatibility for http.cookiejar + def info(self): + return self.headers + + # Overrides from io.IOBase + def close(self): + if not self.closed: + self._fp.close() + + if self._connection: + self._connection.close() + + if not self.auto_close: + io.IOBase.close(self) + + @property + def closed(self): + if not self.auto_close: + return io.IOBase.closed.__get__(self) + elif self._fp is None: + return True + elif hasattr(self._fp, "isclosed"): + return self._fp.isclosed() + elif hasattr(self._fp, "closed"): + return self._fp.closed + else: + return True + + def fileno(self): + if self._fp is None: + raise IOError("HTTPResponse has no file to get a fileno from") + elif hasattr(self._fp, "fileno"): + return self._fp.fileno() + else: + raise IOError( + "The file-like object this HTTPResponse is wrapped " + "around has no file descriptor" + ) + + def flush(self): + if ( + self._fp is not None + and hasattr(self._fp, "flush") + and not getattr(self._fp, "closed", False) + ): + return self._fp.flush() + + def readable(self): + # This method is required for `io` module compatibility. + return True + + def readinto(self, b): + # This method is required for `io` module compatibility. + temp = self.read(len(b)) + if len(temp) == 0: + return 0 + else: + b[: len(temp)] = temp + return len(temp) + + def supports_chunked_reads(self): + """ + Checks if the underlying file-like object looks like a + :class:`http.client.HTTPResponse` object. We do this by testing for + the fp attribute. If it is present we assume it returns raw chunks as + processed by read_chunked(). + """ + return hasattr(self._fp, "fp") + + def _update_chunk_length(self): + # First, we'll figure out length of a chunk and then + # we'll try to read it from socket. + if self.chunk_left is not None: + return + line = self._fp.fp.readline() + line = line.split(b";", 1)[0] + try: + self.chunk_left = int(line, 16) + except ValueError: + # Invalid chunked protocol response, abort. + self.close() + raise InvalidChunkLength(self, line) + + def _handle_chunk(self, amt): + returned_chunk = None + if amt is None: + chunk = self._fp._safe_read(self.chunk_left) + returned_chunk = chunk + self._fp._safe_read(2) # Toss the CRLF at the end of the chunk. + self.chunk_left = None + elif amt < self.chunk_left: + value = self._fp._safe_read(amt) + self.chunk_left = self.chunk_left - amt + returned_chunk = value + elif amt == self.chunk_left: + value = self._fp._safe_read(amt) + self._fp._safe_read(2) # Toss the CRLF at the end of the chunk. + self.chunk_left = None + returned_chunk = value + else: # amt > self.chunk_left + returned_chunk = self._fp._safe_read(self.chunk_left) + self._fp._safe_read(2) # Toss the CRLF at the end of the chunk. + self.chunk_left = None + return returned_chunk + + def read_chunked(self, amt=None, decode_content=None): + """ + Similar to :meth:`HTTPResponse.read`, but with an additional + parameter: ``decode_content``. + + :param amt: + How much of the content to read. If specified, caching is skipped + because it doesn't make sense to cache partial content as the full + response. + + :param decode_content: + If True, will attempt to decode the body based on the + 'content-encoding' header. + """ + self._init_decoder() + # FIXME: Rewrite this method and make it a class with a better structured logic. + if not self.chunked: + raise ResponseNotChunked( + "Response is not chunked. " + "Header 'transfer-encoding: chunked' is missing." + ) + if not self.supports_chunked_reads(): + raise BodyNotHttplibCompatible( + "Body should be http.client.HTTPResponse like. " + "It should have have an fp attribute which returns raw chunks." + ) + + with self._error_catcher(): + # Don't bother reading the body of a HEAD request. + if self._original_response and is_response_to_head(self._original_response): + self._original_response.close() + return + + # If a response is already read and closed + # then return immediately. + if self._fp.fp is None: + return + + while True: + self._update_chunk_length() + if self.chunk_left == 0: + break + chunk = self._handle_chunk(amt) + decoded = self._decode( + chunk, decode_content=decode_content, flush_decoder=False + ) + if decoded: + yield decoded + + if decode_content: + # On CPython and PyPy, we should never need to flush the + # decoder. However, on Jython we *might* need to, so + # lets defensively do it anyway. + decoded = self._flush_decoder() + if decoded: # Platform-specific: Jython. + yield decoded + + # Chunk content ends with \r\n: discard it. + while True: + line = self._fp.fp.readline() + if not line: + # Some sites may not end with '\r\n'. + break + if line == b"\r\n": + break + + # We read everything; close the "file". + if self._original_response: + self._original_response.close() + + def geturl(self): + """ + Returns the URL that was the source of this response. + If the request that generated this response redirected, this method + will return the final redirect location. + """ + if self.retries is not None and len(self.retries.history): + return self.retries.history[-1].redirect_location + else: + return self._request_url + + def __iter__(self): + buffer = [] + for chunk in self.stream(decode_content=True): + if b"\n" in chunk: + chunk = chunk.split(b"\n") + yield b"".join(buffer) + chunk[0] + b"\n" + for x in chunk[1:-1]: + yield x + b"\n" + if chunk[-1]: + buffer = [chunk[-1]] + else: + buffer = [] + else: + buffer.append(chunk) + if buffer: + yield b"".join(buffer) diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/util/__init__.py b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/util/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..4547fc522b690ba2697843edd044f2039a4123a9 --- /dev/null +++ b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/util/__init__.py @@ -0,0 +1,49 @@ +from __future__ import absolute_import + +# For backwards compatibility, provide imports that used to be here. +from .connection import is_connection_dropped +from .request import SKIP_HEADER, SKIPPABLE_HEADERS, make_headers +from .response import is_fp_closed +from .retry import Retry +from .ssl_ import ( + ALPN_PROTOCOLS, + HAS_SNI, + IS_PYOPENSSL, + IS_SECURETRANSPORT, + PROTOCOL_TLS, + SSLContext, + assert_fingerprint, + resolve_cert_reqs, + resolve_ssl_version, + ssl_wrap_socket, +) +from .timeout import Timeout, current_time +from .url import Url, get_host, parse_url, split_first +from .wait import wait_for_read, wait_for_write + +__all__ = ( + "HAS_SNI", + "IS_PYOPENSSL", + "IS_SECURETRANSPORT", + "SSLContext", + "PROTOCOL_TLS", + "ALPN_PROTOCOLS", + "Retry", + "Timeout", + "Url", + "assert_fingerprint", + "current_time", + "is_connection_dropped", + "is_fp_closed", + "get_host", + "parse_url", + "make_headers", + "resolve_cert_reqs", + "resolve_ssl_version", + "split_first", + "ssl_wrap_socket", + "wait_for_read", + "wait_for_write", + "SKIP_HEADER", + "SKIPPABLE_HEADERS", +) diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/__init__.cpython-310.pyc b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..de27b357556d2b1c5e524a4f891636493dbff1e3 Binary files /dev/null and b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/__init__.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/connection.cpython-310.pyc b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/connection.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..334b707a3cd713ef9e954c53cd3950a9ae0ce589 Binary files /dev/null and b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/connection.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/proxy.cpython-310.pyc b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/proxy.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a5793d4f3bccff196ee216d0e590e2668f10c735 Binary files /dev/null and b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/proxy.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/queue.cpython-310.pyc b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/queue.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..55734cac0ae252ac511a9c77d4b0ab57b6353094 Binary files /dev/null and b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/queue.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/request.cpython-310.pyc b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/request.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..914c3255e9f35b27d77a0d0f6d1a4b39d2049da0 Binary files /dev/null and b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/request.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/response.cpython-310.pyc b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/response.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..531ae58c423aa2d83dccb46c4597d976a9fb9838 Binary files /dev/null and b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/response.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/retry.cpython-310.pyc b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/retry.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f5766cfdecb634f9f352463039dd824ff4370e77 Binary files /dev/null and b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/retry.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/ssl_.cpython-310.pyc b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/ssl_.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b9857e2f7fbb3dc6cf2d0d0e7441c975bc775fc5 Binary files /dev/null and b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/ssl_.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/ssl_match_hostname.cpython-310.pyc b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/ssl_match_hostname.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..dad40a0b76c8c701655e8b5a620f715edbfc3d46 Binary files /dev/null and b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/ssl_match_hostname.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/ssltransport.cpython-310.pyc b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/ssltransport.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..04afd0bee2dc41a5da0ff883cd41ba046ca34f8c Binary files /dev/null and b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/ssltransport.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/timeout.cpython-310.pyc b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/timeout.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5b08142b8fbcd02fded547c30e390b3be7c75848 Binary files /dev/null and b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/timeout.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/url.cpython-310.pyc b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/url.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9a5288fd8b88e937efd51a028c6a809431613329 Binary files /dev/null and b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/url.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/wait.cpython-310.pyc b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/wait.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6e04b6cfa3f7e21221bdd15a089d751a7ccaf202 Binary files /dev/null and b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/util/__pycache__/wait.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/util/connection.py b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/util/connection.py new file mode 100644 index 0000000000000000000000000000000000000000..6af1138f260e4eaaa0aa242f7f50b918a283b49f --- /dev/null +++ b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/util/connection.py @@ -0,0 +1,149 @@ +from __future__ import absolute_import + +import socket + +from ..contrib import _appengine_environ +from ..exceptions import LocationParseError +from ..packages import six +from .wait import NoWayToWaitForSocketError, wait_for_read + + +def is_connection_dropped(conn): # Platform-specific + """ + Returns True if the connection is dropped and should be closed. + + :param conn: + :class:`http.client.HTTPConnection` object. + + Note: For platforms like AppEngine, this will always return ``False`` to + let the platform handle connection recycling transparently for us. + """ + sock = getattr(conn, "sock", False) + if sock is False: # Platform-specific: AppEngine + return False + if sock is None: # Connection already closed (such as by httplib). + return True + try: + # Returns True if readable, which here means it's been dropped + return wait_for_read(sock, timeout=0.0) + except NoWayToWaitForSocketError: # Platform-specific: AppEngine + return False + + +# This function is copied from socket.py in the Python 2.7 standard +# library test suite. Added to its signature is only `socket_options`. +# One additional modification is that we avoid binding to IPv6 servers +# discovered in DNS if the system doesn't have IPv6 functionality. +def create_connection( + address, + timeout=socket._GLOBAL_DEFAULT_TIMEOUT, + source_address=None, + socket_options=None, +): + """Connect to *address* and return the socket object. + + Convenience function. Connect to *address* (a 2-tuple ``(host, + port)``) and return the socket object. Passing the optional + *timeout* parameter will set the timeout on the socket instance + before attempting to connect. If no *timeout* is supplied, the + global default timeout setting returned by :func:`socket.getdefaulttimeout` + is used. If *source_address* is set it must be a tuple of (host, port) + for the socket to bind as a source address before making the connection. + An host of '' or port 0 tells the OS to use the default. + """ + + host, port = address + if host.startswith("["): + host = host.strip("[]") + err = None + + # Using the value from allowed_gai_family() in the context of getaddrinfo lets + # us select whether to work with IPv4 DNS records, IPv6 records, or both. + # The original create_connection function always returns all records. + family = allowed_gai_family() + + try: + host.encode("idna") + except UnicodeError: + return six.raise_from( + LocationParseError(u"'%s', label empty or too long" % host), None + ) + + for res in socket.getaddrinfo(host, port, family, socket.SOCK_STREAM): + af, socktype, proto, canonname, sa = res + sock = None + try: + sock = socket.socket(af, socktype, proto) + + # If provided, set socket level options before connecting. + _set_socket_options(sock, socket_options) + + if timeout is not socket._GLOBAL_DEFAULT_TIMEOUT: + sock.settimeout(timeout) + if source_address: + sock.bind(source_address) + sock.connect(sa) + return sock + + except socket.error as e: + err = e + if sock is not None: + sock.close() + sock = None + + if err is not None: + raise err + + raise socket.error("getaddrinfo returns an empty list") + + +def _set_socket_options(sock, options): + if options is None: + return + + for opt in options: + sock.setsockopt(*opt) + + +def allowed_gai_family(): + """This function is designed to work in the context of + getaddrinfo, where family=socket.AF_UNSPEC is the default and + will perform a DNS search for both IPv6 and IPv4 records.""" + + family = socket.AF_INET + if HAS_IPV6: + family = socket.AF_UNSPEC + return family + + +def _has_ipv6(host): + """Returns True if the system can bind an IPv6 address.""" + sock = None + has_ipv6 = False + + # App Engine doesn't support IPV6 sockets and actually has a quota on the + # number of sockets that can be used, so just early out here instead of + # creating a socket needlessly. + # See https://github.com/urllib3/urllib3/issues/1446 + if _appengine_environ.is_appengine_sandbox(): + return False + + if socket.has_ipv6: + # has_ipv6 returns true if cPython was compiled with IPv6 support. + # It does not tell us if the system has IPv6 support enabled. To + # determine that we must bind to an IPv6 address. + # https://github.com/urllib3/urllib3/pull/611 + # https://bugs.python.org/issue658327 + try: + sock = socket.socket(socket.AF_INET6) + sock.bind((host, 0)) + has_ipv6 = True + except Exception: + pass + + if sock: + sock.close() + return has_ipv6 + + +HAS_IPV6 = _has_ipv6("::1") diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/util/proxy.py b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/util/proxy.py new file mode 100644 index 0000000000000000000000000000000000000000..2199cc7b7f004009493d032720c36d6568f9d89e --- /dev/null +++ b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/util/proxy.py @@ -0,0 +1,57 @@ +from .ssl_ import create_urllib3_context, resolve_cert_reqs, resolve_ssl_version + + +def connection_requires_http_tunnel( + proxy_url=None, proxy_config=None, destination_scheme=None +): + """ + Returns True if the connection requires an HTTP CONNECT through the proxy. + + :param URL proxy_url: + URL of the proxy. + :param ProxyConfig proxy_config: + Proxy configuration from poolmanager.py + :param str destination_scheme: + The scheme of the destination. (i.e https, http, etc) + """ + # If we're not using a proxy, no way to use a tunnel. + if proxy_url is None: + return False + + # HTTP destinations never require tunneling, we always forward. + if destination_scheme == "http": + return False + + # Support for forwarding with HTTPS proxies and HTTPS destinations. + if ( + proxy_url.scheme == "https" + and proxy_config + and proxy_config.use_forwarding_for_https + ): + return False + + # Otherwise always use a tunnel. + return True + + +def create_proxy_ssl_context( + ssl_version, cert_reqs, ca_certs=None, ca_cert_dir=None, ca_cert_data=None +): + """ + Generates a default proxy ssl context if one hasn't been provided by the + user. + """ + ssl_context = create_urllib3_context( + ssl_version=resolve_ssl_version(ssl_version), + cert_reqs=resolve_cert_reqs(cert_reqs), + ) + + if ( + not ca_certs + and not ca_cert_dir + and not ca_cert_data + and hasattr(ssl_context, "load_default_certs") + ): + ssl_context.load_default_certs() + + return ssl_context diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/util/queue.py b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/util/queue.py new file mode 100644 index 0000000000000000000000000000000000000000..41784104ee4bd5796006d1052536325d52db1e8c --- /dev/null +++ b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/util/queue.py @@ -0,0 +1,22 @@ +import collections + +from ..packages import six +from ..packages.six.moves import queue + +if six.PY2: + # Queue is imported for side effects on MS Windows. See issue #229. + import Queue as _unused_module_Queue # noqa: F401 + + +class LifoQueue(queue.Queue): + def _init(self, _): + self.queue = collections.deque() + + def _qsize(self, len=len): + return len(self.queue) + + def _put(self, item): + self.queue.append(item) + + def _get(self): + return self.queue.pop() diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/util/request.py b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/util/request.py new file mode 100644 index 0000000000000000000000000000000000000000..330766ef4f3403e05a6ad8ec30f25fe05fdbc199 --- /dev/null +++ b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/util/request.py @@ -0,0 +1,137 @@ +from __future__ import absolute_import + +from base64 import b64encode + +from ..exceptions import UnrewindableBodyError +from ..packages.six import b, integer_types + +# Pass as a value within ``headers`` to skip +# emitting some HTTP headers that are added automatically. +# The only headers that are supported are ``Accept-Encoding``, +# ``Host``, and ``User-Agent``. +SKIP_HEADER = "@@@SKIP_HEADER@@@" +SKIPPABLE_HEADERS = frozenset(["accept-encoding", "host", "user-agent"]) + +ACCEPT_ENCODING = "gzip,deflate" + +_FAILEDTELL = object() + + +def make_headers( + keep_alive=None, + accept_encoding=None, + user_agent=None, + basic_auth=None, + proxy_basic_auth=None, + disable_cache=None, +): + """ + Shortcuts for generating request headers. + + :param keep_alive: + If ``True``, adds 'connection: keep-alive' header. + + :param accept_encoding: + Can be a boolean, list, or string. + ``True`` translates to 'gzip,deflate'. + List will get joined by comma. + String will be used as provided. + + :param user_agent: + String representing the user-agent you want, such as + "python-urllib3/0.6" + + :param basic_auth: + Colon-separated username:password string for 'authorization: basic ...' + auth header. + + :param proxy_basic_auth: + Colon-separated username:password string for 'proxy-authorization: basic ...' + auth header. + + :param disable_cache: + If ``True``, adds 'cache-control: no-cache' header. + + Example:: + + >>> make_headers(keep_alive=True, user_agent="Batman/1.0") + {'connection': 'keep-alive', 'user-agent': 'Batman/1.0'} + >>> make_headers(accept_encoding=True) + {'accept-encoding': 'gzip,deflate'} + """ + headers = {} + if accept_encoding: + if isinstance(accept_encoding, str): + pass + elif isinstance(accept_encoding, list): + accept_encoding = ",".join(accept_encoding) + else: + accept_encoding = ACCEPT_ENCODING + headers["accept-encoding"] = accept_encoding + + if user_agent: + headers["user-agent"] = user_agent + + if keep_alive: + headers["connection"] = "keep-alive" + + if basic_auth: + headers["authorization"] = "Basic " + b64encode(b(basic_auth)).decode("utf-8") + + if proxy_basic_auth: + headers["proxy-authorization"] = "Basic " + b64encode( + b(proxy_basic_auth) + ).decode("utf-8") + + if disable_cache: + headers["cache-control"] = "no-cache" + + return headers + + +def set_file_position(body, pos): + """ + If a position is provided, move file to that point. + Otherwise, we'll attempt to record a position for future use. + """ + if pos is not None: + rewind_body(body, pos) + elif getattr(body, "tell", None) is not None: + try: + pos = body.tell() + except (IOError, OSError): + # This differentiates from None, allowing us to catch + # a failed `tell()` later when trying to rewind the body. + pos = _FAILEDTELL + + return pos + + +def rewind_body(body, body_pos): + """ + Attempt to rewind body to a certain position. + Primarily used for request redirects and retries. + + :param body: + File-like object that supports seek. + + :param int pos: + Position to seek to in file. + """ + body_seek = getattr(body, "seek", None) + if body_seek is not None and isinstance(body_pos, integer_types): + try: + body_seek(body_pos) + except (IOError, OSError): + raise UnrewindableBodyError( + "An error occurred when rewinding request body for redirect/retry." + ) + elif body_pos is _FAILEDTELL: + raise UnrewindableBodyError( + "Unable to record file position for rewinding " + "request body during a redirect/retry." + ) + else: + raise ValueError( + "body_pos must be of type integer, instead it was %s." % type(body_pos) + ) diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/util/response.py b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/util/response.py new file mode 100644 index 0000000000000000000000000000000000000000..5ea609ccedf18eb4ab70f8fc6990448eb6407237 --- /dev/null +++ b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/util/response.py @@ -0,0 +1,107 @@ +from __future__ import absolute_import + +from email.errors import MultipartInvariantViolationDefect, StartBoundaryNotFoundDefect + +from ..exceptions import HeaderParsingError +from ..packages.six.moves import http_client as httplib + + +def is_fp_closed(obj): + """ + Checks whether a given file-like object is closed. + + :param obj: + The file-like object to check. + """ + + try: + # Check `isclosed()` first, in case Python3 doesn't set `closed`. + # GH Issue #928 + return obj.isclosed() + except AttributeError: + pass + + try: + # Check via the official file-like-object way. + return obj.closed + except AttributeError: + pass + + try: + # Check if the object is a container for another file-like object that + # gets released on exhaustion (e.g. HTTPResponse). + return obj.fp is None + except AttributeError: + pass + + raise ValueError("Unable to determine whether fp is closed.") + + +def assert_header_parsing(headers): + """ + Asserts whether all headers have been successfully parsed. + Extracts encountered errors from the result of parsing headers. + + Only works on Python 3. + + :param http.client.HTTPMessage headers: Headers to verify. + + :raises urllib3.exceptions.HeaderParsingError: + If parsing errors are found. + """ + + # This will fail silently if we pass in the wrong kind of parameter. + # To make debugging easier add an explicit check. + if not isinstance(headers, httplib.HTTPMessage): + raise TypeError("expected httplib.Message, got {0}.".format(type(headers))) + + defects = getattr(headers, "defects", None) + get_payload = getattr(headers, "get_payload", None) + + unparsed_data = None + if get_payload: + # get_payload is actually email.message.Message.get_payload; + # we're only interested in the result if it's not a multipart message + if not headers.is_multipart(): + payload = get_payload() + + if isinstance(payload, (bytes, str)): + unparsed_data = payload + if defects: + # httplib is assuming a response body is available + # when parsing headers even when httplib only sends + # header data to parse_headers() This results in + # defects on multipart responses in particular. + # See: https://github.com/urllib3/urllib3/issues/800 + + # So we ignore the following defects: + # - StartBoundaryNotFoundDefect: + # The claimed start boundary was never found. + # - MultipartInvariantViolationDefect: + # A message claimed to be a multipart but no subparts were found. + defects = [ + defect + for defect in defects + if not isinstance( + defect, (StartBoundaryNotFoundDefect, MultipartInvariantViolationDefect) + ) + ] + + if defects or unparsed_data: + raise HeaderParsingError(defects=defects, unparsed_data=unparsed_data) + + +def is_response_to_head(response): + """ + Checks whether the request of a response has been a HEAD-request. + Handles the quirks of AppEngine. + + :param http.client.HTTPResponse response: + Response to check if the originating request + used 'HEAD' as a method. + """ + # FIXME: Can we do this somehow without accessing private httplib _method? + method = response._method + if isinstance(method, int): # Platform-specific: Appengine + return method == 3 + return method.upper() == "HEAD" diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/util/retry.py b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/util/retry.py new file mode 100644 index 0000000000000000000000000000000000000000..9a1e90d0b236420d7f8b4c5c0325a7c17a1f3703 --- /dev/null +++ b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/util/retry.py @@ -0,0 +1,622 @@ +from __future__ import absolute_import + +import email +import logging +import re +import time +import warnings +from collections import namedtuple +from itertools import takewhile + +from ..exceptions import ( + ConnectTimeoutError, + InvalidHeader, + MaxRetryError, + ProtocolError, + ProxyError, + ReadTimeoutError, + ResponseError, +) +from ..packages import six + +log = logging.getLogger(__name__) + + +# Data structure for representing the metadata of requests that result in a retry. +RequestHistory = namedtuple( + "RequestHistory", ["method", "url", "error", "status", "redirect_location"] +) + + +# TODO: In v2 we can remove this sentinel and metaclass with deprecated options. +_Default = object() + + +class _RetryMeta(type): + @property + def DEFAULT_METHOD_WHITELIST(cls): + warnings.warn( + "Using 'Retry.DEFAULT_METHOD_WHITELIST' is deprecated and " + "will be removed in v2.0. Use 'Retry.DEFAULT_ALLOWED_METHODS' instead", + DeprecationWarning, + ) + return cls.DEFAULT_ALLOWED_METHODS + + @DEFAULT_METHOD_WHITELIST.setter + def DEFAULT_METHOD_WHITELIST(cls, value): + warnings.warn( + "Using 'Retry.DEFAULT_METHOD_WHITELIST' is deprecated and " + "will be removed in v2.0. Use 'Retry.DEFAULT_ALLOWED_METHODS' instead", + DeprecationWarning, + ) + cls.DEFAULT_ALLOWED_METHODS = value + + @property + def DEFAULT_REDIRECT_HEADERS_BLACKLIST(cls): + warnings.warn( + "Using 'Retry.DEFAULT_REDIRECT_HEADERS_BLACKLIST' is deprecated and " + "will be removed in v2.0. Use 'Retry.DEFAULT_REMOVE_HEADERS_ON_REDIRECT' instead", + DeprecationWarning, + ) + return cls.DEFAULT_REMOVE_HEADERS_ON_REDIRECT + + @DEFAULT_REDIRECT_HEADERS_BLACKLIST.setter + def DEFAULT_REDIRECT_HEADERS_BLACKLIST(cls, value): + warnings.warn( + "Using 'Retry.DEFAULT_REDIRECT_HEADERS_BLACKLIST' is deprecated and " + "will be removed in v2.0. Use 'Retry.DEFAULT_REMOVE_HEADERS_ON_REDIRECT' instead", + DeprecationWarning, + ) + cls.DEFAULT_REMOVE_HEADERS_ON_REDIRECT = value + + @property + def BACKOFF_MAX(cls): + warnings.warn( + "Using 'Retry.BACKOFF_MAX' is deprecated and " + "will be removed in v2.0. Use 'Retry.DEFAULT_BACKOFF_MAX' instead", + DeprecationWarning, + ) + return cls.DEFAULT_BACKOFF_MAX + + @BACKOFF_MAX.setter + def BACKOFF_MAX(cls, value): + warnings.warn( + "Using 'Retry.BACKOFF_MAX' is deprecated and " + "will be removed in v2.0. Use 'Retry.DEFAULT_BACKOFF_MAX' instead", + DeprecationWarning, + ) + cls.DEFAULT_BACKOFF_MAX = value + + +@six.add_metaclass(_RetryMeta) +class Retry(object): + """Retry configuration. + + Each retry attempt will create a new Retry object with updated values, so + they can be safely reused. + + Retries can be defined as a default for a pool:: + + retries = Retry(connect=5, read=2, redirect=5) + http = PoolManager(retries=retries) + response = http.request('GET', 'http://example.com/') + + Or per-request (which overrides the default for the pool):: + + response = http.request('GET', 'http://example.com/', retries=Retry(10)) + + Retries can be disabled by passing ``False``:: + + response = http.request('GET', 'http://example.com/', retries=False) + + Errors will be wrapped in :class:`~urllib3.exceptions.MaxRetryError` unless + retries are disabled, in which case the causing exception will be raised. + + :param int total: + Total number of retries to allow. Takes precedence over other counts. + + Set to ``None`` to remove this constraint and fall back on other + counts. + + Set to ``0`` to fail on the first retry. + + Set to ``False`` to disable and imply ``raise_on_redirect=False``. + + :param int connect: + How many connection-related errors to retry on. + + These are errors raised before the request is sent to the remote server, + which we assume has not triggered the server to process the request. + + Set to ``0`` to fail on the first retry of this type. + + :param int read: + How many times to retry on read errors. + + These errors are raised after the request was sent to the server, so the + request may have side-effects. + + Set to ``0`` to fail on the first retry of this type. + + :param int redirect: + How many redirects to perform. Limit this to avoid infinite redirect + loops. + + A redirect is a HTTP response with a status code 301, 302, 303, 307 or + 308. + + Set to ``0`` to fail on the first retry of this type. + + Set to ``False`` to disable and imply ``raise_on_redirect=False``. + + :param int status: + How many times to retry on bad status codes. + + These are retries made on responses, where status code matches + ``status_forcelist``. + + Set to ``0`` to fail on the first retry of this type. + + :param int other: + How many times to retry on other errors. + + Other errors are errors that are not connect, read, redirect or status errors. + These errors might be raised after the request was sent to the server, so the + request might have side-effects. + + Set to ``0`` to fail on the first retry of this type. + + If ``total`` is not set, it's a good idea to set this to 0 to account + for unexpected edge cases and avoid infinite retry loops. + + :param iterable allowed_methods: + Set of uppercased HTTP method verbs that we should retry on. + + By default, we only retry on methods which are considered to be + idempotent (multiple requests with the same parameters end with the + same state). See :attr:`Retry.DEFAULT_ALLOWED_METHODS`. + + Set to a ``False`` value to retry on any verb. + + .. warning:: + + Previously this parameter was named ``method_whitelist``, that + usage is deprecated in v1.26.0 and will be removed in v2.0. + + :param iterable status_forcelist: + A set of integer HTTP status codes that we should force a retry on. + A retry is initiated if the request method is in ``allowed_methods`` + and the response status code is in ``status_forcelist``. + + By default, this is disabled with ``None``. + + :param float backoff_factor: + A backoff factor to apply between attempts after the second try + (most errors are resolved immediately by a second try without a + delay). urllib3 will sleep for:: + + {backoff factor} * (2 ** ({number of total retries} - 1)) + + seconds. If the backoff_factor is 0.1, then :func:`.sleep` will sleep + for [0.0s, 0.2s, 0.4s, ...] between retries. It will never be longer + than :attr:`Retry.DEFAULT_BACKOFF_MAX`. + + By default, backoff is disabled (set to 0). + + :param bool raise_on_redirect: Whether, if the number of redirects is + exhausted, to raise a MaxRetryError, or to return a response with a + response code in the 3xx range. + + :param bool raise_on_status: Similar meaning to ``raise_on_redirect``: + whether we should raise an exception, or return a response, + if status falls in ``status_forcelist`` range and retries have + been exhausted. + + :param tuple history: The history of the request encountered during + each call to :meth:`~Retry.increment`. The list is in the order + the requests occurred. Each list item is of class :class:`RequestHistory`. + + :param bool respect_retry_after_header: + Whether to respect Retry-After header on status codes defined as + :attr:`Retry.RETRY_AFTER_STATUS_CODES` or not. + + :param iterable remove_headers_on_redirect: + Sequence of headers to remove from the request when a response + indicating a redirect is returned before firing off the redirected + request. + """ + + #: Default methods to be used for ``allowed_methods`` + DEFAULT_ALLOWED_METHODS = frozenset( + ["HEAD", "GET", "PUT", "DELETE", "OPTIONS", "TRACE"] + ) + + #: Default status codes to be used for ``status_forcelist`` + RETRY_AFTER_STATUS_CODES = frozenset([413, 429, 503]) + + #: Default headers to be used for ``remove_headers_on_redirect`` + DEFAULT_REMOVE_HEADERS_ON_REDIRECT = frozenset( + ["Cookie", "Authorization", "Proxy-Authorization"] + ) + + #: Maximum backoff time. + DEFAULT_BACKOFF_MAX = 120 + + def __init__( + self, + total=10, + connect=None, + read=None, + redirect=None, + status=None, + other=None, + allowed_methods=_Default, + status_forcelist=None, + backoff_factor=0, + raise_on_redirect=True, + raise_on_status=True, + history=None, + respect_retry_after_header=True, + remove_headers_on_redirect=_Default, + # TODO: Deprecated, remove in v2.0 + method_whitelist=_Default, + ): + + if method_whitelist is not _Default: + if allowed_methods is not _Default: + raise ValueError( + "Using both 'allowed_methods' and " + "'method_whitelist' together is not allowed. " + "Instead only use 'allowed_methods'" + ) + warnings.warn( + "Using 'method_whitelist' with Retry is deprecated and " + "will be removed in v2.0. Use 'allowed_methods' instead", + DeprecationWarning, + stacklevel=2, + ) + allowed_methods = method_whitelist + if allowed_methods is _Default: + allowed_methods = self.DEFAULT_ALLOWED_METHODS + if remove_headers_on_redirect is _Default: + remove_headers_on_redirect = self.DEFAULT_REMOVE_HEADERS_ON_REDIRECT + + self.total = total + self.connect = connect + self.read = read + self.status = status + self.other = other + + if redirect is False or total is False: + redirect = 0 + raise_on_redirect = False + + self.redirect = redirect + self.status_forcelist = status_forcelist or set() + self.allowed_methods = allowed_methods + self.backoff_factor = backoff_factor + self.raise_on_redirect = raise_on_redirect + self.raise_on_status = raise_on_status + self.history = history or tuple() + self.respect_retry_after_header = respect_retry_after_header + self.remove_headers_on_redirect = frozenset( + [h.lower() for h in remove_headers_on_redirect] + ) + + def new(self, **kw): + params = dict( + total=self.total, + connect=self.connect, + read=self.read, + redirect=self.redirect, + status=self.status, + other=self.other, + status_forcelist=self.status_forcelist, + backoff_factor=self.backoff_factor, + raise_on_redirect=self.raise_on_redirect, + raise_on_status=self.raise_on_status, + history=self.history, + remove_headers_on_redirect=self.remove_headers_on_redirect, + respect_retry_after_header=self.respect_retry_after_header, + ) + + # TODO: If already given in **kw we use what's given to us + # If not given we need to figure out what to pass. We decide + # based on whether our class has the 'method_whitelist' property + # and if so we pass the deprecated 'method_whitelist' otherwise + # we use 'allowed_methods'. Remove in v2.0 + if "method_whitelist" not in kw and "allowed_methods" not in kw: + if "method_whitelist" in self.__dict__: + warnings.warn( + "Using 'method_whitelist' with Retry is deprecated and " + "will be removed in v2.0. Use 'allowed_methods' instead", + DeprecationWarning, + ) + params["method_whitelist"] = self.allowed_methods + else: + params["allowed_methods"] = self.allowed_methods + + params.update(kw) + return type(self)(**params) + + @classmethod + def from_int(cls, retries, redirect=True, default=None): + """Backwards-compatibility for the old retries format.""" + if retries is None: + retries = default if default is not None else cls.DEFAULT + + if isinstance(retries, Retry): + return retries + + redirect = bool(redirect) and None + new_retries = cls(retries, redirect=redirect) + log.debug("Converted retries value: %r -> %r", retries, new_retries) + return new_retries + + def get_backoff_time(self): + """Formula for computing the current backoff + + :rtype: float + """ + # We want to consider only the last consecutive errors sequence (Ignore redirects). + consecutive_errors_len = len( + list( + takewhile(lambda x: x.redirect_location is None, reversed(self.history)) + ) + ) + if consecutive_errors_len <= 1: + return 0 + + backoff_value = self.backoff_factor * (2 ** (consecutive_errors_len - 1)) + return min(self.DEFAULT_BACKOFF_MAX, backoff_value) + + def parse_retry_after(self, retry_after): + # Whitespace: https://tools.ietf.org/html/rfc7230#section-3.2.4 + if re.match(r"^\s*[0-9]+\s*$", retry_after): + seconds = int(retry_after) + else: + retry_date_tuple = email.utils.parsedate_tz(retry_after) + if retry_date_tuple is None: + raise InvalidHeader("Invalid Retry-After header: %s" % retry_after) + if retry_date_tuple[9] is None: # Python 2 + # Assume UTC if no timezone was specified + # On Python2.7, parsedate_tz returns None for a timezone offset + # instead of 0 if no timezone is given, where mktime_tz treats + # a None timezone offset as local time. + retry_date_tuple = retry_date_tuple[:9] + (0,) + retry_date_tuple[10:] + + retry_date = email.utils.mktime_tz(retry_date_tuple) + seconds = retry_date - time.time() + + if seconds < 0: + seconds = 0 + + return seconds + + def get_retry_after(self, response): + """Get the value of Retry-After in seconds.""" + + retry_after = response.headers.get("Retry-After") + + if retry_after is None: + return None + + return self.parse_retry_after(retry_after) + + def sleep_for_retry(self, response=None): + retry_after = self.get_retry_after(response) + if retry_after: + time.sleep(retry_after) + return True + + return False + + def _sleep_backoff(self): + backoff = self.get_backoff_time() + if backoff <= 0: + return + time.sleep(backoff) + + def sleep(self, response=None): + """Sleep between retry attempts. + + This method will respect a server's ``Retry-After`` response header + and sleep the duration of the time requested. If that is not present, it + will use an exponential backoff. By default, the backoff factor is 0 and + this method will return immediately. + """ + + if self.respect_retry_after_header and response: + slept = self.sleep_for_retry(response) + if slept: + return + + self._sleep_backoff() + + def _is_connection_error(self, err): + """Errors when we're fairly sure that the server did not receive the + request, so it should be safe to retry. + """ + if isinstance(err, ProxyError): + err = err.original_error + return isinstance(err, ConnectTimeoutError) + + def _is_read_error(self, err): + """Errors that occur after the request has been started, so we should + assume that the server began processing it. + """ + return isinstance(err, (ReadTimeoutError, ProtocolError)) + + def _is_method_retryable(self, method): + """Checks if a given HTTP method should be retried upon, depending if + it is included in the allowed_methods + """ + # TODO: For now favor if the Retry implementation sets its own method_whitelist + # property outside of our constructor to avoid breaking custom implementations. + if "method_whitelist" in self.__dict__: + warnings.warn( + "Using 'method_whitelist' with Retry is deprecated and " + "will be removed in v2.0. Use 'allowed_methods' instead", + DeprecationWarning, + ) + allowed_methods = self.method_whitelist + else: + allowed_methods = self.allowed_methods + + if allowed_methods and method.upper() not in allowed_methods: + return False + return True + + def is_retry(self, method, status_code, has_retry_after=False): + """Is this method/status code retryable? (Based on allowlists and control + variables such as the number of total retries to allow, whether to + respect the Retry-After header, whether this header is present, and + whether the returned status code is on the list of status codes to + be retried upon on the presence of the aforementioned header) + """ + if not self._is_method_retryable(method): + return False + + if self.status_forcelist and status_code in self.status_forcelist: + return True + + return ( + self.total + and self.respect_retry_after_header + and has_retry_after + and (status_code in self.RETRY_AFTER_STATUS_CODES) + ) + + def is_exhausted(self): + """Are we out of retries?""" + retry_counts = ( + self.total, + self.connect, + self.read, + self.redirect, + self.status, + self.other, + ) + retry_counts = list(filter(None, retry_counts)) + if not retry_counts: + return False + + return min(retry_counts) < 0 + + def increment( + self, + method=None, + url=None, + response=None, + error=None, + _pool=None, + _stacktrace=None, + ): + """Return a new Retry object with incremented retry counters. + + :param response: A response object, or None, if the server did not + return a response. + :type response: :class:`~urllib3.response.HTTPResponse` + :param Exception error: An error encountered during the request, or + None if the response was received successfully. + + :return: A new ``Retry`` object. + """ + if self.total is False and error: + # Disabled, indicate to re-raise the error. + raise six.reraise(type(error), error, _stacktrace) + + total = self.total + if total is not None: + total -= 1 + + connect = self.connect + read = self.read + redirect = self.redirect + status_count = self.status + other = self.other + cause = "unknown" + status = None + redirect_location = None + + if error and self._is_connection_error(error): + # Connect retry? + if connect is False: + raise six.reraise(type(error), error, _stacktrace) + elif connect is not None: + connect -= 1 + + elif error and self._is_read_error(error): + # Read retry? + if read is False or not self._is_method_retryable(method): + raise six.reraise(type(error), error, _stacktrace) + elif read is not None: + read -= 1 + + elif error: + # Other retry? + if other is not None: + other -= 1 + + elif response and response.get_redirect_location(): + # Redirect retry? + if redirect is not None: + redirect -= 1 + cause = "too many redirects" + redirect_location = response.get_redirect_location() + status = response.status + + else: + # Incrementing because of a server error like a 500 in + # status_forcelist and the given method is in the allowed_methods + cause = ResponseError.GENERIC_ERROR + if response and response.status: + if status_count is not None: + status_count -= 1 + cause = ResponseError.SPECIFIC_ERROR.format(status_code=response.status) + status = response.status + + history = self.history + ( + RequestHistory(method, url, error, status, redirect_location), + ) + + new_retry = self.new( + total=total, + connect=connect, + read=read, + redirect=redirect, + status=status_count, + other=other, + history=history, + ) + + if new_retry.is_exhausted(): + raise MaxRetryError(_pool, url, error or ResponseError(cause)) + + log.debug("Incremented Retry for (url='%s'): %r", url, new_retry) + + return new_retry + + def __repr__(self): + return ( + "{cls.__name__}(total={self.total}, connect={self.connect}, " + "read={self.read}, redirect={self.redirect}, status={self.status})" + ).format(cls=type(self), self=self) + + def __getattr__(self, item): + if item == "method_whitelist": + # TODO: Remove this deprecated alias in v2.0 + warnings.warn( + "Using 'method_whitelist' with Retry is deprecated and " + "will be removed in v2.0. Use 'allowed_methods' instead", + DeprecationWarning, + ) + return self.allowed_methods + try: + return getattr(super(Retry, self), item) + except AttributeError: + return getattr(Retry, item) + + +# For backwards compatibility (equivalent to pre-v1.9): +Retry.DEFAULT = Retry(3) diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/util/ssl_.py b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/util/ssl_.py new file mode 100644 index 0000000000000000000000000000000000000000..0a6a0e06a0d4dbd2c918782f8eda310ba3feca12 --- /dev/null +++ b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/util/ssl_.py @@ -0,0 +1,504 @@ +from __future__ import absolute_import + +import hashlib +import hmac +import os +import sys +import warnings +from binascii import hexlify, unhexlify + +from ..exceptions import ( + InsecurePlatformWarning, + ProxySchemeUnsupported, + SNIMissingWarning, + SSLError, +) +from ..packages import six +from .url import BRACELESS_IPV6_ADDRZ_RE, IPV4_RE + +SSLContext = None +SSLTransport = None +HAS_SNI = False +IS_PYOPENSSL = False +IS_SECURETRANSPORT = False +ALPN_PROTOCOLS = ["http/1.1"] + +# Maps the length of a digest to a possible hash function producing this digest +HASHFUNC_MAP = { + length: getattr(hashlib, algorithm, None) + for length, algorithm in ((32, "md5"), (40, "sha1"), (64, "sha256")) +} + + +def _const_compare_digest_backport(a, b): + """ + Compare two digests of equal length in constant time. + + The digests must be of type str/bytes. + Returns True if the digests match, and False otherwise. + """ + result = abs(len(a) - len(b)) + for left, right in zip(bytearray(a), bytearray(b)): + result |= left ^ right + return result == 0 + + +_const_compare_digest = getattr(hmac, "compare_digest", _const_compare_digest_backport) + +try: # Test for SSL features + import ssl + from ssl import CERT_REQUIRED, wrap_socket +except ImportError: + pass + +try: + from ssl import HAS_SNI # Has SNI? +except ImportError: + pass + +try: + from .ssltransport import SSLTransport +except ImportError: + pass + + +try: # Platform-specific: Python 3.6 + from ssl import PROTOCOL_TLS + + PROTOCOL_SSLv23 = PROTOCOL_TLS +except ImportError: + try: + from ssl import PROTOCOL_SSLv23 as PROTOCOL_TLS + + PROTOCOL_SSLv23 = PROTOCOL_TLS + except ImportError: + PROTOCOL_SSLv23 = PROTOCOL_TLS = 2 + +try: + from ssl import PROTOCOL_TLS_CLIENT +except ImportError: + PROTOCOL_TLS_CLIENT = PROTOCOL_TLS + + +try: + from ssl import OP_NO_COMPRESSION, OP_NO_SSLv2, OP_NO_SSLv3 +except ImportError: + OP_NO_SSLv2, OP_NO_SSLv3 = 0x1000000, 0x2000000 + OP_NO_COMPRESSION = 0x20000 + + +try: # OP_NO_TICKET was added in Python 3.6 + from ssl import OP_NO_TICKET +except ImportError: + OP_NO_TICKET = 0x4000 + + +# A secure default. +# Sources for more information on TLS ciphers: +# +# - https://wiki.mozilla.org/Security/Server_Side_TLS +# - https://www.ssllabs.com/projects/best-practices/index.html +# - https://hynek.me/articles/hardening-your-web-servers-ssl-ciphers/ +# +# The general intent is: +# - prefer cipher suites that offer perfect forward secrecy (DHE/ECDHE), +# - prefer ECDHE over DHE for better performance, +# - prefer any AES-GCM and ChaCha20 over any AES-CBC for better performance and +# security, +# - prefer AES-GCM over ChaCha20 because hardware-accelerated AES is common, +# - disable NULL authentication, MD5 MACs, DSS, and other +# insecure ciphers for security reasons. +# - NOTE: TLS 1.3 cipher suites are managed through a different interface +# not exposed by CPython (yet!) and are enabled by default if they're available. +DEFAULT_CIPHERS = ":".join( + [ + "ECDHE+AESGCM", + "ECDHE+CHACHA20", + "DHE+AESGCM", + "DHE+CHACHA20", + "ECDH+AESGCM", + "DH+AESGCM", + "ECDH+AES", + "DH+AES", + "RSA+AESGCM", + "RSA+AES", + "!aNULL", + "!eNULL", + "!MD5", + "!DSS", + ] +) + +try: + from ssl import SSLContext # Modern SSL? +except ImportError: + + class SSLContext(object): # Platform-specific: Python 2 + def __init__(self, protocol_version): + self.protocol = protocol_version + # Use default values from a real SSLContext + self.check_hostname = False + self.verify_mode = ssl.CERT_NONE + self.ca_certs = None + self.options = 0 + self.certfile = None + self.keyfile = None + self.ciphers = None + + def load_cert_chain(self, certfile, keyfile): + self.certfile = certfile + self.keyfile = keyfile + + def load_verify_locations(self, cafile=None, capath=None, cadata=None): + self.ca_certs = cafile + + if capath is not None: + raise SSLError("CA directories not supported in older Pythons") + + if cadata is not None: + raise SSLError("CA data not supported in older Pythons") + + def set_ciphers(self, cipher_suite): + self.ciphers = cipher_suite + + def wrap_socket(self, socket, server_hostname=None, server_side=False): + warnings.warn( + "A true SSLContext object is not available. This prevents " + "urllib3 from configuring SSL appropriately and may cause " + "certain SSL connections to fail. You can upgrade to a newer " + "version of Python to solve this. For more information, see " + "https://urllib3.readthedocs.io/en/1.26.x/advanced-usage.html" + "#ssl-warnings", + InsecurePlatformWarning, + ) + kwargs = { + "keyfile": self.keyfile, + "certfile": self.certfile, + "ca_certs": self.ca_certs, + "cert_reqs": self.verify_mode, + "ssl_version": self.protocol, + "server_side": server_side, + } + return wrap_socket(socket, ciphers=self.ciphers, **kwargs) + + +def assert_fingerprint(cert, fingerprint): + """ + Checks if given fingerprint matches the supplied certificate. + + :param cert: + Certificate as bytes object. + :param fingerprint: + Fingerprint as string of hexdigits, can be interspersed by colons. + """ + + fingerprint = fingerprint.replace(":", "").lower() + digest_length = len(fingerprint) + if digest_length not in HASHFUNC_MAP: + raise SSLError("Fingerprint of invalid length: {0}".format(fingerprint)) + hashfunc = HASHFUNC_MAP.get(digest_length) + if hashfunc is None: + raise SSLError( + "Hash function implementation unavailable for fingerprint length: {0}".format( + digest_length + ) + ) + + # We need encode() here for py32; works on py2 and p33. + fingerprint_bytes = unhexlify(fingerprint.encode()) + + cert_digest = hashfunc(cert).digest() + + if not _const_compare_digest(cert_digest, fingerprint_bytes): + raise SSLError( + 'Fingerprints did not match. Expected "{0}", got "{1}".'.format( + fingerprint, hexlify(cert_digest) + ) + ) + + +def resolve_cert_reqs(candidate): + """ + Resolves the argument to a numeric constant, which can be passed to + the wrap_socket function/method from the ssl module. + Defaults to :data:`ssl.CERT_REQUIRED`. + If given a string it is assumed to be the name of the constant in the + :mod:`ssl` module or its abbreviation. + (So you can specify `REQUIRED` instead of `CERT_REQUIRED`. + If it's neither `None` nor a string we assume it is already the numeric + constant which can directly be passed to wrap_socket. + """ + if candidate is None: + return CERT_REQUIRED + + if isinstance(candidate, str): + res = getattr(ssl, candidate, None) + if res is None: + res = getattr(ssl, "CERT_" + candidate) + return res + + return candidate + + +def resolve_ssl_version(candidate): + """ + like resolve_cert_reqs + """ + if candidate is None: + return PROTOCOL_TLS + + if isinstance(candidate, str): + res = getattr(ssl, candidate, None) + if res is None: + res = getattr(ssl, "PROTOCOL_" + candidate) + return res + + return candidate + + +def create_urllib3_context( + ssl_version=None, cert_reqs=None, options=None, ciphers=None +): + """All arguments have the same meaning as ``ssl_wrap_socket``. + + By default, this function does a lot of the same work that + ``ssl.create_default_context`` does on Python 3.4+. It: + + - Disables SSLv2, SSLv3, and compression + - Sets a restricted set of server ciphers + + If you wish to enable SSLv3, you can do:: + + from pip._vendor.urllib3.util import ssl_ + context = ssl_.create_urllib3_context() + context.options &= ~ssl_.OP_NO_SSLv3 + + You can do the same to enable compression (substituting ``COMPRESSION`` + for ``SSLv3`` in the last line above). + + :param ssl_version: + The desired protocol version to use. This will default to + PROTOCOL_SSLv23 which will negotiate the highest protocol that both + the server and your installation of OpenSSL support. + :param cert_reqs: + Whether to require the certificate verification. This defaults to + ``ssl.CERT_REQUIRED``. + :param options: + Specific OpenSSL options. These default to ``ssl.OP_NO_SSLv2``, + ``ssl.OP_NO_SSLv3``, ``ssl.OP_NO_COMPRESSION``, and ``ssl.OP_NO_TICKET``. + :param ciphers: + Which cipher suites to allow the server to select. + :returns: + Constructed SSLContext object with specified options + :rtype: SSLContext + """ + # PROTOCOL_TLS is deprecated in Python 3.10 + if not ssl_version or ssl_version == PROTOCOL_TLS: + ssl_version = PROTOCOL_TLS_CLIENT + + context = SSLContext(ssl_version) + + context.set_ciphers(ciphers or DEFAULT_CIPHERS) + + # Setting the default here, as we may have no ssl module on import + cert_reqs = ssl.CERT_REQUIRED if cert_reqs is None else cert_reqs + + if options is None: + options = 0 + # SSLv2 is easily broken and is considered harmful and dangerous + options |= OP_NO_SSLv2 + # SSLv3 has several problems and is now dangerous + options |= OP_NO_SSLv3 + # Disable compression to prevent CRIME attacks for OpenSSL 1.0+ + # (issue #309) + options |= OP_NO_COMPRESSION + # TLSv1.2 only. Unless set explicitly, do not request tickets. + # This may save some bandwidth on wire, and although the ticket is encrypted, + # there is a risk associated with it being on wire, + # if the server is not rotating its ticketing keys properly. + options |= OP_NO_TICKET + + context.options |= options + + # Enable post-handshake authentication for TLS 1.3, see GH #1634. PHA is + # necessary for conditional client cert authentication with TLS 1.3. + # The attribute is None for OpenSSL <= 1.1.0 or does not exist in older + # versions of Python. We only enable on Python 3.7.4+ or if certificate + # verification is enabled to work around Python issue #37428 + # See: https://bugs.python.org/issue37428 + if (cert_reqs == ssl.CERT_REQUIRED or sys.version_info >= (3, 7, 4)) and getattr( + context, "post_handshake_auth", None + ) is not None: + context.post_handshake_auth = True + + def disable_check_hostname(): + if ( + getattr(context, "check_hostname", None) is not None + ): # Platform-specific: Python 3.2 + # We do our own verification, including fingerprints and alternative + # hostnames. So disable it here + context.check_hostname = False + + # The order of the below lines setting verify_mode and check_hostname + # matter due to safe-guards SSLContext has to prevent an SSLContext with + # check_hostname=True, verify_mode=NONE/OPTIONAL. This is made even more + # complex because we don't know whether PROTOCOL_TLS_CLIENT will be used + # or not so we don't know the initial state of the freshly created SSLContext. + if cert_reqs == ssl.CERT_REQUIRED: + context.verify_mode = cert_reqs + disable_check_hostname() + else: + disable_check_hostname() + context.verify_mode = cert_reqs + + # Enable logging of TLS session keys via defacto standard environment variable + # 'SSLKEYLOGFILE', if the feature is available (Python 3.8+). Skip empty values. + if hasattr(context, "keylog_filename"): + sslkeylogfile = os.environ.get("SSLKEYLOGFILE") + if sslkeylogfile: + context.keylog_filename = sslkeylogfile + + return context + + +def ssl_wrap_socket( + sock, + keyfile=None, + certfile=None, + cert_reqs=None, + ca_certs=None, + server_hostname=None, + ssl_version=None, + ciphers=None, + ssl_context=None, + ca_cert_dir=None, + key_password=None, + ca_cert_data=None, + tls_in_tls=False, +): + """ + All arguments except for server_hostname, ssl_context, and ca_cert_dir have + the same meaning as they do when using :func:`ssl.wrap_socket`. + + :param server_hostname: + When SNI is supported, the expected hostname of the certificate + :param ssl_context: + A pre-made :class:`SSLContext` object. If none is provided, one will + be created using :func:`create_urllib3_context`. + :param ciphers: + A string of ciphers we wish the client to support. + :param ca_cert_dir: + A directory containing CA certificates in multiple separate files, as + supported by OpenSSL's -CApath flag or the capath argument to + SSLContext.load_verify_locations(). + :param key_password: + Optional password if the keyfile is encrypted. + :param ca_cert_data: + Optional string containing CA certificates in PEM format suitable for + passing as the cadata parameter to SSLContext.load_verify_locations() + :param tls_in_tls: + Use SSLTransport to wrap the existing socket. + """ + context = ssl_context + if context is None: + # Note: This branch of code and all the variables in it are no longer + # used by urllib3 itself. We should consider deprecating and removing + # this code. + context = create_urllib3_context(ssl_version, cert_reqs, ciphers=ciphers) + + if ca_certs or ca_cert_dir or ca_cert_data: + try: + context.load_verify_locations(ca_certs, ca_cert_dir, ca_cert_data) + except (IOError, OSError) as e: + raise SSLError(e) + + elif ssl_context is None and hasattr(context, "load_default_certs"): + # try to load OS default certs; works well on Windows (require Python3.4+) + context.load_default_certs() + + # Attempt to detect if we get the goofy behavior of the + # keyfile being encrypted and OpenSSL asking for the + # passphrase via the terminal and instead error out. + if keyfile and key_password is None and _is_key_file_encrypted(keyfile): + raise SSLError("Client private key is encrypted, password is required") + + if certfile: + if key_password is None: + context.load_cert_chain(certfile, keyfile) + else: + context.load_cert_chain(certfile, keyfile, key_password) + + try: + if hasattr(context, "set_alpn_protocols"): + context.set_alpn_protocols(ALPN_PROTOCOLS) + except NotImplementedError: # Defensive: in CI, we always have set_alpn_protocols + pass + + # If we detect server_hostname is an IP address then the SNI + # extension should not be used according to RFC3546 Section 3.1 + use_sni_hostname = server_hostname and not is_ipaddress(server_hostname) + # SecureTransport uses server_hostname in certificate verification. + send_sni = (use_sni_hostname and HAS_SNI) or ( + IS_SECURETRANSPORT and server_hostname + ) + # Do not warn the user if server_hostname is an invalid SNI hostname. + if not HAS_SNI and use_sni_hostname: + warnings.warn( + "An HTTPS request has been made, but the SNI (Server Name " + "Indication) extension to TLS is not available on this platform. " + "This may cause the server to present an incorrect TLS " + "certificate, which can cause validation failures. You can upgrade to " + "a newer version of Python to solve this. For more information, see " + "https://urllib3.readthedocs.io/en/1.26.x/advanced-usage.html" + "#ssl-warnings", + SNIMissingWarning, + ) + + if send_sni: + ssl_sock = _ssl_wrap_socket_impl( + sock, context, tls_in_tls, server_hostname=server_hostname + ) + else: + ssl_sock = _ssl_wrap_socket_impl(sock, context, tls_in_tls) + return ssl_sock + + +def is_ipaddress(hostname): + """Detects whether the hostname given is an IPv4 or IPv6 address. + Also detects IPv6 addresses with Zone IDs. + + :param str hostname: Hostname to examine. + :return: True if the hostname is an IP address, False otherwise. + """ + if not six.PY2 and isinstance(hostname, bytes): + # IDN A-label bytes are ASCII compatible. + hostname = hostname.decode("ascii") + return bool(IPV4_RE.match(hostname) or BRACELESS_IPV6_ADDRZ_RE.match(hostname)) + + +def _is_key_file_encrypted(key_file): + """Detects if a key file is encrypted or not.""" + with open(key_file, "r") as f: + for line in f: + # Look for Proc-Type: 4,ENCRYPTED + if "ENCRYPTED" in line: + return True + + return False + + +def _ssl_wrap_socket_impl(sock, ssl_context, tls_in_tls, server_hostname=None): + if tls_in_tls: + if not SSLTransport: + # Import error, ssl is not available. + raise ProxySchemeUnsupported( + "TLS in TLS requires support for the 'ssl' module" + ) + + SSLTransport._validate_ssl_context_for_tls_in_tls(ssl_context) + return SSLTransport(sock, ssl_context, server_hostname) + + if server_hostname: + return ssl_context.wrap_socket(sock, server_hostname=server_hostname) + else: + return ssl_context.wrap_socket(sock) diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/util/ssl_match_hostname.py b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/util/ssl_match_hostname.py new file mode 100644 index 0000000000000000000000000000000000000000..1dd950c489607d06ecc5218292a1b55558b47be8 --- /dev/null +++ b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/util/ssl_match_hostname.py @@ -0,0 +1,159 @@ +"""The match_hostname() function from Python 3.3.3, essential when using SSL.""" + +# Note: This file is under the PSF license as the code comes from the python +# stdlib. http://docs.python.org/3/license.html + +import re +import sys + +# ipaddress has been backported to 2.6+ in pypi. If it is installed on the +# system, use it to handle IPAddress ServerAltnames (this was added in +# python-3.5) otherwise only do DNS matching. This allows +# util.ssl_match_hostname to continue to be used in Python 2.7. +try: + import ipaddress +except ImportError: + ipaddress = None + +__version__ = "3.5.0.1" + + +class CertificateError(ValueError): + pass + + +def _dnsname_match(dn, hostname, max_wildcards=1): + """Matching according to RFC 6125, section 6.4.3 + + http://tools.ietf.org/html/rfc6125#section-6.4.3 + """ + pats = [] + if not dn: + return False + + # Ported from python3-syntax: + # leftmost, *remainder = dn.split(r'.') + parts = dn.split(r".") + leftmost = parts[0] + remainder = parts[1:] + + wildcards = leftmost.count("*") + if wildcards > max_wildcards: + # Issue #17980: avoid denials of service by refusing more + # than one wildcard per fragment. A survey of established + # policy among SSL implementations showed it to be a + # reasonable choice. + raise CertificateError( + "too many wildcards in certificate DNS name: " + repr(dn) + ) + + # speed up common case w/o wildcards + if not wildcards: + return dn.lower() == hostname.lower() + + # RFC 6125, section 6.4.3, subitem 1. + # The client SHOULD NOT attempt to match a presented identifier in which + # the wildcard character comprises a label other than the left-most label. + if leftmost == "*": + # When '*' is a fragment by itself, it matches a non-empty dotless + # fragment. + pats.append("[^.]+") + elif leftmost.startswith("xn--") or hostname.startswith("xn--"): + # RFC 6125, section 6.4.3, subitem 3. + # The client SHOULD NOT attempt to match a presented identifier + # where the wildcard character is embedded within an A-label or + # U-label of an internationalized domain name. + pats.append(re.escape(leftmost)) + else: + # Otherwise, '*' matches any dotless string, e.g. www* + pats.append(re.escape(leftmost).replace(r"\*", "[^.]*")) + + # add the remaining fragments, ignore any wildcards + for frag in remainder: + pats.append(re.escape(frag)) + + pat = re.compile(r"\A" + r"\.".join(pats) + r"\Z", re.IGNORECASE) + return pat.match(hostname) + + +def _to_unicode(obj): + if isinstance(obj, str) and sys.version_info < (3,): + # ignored flake8 # F821 to support python 2.7 function + obj = unicode(obj, encoding="ascii", errors="strict") # noqa: F821 + return obj + + +def _ipaddress_match(ipname, host_ip): + """Exact matching of IP addresses. + + RFC 6125 explicitly doesn't define an algorithm for this + (section 1.7.2 - "Out of Scope"). + """ + # OpenSSL may add a trailing newline to a subjectAltName's IP address + # Divergence from upstream: ipaddress can't handle byte str + ip = ipaddress.ip_address(_to_unicode(ipname).rstrip()) + return ip == host_ip + + +def match_hostname(cert, hostname): + """Verify that *cert* (in decoded format as returned by + SSLSocket.getpeercert()) matches the *hostname*. RFC 2818 and RFC 6125 + rules are followed, but IP addresses are not accepted for *hostname*. + + CertificateError is raised on failure. On success, the function + returns nothing. + """ + if not cert: + raise ValueError( + "empty or no certificate, match_hostname needs a " + "SSL socket or SSL context with either " + "CERT_OPTIONAL or CERT_REQUIRED" + ) + try: + # Divergence from upstream: ipaddress can't handle byte str + host_ip = ipaddress.ip_address(_to_unicode(hostname)) + except (UnicodeError, ValueError): + # ValueError: Not an IP address (common case) + # UnicodeError: Divergence from upstream: Have to deal with ipaddress not taking + # byte strings. addresses should be all ascii, so we consider it not + # an ipaddress in this case + host_ip = None + except AttributeError: + # Divergence from upstream: Make ipaddress library optional + if ipaddress is None: + host_ip = None + else: # Defensive + raise + dnsnames = [] + san = cert.get("subjectAltName", ()) + for key, value in san: + if key == "DNS": + if host_ip is None and _dnsname_match(value, hostname): + return + dnsnames.append(value) + elif key == "IP Address": + if host_ip is not None and _ipaddress_match(value, host_ip): + return + dnsnames.append(value) + if not dnsnames: + # The subject is only checked when there is no dNSName entry + # in subjectAltName + for sub in cert.get("subject", ()): + for key, value in sub: + # XXX according to RFC 2818, the most specific Common Name + # must be used. + if key == "commonName": + if _dnsname_match(value, hostname): + return + dnsnames.append(value) + if len(dnsnames) > 1: + raise CertificateError( + "hostname %r " + "doesn't match either of %s" % (hostname, ", ".join(map(repr, dnsnames))) + ) + elif len(dnsnames) == 1: + raise CertificateError("hostname %r doesn't match %r" % (hostname, dnsnames[0])) + else: + raise CertificateError( + "no appropriate commonName or subjectAltName fields were found" + ) diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/util/ssltransport.py b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/util/ssltransport.py new file mode 100644 index 0000000000000000000000000000000000000000..4a7105d17916a7237f3df6e59d65ca82375f8803 --- /dev/null +++ b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/util/ssltransport.py @@ -0,0 +1,221 @@ +import io +import socket +import ssl + +from ..exceptions import ProxySchemeUnsupported +from ..packages import six + +SSL_BLOCKSIZE = 16384 + + +class SSLTransport: + """ + The SSLTransport wraps an existing socket and establishes an SSL connection. + + Contrary to Python's implementation of SSLSocket, it allows you to chain + multiple TLS connections together. It's particularly useful if you need to + implement TLS within TLS. + + The class supports most of the socket API operations. + """ + + @staticmethod + def _validate_ssl_context_for_tls_in_tls(ssl_context): + """ + Raises a ProxySchemeUnsupported if the provided ssl_context can't be used + for TLS in TLS. + + The only requirement is that the ssl_context provides the 'wrap_bio' + methods. + """ + + if not hasattr(ssl_context, "wrap_bio"): + if six.PY2: + raise ProxySchemeUnsupported( + "TLS in TLS requires SSLContext.wrap_bio() which isn't " + "supported on Python 2" + ) + else: + raise ProxySchemeUnsupported( + "TLS in TLS requires SSLContext.wrap_bio() which isn't " + "available on non-native SSLContext" + ) + + def __init__( + self, socket, ssl_context, server_hostname=None, suppress_ragged_eofs=True + ): + """ + Create an SSLTransport around socket using the provided ssl_context. + """ + self.incoming = ssl.MemoryBIO() + self.outgoing = ssl.MemoryBIO() + + self.suppress_ragged_eofs = suppress_ragged_eofs + self.socket = socket + + self.sslobj = ssl_context.wrap_bio( + self.incoming, self.outgoing, server_hostname=server_hostname + ) + + # Perform initial handshake. + self._ssl_io_loop(self.sslobj.do_handshake) + + def __enter__(self): + return self + + def __exit__(self, *_): + self.close() + + def fileno(self): + return self.socket.fileno() + + def read(self, len=1024, buffer=None): + return self._wrap_ssl_read(len, buffer) + + def recv(self, len=1024, flags=0): + if flags != 0: + raise ValueError("non-zero flags not allowed in calls to recv") + return self._wrap_ssl_read(len) + + def recv_into(self, buffer, nbytes=None, flags=0): + if flags != 0: + raise ValueError("non-zero flags not allowed in calls to recv_into") + if buffer and (nbytes is None): + nbytes = len(buffer) + elif nbytes is None: + nbytes = 1024 + return self.read(nbytes, buffer) + + def sendall(self, data, flags=0): + if flags != 0: + raise ValueError("non-zero flags not allowed in calls to sendall") + count = 0 + with memoryview(data) as view, view.cast("B") as byte_view: + amount = len(byte_view) + while count < amount: + v = self.send(byte_view[count:]) + count += v + + def send(self, data, flags=0): + if flags != 0: + raise ValueError("non-zero flags not allowed in calls to send") + response = self._ssl_io_loop(self.sslobj.write, data) + return response + + def makefile( + self, mode="r", buffering=None, encoding=None, errors=None, newline=None + ): + """ + Python's httpclient uses makefile and buffered io when reading HTTP + messages and we need to support it. + + This is unfortunately a copy and paste of socket.py makefile with small + changes to point to the socket directly. + """ + if not set(mode) <= {"r", "w", "b"}: + raise ValueError("invalid mode %r (only r, w, b allowed)" % (mode,)) + + writing = "w" in mode + reading = "r" in mode or not writing + assert reading or writing + binary = "b" in mode + rawmode = "" + if reading: + rawmode += "r" + if writing: + rawmode += "w" + raw = socket.SocketIO(self, rawmode) + self.socket._io_refs += 1 + if buffering is None: + buffering = -1 + if buffering < 0: + buffering = io.DEFAULT_BUFFER_SIZE + if buffering == 0: + if not binary: + raise ValueError("unbuffered streams must be binary") + return raw + if reading and writing: + buffer = io.BufferedRWPair(raw, raw, buffering) + elif reading: + buffer = io.BufferedReader(raw, buffering) + else: + assert writing + buffer = io.BufferedWriter(raw, buffering) + if binary: + return buffer + text = io.TextIOWrapper(buffer, encoding, errors, newline) + text.mode = mode + return text + + def unwrap(self): + self._ssl_io_loop(self.sslobj.unwrap) + + def close(self): + self.socket.close() + + def getpeercert(self, binary_form=False): + return self.sslobj.getpeercert(binary_form) + + def version(self): + return self.sslobj.version() + + def cipher(self): + return self.sslobj.cipher() + + def selected_alpn_protocol(self): + return self.sslobj.selected_alpn_protocol() + + def selected_npn_protocol(self): + return self.sslobj.selected_npn_protocol() + + def shared_ciphers(self): + return self.sslobj.shared_ciphers() + + def compression(self): + return self.sslobj.compression() + + def settimeout(self, value): + self.socket.settimeout(value) + + def gettimeout(self): + return self.socket.gettimeout() + + def _decref_socketios(self): + self.socket._decref_socketios() + + def _wrap_ssl_read(self, len, buffer=None): + try: + return self._ssl_io_loop(self.sslobj.read, len, buffer) + except ssl.SSLError as e: + if e.errno == ssl.SSL_ERROR_EOF and self.suppress_ragged_eofs: + return 0 # eof, return 0. + else: + raise + + def _ssl_io_loop(self, func, *args): + """Performs an I/O loop between incoming/outgoing and the socket.""" + should_loop = True + ret = None + + while should_loop: + errno = None + try: + ret = func(*args) + except ssl.SSLError as e: + if e.errno not in (ssl.SSL_ERROR_WANT_READ, ssl.SSL_ERROR_WANT_WRITE): + # WANT_READ, and WANT_WRITE are expected, others are not. + raise e + errno = e.errno + + buf = self.outgoing.read() + self.socket.sendall(buf) + + if errno is None: + should_loop = False + elif errno == ssl.SSL_ERROR_WANT_READ: + buf = self.socket.recv(SSL_BLOCKSIZE) + if buf: + self.incoming.write(buf) + else: + self.incoming.write_eof() + return ret diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/util/timeout.py b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/util/timeout.py new file mode 100644 index 0000000000000000000000000000000000000000..78e18a6272482e3946de83c0274badc4a5cfcdfa --- /dev/null +++ b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/util/timeout.py @@ -0,0 +1,271 @@ +from __future__ import absolute_import + +import time + +# The default socket timeout, used by httplib to indicate that no timeout was; specified by the user +from socket import _GLOBAL_DEFAULT_TIMEOUT, getdefaulttimeout + +from ..exceptions import TimeoutStateError + +# A sentinel value to indicate that no timeout was specified by the user in +# urllib3 +_Default = object() + + +# Use time.monotonic if available. +current_time = getattr(time, "monotonic", time.time) + + +class Timeout(object): + """Timeout configuration. + + Timeouts can be defined as a default for a pool: + + .. code-block:: python + + timeout = Timeout(connect=2.0, read=7.0) + http = PoolManager(timeout=timeout) + response = http.request('GET', 'http://example.com/') + + Or per-request (which overrides the default for the pool): + + .. code-block:: python + + response = http.request('GET', 'http://example.com/', timeout=Timeout(10)) + + Timeouts can be disabled by setting all the parameters to ``None``: + + .. code-block:: python + + no_timeout = Timeout(connect=None, read=None) + response = http.request('GET', 'http://example.com/, timeout=no_timeout) + + + :param total: + This combines the connect and read timeouts into one; the read timeout + will be set to the time leftover from the connect attempt. In the + event that both a connect timeout and a total are specified, or a read + timeout and a total are specified, the shorter timeout will be applied. + + Defaults to None. + + :type total: int, float, or None + + :param connect: + The maximum amount of time (in seconds) to wait for a connection + attempt to a server to succeed. Omitting the parameter will default the + connect timeout to the system default, probably `the global default + timeout in socket.py + `_. + None will set an infinite timeout for connection attempts. + + :type connect: int, float, or None + + :param read: + The maximum amount of time (in seconds) to wait between consecutive + read operations for a response from the server. Omitting the parameter + will default the read timeout to the system default, probably `the + global default timeout in socket.py + `_. + None will set an infinite timeout. + + :type read: int, float, or None + + .. note:: + + Many factors can affect the total amount of time for urllib3 to return + an HTTP response. + + For example, Python's DNS resolver does not obey the timeout specified + on the socket. Other factors that can affect total request time include + high CPU load, high swap, the program running at a low priority level, + or other behaviors. + + In addition, the read and total timeouts only measure the time between + read operations on the socket connecting the client and the server, + not the total amount of time for the request to return a complete + response. For most requests, the timeout is raised because the server + has not sent the first byte in the specified time. This is not always + the case; if a server streams one byte every fifteen seconds, a timeout + of 20 seconds will not trigger, even though the request will take + several minutes to complete. + + If your goal is to cut off any request after a set amount of wall clock + time, consider having a second "watcher" thread to cut off a slow + request. + """ + + #: A sentinel object representing the default timeout value + DEFAULT_TIMEOUT = _GLOBAL_DEFAULT_TIMEOUT + + def __init__(self, total=None, connect=_Default, read=_Default): + self._connect = self._validate_timeout(connect, "connect") + self._read = self._validate_timeout(read, "read") + self.total = self._validate_timeout(total, "total") + self._start_connect = None + + def __repr__(self): + return "%s(connect=%r, read=%r, total=%r)" % ( + type(self).__name__, + self._connect, + self._read, + self.total, + ) + + # __str__ provided for backwards compatibility + __str__ = __repr__ + + @classmethod + def resolve_default_timeout(cls, timeout): + return getdefaulttimeout() if timeout is cls.DEFAULT_TIMEOUT else timeout + + @classmethod + def _validate_timeout(cls, value, name): + """Check that a timeout attribute is valid. + + :param value: The timeout value to validate + :param name: The name of the timeout attribute to validate. This is + used to specify in error messages. + :return: The validated and casted version of the given value. + :raises ValueError: If it is a numeric value less than or equal to + zero, or the type is not an integer, float, or None. + """ + if value is _Default: + return cls.DEFAULT_TIMEOUT + + if value is None or value is cls.DEFAULT_TIMEOUT: + return value + + if isinstance(value, bool): + raise ValueError( + "Timeout cannot be a boolean value. It must " + "be an int, float or None." + ) + try: + float(value) + except (TypeError, ValueError): + raise ValueError( + "Timeout value %s was %s, but it must be an " + "int, float or None." % (name, value) + ) + + try: + if value <= 0: + raise ValueError( + "Attempted to set %s timeout to %s, but the " + "timeout cannot be set to a value less " + "than or equal to 0." % (name, value) + ) + except TypeError: + # Python 3 + raise ValueError( + "Timeout value %s was %s, but it must be an " + "int, float or None." % (name, value) + ) + + return value + + @classmethod + def from_float(cls, timeout): + """Create a new Timeout from a legacy timeout value. + + The timeout value used by httplib.py sets the same timeout on the + connect(), and recv() socket requests. This creates a :class:`Timeout` + object that sets the individual timeouts to the ``timeout`` value + passed to this function. + + :param timeout: The legacy timeout value. + :type timeout: integer, float, sentinel default object, or None + :return: Timeout object + :rtype: :class:`Timeout` + """ + return Timeout(read=timeout, connect=timeout) + + def clone(self): + """Create a copy of the timeout object + + Timeout properties are stored per-pool but each request needs a fresh + Timeout object to ensure each one has its own start/stop configured. + + :return: a copy of the timeout object + :rtype: :class:`Timeout` + """ + # We can't use copy.deepcopy because that will also create a new object + # for _GLOBAL_DEFAULT_TIMEOUT, which socket.py uses as a sentinel to + # detect the user default. + return Timeout(connect=self._connect, read=self._read, total=self.total) + + def start_connect(self): + """Start the timeout clock, used during a connect() attempt + + :raises urllib3.exceptions.TimeoutStateError: if you attempt + to start a timer that has been started already. + """ + if self._start_connect is not None: + raise TimeoutStateError("Timeout timer has already been started.") + self._start_connect = current_time() + return self._start_connect + + def get_connect_duration(self): + """Gets the time elapsed since the call to :meth:`start_connect`. + + :return: Elapsed time in seconds. + :rtype: float + :raises urllib3.exceptions.TimeoutStateError: if you attempt + to get duration for a timer that hasn't been started. + """ + if self._start_connect is None: + raise TimeoutStateError( + "Can't get connect duration for timer that has not started." + ) + return current_time() - self._start_connect + + @property + def connect_timeout(self): + """Get the value to use when setting a connection timeout. + + This will be a positive float or integer, the value None + (never timeout), or the default system timeout. + + :return: Connect timeout. + :rtype: int, float, :attr:`Timeout.DEFAULT_TIMEOUT` or None + """ + if self.total is None: + return self._connect + + if self._connect is None or self._connect is self.DEFAULT_TIMEOUT: + return self.total + + return min(self._connect, self.total) + + @property + def read_timeout(self): + """Get the value for the read timeout. + + This assumes some time has elapsed in the connection timeout and + computes the read timeout appropriately. + + If self.total is set, the read timeout is dependent on the amount of + time taken by the connect timeout. If the connection time has not been + established, a :exc:`~urllib3.exceptions.TimeoutStateError` will be + raised. + + :return: Value to use for the read timeout. + :rtype: int, float, :attr:`Timeout.DEFAULT_TIMEOUT` or None + :raises urllib3.exceptions.TimeoutStateError: If :meth:`start_connect` + has not yet been called on this object. + """ + if ( + self.total is not None + and self.total is not self.DEFAULT_TIMEOUT + and self._read is not None + and self._read is not self.DEFAULT_TIMEOUT + ): + # In case the connect timeout has not yet been established. + if self._start_connect is None: + return self._read + return max(0, min(self.total - self.get_connect_duration(), self._read)) + elif self.total is not None and self.total is not self.DEFAULT_TIMEOUT: + return max(0, self.total - self.get_connect_duration()) + else: + return self._read diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/util/url.py b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/util/url.py new file mode 100644 index 0000000000000000000000000000000000000000..a960b2f3c5f3d11fc9ae43638da9877d635e8d91 --- /dev/null +++ b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/util/url.py @@ -0,0 +1,435 @@ +from __future__ import absolute_import + +import re +from collections import namedtuple + +from ..exceptions import LocationParseError +from ..packages import six + +url_attrs = ["scheme", "auth", "host", "port", "path", "query", "fragment"] + +# We only want to normalize urls with an HTTP(S) scheme. +# urllib3 infers URLs without a scheme (None) to be http. +NORMALIZABLE_SCHEMES = ("http", "https", None) + +# Almost all of these patterns were derived from the +# 'rfc3986' module: https://github.com/python-hyper/rfc3986 +PERCENT_RE = re.compile(r"%[a-fA-F0-9]{2}") +SCHEME_RE = re.compile(r"^(?:[a-zA-Z][a-zA-Z0-9+-]*:|/)") +URI_RE = re.compile( + r"^(?:([a-zA-Z][a-zA-Z0-9+.-]*):)?" + r"(?://([^\\/?#]*))?" + r"([^?#]*)" + r"(?:\?([^#]*))?" + r"(?:#(.*))?$", + re.UNICODE | re.DOTALL, +) + +IPV4_PAT = r"(?:[0-9]{1,3}\.){3}[0-9]{1,3}" +HEX_PAT = "[0-9A-Fa-f]{1,4}" +LS32_PAT = "(?:{hex}:{hex}|{ipv4})".format(hex=HEX_PAT, ipv4=IPV4_PAT) +_subs = {"hex": HEX_PAT, "ls32": LS32_PAT} +_variations = [ + # 6( h16 ":" ) ls32 + "(?:%(hex)s:){6}%(ls32)s", + # "::" 5( h16 ":" ) ls32 + "::(?:%(hex)s:){5}%(ls32)s", + # [ h16 ] "::" 4( h16 ":" ) ls32 + "(?:%(hex)s)?::(?:%(hex)s:){4}%(ls32)s", + # [ *1( h16 ":" ) h16 ] "::" 3( h16 ":" ) ls32 + "(?:(?:%(hex)s:)?%(hex)s)?::(?:%(hex)s:){3}%(ls32)s", + # [ *2( h16 ":" ) h16 ] "::" 2( h16 ":" ) ls32 + "(?:(?:%(hex)s:){0,2}%(hex)s)?::(?:%(hex)s:){2}%(ls32)s", + # [ *3( h16 ":" ) h16 ] "::" h16 ":" ls32 + "(?:(?:%(hex)s:){0,3}%(hex)s)?::%(hex)s:%(ls32)s", + # [ *4( h16 ":" ) h16 ] "::" ls32 + "(?:(?:%(hex)s:){0,4}%(hex)s)?::%(ls32)s", + # [ *5( h16 ":" ) h16 ] "::" h16 + "(?:(?:%(hex)s:){0,5}%(hex)s)?::%(hex)s", + # [ *6( h16 ":" ) h16 ] "::" + "(?:(?:%(hex)s:){0,6}%(hex)s)?::", +] + +UNRESERVED_PAT = r"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789._\-~" +IPV6_PAT = "(?:" + "|".join([x % _subs for x in _variations]) + ")" +ZONE_ID_PAT = "(?:%25|%)(?:[" + UNRESERVED_PAT + "]|%[a-fA-F0-9]{2})+" +IPV6_ADDRZ_PAT = r"\[" + IPV6_PAT + r"(?:" + ZONE_ID_PAT + r")?\]" +REG_NAME_PAT = r"(?:[^\[\]%:/?#]|%[a-fA-F0-9]{2})*" +TARGET_RE = re.compile(r"^(/[^?#]*)(?:\?([^#]*))?(?:#.*)?$") + +IPV4_RE = re.compile("^" + IPV4_PAT + "$") +IPV6_RE = re.compile("^" + IPV6_PAT + "$") +IPV6_ADDRZ_RE = re.compile("^" + IPV6_ADDRZ_PAT + "$") +BRACELESS_IPV6_ADDRZ_RE = re.compile("^" + IPV6_ADDRZ_PAT[2:-2] + "$") +ZONE_ID_RE = re.compile("(" + ZONE_ID_PAT + r")\]$") + +_HOST_PORT_PAT = ("^(%s|%s|%s)(?::0*?(|0|[1-9][0-9]{0,4}))?$") % ( + REG_NAME_PAT, + IPV4_PAT, + IPV6_ADDRZ_PAT, +) +_HOST_PORT_RE = re.compile(_HOST_PORT_PAT, re.UNICODE | re.DOTALL) + +UNRESERVED_CHARS = set( + "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789._-~" +) +SUB_DELIM_CHARS = set("!$&'()*+,;=") +USERINFO_CHARS = UNRESERVED_CHARS | SUB_DELIM_CHARS | {":"} +PATH_CHARS = USERINFO_CHARS | {"@", "/"} +QUERY_CHARS = FRAGMENT_CHARS = PATH_CHARS | {"?"} + + +class Url(namedtuple("Url", url_attrs)): + """ + Data structure for representing an HTTP URL. Used as a return value for + :func:`parse_url`. Both the scheme and host are normalized as they are + both case-insensitive according to RFC 3986. + """ + + __slots__ = () + + def __new__( + cls, + scheme=None, + auth=None, + host=None, + port=None, + path=None, + query=None, + fragment=None, + ): + if path and not path.startswith("/"): + path = "/" + path + if scheme is not None: + scheme = scheme.lower() + return super(Url, cls).__new__( + cls, scheme, auth, host, port, path, query, fragment + ) + + @property + def hostname(self): + """For backwards-compatibility with urlparse. We're nice like that.""" + return self.host + + @property + def request_uri(self): + """Absolute path including the query string.""" + uri = self.path or "/" + + if self.query is not None: + uri += "?" + self.query + + return uri + + @property + def netloc(self): + """Network location including host and port""" + if self.port: + return "%s:%d" % (self.host, self.port) + return self.host + + @property + def url(self): + """ + Convert self into a url + + This function should more or less round-trip with :func:`.parse_url`. The + returned url may not be exactly the same as the url inputted to + :func:`.parse_url`, but it should be equivalent by the RFC (e.g., urls + with a blank port will have : removed). + + Example: :: + + >>> U = parse_url('http://google.com/mail/') + >>> U.url + 'http://google.com/mail/' + >>> Url('http', 'username:password', 'host.com', 80, + ... '/path', 'query', 'fragment').url + 'http://username:password@host.com:80/path?query#fragment' + """ + scheme, auth, host, port, path, query, fragment = self + url = u"" + + # We use "is not None" we want things to happen with empty strings (or 0 port) + if scheme is not None: + url += scheme + u"://" + if auth is not None: + url += auth + u"@" + if host is not None: + url += host + if port is not None: + url += u":" + str(port) + if path is not None: + url += path + if query is not None: + url += u"?" + query + if fragment is not None: + url += u"#" + fragment + + return url + + def __str__(self): + return self.url + + +def split_first(s, delims): + """ + .. deprecated:: 1.25 + + Given a string and an iterable of delimiters, split on the first found + delimiter. Return two split parts and the matched delimiter. + + If not found, then the first part is the full input string. + + Example:: + + >>> split_first('foo/bar?baz', '?/=') + ('foo', 'bar?baz', '/') + >>> split_first('foo/bar?baz', '123') + ('foo/bar?baz', '', None) + + Scales linearly with number of delims. Not ideal for large number of delims. + """ + min_idx = None + min_delim = None + for d in delims: + idx = s.find(d) + if idx < 0: + continue + + if min_idx is None or idx < min_idx: + min_idx = idx + min_delim = d + + if min_idx is None or min_idx < 0: + return s, "", None + + return s[:min_idx], s[min_idx + 1 :], min_delim + + +def _encode_invalid_chars(component, allowed_chars, encoding="utf-8"): + """Percent-encodes a URI component without reapplying + onto an already percent-encoded component. + """ + if component is None: + return component + + component = six.ensure_text(component) + + # Normalize existing percent-encoded bytes. + # Try to see if the component we're encoding is already percent-encoded + # so we can skip all '%' characters but still encode all others. + component, percent_encodings = PERCENT_RE.subn( + lambda match: match.group(0).upper(), component + ) + + uri_bytes = component.encode("utf-8", "surrogatepass") + is_percent_encoded = percent_encodings == uri_bytes.count(b"%") + encoded_component = bytearray() + + for i in range(0, len(uri_bytes)): + # Will return a single character bytestring on both Python 2 & 3 + byte = uri_bytes[i : i + 1] + byte_ord = ord(byte) + if (is_percent_encoded and byte == b"%") or ( + byte_ord < 128 and byte.decode() in allowed_chars + ): + encoded_component += byte + continue + encoded_component.extend(b"%" + (hex(byte_ord)[2:].encode().zfill(2).upper())) + + return encoded_component.decode(encoding) + + +def _remove_path_dot_segments(path): + # See http://tools.ietf.org/html/rfc3986#section-5.2.4 for pseudo-code + segments = path.split("/") # Turn the path into a list of segments + output = [] # Initialize the variable to use to store output + + for segment in segments: + # '.' is the current directory, so ignore it, it is superfluous + if segment == ".": + continue + # Anything other than '..', should be appended to the output + elif segment != "..": + output.append(segment) + # In this case segment == '..', if we can, we should pop the last + # element + elif output: + output.pop() + + # If the path starts with '/' and the output is empty or the first string + # is non-empty + if path.startswith("/") and (not output or output[0]): + output.insert(0, "") + + # If the path starts with '/.' or '/..' ensure we add one more empty + # string to add a trailing '/' + if path.endswith(("/.", "/..")): + output.append("") + + return "/".join(output) + + +def _normalize_host(host, scheme): + if host: + if isinstance(host, six.binary_type): + host = six.ensure_str(host) + + if scheme in NORMALIZABLE_SCHEMES: + is_ipv6 = IPV6_ADDRZ_RE.match(host) + if is_ipv6: + # IPv6 hosts of the form 'a::b%zone' are encoded in a URL as + # such per RFC 6874: 'a::b%25zone'. Unquote the ZoneID + # separator as necessary to return a valid RFC 4007 scoped IP. + match = ZONE_ID_RE.search(host) + if match: + start, end = match.span(1) + zone_id = host[start:end] + + if zone_id.startswith("%25") and zone_id != "%25": + zone_id = zone_id[3:] + else: + zone_id = zone_id[1:] + zone_id = "%" + _encode_invalid_chars(zone_id, UNRESERVED_CHARS) + return host[:start].lower() + zone_id + host[end:] + else: + return host.lower() + elif not IPV4_RE.match(host): + return six.ensure_str( + b".".join([_idna_encode(label) for label in host.split(".")]) + ) + return host + + +def _idna_encode(name): + if name and any(ord(x) >= 128 for x in name): + try: + from pip._vendor import idna + except ImportError: + six.raise_from( + LocationParseError("Unable to parse URL without the 'idna' module"), + None, + ) + try: + return idna.encode(name.lower(), strict=True, std3_rules=True) + except idna.IDNAError: + six.raise_from( + LocationParseError(u"Name '%s' is not a valid IDNA label" % name), None + ) + return name.lower().encode("ascii") + + +def _encode_target(target): + """Percent-encodes a request target so that there are no invalid characters""" + path, query = TARGET_RE.match(target).groups() + target = _encode_invalid_chars(path, PATH_CHARS) + query = _encode_invalid_chars(query, QUERY_CHARS) + if query is not None: + target += "?" + query + return target + + +def parse_url(url): + """ + Given a url, return a parsed :class:`.Url` namedtuple. Best-effort is + performed to parse incomplete urls. Fields not provided will be None. + This parser is RFC 3986 and RFC 6874 compliant. + + The parser logic and helper functions are based heavily on + work done in the ``rfc3986`` module. + + :param str url: URL to parse into a :class:`.Url` namedtuple. + + Partly backwards-compatible with :mod:`urlparse`. + + Example:: + + >>> parse_url('http://google.com/mail/') + Url(scheme='http', host='google.com', port=None, path='/mail/', ...) + >>> parse_url('google.com:80') + Url(scheme=None, host='google.com', port=80, path=None, ...) + >>> parse_url('/foo?bar') + Url(scheme=None, host=None, port=None, path='/foo', query='bar', ...) + """ + if not url: + # Empty + return Url() + + source_url = url + if not SCHEME_RE.search(url): + url = "//" + url + + try: + scheme, authority, path, query, fragment = URI_RE.match(url).groups() + normalize_uri = scheme is None or scheme.lower() in NORMALIZABLE_SCHEMES + + if scheme: + scheme = scheme.lower() + + if authority: + auth, _, host_port = authority.rpartition("@") + auth = auth or None + host, port = _HOST_PORT_RE.match(host_port).groups() + if auth and normalize_uri: + auth = _encode_invalid_chars(auth, USERINFO_CHARS) + if port == "": + port = None + else: + auth, host, port = None, None, None + + if port is not None: + port = int(port) + if not (0 <= port <= 65535): + raise LocationParseError(url) + + host = _normalize_host(host, scheme) + + if normalize_uri and path: + path = _remove_path_dot_segments(path) + path = _encode_invalid_chars(path, PATH_CHARS) + if normalize_uri and query: + query = _encode_invalid_chars(query, QUERY_CHARS) + if normalize_uri and fragment: + fragment = _encode_invalid_chars(fragment, FRAGMENT_CHARS) + + except (ValueError, AttributeError): + return six.raise_from(LocationParseError(source_url), None) + + # For the sake of backwards compatibility we put empty + # string values for path if there are any defined values + # beyond the path in the URL. + # TODO: Remove this when we break backwards compatibility. + if not path: + if query is not None or fragment is not None: + path = "" + else: + path = None + + # Ensure that each part of the URL is a `str` for + # backwards compatibility. + if isinstance(url, six.text_type): + ensure_func = six.ensure_text + else: + ensure_func = six.ensure_str + + def ensure_type(x): + return x if x is None else ensure_func(x) + + return Url( + scheme=ensure_type(scheme), + auth=ensure_type(auth), + host=ensure_type(host), + port=port, + path=ensure_type(path), + query=ensure_type(query), + fragment=ensure_type(fragment), + ) + + +def get_host(url): + """ + Deprecated. Use :func:`parse_url` instead. + """ + p = parse_url(url) + return p.scheme or "http", p.hostname, p.port diff --git a/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/util/wait.py b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/util/wait.py new file mode 100644 index 0000000000000000000000000000000000000000..21b4590b3dc9b58902b0d47164b9023e54a85ef8 --- /dev/null +++ b/venv/lib/python3.10/site-packages/pip/_vendor/urllib3/util/wait.py @@ -0,0 +1,152 @@ +import errno +import select +import sys +from functools import partial + +try: + from time import monotonic +except ImportError: + from time import time as monotonic + +__all__ = ["NoWayToWaitForSocketError", "wait_for_read", "wait_for_write"] + + +class NoWayToWaitForSocketError(Exception): + pass + + +# How should we wait on sockets? +# +# There are two types of APIs you can use for waiting on sockets: the fancy +# modern stateful APIs like epoll/kqueue, and the older stateless APIs like +# select/poll. The stateful APIs are more efficient when you have a lots of +# sockets to keep track of, because you can set them up once and then use them +# lots of times. But we only ever want to wait on a single socket at a time +# and don't want to keep track of state, so the stateless APIs are actually +# more efficient. So we want to use select() or poll(). +# +# Now, how do we choose between select() and poll()? On traditional Unixes, +# select() has a strange calling convention that makes it slow, or fail +# altogether, for high-numbered file descriptors. The point of poll() is to fix +# that, so on Unixes, we prefer poll(). +# +# On Windows, there is no poll() (or at least Python doesn't provide a wrapper +# for it), but that's OK, because on Windows, select() doesn't have this +# strange calling convention; plain select() works fine. +# +# So: on Windows we use select(), and everywhere else we use poll(). We also +# fall back to select() in case poll() is somehow broken or missing. + +if sys.version_info >= (3, 5): + # Modern Python, that retries syscalls by default + def _retry_on_intr(fn, timeout): + return fn(timeout) + +else: + # Old and broken Pythons. + def _retry_on_intr(fn, timeout): + if timeout is None: + deadline = float("inf") + else: + deadline = monotonic() + timeout + + while True: + try: + return fn(timeout) + # OSError for 3 <= pyver < 3.5, select.error for pyver <= 2.7 + except (OSError, select.error) as e: + # 'e.args[0]' incantation works for both OSError and select.error + if e.args[0] != errno.EINTR: + raise + else: + timeout = deadline - monotonic() + if timeout < 0: + timeout = 0 + if timeout == float("inf"): + timeout = None + continue + + +def select_wait_for_socket(sock, read=False, write=False, timeout=None): + if not read and not write: + raise RuntimeError("must specify at least one of read=True, write=True") + rcheck = [] + wcheck = [] + if read: + rcheck.append(sock) + if write: + wcheck.append(sock) + # When doing a non-blocking connect, most systems signal success by + # marking the socket writable. Windows, though, signals success by marked + # it as "exceptional". We paper over the difference by checking the write + # sockets for both conditions. (The stdlib selectors module does the same + # thing.) + fn = partial(select.select, rcheck, wcheck, wcheck) + rready, wready, xready = _retry_on_intr(fn, timeout) + return bool(rready or wready or xready) + + +def poll_wait_for_socket(sock, read=False, write=False, timeout=None): + if not read and not write: + raise RuntimeError("must specify at least one of read=True, write=True") + mask = 0 + if read: + mask |= select.POLLIN + if write: + mask |= select.POLLOUT + poll_obj = select.poll() + poll_obj.register(sock, mask) + + # For some reason, poll() takes timeout in milliseconds + def do_poll(t): + if t is not None: + t *= 1000 + return poll_obj.poll(t) + + return bool(_retry_on_intr(do_poll, timeout)) + + +def null_wait_for_socket(*args, **kwargs): + raise NoWayToWaitForSocketError("no select-equivalent available") + + +def _have_working_poll(): + # Apparently some systems have a select.poll that fails as soon as you try + # to use it, either due to strange configuration or broken monkeypatching + # from libraries like eventlet/greenlet. + try: + poll_obj = select.poll() + _retry_on_intr(poll_obj.poll, 0) + except (AttributeError, OSError): + return False + else: + return True + + +def wait_for_socket(*args, **kwargs): + # We delay choosing which implementation to use until the first time we're + # called. We could do it at import time, but then we might make the wrong + # decision if someone goes wild with monkeypatching select.poll after + # we're imported. + global wait_for_socket + if _have_working_poll(): + wait_for_socket = poll_wait_for_socket + elif hasattr(select, "select"): + wait_for_socket = select_wait_for_socket + else: # Platform-specific: Appengine. + wait_for_socket = null_wait_for_socket + return wait_for_socket(*args, **kwargs) + + +def wait_for_read(sock, timeout=None): + """Waits for reading to be available on a given socket. + Returns True if the socket is readable, or False if the timeout expired. + """ + return wait_for_socket(sock, read=True, timeout=timeout) + + +def wait_for_write(sock, timeout=None): + """Waits for writing to be available on a given socket. + Returns True if the socket is readable, or False if the timeout expired. + """ + return wait_for_socket(sock, write=True, timeout=timeout) diff --git a/venv/lib/python3.10/site-packages/pluggy-1.6.0.dist-info/INSTALLER b/venv/lib/python3.10/site-packages/pluggy-1.6.0.dist-info/INSTALLER new file mode 100644 index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68 --- /dev/null +++ b/venv/lib/python3.10/site-packages/pluggy-1.6.0.dist-info/INSTALLER @@ -0,0 +1 @@ +pip diff --git a/venv/lib/python3.10/site-packages/pluggy-1.6.0.dist-info/METADATA b/venv/lib/python3.10/site-packages/pluggy-1.6.0.dist-info/METADATA new file mode 100644 index 0000000000000000000000000000000000000000..12345f88ebe873247f9298feca3e469e7e8af87f --- /dev/null +++ b/venv/lib/python3.10/site-packages/pluggy-1.6.0.dist-info/METADATA @@ -0,0 +1,152 @@ +Metadata-Version: 2.4 +Name: pluggy +Version: 1.6.0 +Summary: plugin and hook calling mechanisms for python +Author-email: Holger Krekel +License: MIT +Classifier: Development Status :: 6 - Mature +Classifier: Intended Audience :: Developers +Classifier: License :: OSI Approved :: MIT License +Classifier: Operating System :: POSIX +Classifier: Operating System :: Microsoft :: Windows +Classifier: Operating System :: MacOS :: MacOS X +Classifier: Topic :: Software Development :: Testing +Classifier: Topic :: Software Development :: Libraries +Classifier: Topic :: Utilities +Classifier: Programming Language :: Python :: Implementation :: CPython +Classifier: Programming Language :: Python :: Implementation :: PyPy +Classifier: Programming Language :: Python :: 3 +Classifier: Programming Language :: Python :: 3 :: Only +Classifier: Programming Language :: Python :: 3.9 +Classifier: Programming Language :: Python :: 3.10 +Classifier: Programming Language :: Python :: 3.11 +Classifier: Programming Language :: Python :: 3.12 +Classifier: Programming Language :: Python :: 3.13 +Requires-Python: >=3.9 +Description-Content-Type: text/x-rst +License-File: LICENSE +Provides-Extra: dev +Requires-Dist: pre-commit; extra == "dev" +Requires-Dist: tox; extra == "dev" +Provides-Extra: testing +Requires-Dist: pytest; extra == "testing" +Requires-Dist: pytest-benchmark; extra == "testing" +Requires-Dist: coverage; extra == "testing" +Dynamic: license-file + +==================================================== +pluggy - A minimalist production ready plugin system +==================================================== + +|pypi| |conda-forge| |versions| |github-actions| |gitter| |black| |codecov| + +This is the core framework used by the `pytest`_, `tox`_, and `devpi`_ projects. + +Please `read the docs`_ to learn more! + +A definitive example +==================== +.. code-block:: python + + import pluggy + + hookspec = pluggy.HookspecMarker("myproject") + hookimpl = pluggy.HookimplMarker("myproject") + + + class MySpec: + """A hook specification namespace.""" + + @hookspec + def myhook(self, arg1, arg2): + """My special little hook that you can customize.""" + + + class Plugin_1: + """A hook implementation namespace.""" + + @hookimpl + def myhook(self, arg1, arg2): + print("inside Plugin_1.myhook()") + return arg1 + arg2 + + + class Plugin_2: + """A 2nd hook implementation namespace.""" + + @hookimpl + def myhook(self, arg1, arg2): + print("inside Plugin_2.myhook()") + return arg1 - arg2 + + + # create a manager and add the spec + pm = pluggy.PluginManager("myproject") + pm.add_hookspecs(MySpec) + + # register plugins + pm.register(Plugin_1()) + pm.register(Plugin_2()) + + # call our ``myhook`` hook + results = pm.hook.myhook(arg1=1, arg2=2) + print(results) + + +Running this directly gets us:: + + $ python docs/examples/toy-example.py + inside Plugin_2.myhook() + inside Plugin_1.myhook() + [-1, 3] + + +.. badges + +.. |pypi| image:: https://img.shields.io/pypi/v/pluggy.svg + :target: https://pypi.org/pypi/pluggy + +.. |versions| image:: https://img.shields.io/pypi/pyversions/pluggy.svg + :target: https://pypi.org/pypi/pluggy + +.. |github-actions| image:: https://github.com/pytest-dev/pluggy/workflows/main/badge.svg + :target: https://github.com/pytest-dev/pluggy/actions + +.. |conda-forge| image:: https://img.shields.io/conda/vn/conda-forge/pluggy.svg + :target: https://anaconda.org/conda-forge/pytest + +.. |gitter| image:: https://badges.gitter.im/pytest-dev/pluggy.svg + :alt: Join the chat at https://gitter.im/pytest-dev/pluggy + :target: https://gitter.im/pytest-dev/pluggy?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge + +.. |black| image:: https://img.shields.io/badge/code%20style-black-000000.svg + :target: https://github.com/ambv/black + +.. |codecov| image:: https://codecov.io/gh/pytest-dev/pluggy/branch/master/graph/badge.svg + :target: https://codecov.io/gh/pytest-dev/pluggy + :alt: Code coverage Status + +.. links +.. _pytest: + http://pytest.org +.. _tox: + https://tox.readthedocs.org +.. _devpi: + http://doc.devpi.net +.. _read the docs: + https://pluggy.readthedocs.io/en/latest/ + + +Support pluggy +-------------- + +`Open Collective`_ is an online funding platform for open and transparent communities. +It provides tools to raise money and share your finances in full transparency. + +It is the platform of choice for individuals and companies that want to make one-time or +monthly donations directly to the project. + +``pluggy`` is part of the ``pytest-dev`` project, see more details in the `pytest collective`_. + +.. _Open Collective: https://opencollective.com +.. _pytest collective: https://opencollective.com/pytest diff --git a/venv/lib/python3.10/site-packages/pluggy-1.6.0.dist-info/RECORD b/venv/lib/python3.10/site-packages/pluggy-1.6.0.dist-info/RECORD new file mode 100644 index 0000000000000000000000000000000000000000..286665d5add4fb9b4de7371401e609a6b1753526 --- /dev/null +++ b/venv/lib/python3.10/site-packages/pluggy-1.6.0.dist-info/RECORD @@ -0,0 +1,23 @@ +pluggy-1.6.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +pluggy-1.6.0.dist-info/METADATA,sha256=dDjDXuJaCV63QW-EtGHC10Qlxec0rVTDkSRTxlJE4Bw,4811 +pluggy-1.6.0.dist-info/RECORD,, +pluggy-1.6.0.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91 +pluggy-1.6.0.dist-info/licenses/LICENSE,sha256=1rZebCE6XQtXeRHTTW5ZSbn1nXbCOMUHGi8_wWz7JgY,1110 +pluggy-1.6.0.dist-info/top_level.txt,sha256=xKSCRhai-v9MckvMuWqNz16c1tbsmOggoMSwTgcpYHE,7 +pluggy/__init__.py,sha256=D6dp1gmEDjtDp8hAwQc-qrgaulnL4iltrqkLDd-g9tg,811 +pluggy/__pycache__/__init__.cpython-310.pyc,, +pluggy/__pycache__/_callers.cpython-310.pyc,, +pluggy/__pycache__/_hooks.cpython-310.pyc,, +pluggy/__pycache__/_manager.cpython-310.pyc,, +pluggy/__pycache__/_result.cpython-310.pyc,, +pluggy/__pycache__/_tracing.cpython-310.pyc,, +pluggy/__pycache__/_version.cpython-310.pyc,, +pluggy/__pycache__/_warnings.cpython-310.pyc,, +pluggy/_callers.py,sha256=gEZllGaSYVssZ2UmpNfmYC0bdVgh2jYbAFeYKvuRMjY,5991 +pluggy/_hooks.py,sha256=E6f3nYcI6dbEuO0Gmy61ozgGU_59_e69kC08a06EBuo,25218 +pluggy/_manager.py,sha256=K4Ip_pkEjvT2oOIfQPp8CwAWoXVnENgQRcy9tlGii0o,20219 +pluggy/_result.py,sha256=3Xfy7DrjXbYb7puRquyY2VbidIWNq6Pp7QnuElMdj8Q,3098 +pluggy/_tracing.py,sha256=nXd2BCmDgf8jJxV-HO3PqxR-WV53eWnF8B4AF1nJGgo,2073 +pluggy/_version.py,sha256=5FGJNp9Lkk9uOxeCjXpoCGBF79Ar6LGPOR7-atBqb_4,511 +pluggy/_warnings.py,sha256=td0AvZBpfamriCC3OqsLwxMh-SzAMjfjmc58T5vP3lw,828 +pluggy/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 diff --git a/venv/lib/python3.10/site-packages/pluggy-1.6.0.dist-info/WHEEL b/venv/lib/python3.10/site-packages/pluggy-1.6.0.dist-info/WHEEL new file mode 100644 index 0000000000000000000000000000000000000000..e9653ae033ea36c4cecbdb5a1e4f6b376733b414 --- /dev/null +++ b/venv/lib/python3.10/site-packages/pluggy-1.6.0.dist-info/WHEEL @@ -0,0 +1,5 @@ +Wheel-Version: 1.0 +Generator: setuptools (80.7.1) +Root-Is-Purelib: true +Tag: py3-none-any + diff --git a/venv/lib/python3.10/site-packages/pluggy-1.6.0.dist-info/licenses/LICENSE b/venv/lib/python3.10/site-packages/pluggy-1.6.0.dist-info/licenses/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..85f4dd63d2da8e31d7e84d5180f016fdfe315c2c --- /dev/null +++ b/venv/lib/python3.10/site-packages/pluggy-1.6.0.dist-info/licenses/LICENSE @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) 2015 holger krekel (rather uses bitbucket/hpk42) + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/venv/lib/python3.10/site-packages/pluggy-1.6.0.dist-info/top_level.txt b/venv/lib/python3.10/site-packages/pluggy-1.6.0.dist-info/top_level.txt new file mode 100644 index 0000000000000000000000000000000000000000..11bdb5c1f5fcdd91af5d587c352039cb8476af49 --- /dev/null +++ b/venv/lib/python3.10/site-packages/pluggy-1.6.0.dist-info/top_level.txt @@ -0,0 +1 @@ +pluggy diff --git a/venv/lib/python3.10/site-packages/pydantic_core-2.33.2.dist-info/INSTALLER b/venv/lib/python3.10/site-packages/pydantic_core-2.33.2.dist-info/INSTALLER new file mode 100644 index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68 --- /dev/null +++ b/venv/lib/python3.10/site-packages/pydantic_core-2.33.2.dist-info/INSTALLER @@ -0,0 +1 @@ +pip diff --git a/venv/lib/python3.10/site-packages/pydantic_core-2.33.2.dist-info/METADATA b/venv/lib/python3.10/site-packages/pydantic_core-2.33.2.dist-info/METADATA new file mode 100644 index 0000000000000000000000000000000000000000..9b98dfcbf13183cfd2fe29a26d56981240e1f63d --- /dev/null +++ b/venv/lib/python3.10/site-packages/pydantic_core-2.33.2.dist-info/METADATA @@ -0,0 +1,160 @@ +Metadata-Version: 2.4 +Name: pydantic_core +Version: 2.33.2 +Classifier: Development Status :: 3 - Alpha +Classifier: Programming Language :: Python +Classifier: Programming Language :: Python :: 3 +Classifier: Programming Language :: Python :: 3 :: Only +Classifier: Programming Language :: Python :: 3.9 +Classifier: Programming Language :: Python :: 3.10 +Classifier: Programming Language :: Python :: 3.11 +Classifier: Programming Language :: Python :: 3.12 +Classifier: Programming Language :: Python :: 3.13 +Classifier: Programming Language :: Rust +Classifier: Framework :: Pydantic +Classifier: Intended Audience :: Developers +Classifier: Intended Audience :: Information Technology +Classifier: License :: OSI Approved :: MIT License +Classifier: Operating System :: POSIX :: Linux +Classifier: Operating System :: Microsoft :: Windows +Classifier: Operating System :: MacOS +Classifier: Typing :: Typed +Requires-Dist: typing-extensions>=4.6.0,!=4.7.0 +License-File: LICENSE +Summary: Core functionality for Pydantic validation and serialization +Home-Page: https://github.com/pydantic/pydantic-core +Author-email: Samuel Colvin , Adrian Garcia Badaracco <1755071+adriangb@users.noreply.github.com>, David Montague , David Hewitt , Sydney Runkle , Victorien Plot +License: MIT +Requires-Python: >=3.9 +Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM +Project-URL: Homepage, https://github.com/pydantic/pydantic-core +Project-URL: Funding, https://github.com/sponsors/samuelcolvin +Project-URL: Source, https://github.com/pydantic/pydantic-core + +# pydantic-core + +[![CI](https://github.com/pydantic/pydantic-core/workflows/ci/badge.svg?event=push)](https://github.com/pydantic/pydantic-core/actions?query=event%3Apush+branch%3Amain+workflow%3Aci) +[![Coverage](https://codecov.io/gh/pydantic/pydantic-core/branch/main/graph/badge.svg)](https://codecov.io/gh/pydantic/pydantic-core) +[![pypi](https://img.shields.io/pypi/v/pydantic-core.svg)](https://pypi.python.org/pypi/pydantic-core) +[![versions](https://img.shields.io/pypi/pyversions/pydantic-core.svg)](https://github.com/pydantic/pydantic-core) +[![license](https://img.shields.io/github/license/pydantic/pydantic-core.svg)](https://github.com/pydantic/pydantic-core/blob/main/LICENSE) + +This package provides the core functionality for [pydantic](https://docs.pydantic.dev) validation and serialization. + +Pydantic-core is currently around 17x faster than pydantic V1. +See [`tests/benchmarks/`](./tests/benchmarks/) for details. + +## Example of direct usage + +_NOTE: You should not need to use pydantic-core directly; instead, use pydantic, which in turn uses pydantic-core._ + +```py +from pydantic_core import SchemaValidator, ValidationError + + +v = SchemaValidator( + { + 'type': 'typed-dict', + 'fields': { + 'name': { + 'type': 'typed-dict-field', + 'schema': { + 'type': 'str', + }, + }, + 'age': { + 'type': 'typed-dict-field', + 'schema': { + 'type': 'int', + 'ge': 18, + }, + }, + 'is_developer': { + 'type': 'typed-dict-field', + 'schema': { + 'type': 'default', + 'schema': {'type': 'bool'}, + 'default': True, + }, + }, + }, + } +) + +r1 = v.validate_python({'name': 'Samuel', 'age': 35}) +assert r1 == {'name': 'Samuel', 'age': 35, 'is_developer': True} + +# pydantic-core can also validate JSON directly +r2 = v.validate_json('{"name": "Samuel", "age": 35}') +assert r1 == r2 + +try: + v.validate_python({'name': 'Samuel', 'age': 11}) +except ValidationError as e: + print(e) + """ + 1 validation error for model + age + Input should be greater than or equal to 18 + [type=greater_than_equal, context={ge: 18}, input_value=11, input_type=int] + """ +``` + +## Getting Started + +You'll need rust stable [installed](https://rustup.rs/), or rust nightly if you want to generate accurate coverage. + +With rust and python 3.9+ installed, compiling pydantic-core should be possible with roughly the following: + +```bash +# clone this repo or your fork +git clone git@github.com:pydantic/pydantic-core.git +cd pydantic-core +# create a new virtual env +python3 -m venv env +source env/bin/activate +# install dependencies and install pydantic-core +make install +``` + +That should be it, the example shown above should now run. + +You might find it useful to look at [`python/pydantic_core/_pydantic_core.pyi`](./python/pydantic_core/_pydantic_core.pyi) and +[`python/pydantic_core/core_schema.py`](./python/pydantic_core/core_schema.py) for more information on the python API, +beyond that, [`tests/`](./tests) provide a large number of examples of usage. + +If you want to contribute to pydantic-core, you'll want to use some other make commands: +* `make build-dev` to build the package during development +* `make build-prod` to perform an optimised build for benchmarking +* `make test` to run the tests +* `make testcov` to run the tests and generate a coverage report +* `make lint` to run the linter +* `make format` to format python and rust code +* `make` to run `format build-dev lint test` + +## Profiling + +It's possible to profile the code using the [`flamegraph` utility from `flamegraph-rs`](https://github.com/flamegraph-rs/flamegraph). (Tested on Linux.) You can install this with `cargo install flamegraph`. + +Run `make build-profiling` to install a release build with debugging symbols included (needed for profiling). + +Once that is built, you can profile pytest benchmarks with (e.g.): + +```bash +flamegraph -- pytest tests/benchmarks/test_micro_benchmarks.py -k test_list_of_ints_core_py --benchmark-enable +``` +The `flamegraph` command will produce an interactive SVG at `flamegraph.svg`. + +## Releasing + +1. Bump package version locally. Do not just edit `Cargo.toml` on Github, you need both `Cargo.toml` and `Cargo.lock` to be updated. +2. Make a PR for the version bump and merge it. +3. Go to https://github.com/pydantic/pydantic-core/releases and click "Draft a new release" +4. In the "Choose a tag" dropdown enter the new tag `v` and select "Create new tag on publish" when the option appears. +5. Enter the release title in the form "v " +6. Click Generate release notes button +7. Click Publish release +8. Go to https://github.com/pydantic/pydantic-core/actions and ensure that all build for release are done successfully. +9. Go to https://pypi.org/project/pydantic-core/ and ensure that the latest release is published. +10. Done 🎉 + diff --git a/venv/lib/python3.10/site-packages/pydantic_core-2.33.2.dist-info/RECORD b/venv/lib/python3.10/site-packages/pydantic_core-2.33.2.dist-info/RECORD new file mode 100644 index 0000000000000000000000000000000000000000..27d64c643e275f6c08a81c2ee89cdd026ff440f3 --- /dev/null +++ b/venv/lib/python3.10/site-packages/pydantic_core-2.33.2.dist-info/RECORD @@ -0,0 +1,12 @@ +pydantic_core-2.33.2.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +pydantic_core-2.33.2.dist-info/METADATA,sha256=78lBoOZz4Kzfzz_yMI_qFHMFs2SE3VgnWpeGPtjycKs,6757 +pydantic_core-2.33.2.dist-info/RECORD,, +pydantic_core-2.33.2.dist-info/WHEEL,sha256=vZCrFUqux3RT3x-5MYcfGpyb4lW1eii-LV1Nx1Zs4nE,129 +pydantic_core-2.33.2.dist-info/licenses/LICENSE,sha256=Kv3TDVS01itvSIprzBVG6E7FBh8T9CCcA9ASNIeDeVo,1080 +pydantic_core/__init__.py,sha256=TzOWuJMgpXaZcPiS2Yjd8OUqjPbKOupdzXp3dZjWCGc,4403 +pydantic_core/__pycache__/__init__.cpython-310.pyc,, +pydantic_core/__pycache__/core_schema.cpython-310.pyc,, +pydantic_core/_pydantic_core.cpython-310-x86_64-linux-gnu.so,sha256=zm2niEcIylxNx_vxVvTeWr_FqSJUzHJxoyplEnvmaEA,4768792 +pydantic_core/_pydantic_core.pyi,sha256=xIR9CkJaClUD5HcHtGEPElBpWiD33PaxLKnss8rsuSM,43359 +pydantic_core/core_schema.py,sha256=98qpsz-jklOqmsA9h-zWg4K4jNkkk6N_nDBLW3Cjp-w,149655 +pydantic_core/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 diff --git a/venv/lib/python3.10/site-packages/pydantic_core-2.33.2.dist-info/WHEEL b/venv/lib/python3.10/site-packages/pydantic_core-2.33.2.dist-info/WHEEL new file mode 100644 index 0000000000000000000000000000000000000000..1ccdf6541fd95ae8009152c2cd9ca8be003d8b0a --- /dev/null +++ b/venv/lib/python3.10/site-packages/pydantic_core-2.33.2.dist-info/WHEEL @@ -0,0 +1,4 @@ +Wheel-Version: 1.0 +Generator: maturin (1.8.3) +Root-Is-Purelib: false +Tag: cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64 diff --git a/venv/lib/python3.10/site-packages/pydantic_core-2.33.2.dist-info/licenses/LICENSE b/venv/lib/python3.10/site-packages/pydantic_core-2.33.2.dist-info/licenses/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..0716871caabdbbb3e77a0371d49936cef1923ea1 --- /dev/null +++ b/venv/lib/python3.10/site-packages/pydantic_core-2.33.2.dist-info/licenses/LICENSE @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) 2022 Samuel Colvin + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/venv/lib/python3.10/site-packages/pygsheets/__init__.py b/venv/lib/python3.10/site-packages/pygsheets/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..be55f0685b0f1c7711dd1b4249c487de016f29f1 --- /dev/null +++ b/venv/lib/python3.10/site-packages/pygsheets/__init__.py @@ -0,0 +1,41 @@ +# -*- coding: utf-8 -*- + +""" +pygsheets +~~~~~~~~~ + +Google Spreadsheets client library. + +""" + +__version__ = '2.0.6' +__author__ = 'Nithin Murali' + +from pygsheets.authorization import authorize +from pygsheets.spreadsheet import Spreadsheet +from pygsheets.worksheet import Worksheet +from pygsheets.cell import Cell +from pygsheets.datarange import DataRange +from pygsheets.address import GridRange, Address +from pygsheets.chart import Chart +from pygsheets.utils import format_addr +from pygsheets.custom_types import (FormatType, WorkSheetProperty, DateTimeRenderOption, + ValueRenderOption, ExportType, ChartType, HorizontalAlignment, + VerticalAlignment) +from pygsheets.exceptions import (PyGsheetsException, AuthenticationError, + SpreadsheetNotFound, NoValidUrlKeyFound, + IncorrectCellLabel, WorksheetNotFound, + RequestError, CellNotFound, InvalidUser, + InvalidArgumentValue) + + +# Set default logging handler to avoid "No handler found" warnings. +import logging +try: # Python 2.7+ + from logging import NullHandler +except ImportError: + class NullHandler(logging.Handler): + def emit(self, record): + pass + +logging.getLogger(__name__).addHandler(NullHandler()) diff --git a/venv/lib/python3.10/site-packages/pygsheets/__pycache__/__init__.cpython-310.pyc b/venv/lib/python3.10/site-packages/pygsheets/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b330cdbba274cd5c0ccf3c18b33b0e0d299036bf Binary files /dev/null and b/venv/lib/python3.10/site-packages/pygsheets/__pycache__/__init__.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pygsheets/__pycache__/address.cpython-310.pyc b/venv/lib/python3.10/site-packages/pygsheets/__pycache__/address.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..81e3d56483d4c9c1d3fd7a98b3fd9c780db167ec Binary files /dev/null and b/venv/lib/python3.10/site-packages/pygsheets/__pycache__/address.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pygsheets/__pycache__/authorization.cpython-310.pyc b/venv/lib/python3.10/site-packages/pygsheets/__pycache__/authorization.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..45a676cd0a018597e82cc0d493bf6fb7cf344dcb Binary files /dev/null and b/venv/lib/python3.10/site-packages/pygsheets/__pycache__/authorization.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pygsheets/__pycache__/cell.cpython-310.pyc b/venv/lib/python3.10/site-packages/pygsheets/__pycache__/cell.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..527ff03b2bb343e14ab71e5bab33df25c89fcdaa Binary files /dev/null and b/venv/lib/python3.10/site-packages/pygsheets/__pycache__/cell.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pygsheets/__pycache__/chart.cpython-310.pyc b/venv/lib/python3.10/site-packages/pygsheets/__pycache__/chart.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..30879b9b0cabd4dc0bb2dc7b807c0124402f5fb9 Binary files /dev/null and b/venv/lib/python3.10/site-packages/pygsheets/__pycache__/chart.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pygsheets/__pycache__/client.cpython-310.pyc b/venv/lib/python3.10/site-packages/pygsheets/__pycache__/client.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f64e022cfdcdbe1ae738d5717ce51a2b5a55f0fa Binary files /dev/null and b/venv/lib/python3.10/site-packages/pygsheets/__pycache__/client.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pygsheets/__pycache__/custom_types.cpython-310.pyc b/venv/lib/python3.10/site-packages/pygsheets/__pycache__/custom_types.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ebce280f55f4f92eddd06a7addc980fbe7527ec7 Binary files /dev/null and b/venv/lib/python3.10/site-packages/pygsheets/__pycache__/custom_types.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pygsheets/__pycache__/datarange.cpython-310.pyc b/venv/lib/python3.10/site-packages/pygsheets/__pycache__/datarange.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b18a358ccf41f4536fc405de2d326a781d358fcd Binary files /dev/null and b/venv/lib/python3.10/site-packages/pygsheets/__pycache__/datarange.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pygsheets/__pycache__/developer_metadata.cpython-310.pyc b/venv/lib/python3.10/site-packages/pygsheets/__pycache__/developer_metadata.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fde63774ae49ec71fa123c2355f8a74ab47f1f18 Binary files /dev/null and b/venv/lib/python3.10/site-packages/pygsheets/__pycache__/developer_metadata.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pygsheets/__pycache__/drive.cpython-310.pyc b/venv/lib/python3.10/site-packages/pygsheets/__pycache__/drive.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..44403c75d0cddc1c9c32a4ed9a602634d8db040e Binary files /dev/null and b/venv/lib/python3.10/site-packages/pygsheets/__pycache__/drive.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pygsheets/__pycache__/exceptions.cpython-310.pyc b/venv/lib/python3.10/site-packages/pygsheets/__pycache__/exceptions.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1670b30fe06a62f0d5c3ad73a78b1b6366dd3fbe Binary files /dev/null and b/venv/lib/python3.10/site-packages/pygsheets/__pycache__/exceptions.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pygsheets/__pycache__/sheet.cpython-310.pyc b/venv/lib/python3.10/site-packages/pygsheets/__pycache__/sheet.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7476fa3daf79efe3f89b408f7f11da72267cd5bd Binary files /dev/null and b/venv/lib/python3.10/site-packages/pygsheets/__pycache__/sheet.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pygsheets/__pycache__/spreadsheet.cpython-310.pyc b/venv/lib/python3.10/site-packages/pygsheets/__pycache__/spreadsheet.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b4df0c012fa1a023fb7463996b5d0e5fc172f25c Binary files /dev/null and b/venv/lib/python3.10/site-packages/pygsheets/__pycache__/spreadsheet.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pygsheets/__pycache__/utils.cpython-310.pyc b/venv/lib/python3.10/site-packages/pygsheets/__pycache__/utils.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..287d92316124da45d454906823d40f430d2acf44 Binary files /dev/null and b/venv/lib/python3.10/site-packages/pygsheets/__pycache__/utils.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pygsheets/__pycache__/worksheet.cpython-310.pyc b/venv/lib/python3.10/site-packages/pygsheets/__pycache__/worksheet.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..52b930d5f9d9bb43722cd1f3ed2bbb6c6e224e8a Binary files /dev/null and b/venv/lib/python3.10/site-packages/pygsheets/__pycache__/worksheet.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/pygsheets/address.py b/venv/lib/python3.10/site-packages/pygsheets/address.py new file mode 100644 index 0000000000000000000000000000000000000000..5f5a73656a2b3324903b23bb77eb09d2eb6c4727 --- /dev/null +++ b/venv/lib/python3.10/site-packages/pygsheets/address.py @@ -0,0 +1,556 @@ +from pygsheets.exceptions import InvalidArgumentValue, IncorrectCellLabel +import re + + +class Address(object): + """ + Represents the address of a cell. + This can also be unbound in an axes. So 'A' is also a valid address but this + requires explict setting of param `allow_non_single`. + First index correspond to the rows, second index corresponds to columns. + Integer Indexes start from 1. + + >>> a = Address('A2') + >>> a.index + (2, 1) + >>> a.label + 'A2' + >>> a[0] + 2 + >>> a[1] + 1 + >>> a = Address((1, 4)) + >>> a.index + (1, 4) + >>> a.label + D1 + >>> b = a + (3,0) + >>> b +
+ >>> b == (4, 4) + True + >>> column_a = Address((None, 1), True) + >>> column_a +
+ >>> row_2 = Address('2', True) + >>> row_2 +
+ """ + + _MAGIC_NUMBER = 64 + + def __init__(self, value, allow_non_single=False): + self._is_single = True + self.allow_non_single = allow_non_single + + if isinstance(value, str): + self._value = self._label_to_coordinates(value) + elif isinstance(value, tuple) or isinstance(value, list): + assert len(value) == 2, 'tuple should be of length 2' + assert type(value[0]) is int or value[0] is None, 'address row should be int' + assert type(value[1]) is int or value[1] is None, 'address col should be int' + self._value = tuple(value) + self._validate() + elif not value and self.allow_non_single: + self._value = (None, None) + self._validate() + elif isinstance(value, Address): + self._value = self._label_to_coordinates(value.label) + else: + raise IncorrectCellLabel('Only labels in A1 notation, coordinates as a tuple or ' + 'pygsheets.Address objects are accepted.') + + @property + def label(self): + """ Label of the current address in A1 format.""" + return self._value_as_label() + + @property + def row(self): + """Row of the address""" + return self._value[0] + + @property + def col(self): + """Column of the address""" + return self._value[1] + + @row.setter + def row(self, value): + self._value = value, self._value[1] + + @col.setter + def col(self, value): + self._value = self._value[0], value + + @property + def index(self): + """Current Address in tuple format. Both axes starts at 1.""" + return tuple(self._value) + + def _validate(self): + if not self.allow_non_single and (self._value[0] is None or self._value[0] is None): + raise InvalidArgumentValue("Address cannot be unbounded if allow_non_single is not set.") + + if self._value[0]: + row = int(self._value[0]) + if row < 1: + raise InvalidArgumentValue('Address coordinates may not be below zero: ' + repr(self._value)) + + if self._value[1]: + col = int(self._value[1]) + if col < 1: + raise InvalidArgumentValue('Address coordinates may not be below zero: ' + repr(self._value)) + + def _value_as_label(self): + """Transforms tuple coordinates into a label of the form A1.""" + self._validate() + + row_label, column_label = '', '' + if self._value[0]: + row_label = str(self._value[0]) + + if self._value[1]: + col = int(self._value[1]) + div = col + column_label = '' + while div: + (div, mod) = divmod(div, 26) + if mod == 0: + mod = 26 + div -= 1 + column_label = chr(mod + self._MAGIC_NUMBER) + column_label + + return '{}{}'.format(column_label, row_label) + + def _label_to_coordinates(self, label): + """Transforms a label in A1 notation into numeric coordinates and returns them as tuple.""" + m = re.match(r'([A-Za-z]*)(\d*)', label) + if m: + column_label = m.group(1).upper() + row, col = m.group(2), 0 + if column_label: + for i, c in enumerate(reversed(column_label)): + col += (ord(c) - self._MAGIC_NUMBER) * (26 ** i) + col = int(col) + else: + col = None + row = int(row) if row else None + if not m or (not self.allow_non_single and not (row and col)): + raise IncorrectCellLabel('Not a valid cell label format: {}.'.format(label)) + return row, col + + def __repr__(self): + return '<%s %s>' % (self.__class__.__name__, str(self.label)) + + def __iter__(self): + return iter(self._value) + + def __getitem__(self, item): + return self._value[item] + + def __setitem__(self, key, value): + current_value = list(self._value) + current_value[key] = value + self._value = tuple(current_value) + + def __add__(self, other): + if type(other) is tuple or isinstance(other, Address): + return Address((self._value[0] + other[0], self._value[1] + other[1])) + else: + raise NotImplementedError + + def __sub__(self, other): + if type(other) is tuple or isinstance(other, Address): + return Address((self._value[0] - other[0], self._value[1] - other[1])) + else: + raise NotImplementedError + + def __eq__(self, other): + if isinstance(other, Address): + return self.label == other.label + elif type(other) is str: + return self.label == other + elif type(other) is tuple or type(other) is list: + return self._value == tuple(other) + else: + return super(Address, self).__eq__(other) + + def __ne__(self, other): + return not self.__eq__(other) + + def __bool__(self): + return not (self._value[0] is None and self._value[1] is None) + + __nonzero__ = __bool__ + + +class GridRange(object): + """ + Represents a rectangular (can be unbounded) range of adresses on a sheet. + All indexes are one-based and are closed, ie the start index and the end index is inclusive + Missing indexes indicate the range is unbounded on that side. + + A:B, A1:B3, 1:2 are all valid index, but A:1, 2:D are not + + grange.start = (1, None) will make the range unbounded on column + grange.indexes = ((None, None), (None, None)) will make the range completely unbounded, ie. whole sheet + + Example: + + >>> grange = GridRange(worksheet=wks, start='A1', end='D4') + >>> grange + + >>> grange.start = 'A' # will remove bounding in rows + + >>> grange.start = 'A1' # cannot add bounding at just start + + >>> grange.indexes = ('A1', 'D4') # cannot add bounding at just start + + >>> grange.end = (3, 5) # tuples will also work + + >>> grange.end = (None, 5) # make unbounded on rows + + >>> grange.end = (None, None) # make it unbounded on one index + + >>> grange.start = None # make it unbounded on both indexes + + >>> grange.start = 'A1' # make it unbounded on single index,now AZ100 is bottom right cell of worksheet + + >>> 'A1' in grange + True + >>> (100,100) in grange + False + >>> for address in grange: + >>> print(address) + Address((1,1)) + Address((1,2)) + ... + + Reference: `GridRange API docs `__ + + """ + + def __init__(self, label=None, worksheet=None, start=None, end=None, worksheet_title=None, + worksheet_id=None, propertiesjson=None): + """ + :param label: label in A1 format + :param worksheet: worksheet object this grange belongs to + :param start: start address of the range + :param end: end address of the range + :param worksheet_title: worksheet title if worksheet not given + :param worksheet_id: worksheet id if worksheet not given + :param propertiesjson: json with all range properties + """ + self._worksheet_title = worksheet_title + self._worksheet_id = worksheet_id + self._worksheet = worksheet + self._start = Address(start, True) + self._end = Address(end, True) + # if fill_bounds and self._start and not self._end: + # if not worksheet: + # raise InvalidArgumentValue('worksheet need to fill bounds.') + # self._end = Address((worksheet.rows, worksheet.cols), True) + # if fill_bounds and self._end and not self._start: + # self._start = Address('A1', True) + if propertiesjson: + self.set_json(propertiesjson) + elif label: + self._calculate_addresses(label) + else: + self._apply_index_constraints() + self._calculate_label() + + @property + def start(self): + """ address of top left cell (index). """ + if not self._start and self._end: + top_index = [1, 1] + if not self._end[0]: + top_index[0] = None + if not self._end[1]: + top_index[1] = None + return Address(tuple(top_index), True) + return self._start + + @start.setter + def start(self, value): + # prev = self._start, self._end + self._start = Address(value, allow_non_single=True) + self._apply_index_constraints() + self._calculate_label() + + @property + def end(self): + """ address of bottom right cell (index) """ + if not self._end and self._start: + if not self._worksheet: + raise InvalidArgumentValue('worksheet is required for unbounded ranges') + bottom_index = [self._worksheet.rows, self._worksheet.cols] + if not self._start[0]: + bottom_index[0] = None + if not self._start[1]: + bottom_index[1] = None + return Address(tuple(bottom_index), True) + return self._end + + @end.setter + def end(self, value): + # prev = self._start, self._end + self._end = Address(value, allow_non_single=True) + self._apply_index_constraints() + self._calculate_label() + + @property + def indexes(self): + """ Indexes of this range as a tuple """ + return self.start, self.end + + @indexes.setter + def indexes(self, value): + if type(value) is not tuple: + raise InvalidArgumentValue("Please provide a tuple") + self._start, self._end = Address(value[0], True), Address(value[1], True) + self._apply_index_constraints() + self._calculate_label() + + @property + def label(self): + """ Label in A1 notation format """ + return self._calculate_label() + + @label.setter + def label(self, value): + if type(value) is not str: + raise InvalidArgumentValue('non string value for label') + self._calculate_addresses(value) + + @property + def worksheet_id(self): + """ Id of woksheet this range belongs to """ + if self._worksheet: + return self._worksheet.id + return self._worksheet_id + + @worksheet_id.setter + def worksheet_id(self, value): + if self._worksheet: + if self._worksheet.id == value: + return + else: + raise InvalidArgumentValue("This range already has a worksheet with different id set.") + self._worksheet_id = value + + @property + def worksheet_title(self): + """ Title of woksheet this range belongs to """ + if self._worksheet: + return self._worksheet.title + return self._worksheet_title + + @worksheet_title.setter + def worksheet_title(self, value): + if not value: + return + if self._worksheet: + if self._worksheet.title == value: + return + else: + raise InvalidArgumentValue("This range already has a worksheet with different title set.") + self._worksheet_title = value + self._calculate_label() + + @staticmethod + def create(data, wks=None): + """ + create a Gridrange from various type of data + :param data: can be string in A format,tuple or list, dict in GridRange format, GridRange object + :param wks: worksheet to link to (optional) + :return: GridRange object + """ + if isinstance(data, GridRange): + grange = data + elif isinstance(data, str): + grange = GridRange(label=data, worksheet=wks) + elif isinstance(data, tuple) or isinstance(data, list): + if len(data) < 2: raise InvalidArgumentValue("start and end required") + grange = GridRange(start=data[0], end=data[1], worksheet=wks) + elif isinstance(data, dict): + grange = GridRange(propertiesjson=data, worksheet=wks) + else: + raise InvalidArgumentValue(data) + if wks: + grange.set_worksheet(wks) + return grange + + def set_worksheet(self, value): + """ set the worksheet of this grid range. """ + self._worksheet = value + self._worksheet_id = value.id + self._worksheet_title = value.title + self._calculate_label() + + def _apply_index_constraints(self): + if not self._start or not self._end: + return + + # # If range was single celled, and one is set to none, make both unbound + # if prev and prev[0] == prev[1]: + # if not self._start: + # self._end = self._start + # return + # if not self._end: + # self._start = self._end + # return + # # if range is not single celled, and one index is unbounded make it single celled + # if not self._end: + # self._end = self._start + # if not self._start: + # self._start = self._end + + # Check if unbound on different axes + if ((self._start[0] and not self._start[1]) and (not self._end[0] and self._end[1])) or \ + (not self._start[0] and self._start[1]) and (self._end[0] and not self._end[1]): + self._start, self._end = Address(None, True), Address(None, True) + raise InvalidArgumentValue('Invalid indexes set. Indexes should be unbounded at same axes.') + + # If one axes is unbounded on an index, make other index also unbounded on same axes + if self._start[0] is None or self._end[0] is None: + self._start[0], self._end[0] = None, None + elif self._start[1] is None or self._end[1] is None: + self._start[1], self._end[1] = None, None + + # verify + # if (self._start[0] and not self._end[0]) or (not self._start[0] and self._end[0]) or \ + # (self._start[1] and not self._end[1]) or (not self._start[1] and self._end[1]): + # self._start, self._end = Address(None, True), Address(None, True) + # raise InvalidArgumentValue('Invalid start and end set for this range') + + if self._start and self._end: + if self._start[0]: + assert self._start[0] <= self._end[0] + if self._start[1]: + assert self._start[1] <= self._end[1] + + self._calculate_label() + + def _calculate_label(self): + """update label from values """ + label = "'" + self.worksheet_title + "'" if self.worksheet_title else '' + if self.start and self.end: + label += "!" + self.start.label + ":" + self.end.label + return label + + def _calculate_addresses(self, label): + """ update values from label """ + self._start, self._end = Address(None, True), Address(None, True) + + if len(label.split('!')) > 1: + self.worksheet_title = label.split('!')[0] + rem = label.split('!')[1] + if ":" in rem: + self._start = Address(rem.split(":")[0], allow_non_single=True) + self._end = Address(rem.split(":")[1], allow_non_single=True) + else: + self._start = Address(rem, allow_non_single=True) + elif self._worksheet: + if ":" in label: + self._start = Address(label.split(":")[0], allow_non_single=True) + self._end = Address(label.split(":")[1], allow_non_single=True) + else: + self._start = Address(label, allow_non_single=True) + else: + pass + + self._apply_index_constraints() + + def to_json(self): + """ Get json representation of this grid range. """ + if self.worksheet_id is None: + raise Exception("worksheet id not set for this range.") + return_dict = {"sheetId": self.worksheet_id} + if self.start[0]: + return_dict["startRowIndex"] = self.start[0] - 1 + if self.start[1]: + return_dict["startColumnIndex"] = self.start[1] - 1 + if self.end[0]: + return_dict["endRowIndex"] = self.end[0] + if self.end[1]: + return_dict["endColumnIndex"] = self.end[1] + return return_dict + + def set_json(self, namedjson): + """ + Apply a Gridrange json to this named range. + + :param namedjson: json object of the GridRange format + + Reference: `GridRange docs `__ + """ + if 'sheetId' in namedjson: + self.worksheet_id = namedjson['sheetId'] + start_row_idx = namedjson.get('startRowIndex', None) + end_row_idx = namedjson.get('endRowIndex', None) + start_col_idx = namedjson.get('startColumnIndex', None) + end_col_idx = namedjson.get('endColumnIndex', None) + + start_row_idx = start_row_idx + 1 if start_row_idx is not None else start_row_idx + start_col_idx = start_col_idx + 1 if start_col_idx is not None else start_col_idx + + self._start = Address((start_row_idx, start_col_idx), True) + self._end = Address((end_row_idx, end_col_idx), True) + + self._calculate_label() + + def get_bounded_indexes(self): + """ get bounded indexes of this range based on worksheet size, if the indexes are unbounded """ + start_r, start_c = tuple(iter(self.start)) if self.start else (None, None) + end_r, end_c = tuple(iter(self.end)) if self.end else (None, None) + start_r = start_r if start_r else 1 + start_c = start_c if start_c else 1 + if not self._worksheet and not (end_r or end_c): + raise InvalidArgumentValue('Worksheet not set for calculating size.') + end_r = end_r if end_r else self._worksheet.rows + end_c = end_c if end_c else self._worksheet.cols + return Address((start_r, start_c)), Address((end_r, end_c)) + + @property + def height(self): + """ Height of this gridrange """ + start, end = self.get_bounded_indexes() + return end[0] - start[0] + 1 + + @property + def width(self): + """ Width of this gridrange """ + start, end = self.get_bounded_indexes() + return end[1] - start[1] + 1 + + def contains(self, address): + return self.start[0] <= address.row <= self.end[0] and self.start[1] <= address.col <= self.end[1] + + def __repr__(self): + return '<%s %s>' % (self.__class__.__name__, str(self.label)) + + def __eq__(self, other): + if isinstance(other, GridRange): + return self.label == other.label + elif type(other) is str: + return self.label == other + else: + return super(GridRange, self).__eq__(other) + + def __ne__(self, other): + return not self.__eq__(other) + + def __contains__(self, item): + try: + item = Address(item) + except IncorrectCellLabel: + raise InvalidArgumentValue("Gridrange can only contain an address") + return self.contains(item) + + def __iter__(self): + for r in range(self.start[0], self.end[0]+1): + for c in range(self.start[1], self.end[1]+1): + yield Address((r, c)) diff --git a/venv/lib/python3.10/site-packages/pygsheets/authorization.py b/venv/lib/python3.10/site-packages/pygsheets/authorization.py new file mode 100644 index 0000000000000000000000000000000000000000..3da1580bcc2c545c58b4c32691656668c27326c1 --- /dev/null +++ b/venv/lib/python3.10/site-packages/pygsheets/authorization.py @@ -0,0 +1,141 @@ +# -*- coding: utf-8 -*-. +import os +import json +import warnings + +from google.oauth2 import service_account +from google.oauth2.credentials import Credentials +from google_auth_oauthlib.flow import Flow, InstalledAppFlow +from google.auth.transport.requests import Request + +from pygsheets.client import Client + +try: + input = raw_input +except NameError: + pass + + +def _get_user_authentication_credentials(client_secret_file, scopes, credential_directory=None, local=False): + """Returns user credentials.""" + if credential_directory is None: + credential_directory = os.getcwd() + elif credential_directory == 'global': + home_dir = os.path.expanduser('~') + credential_directory = os.path.join(home_dir, '.credentials') + if not os.path.exists(credential_directory): + os.makedirs(credential_directory) + else: + pass + + credentials_path = os.path.join(credential_directory, 'sheets.googleapis.com-python.json') # TODO Change hardcoded name? + + credentials = None + if os.path.exists(credentials_path): + # expect these to be valid. may expire at some point, but should be refreshed by google api client... + credentials = Credentials.from_authorized_user_file(credentials_path, scopes=scopes) + + if credentials: + if credentials.expired and credentials.refresh_token: + credentials.refresh(Request()) + else: + if local: + flow = InstalledAppFlow.from_client_secrets_file(client_secret_file, scopes) + credentials = flow.run_local_server() + else: + flow = Flow.from_client_secrets_file(client_secret_file, scopes=scopes, + redirect_uri='urn:ietf:wg:oauth:2.0:oob') + auth_url, _ = flow.authorization_url(prompt='consent') + + print('Please go to this URL and finish the authentication flow: {}'.format(auth_url)) + code = input('Enter the authorization code: ') + flow.fetch_token(code=code) + credentials = flow.credentials + + # Save the credentials for the next run + credentials_as_dict = { + 'token': credentials.token, + 'refresh_token': credentials.refresh_token, + 'id_token': credentials.id_token, + 'token_uri': credentials.token_uri, + 'client_id': credentials.client_id, + 'client_secret': credentials.client_secret + } + try: + with open(credentials_path, 'w') as file: + file.write(json.dumps(credentials_as_dict)) + except OSError: + print("Unable to save the credentials to file-system") + + return credentials + + +_SCOPES = ('https://www.googleapis.com/auth/spreadsheets', 'https://www.googleapis.com/auth/drive') + +_deprecated_keyword_mapping = { + 'outh_file': 'client_secret', + 'outh_creds_store': 'credentials_directory', + 'service_file': 'service_account_file', + 'credentials': 'custom_credentials' +} + + +def authorize(client_secret='client_secret.json', + service_account_file=None, + service_account_env_var=None, + service_account_json=None, + credentials_directory='', + scopes=_SCOPES, + custom_credentials=None, + local=False, + **kwargs): + + """Authenticate this application with a google account. + + See general authorization documentation for details on how to attain the necessary files. + + :param client_secret: Location of the oauth2 credentials file. + :param service_account_file: Location of a service account file. + :param service_account_env_var: Use an environment variable to provide service account credentials. + :param service_account_json: pass in json string directly; could use aws secret manager or azure key vault to + store value + :param credentials_directory: Location of the token file created by the OAuth2 process. Use 'global' to store in + global location, which is OS dependent. Default None will store token file in + current working directory. Please note that this is override your client secret. + :param custom_credentials: A custom or pre-made credentials object. Will ignore all other params. + :param scopes: The scopes for which the authentication applies. + :param local: If local then a browser will be opened to autheticate + :param kwargs: Parameters to be handed into the client constructor. + :returns: :class:`Client` + + .. warning:: + The `credentials_directory` overrides `client_secret`. So you might be accidently using a different credential + than intended, if you are using global `credentials_directory` in more than one script. + + """ + + for key in kwargs: + if key in ['outh_file', 'outh_creds_store', 'service_file', 'credentials']: + warnings.warn('The argument {} is deprecated. Use {} instead.'.format(key, _deprecated_keyword_mapping[key]) + , category=DeprecationWarning) + client_secret = kwargs.pop('outh_file', client_secret) + service_account_file = kwargs.pop('service_file', service_account_file) + credentials_directory = kwargs.pop('outh_creds_store', credentials_directory) + custom_credentials = kwargs.pop('credentials', custom_credentials) + + if custom_credentials is not None: + credentials = custom_credentials + elif service_account_env_var is not None: + service_account_info = json.loads(os.environ[service_account_env_var]) + credentials = service_account.Credentials.from_service_account_info( + service_account_info, scopes=scopes) + elif service_account_json is not None: + service_account_info = json.loads(service_account_json) + credentials = service_account.Credentials.from_service_account_info( + service_account_info, scopes=scopes) + elif service_account_file is not None: + credentials = service_account.Credentials.from_service_account_file(service_account_file, scopes=scopes) + else: + credentials = _get_user_authentication_credentials(client_secret, scopes, credentials_directory, local) + + return Client(credentials, **kwargs) diff --git a/venv/lib/python3.10/site-packages/pygsheets/cell.py b/venv/lib/python3.10/site-packages/pygsheets/cell.py new file mode 100644 index 0000000000000000000000000000000000000000..c3777e09591c9cc36ffd40d6dffa7eca70b18abc --- /dev/null +++ b/venv/lib/python3.10/site-packages/pygsheets/cell.py @@ -0,0 +1,572 @@ +# -*- coding: utf-8 -*-. + +""" +pygsheets.cell +~~~~~~~~~~~~~~ + +This module represents a cell within the worksheet. + +""" + +from pygsheets.custom_types import * +from pygsheets.exceptions import (IncorrectCellLabel, CellNotFound, InvalidArgumentValue) +from pygsheets.utils import format_addr, is_number, format_color +from pygsheets.address import Address, GridRange + + +class Cell(object): + """ + Represents a single cell of a sheet. + + Each cell is either a simple local value or directly linked to a specific cell of a sheet. When linked any + changes to the cell will update the :class:`Worksheet ` immediately. + + :param pos: Address of the cell as coordinate tuple or label. + :param val: Value stored inside of the cell. + :param worksheet: Worksheet this cell belongs to. + :param cell_data: This cells data stored in json, with the same structure as cellData of the Google Sheets API v4. + """ + + def __init__(self, pos, val='', worksheet=None, cell_data=None): + self._worksheet = worksheet + + self._address = Address(pos, False) + + self._value = val # formatted value + self._unformated_value = val # un-formatted value + self._formula = '' + self._note = None + if self._worksheet is None: + self._linked = False + else: + self._linked = True + self._parent = None + self._color = (None, None, None, None) + self._simplecell = True # if format, notes etc wont be fetched on each update + self.format = (None, None) # number format + self.text_format = {} # the text format as json + self.text_rotation = None # the text rotation as json + + self._horizontal_alignment = None + self._vertical_alignment = None + self.borders = None + """Border Properties as dictionary. + Reference: `api object `__.""" + self.parse_value = True + """Determines how values are interpreted by Google Sheets (True: USER_ENTERED; False: RAW). + + Reference: `sheets api `__""" + self._wrap_strategy = None + self.is_dirty = True + + if cell_data is not None: + self.set_json(cell_data) + + @property + def row(self): + """Row number of the cell.""" + return self.address.row + + @row.setter + def row(self, row): + self.address = (row, self.col) + + @property + def col(self): + """Column number of the cell.""" + return self.address.col + + @col.setter + def col(self, col): + self.address = (self.row, col) + + @property + def label(self): + """This cells label (e.g. 'A1').""" + return self.address.label + + @label.setter + def label(self, label): + self.address = label + + @property + def address(self): + """ Address object representing the cell location. """ + return self._address + + @address.setter + def address(self, value): + if self._linked: + ncell = self._worksheet.cell(value) + self.__dict__.update(ncell.__dict__) + else: + self._address = Address(value) + + @property + def value(self): + """This cells formatted value.""" + return self._value + + @value.setter + def value(self, value): + self._value = value + if self._linked: + self._worksheet.update_value(self.label, value, self.parse_value) + if not self._simplecell: # for unformated value and formula + self.fetch() + else: + self._formula = value if str(value).startswith('=') else '' + self._unformated_value = '' + + @property + def value_unformatted(self): + """Unformatted value of this cell.""" + return self._unformated_value + + @property + def formula(self): + """Get/Set this cells formula if any.""" + if self._simplecell: + self.fetch() + return self._formula + + @formula.setter + def formula(self, formula): + if not formula.startswith('='): + formula = "=" + formula + tmp = self.parse_value + self.parse_value = True + self.value = formula + self._formula = formula + self.parse_value = tmp + self.fetch() + + @property + def horizontal_alignment(self): + """Horizontal alignment of the value in this cell. + possible vlaues: :class:`HorizontalAlignment ` """ + self.update() + return self._horizontal_alignment + + @horizontal_alignment.setter + def horizontal_alignment(self, value): + if isinstance(value, HorizontalAlignment): + self._horizontal_alignment = value + self.update() + else: + raise InvalidArgumentValue('Use HorizontalAlignment object for setting the horizontal alignment.') + + @property + def vertical_alignment(self): + """Vertical alignment of the value in this cell. + possible vlaues: :class:`VerticalAlignment ` """ + self.update() + return self._vertical_alignment + + @vertical_alignment.setter + def vertical_alignment(self, value): + if isinstance(value, VerticalAlignment): + self._vertical_alignment = value + self.update() + else: + raise InvalidArgumentValue('Use VerticalAlignment for setting the vertical alignment.') + + @property + def wrap_strategy(self): + """ + How to wrap text in this cell. + Possible wrap strategies: 'OVERFLOW_CELL', 'LEGACY_WRAP', 'CLIP', 'WRAP'. + `Reference: api docs `__ + """ + return self._wrap_strategy + + @wrap_strategy.setter + def wrap_strategy(self, wrap_strategy): + self._wrap_strategy = wrap_strategy + self.update() + + @property + def note(self): + """Get/Set note of this cell.""" + if self._simplecell: + self.fetch() + return self._note + + @note.setter + def note(self, note): + if self._simplecell: + self.fetch() + self._note = note + self.update() + + @property + def color(self): + """Get/Set background color of this cell as a tuple (red, green, blue, alpha).""" + if self._simplecell: + self.fetch() + return self._color + + @color.setter + def color(self, value): + if self._simplecell: + self.fetch() + if type(value) is tuple: + if len(value) < 4: + value = list(value) + [1.0]*(4-len(value)) + else: + value = (value, 1.0, 1.0, 1.0) + for c in value: + if c < 0 or c > 1: + raise InvalidArgumentValue("Color should be in range 0-1") + self._color = tuple(value) + self.update() + + @property + def simple(self): + """Simple cells only fetch the value itself. Set to false to fetch all cell properties.""" + return self._simplecell + + @simple.setter + def simple(self, value): + self._simplecell = value + + def set_text_format(self, attribute, value): + """ + Set a text format property of this cell. + + Each format property must be set individually. Any format property which is not set will be considered + unspecified. + + Attribute: + - foregroundColor: Sets the texts color. (tuple as (red, green, blue, alpha)) + - fontFamily: Sets the texts font. (string) + - fontSize: Sets the text size. (integer) + - bold: Set/remove bold format. (boolean) + - italic: Set/remove italic format. (boolean) + - strikethrough: Set/remove strike through format. (boolean) + - underline: Set/remove underline format. (boolean) + + Reference: `api docs `__ + + :param attribute: The format property to set. + :param value: The value the format property should be set to. + + :return: :class:`cell ` + """ + if self._simplecell: + self.fetch() + if attribute not in ["foregroundColor", "fontFamily", "fontSize", "bold", "italic", + "strikethrough", "underline"]: + raise InvalidArgumentValue("Not a valid attribute. Check documentation for more information.") + if self.text_format: + self.text_format[attribute] = value + else: + self.text_format = {attribute: value} + self.update() + return self + + def set_number_format(self, format_type, pattern=''): + """ + Set number format of this cell. + + Reference: `api docs `__ + + :param format_type: The type of the number format. Should be of type :class:`FormatType `. + :param pattern: Pattern string used for formatting. If not set, a default pattern will be used. + See reference for supported patterns. + :return: :class:`cell ` + + """ + if not isinstance(format_type, FormatType): + raise InvalidArgumentValue("format_type should be of type pygsheets.FormatType") + if self._simplecell: + self.fetch() + self.format = (format_type, pattern) + self.update() + return self + + def set_text_rotation(self, attribute, value): + """ + The rotation applied to text in this cell. + + Can be defined as "angle" or as "vertical". May not define both! + + angle: + [number] The angle between the standard orientation and the desired orientation. + Measured in degrees. Valid values are between -90 and 90. Positive angles are angled upwards, + negative are angled downwards. + + Note: For LTR text direction positive angles are in the counterclockwise direction, + whereas for RTL they are in the clockwise direction. + + vertical: + [boolean] If true, text reads top to bottom, but the orientation of individual characters is unchanged. + + Reference: `api_docs __` + + :param attribute: "angle" or "vertical" + :param value: Corresponding value for the attribute. angle in (-90,90) for 'angle', boolean for 'vertical' + :return: :class:`cell ` + """ + if self._simplecell: + self.fetch() + if attribute not in ["angle", "vertical"]: + raise InvalidArgumentValue("Text rotation can be set as 'angle' or 'vertical'. " + "See documentation for details.") + if attribute == "angle": + if type(value) != int: + raise InvalidArgumentValue("Property 'angle' must be an int.") + if value not in range(-90, 91): + raise InvalidArgumentValue("Property 'angle' must be in range -90 and 90.") + if attribute == "vertical": + if type(value) != bool: + raise InvalidArgumentValue("Property 'vertical' must be set as boolean.") + + self.text_rotation = {attribute: value} + self.update() + return self + + def set_horizontal_alignment(self, value): + """ + Set horizondal alignemnt of text in the cell + + :param value: Horizondal alignment value, instance of :class:`HorizontalAlignment ` + :return: :class:`cell ` + """ + if self._simplecell: + self.fetch() + self.horizontal_alignment = value + return self + + def set_vertical_alignment(self, value): + """ + Set vertical alignemnt of text in the cell + + :param value: Vertical alignment value, instance of :class:`VerticalAlignment ` + :return: :class:`cell ` + """ + if self._simplecell: + self.fetch() + self.vertical_alignment = value + return self + + def set_value(self, value): + """ + Set value of the cell + + :param value: value to be set + :return: :class:`cell ` + """ + self.value = value + return self + + def unlink(self): + """Unlink this cell from its worksheet. + + Unlinked cells will no longer automatically update the sheet when changed. Use update or link to update the + sheet.""" + self._linked = False + self.is_dirty = False + return self + + def link(self, worksheet=None, update=False): + """ + Link cell with the specified worksheet. + + Linked cells will synchronize any changes with the sheet as they happen. + + :param worksheet: The worksheet to link to. Can be None if the cell was linked to a worksheet previously. + :param update: Update the cell immediately after linking if the cell has changed + :return: :class:`cell ` + """ + if worksheet is None and self._worksheet is None: + raise InvalidArgumentValue("No worksheet defined to link this cell to.") + self._linked = True + if worksheet: + self._worksheet = worksheet + if update and self.is_dirty: + self.update() + return self + + def neighbour(self, position): + """ + Get a neighbouring cell of this cell. + + :param position: This may be a string 'right', 'left', 'top', 'bottom' or a tuple of relative positions + (e.g. (1, 2) will return a cell one below and two to the right). + :return: :class:`neighbouring cell ` + """ + if not self._linked: + return False + addr = Address(self._address) + if type(position) == tuple: + addr = addr + position + # TODO: this does not work if position is a list... + elif type(position) == str: + if "right" in position: + addr[1] += 1 + if "left" in position: + addr[1] -= 1 + if "top" in position: + addr[0] -= 1 + if "bottom" in position: + addr[0] += 1 + try: + ncell = self._worksheet.cell(addr) + except IncorrectCellLabel: + raise CellNotFound + return ncell + + def fetch(self, keep_simple=False): + """Update the value in this cell from the linked worksheet.""" + if not keep_simple: self._simplecell = False + if self._linked: + result = self._worksheet.client.sheet.get(self._worksheet.spreadsheet.id, + fields='sheets/data/rowData', + includeGridData=True, + ranges=self._worksheet._get_range(self.label)) + try: + result = result['sheets'][0]['data'][0]['rowData'][0]['values'][0] + except (KeyError, IndexError): + result = dict() + self.set_json(result) + return self + else: + return False + + def refresh(self): + """Refresh the value and properties in this cell from the linked worksheet. + Same as fetch. + """ + self.fetch(False) + + def update(self, force=False, get_request=False, worksheet_id=None): + """ + Update the cell of the linked sheet or the worksheet given as parameter. + + :param force: Force an update from the sheet, even if it is unlinked. + :param get_request: Return the request object instead of sending the request directly. + :param worksheet_id: Needed if the cell is not linked otherwise the cells worksheet is used. + """ + if not (self._linked or force) and not get_request: + return False + self._simplecell = False + worksheet_id = worksheet_id if worksheet_id is not None else self._worksheet.id + request = { + "repeatCell": { + "range": GridRange(start=self._address, end=self._address, worksheet_id=worksheet_id).to_json(), + "cell": self.get_json(), + "fields": "userEnteredFormat, note, userEnteredValue" + } + } + if get_request: + return request + self._worksheet.client.sheet.batch_update(self._worksheet.spreadsheet.id, request) + + def get_json(self): + """Returns the cell as a dictionary structured like the Google Sheets API v4.""" + try: + nformat, pattern = self.format + except TypeError: + nformat, pattern = self.format, "" + + if self._formula != '': + value = self._formula + value_key = 'formulaValue' + elif is_number(self._value): + value = self._value + value_key = 'numberValue' + elif type(self._value) is bool: + value = self._value + value_key = 'boolValue' + elif type(self._value) is str or type(self._value) is unicode: + value = self._value + value_key = 'stringValue' + else: # @TODO errorValue key not handled + value = self._value + value_key = 'errorValue' + + ret_json = dict() + ret_json["userEnteredFormat"] = dict() + + if self.format[0] is not None: + ret_json["userEnteredFormat"]["numberFormat"] = {"type": getattr(nformat, 'value', nformat), + "pattern": pattern} + if self._color[0] is not None: + ret_json["userEnteredFormat"]["backgroundColor"] = {"red": self._color[0], "green": self._color[1], + "blue": self._color[2], "alpha": self._color[3]} + if self.text_format is not None: + ret_json["userEnteredFormat"]["textFormat"] = self.text_format.copy() + fg = ret_json["userEnteredFormat"]["textFormat"].get('foregroundColor', None) + ret_json["userEnteredFormat"]["textFormat"]['foregroundColor'] = format_color(fg, to='dict') + + if self.borders is not None: + ret_json["userEnteredFormat"]["borders"] = self.borders + if self._horizontal_alignment is not None: + ret_json["userEnteredFormat"]["horizontalAlignment"] = self._horizontal_alignment.value + if self._vertical_alignment is not None: + ret_json["userEnteredFormat"]["verticalAlignment"] = self._vertical_alignment.value + if self._wrap_strategy is not None: + ret_json["userEnteredFormat"]["wrapStrategy"] = self._wrap_strategy + if self.text_rotation is not None: + ret_json["userEnteredFormat"]["textRotation"] = self.text_rotation + + if self._note is not None: + ret_json["note"] = self._note + ret_json["userEnteredValue"] = {value_key: value} + + return ret_json + + def set_json(self, cell_data): + """ + Reads a json-dictionary returned by the Google Sheets API v4 and initialize all the properties from it. + + :param cell_data: The cells data. + """ + self._simplecell = False + + self._value = cell_data.get('formattedValue', '') + try: + self._unformated_value = list(cell_data['effectiveValue'].values())[0] + except (KeyError, IndexError): + self._unformated_value = '' + self._formula = cell_data.get('userEnteredValue', {}).get('formulaValue', '') + + self._note = cell_data.get('note', None) + nformat = cell_data.get('userEnteredFormat', {}).get('numberFormat', {}) + self.format = (nformat.get('type', None), nformat.get('pattern', '')) + color = cell_data.get('userEnteredFormat', {}) \ + .get('backgroundColor', {'red': None, 'green': None, 'blue': None, 'alpha': None}) + + self._color = (color.get('red', 0), color.get('green', 0), color.get('blue', 0), color.get('alpha', 0)) + self.text_format = cell_data.get('userEnteredFormat', {}).get('textFormat', None) + if self.text_format and self.text_format.get('foregroundColor', None): + self.text_format['foregroundColor'] = format_color(self.text_format['foregroundColor'], to='tuple') + self.text_rotation = cell_data.get('userEnteredFormat', {}).get('textRotation', None) + self.borders = cell_data.get('userEnteredFormat', {}).get('borders', None) + self._wrap_strategy = cell_data.get('userEnteredFormat', {}).get('wrapStrategy', "WRAP_STRATEGY_UNSPECIFIED") + + nhorozondal_alignment = cell_data.get('userEnteredFormat', {}).get('horizontalAlignment', None) + self._horizontal_alignment = \ + HorizontalAlignment[nhorozondal_alignment] if nhorozondal_alignment is not None else None + nvertical_alignment = cell_data.get('userEnteredFormat', {}).get('verticalAlignment', None) + self._vertical_alignment = \ + VerticalAlignment[nvertical_alignment] if nvertical_alignment is not None else None + + self.hyperlink = cell_data.get('hyperlink', '') + + def __setattr__(self, key, value): + if key not in ['_linked', '_worksheet']: + self.__dict__['is_dirty'] = True + super(Cell, self).__setattr__(key, value) + + def __eq__(self, other): + if self._worksheet is not None and other._worksheet is not None: + if self._worksheet != other._worksheet: + return False + if self.label != other.label: + return False + return True + + def __repr__(self): + return '<%s %s %s>' % (self.__class__.__name__, self.label, repr(self.value)) diff --git a/venv/lib/python3.10/site-packages/pygsheets/chart.py b/venv/lib/python3.10/site-packages/pygsheets/chart.py new file mode 100644 index 0000000000000000000000000000000000000000..2aed07f575cbd575ef7bd5810dfc0931ab67b86b --- /dev/null +++ b/venv/lib/python3.10/site-packages/pygsheets/chart.py @@ -0,0 +1,370 @@ +from pygsheets.utils import format_addr +from pygsheets.cell import Cell +from pygsheets.custom_types import ChartType +from pygsheets.exceptions import InvalidArgumentValue + + +class Chart(object): + """ + Represents a chart in a sheet. + + :param worksheet: Worksheet object in which the chart resides + :param domain: Cell range of the desired chart domain in the form of tuple of tuples + :param ranges: Cell ranges of the desired ranges in the form of list of tuple of tuples + :param chart_type: An instance of :class:`ChartType` Enum. + :param title: Title of the chart + :param anchor_cell: Position of the left corner of the chart in the form of cell address or cell object + :param json_obj: Represents a json structure of the chart as given in `api `__. + """ + def __init__(self, worksheet, domain=None, ranges=None, chart_type=None, title='', anchor_cell=None, json_obj=None): + self._title = title + self._chart_type = chart_type + self._domain = () + if domain: + self._domain = (format_addr(domain[0], 'tuple'), format_addr(domain[1], 'tuple')) + self._ranges = [] + if ranges: + for i in range(len(ranges)): + self._ranges.append((format_addr(ranges[i][0], 'tuple'), format_addr(ranges[i][1], 'tuple'))) + self._worksheet = worksheet + self._title_font_family = 'Roboto' + self._font_name = 'Roboto' + self._legend_position = 'RIGHT_LEGEND' + self._chart_id = None + self._anchor_cell = anchor_cell + if json_obj is None: + self._create_chart() + else: + self.set_json(json_obj) + + @property + def title(self): + """Title of the chart""" + return self._title + + @title.setter + def title(self, new_title): + temp = self._title + self._title = new_title + try: + self.update_chart() + except: + self._title = temp + + @property + def domain(self): + """ + Domain of the chart. + The domain takes the cell range in the form of tuple of cell adresses. Where first adress is the + top cell of the column and 2nd element the last adress of the column. + + Example: ((1,1),(6,1)) or ('A1','A6') + """ + return self._domain + + @domain.setter + def domain(self, new_domain): + new_domain = (format_addr(new_domain[0], 'tuple'), format_addr(new_domain[1], 'tuple')) + temp = self._domain + self._domain = new_domain + try: + self.update_chart() + except: + self._domain = temp + + @property + def chart_type(self): + """Type of the chart + The specificed as enum of type :class:'ChartType' + + The available chart types are given in the `api docs `__ . + """ + return self._chart_type + + @chart_type.setter + def chart_type(self, new_chart_type): + if not isinstance(new_chart_type, ChartType): + raise InvalidArgumentValue + temp = self._chart_type + self._chart_type = new_chart_type + try: + self.update_chart() + except: + self._chart_type = temp + + @property + def ranges(self): + """ + Ranges of the chart (y values) + A chart can have multiple columns as range. So you can provide them as a list. The ranges are + taken in the form of list of tuple of cell adresses. where each tuple inside the list represents + a column as staring and ending cell. + + Example: + [((1,2),(6,2)), ((1,3),(6,3))] or [('B1','B6'), ('C1','C6')] + """ + return self._ranges + + @ranges.setter + def ranges(self, new_ranges): + if type(new_ranges) is tuple: + new_ranges = [new_ranges] + + for i in range(len(new_ranges)): + new_ranges[i] = (format_addr(new_ranges[i][0], 'tuple'), format_addr(new_ranges[i][1], 'tuple')) + + temp = self._ranges + self._ranges = new_ranges + try: + self.update_chart() + except: + self._ranges = temp + + @property + def title_font_family(self): + """ + Font family of the title. (Default: 'Roboto') + """ + return self._title_font_family + + @title_font_family.setter + def title_font_family(self, new_title_font_family): + temp = self._title_font_family + self._title_font_family = new_title_font_family + try: + self.update_chart() + except: + self._title_font_family = temp + + @property + def font_name(self): + """ + Font name for the chart. (Default: 'Roboto') + """ + return self._font_name + + @font_name.setter + def font_name(self, new_font_name): + temp = self._font_name + self._font_name = new_font_name + try: + self.update_chart() + except: + self._font_name = temp + + @property + def legend_position(self): + """ + Legend postion of the chart. (Default: 'RIGHT_LEGEND') + The available options are given in the `api docs `__. + """ + return self._legend_position + + @legend_position.setter + def legend_position(self, new_legend_position): + temp = self._legend_position + self._legend_position = new_legend_position + try: + self.update_chart() + except: + self._legend_position = temp + + @property + def id(self): + """Id of the this chart.""" + return self._chart_id + + @property + def anchor_cell(self): + """Position of the left corner of the chart in the form of cell address or cell object, + Changing this will move the chart. + """ + return self._anchor_cell + + @anchor_cell.setter + def anchor_cell(self, new_anchor_cell): + temp = self._anchor_cell + try: + if type(new_anchor_cell) is Cell: + self._anchor_cell = (new_anchor_cell.row, new_anchor_cell.col) + self._update_position() + else: + self._anchor_cell = format_addr(new_anchor_cell, 'tuple') + self._update_position() + except: + self._anchor_cell = temp + + def delete(self): + """ + Deletes the chart. + + .. warning:: + Once the chart is deleted the objects of that chart still exist and should not be used. + """ + request = { + "deleteEmbeddedObject": { + "objectId": self._chart_id + } + } + self._worksheet.client.sheet.batch_update(self._worksheet.spreadsheet.id, request) + + def refresh(self): + """Refreshes the object to incorporate the changes made in the chart through other objects or Google sheet""" + chart_data = self._worksheet.client.sheet.get(self._worksheet.spreadsheet.id, fields='sheets(charts,properties)') + sheet_list = chart_data.get('sheets') + for sheet in sheet_list: + if sheet.get('properties', {}).get('sheetId', None) is self._worksheet.id: + chart_list = sheet.get('charts') + if chart_list: + for chart in chart_list: + if chart.get('chartId') == self._chart_id: + self.set_json(chart) + + def _get_anchor_cell(self): + if self._anchor_cell is None: + if self._domain: + return { + "columnIndex": self._domain[1][1]-1, + "rowIndex": self._domain[1][0], "sheetId": self._worksheet.id} + else: + return {"columnIndex": 0, "rowIndex": 0, "sheetId": self._worksheet.id} + + else: + if type(self._anchor_cell) is Cell: + return { + "columnIndex": self._anchor_cell.col-1, + "rowIndex": self._anchor_cell.row-1, "sheetId": self._worksheet.id} + else: + cell = format_addr(self._anchor_cell, 'tuple') + return { + "columnIndex": cell[1]-1, + "rowIndex": cell[0]-1, "sheetId": self._worksheet.id} + + def _get_ranges_request(self): + ranges_request_list = [] + for i in range(len(self._ranges)): + req = { + 'series': { + 'sourceRange': { + 'sources': [self._worksheet.get_gridrange(self._ranges[i][0], self._ranges[i][1])] + } + }, + } + ranges_request_list.append(req) + return ranges_request_list + + def _create_chart(self): + domains = [] + if self._domain: + domains.append({ + "domain": { + "sourceRange": { + "sources": [self._worksheet.get_gridrange(self._domain[0], self._domain[1])] + } + } + }) + + request = { + "addChart": { + "chart": { + "spec": { + "title": self._title, + "basicChart": { + "chartType": self._chart_type.value, + "domains": domains, + "series": self._get_ranges_request() + } + }, + "position": { + "overlayPosition": { + "anchorCell": self._get_anchor_cell() + } + } + } + } + } + response = self._worksheet.client.sheet.batch_update(self._worksheet.spreadsheet.id, request) + chart_data_list = response.get('replies') + chart_json = chart_data_list[0].get('addChart',{}).get('chart') + self.set_json(chart_json) + + def _update_position(self): + request = { + "updateEmbeddedObjectPosition": { + "objectId": self._chart_id, + "newPosition": { + "overlayPosition": { + "anchorCell": { + "sheetId": self._worksheet.id, + "rowIndex": self._anchor_cell[0]-1, + "columnIndex": self._anchor_cell[1]-1 + } + } + }, + "fields": "*" + }} + self._worksheet.client.sheet.batch_update(self._worksheet.spreadsheet.id, request) + + def update_chart(self): + """updates the applied changes to the sheet.""" + request = { + 'updateChartSpec':{ + 'chartId': self._chart_id, "spec": self.get_json()} + } + self._worksheet.client.sheet.batch_update(self._worksheet.spreadsheet.id, request) + + def get_json(self): + """Returns the chart as a dictionary structured like the Google Sheets API v4.""" + + domains = [{'domain': {'sourceRange': {'sources': [ + self._worksheet.get_gridrange(self._domain[0], self._domain[1])]}}}] + ranges = self._get_ranges_request() + spec = dict() + spec['title'] = self._title + spec['basicChart'] = dict() + spec['titleTextFormat'] = dict() + spec['basicChart']['chartType'] = self._chart_type.value + spec['basicChart']['legendPosition'] = self._legend_position + spec['titleTextFormat']['fontFamily'] = self._title_font_family + spec['fontName'] = self._font_name + spec['basicChart']['domains'] = domains + spec['basicChart']['series'] = ranges + return spec + + def set_json(self, chart_data): + """ + Reads a json-dictionary returned by the Google Sheets API v4 and initialize all the properties from it. + + :param chart_data: The chart data as json specified in sheets api. + """ + anchor_cell_data = chart_data.get('position',{}).get('overlayPosition',{}).get('anchorCell') + self._anchor_cell = (anchor_cell_data.get('rowIndex',0)+1, anchor_cell_data.get('columnIndex',0)+1) + self._title = chart_data.get('spec',{}).get('title',None) + self._chart_id = chart_data.get('chartId',None) + self._title_font_family = chart_data.get('spec',{}).get('titleTextFormat',{}).get('fontFamily',None) + self._font_name = chart_data.get('spec',{}).get('titleTextFormat',{}).get('fontFamily',None) + basic_chart = chart_data.get('spec',{}).get('basicChart', None) + self._chart_type = ChartType(basic_chart.get('chartType', None)) + self._legend_position = basic_chart.get('legendPosition', None) + domain_list = basic_chart.get('domains', []) + for d in domain_list: + source_list = d.get('domain', {}).get('sourceRange', {}).get('sources', None) + for source in source_list: + start_row = source.get('startRowIndex',0) + end_row = source.get('endRowIndex',0) + start_column = source.get('startColumnIndex',0) + end_column = source.get('endColumnIndex',0) + self._domain = [(start_row+1, start_column+1),(end_row, end_column)] + range_list = basic_chart.get('series', []) + self._ranges = [] + for r in range_list: + source_list = r.get('series',{}).get('sourceRange',{}).get('sources',None) + for source in source_list: + start_row = source.get('startRowIndex',0) + end_row = source.get('endRowIndex',0) + start_column = source.get('startColumnIndex',0) + end_column = source.get('endColumnIndex',0) + self._ranges.append([(start_row+1, start_column+1), (end_row, end_column)]) + + def __repr__(self): + return '<%s %s %s>' % (self.__class__.__name__, self.chart_type.value, repr(self.title)) diff --git a/venv/lib/python3.10/site-packages/pygsheets/client.py b/venv/lib/python3.10/site-packages/pygsheets/client.py new file mode 100644 index 0000000000000000000000000000000000000000..341b3dc4bce02374e5180e043ad40954925c8ae4 --- /dev/null +++ b/venv/lib/python3.10/site-packages/pygsheets/client.py @@ -0,0 +1,247 @@ +# -*- coding: utf-8 -*-. +import re +import warnings +import os +import logging + + +from pygsheets.drive import DriveAPIWrapper +from pygsheets.sheet import SheetAPIWrapper +from pygsheets.spreadsheet import Spreadsheet +from pygsheets.exceptions import SpreadsheetNotFound, NoValidUrlKeyFound +from pygsheets.custom_types import ValueRenderOption, DateTimeRenderOption + +from google_auth_httplib2 import AuthorizedHttp + +GOOGLE_SHEET_CELL_UPDATES_LIMIT = 50000 + +_url_key_re_v1 = re.compile(r'key=([^&#]+)') +_url_key_re_v2 = re.compile(r"/spreadsheets/d/([a-zA-Z0-9-_]+)") +_email_patttern = re.compile(r"\"?([-a-zA-Z0-9.`?{}]+@[-a-zA-Z0-9.]+\.\w+)\"?") +# _domain_pattern = re.compile("(?!-)[A-Z\d-]{1,63}(?>> import pygsheets + >>> c = pygsheets.authorize() + + The sheet API service object is stored in the sheet property and the drive API service object in the drive property. + + >>> c.sheet.get('') + >>> c.drive.delete('') + + :param credentials: The credentials object returned by google-auth or google-auth-oauthlib. + :param retries: (Optional) Number of times to retry a connection before raising a TimeOut error. + Default: 3 + :param http: The underlying HTTP object to use to make requests. If not specified, a + :class:`httplib2.Http` instance will be constructed. + :param check: Check for quota error and apply rate limiting. + :param seconds_per_quota: Default value is 100 seconds + + """ + + spreadsheet_cls = Spreadsheet + + def __init__(self, credentials, retries=3, http=None, check=True, seconds_per_quota=100): + self.oauth = credentials + self.logger = logging.getLogger(__name__) + + http = AuthorizedHttp(credentials, http=http) + data_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "data") + + self.sheet = SheetAPIWrapper(http, data_path, retries=retries, check=check, seconds_per_quota=seconds_per_quota) + self.drive = DriveAPIWrapper(http, data_path) + + @property + def teamDriveId(self): + """ Enable team drive support, set None to disable + + Deprecated: use client.drive.enable_team_drive(team_drive_id=?) + """ + return self.drive.team_drive_id + + @teamDriveId.setter + def teamDriveId(self, value): + warnings.warn("Depricated please use drive.enable_team_drive") + self.drive.enable_team_drive(value) + + def spreadsheet_ids(self, query=None): + """Get a list of all spreadsheet ids present in the Google Drive or TeamDrive accessed.""" + return [x['id'] for x in self.drive.spreadsheet_metadata(query)] + + def set_batch_mode(self, value): + """Set the client in batch mode. If True will batch all custom requests and wil combine them + into single request. setting batchmode will clear all previous cached data. Also note that batch mode + only caches sheetUpdate requests not value updates or clear requests.""" + self.sheet.set_batch_mode(value) + + def run_batch(self): + """Run currently batched requests.""" + self.sheet.run_batch() + + def spreadsheet_titles(self, query=None): + """Get a list of all spreadsheet titles present in the Google Drive or TeamDrive accessed.""" + return [x['name'] for x in self.drive.spreadsheet_metadata(query)] + + def create(self, title, template=None, folder=None, folder_name=None, **kwargs): + """Create a new spreadsheet. + + The title will always be set to the given value (even overwriting the templates title). The template + can either be a `spreadsheet resource `_ + or an instance of :class:`~pygsheets.Spreadsheet`. In both cases undefined values will be ignored. + + :param title: Title of the new spreadsheet. + :param template: A template to create the new spreadsheet from. + :param folder: The Id of the folder this sheet will be stored in. + :param folder_name: The Name of the folder this sheet will be stored in. + :param kwargs: Standard parameters (see reference for details). + :return: :class:`~pygsheets.Spreadsheet` + """ + + if isinstance(template, str): + result = self.drive.copy_file(template, title, folder) + return self.open_by_key(result['id']) + + if isinstance(template, Spreadsheet): + result = self.drive.copy_file(template.id, title, folder) + return self.open_by_key(result['id']) + + if folder_name and not folder: + folder = self.drive.get_folder_id(folder_name) + + result = self.sheet.create(title, template=template, **kwargs) + if folder: + self.drive.move_file(result['spreadsheetId'], + old_folder=self.drive.spreadsheet_metadata(fid=result['spreadsheetId'])[0].get('parents', [None])[0], + new_folder=folder) + return self.spreadsheet_cls(self, jsonsheet=result) + + def open(self, title): + """Open a spreadsheet by title. + + In a case where there are several sheets with the same title, the first one found is returned. + + >>> import pygsheets + >>> c = pygsheets.authorize() + >>> c.open('TestSheet') + + :param title: A title of a spreadsheet. + + :returns: :class:`~pygsheets.Spreadsheet` + :raises pygsheets.SpreadsheetNotFound: No spreadsheet with the given title was found. + """ + try: + spreadsheet = list(filter(lambda x: x['name'] == title, self.drive.spreadsheet_metadata()))[0] + return self.open_by_key(spreadsheet['id']) + except (KeyError, IndexError): + raise SpreadsheetNotFound('Could not find a spreadsheet with title %s.' % title) + + def open_by_key(self, key): + """Open a spreadsheet by key. + + >>> import pygsheets + >>> c = pygsheets.authorize() + >>> c.open_by_key('0BmgG6nO_6dprdS1MN3d3MkdPa142WFRrdnRRUWl1UFE') + + :param key: The key of a spreadsheet. (can be found in the sheet URL) + :returns: :class:`~pygsheets.Spreadsheet` + :raises pygsheets.SpreadsheetNotFound: The given spreadsheet ID was not found. + """ + response = self.sheet.get(key, includeGridData=False) + return self.spreadsheet_cls(self, response) + + def open_by_url(self, url): + """Open a spreadsheet by URL. + + >>> import pygsheets + >>> c = pygsheets.authorize() + >>> c.open_by_url('https://docs.google.com/spreadsheet/ccc?key=0Bm...FE&hl') + + :param url: URL of a spreadsheet as it appears in a browser. + :returns: :class:`~pygsheets.Spreadsheet` + :raises pygsheets.SpreadsheetNotFound: No spreadsheet was found with the given URL. + """ + m1 = _url_key_re_v1.search(url) + if m1: + return self.open_by_key(m1.group(1)) + + else: + m2 = _url_key_re_v2.search(url) + if m2: + return self.open_by_key(m2.group(1)) + else: + raise NoValidUrlKeyFound + + def open_all(self, query=''): + """Opens all available spreadsheets. + + Result can be filtered when specifying the query parameter. On the details on how to form the query: + + `Reference `_ + + :param query: (Optional) Can be used to filter the returned metadata. + :returns: A list of :class:`~pygsheets.Spreadsheet`. + """ + return [self.open_by_key(key) for key in self.spreadsheet_ids(query=query)] + + def open_as_json(self, key): + """Return a json representation of the spreadsheet. + + See `Reference `__ for details. + """ + return self.sheet.get(key, + fields='properties,sheets(properties,protectedRanges,merges,conditionalFormats,filterViews),spreadsheetId,namedRanges', + includeGridData=False) + + def get_range(self, spreadsheet_id, + value_range=None, + major_dimension='ROWS', + value_render_option=ValueRenderOption.FORMATTED_VALUE, + date_time_render_option=DateTimeRenderOption.SERIAL_NUMBER, + value_ranges=None): + """Returns a range of values from a spreadsheet. The caller must specify the spreadsheet ID and a range. + + Reference: `request `__ + + :param spreadsheet_id: The ID of the spreadsheet to retrieve data from. + :param value_range: The A1 notation of the values to retrieve. + :param value_ranges: The list of A1 notation of the values to retrieve. + :param major_dimension: The major dimension that results should use. + For example, if the spreadsheet data is: A1=1,B1=2,A2=3,B2=4, then + requesting range=A1:B2,majorDimension=ROWS will return [[1,2],[3,4]], + whereas requesting range=A1:B2,majorDimension=COLUMNS will return + [[1,3],[2,4]]. + :param value_render_option: How values should be represented in the output. The default + render option is `ValueRenderOption.FORMATTED_VALUE`. + :param date_time_render_option: How dates, times, and durations should be represented in the output. + This is ignored if `valueRenderOption` is `FORMATTED_VALUE`. The default + dateTime render option is [`DateTimeRenderOption.SERIAL_NUMBER`]. + :return: An array of arrays with the values fetched. Returns an empty array if no + values were fetched. Values are dynamically typed as int, float or string. + """ + if value_range: + result = self.sheet.values_get(spreadsheet_id, value_range, major_dimension, value_render_option, + date_time_render_option) + try: + return result['values'] + except KeyError: + return [['']] + elif value_ranges: + results = self.sheet.values_batch_get(spreadsheet_id, value_ranges, major_dimension, value_render_option, + date_time_render_option) + values = [] + for result in results: + try: + values.append(result['values']) + except KeyError: + values.append([['']]) + return values diff --git a/venv/lib/python3.10/site-packages/pygsheets/custom_types.py b/venv/lib/python3.10/site-packages/pygsheets/custom_types.py new file mode 100644 index 0000000000000000000000000000000000000000..36b1e7a10f54671c17297a5926a6aeb9ed626f18 --- /dev/null +++ b/venv/lib/python3.10/site-packages/pygsheets/custom_types.py @@ -0,0 +1,121 @@ +# -*- coding: utf-8 -*-. + +""" +pygsheets.custom_types +~~~~~~~~~~~~~~~~~~~~~~ + +This module contains common Enums used in pygsheets + +""" + +from enum import Enum + + +# @TODO use this +class WorkSheetProperty(Enum): + """available properties of worksheets""" + TITLE = 'title' + ID = 'id' + INDEX = 'index' + + +class ValueRenderOption(Enum): + """Determines how values should be rendered in the output. + + `ValueRenderOption Docs `_ + + FORMATTED_VALUE: Values will be calculated & formatted in the reply according to the cell's formatting. + Formatting is based on the spreadsheet's locale, not the requesting user's locale. + For example, if A1 is 1.23 and A2 is =A1 and formatted as currency, + then A2 would return "$1.23". + + UNFORMATTED_VALUE : Values will be calculated, but not formatted in the reply. + For example, if A1 is 1.23 and A2 is =A1 and formatted as currency, + then A2 would return the number 1.23. + + FORMULA : Values will not be calculated. The reply will include the formulas. + For example, if A1 is 1.23 and A2 is =A1 and formatted as currency, then A2 would return "=A1". + """ + FORMATTED_VALUE = 'FORMATTED_VALUE' + UNFORMATTED_VALUE = 'UNFORMATTED_VALUE' + FORMULA = 'FORMULA' + + +class DateTimeRenderOption(Enum): + """Determines how dates should be rendered in the output. + + `DateTimeRenderOption Doc `_ + + SERIAL_NUMBER: Instructs date, time, datetime, and duration fields to be output as doubles in "serial number" + format, as popularized by Lotus 1-2-3. The whole number portion of the value (left of the + decimal) counts the days since December 30th 1899. The fractional portion (right of the decimal) + counts the time as a fraction of the day. For example, January 1st 1900 at noon would be 2.5, 2 + because it's 2 days after December 30st 1899, and .5 because noon is half a day. February 1st + 1900 at 3pm would be 33.625. This correctly treats the year 1900 as not a leap year. + + FORMATTED_STRING: Instructs date, time, datetime, and duration fields to be output as strings in their given + number format (which is dependent on the spreadsheet locale). + """ + SERIAL_NUMBER = 'SERIAL_NUMBER' + FORMATTED_STRING = 'FORMATTED_STRING' + + +class FormatType(Enum): + """Enum for cell formats.""" + CUSTOM = None + TEXT = 'TEXT' + NUMBER = 'NUMBER' + PERCENT = 'PERCENT' + CURRENCY = 'CURRENCY' + DATE = 'DATE' + TIME = 'TIME' + DATE_TIME = 'DATE_TIME' + SCIENTIFIC = 'SCIENTIFIC' + + +class ExportType(Enum): + """Enum for possible export types""" + XLS = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet:.xls" + ODT = "application/x-vnd.oasis.opendocument.spreadsheet:.odt" + PDF = "application/pdf:.pdf" + CSV = "text/csv:.csv" + TSV = 'text/tab-separated-values:.tsv' + HTML = 'application/zip:.zip' + + +class HorizontalAlignment(Enum): + """Horizontal alignment of the cell. + + `HorizontalAlignment doc `_ + + """ + LEFT = 'LEFT' + RIGHT = 'RIGHT' + CENTER = 'CENTER' + NONE = None + + +class VerticalAlignment(Enum): + """Vertical alignment of the cell. + + `VerticalAlignment doc `_ + + """ + TOP = 'TOP' + MIDDLE = 'MIDDLE' + BOTTOM = 'BOTTOM' + NONE = None + + +class ChartType(Enum): + """Enum for basic chart types + + Reference: `insert request `_ + """ + BAR = "BAR" + LINE = "LINE" + AREA = "AREA" + COLUMN = "COLUMN" + SCATTER = "SCATTER" + COMBO = "COMBO" + STEPPED_AREA = "STEPPED_AREA" diff --git a/venv/lib/python3.10/site-packages/pygsheets/data/drive_discovery.json b/venv/lib/python3.10/site-packages/pygsheets/data/drive_discovery.json new file mode 100644 index 0000000000000000000000000000000000000000..f55b83af5177b6f8eda24cd315423fbf30c6d8b7 --- /dev/null +++ b/venv/lib/python3.10/site-packages/pygsheets/data/drive_discovery.json @@ -0,0 +1,4400 @@ +{ + "kind": "discovery#restDescription", + "etag": "\"uWj2hSb4GVjzdDlAnRd2gbM1ZQ8/a8KMcrnrtNnIzQGgPxu2yf5CeKU\"", + "discoveryVersion": "v1", + "id": "drive:v3", + "name": "drive", + "version": "v3", + "revision": "20220919", + "title": "Drive API", + "description": "Manages files in Drive including uploading, downloading, searching, detecting changes, and updating sharing permissions.", + "ownerDomain": "google.com", + "ownerName": "Google", + "icons": { + "x16": "https://ssl.gstatic.com/docs/doclist/images/drive_icon_16.png", + "x32": "https://ssl.gstatic.com/docs/doclist/images/drive_icon_32.png" + }, + "documentationLink": "https://developers.google.com/drive/", + "protocol": "rest", + "baseUrl": "https://www.googleapis.com/drive/v3/", + "basePath": "/drive/v3/", + "rootUrl": "https://www.googleapis.com/", + "servicePath": "drive/v3/", + "batchPath": "batch/drive/v3", + "parameters": { + "alt": { + "type": "string", + "description": "Data format for the response.", + "default": "json", + "enum": [ + "json" + ], + "enumDescriptions": [ + "Responses with Content-Type of application/json" + ], + "location": "query" + }, + "fields": { + "type": "string", + "description": "Selector specifying which fields to include in a partial response.", + "location": "query" + }, + "key": { + "type": "string", + "description": "API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token.", + "location": "query" + }, + "oauth_token": { + "type": "string", + "description": "OAuth 2.0 token for the current user.", + "location": "query" + }, + "prettyPrint": { + "type": "boolean", + "description": "Returns response with indentations and line breaks.", + "default": "true", + "location": "query" + }, + "quotaUser": { + "type": "string", + "description": "An opaque string that represents a user for quota purposes. Must not exceed 40 characters.", + "location": "query" + }, + "userIp": { + "type": "string", + "description": "Deprecated. Please use quotaUser instead.", + "location": "query" + } + }, + "auth": { + "oauth2": { + "scopes": { + "https://www.googleapis.com/auth/drive": { + "description": "See, edit, create, and delete all of your Google Drive files" + }, + "https://www.googleapis.com/auth/drive.appdata": { + "description": "See, create, and delete its own configuration data in your Google Drive" + }, + "https://www.googleapis.com/auth/drive.file": { + "description": "See, edit, create, and delete only the specific Google Drive files you use with this app" + }, + "https://www.googleapis.com/auth/drive.metadata": { + "description": "View and manage metadata of files in your Google Drive" + }, + "https://www.googleapis.com/auth/drive.metadata.readonly": { + "description": "See information about your Google Drive files" + }, + "https://www.googleapis.com/auth/drive.photos.readonly": { + "description": "View the photos, videos and albums in your Google Photos" + }, + "https://www.googleapis.com/auth/drive.readonly": { + "description": "See and download all your Google Drive files" + }, + "https://www.googleapis.com/auth/drive.scripts": { + "description": "Modify your Google Apps Script scripts' behavior" + } + } + } + }, + "schemas": { + "About": { + "id": "About", + "type": "object", + "description": "Information about the user, the user's Drive, and system capabilities.", + "properties": { + "appInstalled": { + "type": "boolean", + "description": "Whether the user has installed the requesting app." + }, + "canCreateDrives": { + "type": "boolean", + "description": "Whether the user can create shared drives." + }, + "canCreateTeamDrives": { + "type": "boolean", + "description": "Deprecated - use canCreateDrives instead." + }, + "driveThemes": { + "type": "array", + "description": "A list of themes that are supported for shared drives.", + "items": { + "type": "object", + "properties": { + "backgroundImageLink": { + "type": "string", + "description": "A link to this theme's background image." + }, + "colorRgb": { + "type": "string", + "description": "The color of this theme as an RGB hex string." + }, + "id": { + "type": "string", + "description": "The ID of the theme." + } + } + } + }, + "exportFormats": { + "type": "object", + "description": "A map of source MIME type to possible targets for all supported exports.", + "additionalProperties": { + "type": "array", + "items": { + "type": "string" + } + } + }, + "folderColorPalette": { + "type": "array", + "description": "The currently supported folder colors as RGB hex strings.", + "items": { + "type": "string" + } + }, + "importFormats": { + "type": "object", + "description": "A map of source MIME type to possible targets for all supported imports.", + "additionalProperties": { + "type": "array", + "items": { + "type": "string" + } + } + }, + "kind": { + "type": "string", + "description": "Identifies what kind of resource this is. Value: the fixed string \"drive#about\".", + "default": "drive#about" + }, + "maxImportSizes": { + "type": "object", + "description": "A map of maximum import sizes by MIME type, in bytes.", + "additionalProperties": { + "type": "string", + "format": "int64" + } + }, + "maxUploadSize": { + "type": "string", + "description": "The maximum upload size in bytes.", + "format": "int64" + }, + "storageQuota": { + "type": "object", + "description": "The user's storage quota limits and usage. All fields are measured in bytes.", + "properties": { + "limit": { + "type": "string", + "description": "The usage limit, if applicable. This will not be present if the user has unlimited storage.", + "format": "int64" + }, + "usage": { + "type": "string", + "description": "The total usage across all services.", + "format": "int64" + }, + "usageInDrive": { + "type": "string", + "description": "The usage by all files in Google Drive.", + "format": "int64" + }, + "usageInDriveTrash": { + "type": "string", + "description": "The usage by trashed files in Google Drive.", + "format": "int64" + } + } + }, + "teamDriveThemes": { + "type": "array", + "description": "Deprecated - use driveThemes instead.", + "items": { + "type": "object", + "properties": { + "backgroundImageLink": { + "type": "string", + "description": "Deprecated - use driveThemes/backgroundImageLink instead." + }, + "colorRgb": { + "type": "string", + "description": "Deprecated - use driveThemes/colorRgb instead." + }, + "id": { + "type": "string", + "description": "Deprecated - use driveThemes/id instead." + } + } + } + }, + "user": { + "$ref": "User", + "description": "The authenticated user." + } + } + }, + "Change": { + "id": "Change", + "type": "object", + "description": "A change to a file or shared drive.", + "properties": { + "changeType": { + "type": "string", + "description": "The type of the change. Possible values are file and drive." + }, + "drive": { + "$ref": "Drive", + "description": "The updated state of the shared drive. Present if the changeType is drive, the user is still a member of the shared drive, and the shared drive has not been deleted." + }, + "driveId": { + "type": "string", + "description": "The ID of the shared drive associated with this change." + }, + "file": { + "$ref": "File", + "description": "The updated state of the file. Present if the type is file and the file has not been removed from this list of changes." + }, + "fileId": { + "type": "string", + "description": "The ID of the file which has changed." + }, + "kind": { + "type": "string", + "description": "Identifies what kind of resource this is. Value: the fixed string \"drive#change\".", + "default": "drive#change" + }, + "removed": { + "type": "boolean", + "description": "Whether the file or shared drive has been removed from this list of changes, for example by deletion or loss of access." + }, + "teamDrive": { + "$ref": "TeamDrive", + "description": "Deprecated - use drive instead." + }, + "teamDriveId": { + "type": "string", + "description": "Deprecated - use driveId instead." + }, + "time": { + "type": "string", + "description": "The time of this change (RFC 3339 date-time).", + "format": "date-time" + }, + "type": { + "type": "string", + "description": "Deprecated - use changeType instead." + } + } + }, + "ChangeList": { + "id": "ChangeList", + "type": "object", + "description": "A list of changes for a user.", + "properties": { + "changes": { + "type": "array", + "description": "The list of changes. If nextPageToken is populated, then this list may be incomplete and an additional page of results should be fetched.", + "items": { + "$ref": "Change" + } + }, + "kind": { + "type": "string", + "description": "Identifies what kind of resource this is. Value: the fixed string \"drive#changeList\".", + "default": "drive#changeList" + }, + "newStartPageToken": { + "type": "string", + "description": "The starting page token for future changes. This will be present only if the end of the current changes list has been reached." + }, + "nextPageToken": { + "type": "string", + "description": "The page token for the next page of changes. This will be absent if the end of the changes list has been reached. If the token is rejected for any reason, it should be discarded, and pagination should be restarted from the first page of results." + } + } + }, + "Channel": { + "id": "Channel", + "type": "object", + "description": "An notification channel used to watch for resource changes.", + "properties": { + "address": { + "type": "string", + "description": "The address where notifications are delivered for this channel." + }, + "expiration": { + "type": "string", + "description": "Date and time of notification channel expiration, expressed as a Unix timestamp, in milliseconds. Optional.", + "format": "int64" + }, + "id": { + "type": "string", + "description": "A UUID or similar unique string that identifies this channel." + }, + "kind": { + "type": "string", + "description": "Identifies this as a notification channel used to watch for changes to a resource, which is \"api#channel\".", + "default": "api#channel" + }, + "params": { + "type": "object", + "description": "Additional parameters controlling delivery channel behavior. Optional.", + "additionalProperties": { + "type": "string", + "description": "Declares a new parameter by name." + } + }, + "payload": { + "type": "boolean", + "description": "A Boolean value to indicate whether payload is wanted. Optional." + }, + "resourceId": { + "type": "string", + "description": "An opaque ID that identifies the resource being watched on this channel. Stable across different API versions." + }, + "resourceUri": { + "type": "string", + "description": "A version-specific identifier for the watched resource." + }, + "token": { + "type": "string", + "description": "An arbitrary string delivered to the target address with each notification delivered over this channel. Optional." + }, + "type": { + "type": "string", + "description": "The type of delivery mechanism used for this channel. Valid values are \"web_hook\" (or \"webhook\"). Both values refer to a channel where Http requests are used to deliver messages." + } + } + }, + "Comment": { + "id": "Comment", + "type": "object", + "description": "A comment on a file.", + "properties": { + "anchor": { + "type": "string", + "description": "A region of the document represented as a JSON string. For details on defining anchor properties, refer to Add comments and replies." + }, + "author": { + "$ref": "User", + "description": "The author of the comment. The author's email address and permission ID will not be populated." + }, + "content": { + "type": "string", + "description": "The plain text content of the comment. This field is used for setting the content, while htmlContent should be displayed.", + "annotations": { + "required": [ + "drive.comments.create", + "drive.comments.update" + ] + } + }, + "createdTime": { + "type": "string", + "description": "The time at which the comment was created (RFC 3339 date-time).", + "format": "date-time" + }, + "deleted": { + "type": "boolean", + "description": "Whether the comment has been deleted. A deleted comment has no content." + }, + "htmlContent": { + "type": "string", + "description": "The content of the comment with HTML formatting." + }, + "id": { + "type": "string", + "description": "The ID of the comment." + }, + "kind": { + "type": "string", + "description": "Identifies what kind of resource this is. Value: the fixed string \"drive#comment\".", + "default": "drive#comment" + }, + "modifiedTime": { + "type": "string", + "description": "The last time the comment or any of its replies was modified (RFC 3339 date-time).", + "format": "date-time" + }, + "quotedFileContent": { + "type": "object", + "description": "The file content to which the comment refers, typically within the anchor region. For a text file, for example, this would be the text at the location of the comment.", + "properties": { + "mimeType": { + "type": "string", + "description": "The MIME type of the quoted content." + }, + "value": { + "type": "string", + "description": "The quoted content itself. This is interpreted as plain text if set through the API." + } + } + }, + "replies": { + "type": "array", + "description": "The full list of replies to the comment in chronological order.", + "items": { + "$ref": "Reply" + } + }, + "resolved": { + "type": "boolean", + "description": "Whether the comment has been resolved by one of its replies." + } + } + }, + "CommentList": { + "id": "CommentList", + "type": "object", + "description": "A list of comments on a file.", + "properties": { + "comments": { + "type": "array", + "description": "The list of comments. If nextPageToken is populated, then this list may be incomplete and an additional page of results should be fetched.", + "items": { + "$ref": "Comment" + } + }, + "kind": { + "type": "string", + "description": "Identifies what kind of resource this is. Value: the fixed string \"drive#commentList\".", + "default": "drive#commentList" + }, + "nextPageToken": { + "type": "string", + "description": "The page token for the next page of comments. This will be absent if the end of the comments list has been reached. If the token is rejected for any reason, it should be discarded, and pagination should be restarted from the first page of results." + } + } + }, + "ContentRestriction": { + "id": "ContentRestriction", + "type": "object", + "description": "A restriction for accessing the content of the file.", + "properties": { + "readOnly": { + "type": "boolean", + "description": "Whether the content of the file is read-only. If a file is read-only, a new revision of the file may not be added, comments may not be added or modified, and the title of the file may not be modified." + }, + "reason": { + "type": "string", + "description": "Reason for why the content of the file is restricted. This is only mutable on requests that also set readOnly=true." + }, + "restrictingUser": { + "$ref": "User", + "description": "The user who set the content restriction. Only populated if readOnly is true." + }, + "restrictionTime": { + "type": "string", + "description": "The time at which the content restriction was set (formatted RFC 3339 timestamp). Only populated if readOnly is true.", + "format": "date-time" + }, + "type": { + "type": "string", + "description": "The type of the content restriction. Currently the only possible value is globalContentRestriction." + } + } + }, + "Drive": { + "id": "Drive", + "type": "object", + "description": "Representation of a shared drive.", + "properties": { + "backgroundImageFile": { + "type": "object", + "description": "An image file and cropping parameters from which a background image for this shared drive is set. This is a write only field; it can only be set on drive.drives.update requests that don't set themeId. When specified, all fields of the backgroundImageFile must be set.", + "properties": { + "id": { + "type": "string", + "description": "The ID of an image file in Google Drive to use for the background image." + }, + "width": { + "type": "number", + "description": "The width of the cropped image in the closed range of 0 to 1. This value represents the width of the cropped image divided by the width of the entire image. The height is computed by applying a width to height aspect ratio of 80 to 9. The resulting image must be at least 1280 pixels wide and 144 pixels high.", + "format": "float" + }, + "xCoordinate": { + "type": "number", + "description": "The X coordinate of the upper left corner of the cropping area in the background image. This is a value in the closed range of 0 to 1. This value represents the horizontal distance from the left side of the entire image to the left side of the cropping area divided by the width of the entire image.", + "format": "float" + }, + "yCoordinate": { + "type": "number", + "description": "The Y coordinate of the upper left corner of the cropping area in the background image. This is a value in the closed range of 0 to 1. This value represents the vertical distance from the top side of the entire image to the top side of the cropping area divided by the height of the entire image.", + "format": "float" + } + } + }, + "backgroundImageLink": { + "type": "string", + "description": "A short-lived link to this shared drive's background image." + }, + "capabilities": { + "type": "object", + "description": "Capabilities the current user has on this shared drive.", + "properties": { + "canAddChildren": { + "type": "boolean", + "description": "Whether the current user can add children to folders in this shared drive." + }, + "canChangeCopyRequiresWriterPermissionRestriction": { + "type": "boolean", + "description": "Whether the current user can change the copyRequiresWriterPermission restriction of this shared drive." + }, + "canChangeDomainUsersOnlyRestriction": { + "type": "boolean", + "description": "Whether the current user can change the domainUsersOnly restriction of this shared drive." + }, + "canChangeDriveBackground": { + "type": "boolean", + "description": "Whether the current user can change the background of this shared drive." + }, + "canChangeDriveMembersOnlyRestriction": { + "type": "boolean", + "description": "Whether the current user can change the driveMembersOnly restriction of this shared drive." + }, + "canComment": { + "type": "boolean", + "description": "Whether the current user can comment on files in this shared drive." + }, + "canCopy": { + "type": "boolean", + "description": "Whether the current user can copy files in this shared drive." + }, + "canDeleteChildren": { + "type": "boolean", + "description": "Whether the current user can delete children from folders in this shared drive." + }, + "canDeleteDrive": { + "type": "boolean", + "description": "Whether the current user can delete this shared drive. Attempting to delete the shared drive may still fail if there are untrashed items inside the shared drive." + }, + "canDownload": { + "type": "boolean", + "description": "Whether the current user can download files in this shared drive." + }, + "canEdit": { + "type": "boolean", + "description": "Whether the current user can edit files in this shared drive" + }, + "canListChildren": { + "type": "boolean", + "description": "Whether the current user can list the children of folders in this shared drive." + }, + "canManageMembers": { + "type": "boolean", + "description": "Whether the current user can add members to this shared drive or remove them or change their role." + }, + "canReadRevisions": { + "type": "boolean", + "description": "Whether the current user can read the revisions resource of files in this shared drive." + }, + "canRename": { + "type": "boolean", + "description": "Whether the current user can rename files or folders in this shared drive." + }, + "canRenameDrive": { + "type": "boolean", + "description": "Whether the current user can rename this shared drive." + }, + "canResetDriveRestrictions": { + "type": "boolean", + "description": "Whether the current user can reset the shared drive restrictions to defaults." + }, + "canShare": { + "type": "boolean", + "description": "Whether the current user can share files or folders in this shared drive." + }, + "canTrashChildren": { + "type": "boolean", + "description": "Whether the current user can trash children from folders in this shared drive." + } + } + }, + "colorRgb": { + "type": "string", + "description": "The color of this shared drive as an RGB hex string. It can only be set on a drive.drives.update request that does not set themeId." + }, + "createdTime": { + "type": "string", + "description": "The time at which the shared drive was created (RFC 3339 date-time).", + "format": "date-time" + }, + "hidden": { + "type": "boolean", + "description": "Whether the shared drive is hidden from default view." + }, + "id": { + "type": "string", + "description": "The ID of this shared drive which is also the ID of the top level folder of this shared drive." + }, + "kind": { + "type": "string", + "description": "Identifies what kind of resource this is. Value: the fixed string \"drive#drive\".", + "default": "drive#drive" + }, + "name": { + "type": "string", + "description": "The name of this shared drive.", + "annotations": { + "required": [ + "drive.drives.create" + ] + } + }, + "orgUnitId": { + "type": "string", + "description": "The organizational unit of this shared drive. This field is only populated on drives.list responses when the useDomainAdminAccess parameter is set to true." + }, + "restrictions": { + "type": "object", + "description": "A set of restrictions that apply to this shared drive or items inside this shared drive.", + "properties": { + "adminManagedRestrictions": { + "type": "boolean", + "description": "Whether administrative privileges on this shared drive are required to modify restrictions." + }, + "copyRequiresWriterPermission": { + "type": "boolean", + "description": "Whether the options to copy, print, or download files inside this shared drive, should be disabled for readers and commenters. When this restriction is set to true, it will override the similarly named field to true for any file inside this shared drive." + }, + "domainUsersOnly": { + "type": "boolean", + "description": "Whether access to this shared drive and items inside this shared drive is restricted to users of the domain to which this shared drive belongs. This restriction may be overridden by other sharing policies controlled outside of this shared drive." + }, + "driveMembersOnly": { + "type": "boolean", + "description": "Whether access to items inside this shared drive is restricted to its members." + } + } + }, + "themeId": { + "type": "string", + "description": "The ID of the theme from which the background image and color will be set. The set of possible driveThemes can be retrieved from a drive.about.get response. When not specified on a drive.drives.create request, a random theme is chosen from which the background image and color are set. This is a write-only field; it can only be set on requests that don't set colorRgb or backgroundImageFile." + } + } + }, + "DriveList": { + "id": "DriveList", + "type": "object", + "description": "A list of shared drives.", + "properties": { + "drives": { + "type": "array", + "description": "The list of shared drives. If nextPageToken is populated, then this list may be incomplete and an additional page of results should be fetched.", + "items": { + "$ref": "Drive" + } + }, + "kind": { + "type": "string", + "description": "Identifies what kind of resource this is. Value: the fixed string \"drive#driveList\".", + "default": "drive#driveList" + }, + "nextPageToken": { + "type": "string", + "description": "The page token for the next page of shared drives. This will be absent if the end of the list has been reached. If the token is rejected for any reason, it should be discarded, and pagination should be restarted from the first page of results." + } + } + }, + "File": { + "id": "File", + "type": "object", + "description": "The metadata for a file.", + "properties": { + "appProperties": { + "type": "object", + "description": "A collection of arbitrary key-value pairs which are private to the requesting app.\nEntries with null values are cleared in update and copy requests. These properties can only be retrieved using an authenticated request. An authenticated request uses an access token obtained with a OAuth 2 client ID. You cannot use an API key to retrieve private properties.", + "additionalProperties": { + "type": "string" + } + }, + "capabilities": { + "type": "object", + "description": "Capabilities the current user has on this file. Each capability corresponds to a fine-grained action that a user may take.", + "properties": { + "canAcceptOwnership": { + "type": "boolean", + "description": "Whether the current user is the pending owner of the file. Not populated for shared drive files." + }, + "canAddChildren": { + "type": "boolean", + "description": "Whether the current user can add children to this folder. This is always false when the item is not a folder." + }, + "canAddFolderFromAnotherDrive": { + "type": "boolean", + "description": "Whether the current user can add a folder from another drive (different shared drive or My Drive) to this folder. This is false when the item is not a folder. Only populated for items in shared drives." + }, + "canAddMyDriveParent": { + "type": "boolean", + "description": "Whether the current user can add a parent for the item without removing an existing parent in the same request. Not populated for shared drive files." + }, + "canChangeCopyRequiresWriterPermission": { + "type": "boolean", + "description": "Whether the current user can change the copyRequiresWriterPermission restriction of this file." + }, + "canChangeSecurityUpdateEnabled": { + "type": "boolean", + "description": "Whether the current user can change the securityUpdateEnabled field on link share metadata." + }, + "canChangeViewersCanCopyContent": { + "type": "boolean", + "description": "Deprecated" + }, + "canComment": { + "type": "boolean", + "description": "Whether the current user can comment on this file." + }, + "canCopy": { + "type": "boolean", + "description": "Whether the current user can copy this file. For an item in a shared drive, whether the current user can copy non-folder descendants of this item, or this item itself if it is not a folder." + }, + "canDelete": { + "type": "boolean", + "description": "Whether the current user can delete this file." + }, + "canDeleteChildren": { + "type": "boolean", + "description": "Whether the current user can delete children of this folder. This is false when the item is not a folder. Only populated for items in shared drives." + }, + "canDownload": { + "type": "boolean", + "description": "Whether the current user can download this file." + }, + "canEdit": { + "type": "boolean", + "description": "Whether the current user can edit this file. Other factors may limit the type of changes a user can make to a file. For example, see canChangeCopyRequiresWriterPermission or canModifyContent." + }, + "canListChildren": { + "type": "boolean", + "description": "Whether the current user can list the children of this folder. This is always false when the item is not a folder." + }, + "canModifyContent": { + "type": "boolean", + "description": "Whether the current user can modify the content of this file." + }, + "canModifyContentRestriction": { + "type": "boolean", + "description": "Whether the current user can modify restrictions on content of this file." + }, + "canModifyLabels": { + "type": "boolean", + "description": "Whether the current user can modify the labels on this file." + }, + "canMoveChildrenOutOfDrive": { + "type": "boolean", + "description": "Whether the current user can move children of this folder outside of the shared drive. This is false when the item is not a folder. Only populated for items in shared drives." + }, + "canMoveChildrenOutOfTeamDrive": { + "type": "boolean", + "description": "Deprecated - use canMoveChildrenOutOfDrive instead." + }, + "canMoveChildrenWithinDrive": { + "type": "boolean", + "description": "Whether the current user can move children of this folder within this drive. This is false when the item is not a folder. Note that a request to move the child may still fail depending on the current user's access to the child and to the destination folder." + }, + "canMoveChildrenWithinTeamDrive": { + "type": "boolean", + "description": "Deprecated - use canMoveChildrenWithinDrive instead." + }, + "canMoveItemIntoTeamDrive": { + "type": "boolean", + "description": "Deprecated - use canMoveItemOutOfDrive instead." + }, + "canMoveItemOutOfDrive": { + "type": "boolean", + "description": "Whether the current user can move this item outside of this drive by changing its parent. Note that a request to change the parent of the item may still fail depending on the new parent that is being added." + }, + "canMoveItemOutOfTeamDrive": { + "type": "boolean", + "description": "Deprecated - use canMoveItemOutOfDrive instead." + }, + "canMoveItemWithinDrive": { + "type": "boolean", + "description": "Whether the current user can move this item within this drive. Note that a request to change the parent of the item may still fail depending on the new parent that is being added and the parent that is being removed." + }, + "canMoveItemWithinTeamDrive": { + "type": "boolean", + "description": "Deprecated - use canMoveItemWithinDrive instead." + }, + "canMoveTeamDriveItem": { + "type": "boolean", + "description": "Deprecated - use canMoveItemWithinDrive or canMoveItemOutOfDrive instead." + }, + "canReadDrive": { + "type": "boolean", + "description": "Whether the current user can read the shared drive to which this file belongs. Only populated for items in shared drives." + }, + "canReadLabels": { + "type": "boolean", + "description": "Whether the current user can read the labels on this file." + }, + "canReadRevisions": { + "type": "boolean", + "description": "Whether the current user can read the revisions resource of this file. For a shared drive item, whether revisions of non-folder descendants of this item, or this item itself if it is not a folder, can be read." + }, + "canReadTeamDrive": { + "type": "boolean", + "description": "Deprecated - use canReadDrive instead." + }, + "canRemoveChildren": { + "type": "boolean", + "description": "Whether the current user can remove children from this folder. This is always false when the item is not a folder. For a folder in a shared drive, use canDeleteChildren or canTrashChildren instead." + }, + "canRemoveMyDriveParent": { + "type": "boolean", + "description": "Whether the current user can remove a parent from the item without adding another parent in the same request. Not populated for shared drive files." + }, + "canRename": { + "type": "boolean", + "description": "Whether the current user can rename this file." + }, + "canShare": { + "type": "boolean", + "description": "Whether the current user can modify the sharing settings for this file." + }, + "canTrash": { + "type": "boolean", + "description": "Whether the current user can move this file to trash." + }, + "canTrashChildren": { + "type": "boolean", + "description": "Whether the current user can trash children of this folder. This is false when the item is not a folder. Only populated for items in shared drives." + }, + "canUntrash": { + "type": "boolean", + "description": "Whether the current user can restore this file from trash." + } + } + }, + "contentHints": { + "type": "object", + "description": "Additional information about the content of the file. These fields are never populated in responses.", + "properties": { + "indexableText": { + "type": "string", + "description": "Text to be indexed for the file to improve fullText queries. This is limited to 128KB in length and may contain HTML elements." + }, + "thumbnail": { + "type": "object", + "description": "A thumbnail for the file. This will only be used if Google Drive cannot generate a standard thumbnail.", + "properties": { + "image": { + "type": "string", + "description": "The thumbnail data encoded with URL-safe Base64 (RFC 4648 section 5).", + "format": "byte" + }, + "mimeType": { + "type": "string", + "description": "The MIME type of the thumbnail." + } + } + } + } + }, + "contentRestrictions": { + "type": "array", + "description": "Restrictions for accessing the content of the file. Only populated if such a restriction exists.", + "items": { + "$ref": "ContentRestriction" + } + }, + "copyRequiresWriterPermission": { + "type": "boolean", + "description": "Whether the options to copy, print, or download this file, should be disabled for readers and commenters." + }, + "createdTime": { + "type": "string", + "description": "The time at which the file was created (RFC 3339 date-time).", + "format": "date-time" + }, + "description": { + "type": "string", + "description": "A short description of the file." + }, + "driveId": { + "type": "string", + "description": "ID of the shared drive the file resides in. Only populated for items in shared drives." + }, + "explicitlyTrashed": { + "type": "boolean", + "description": "Whether the file has been explicitly trashed, as opposed to recursively trashed from a parent folder." + }, + "exportLinks": { + "type": "object", + "description": "Links for exporting Docs Editors files to specific formats.", + "readOnly": true, + "additionalProperties": { + "type": "string", + "description": "A mapping from export format to URL" + } + }, + "fileExtension": { + "type": "string", + "description": "The final component of fullFileExtension. This is only available for files with binary content in Google Drive." + }, + "folderColorRgb": { + "type": "string", + "description": "The color for a folder or shortcut to a folder as an RGB hex string. The supported colors are published in the folderColorPalette field of the About resource.\nIf an unsupported color is specified, the closest color in the palette will be used instead." + }, + "fullFileExtension": { + "type": "string", + "description": "The full file extension extracted from the name field. May contain multiple concatenated extensions, such as \"tar.gz\". This is only available for files with binary content in Google Drive.\nThis is automatically updated when the name field changes, however it is not cleared if the new name does not contain a valid extension." + }, + "hasAugmentedPermissions": { + "type": "boolean", + "description": "Whether there are permissions directly on this file. This field is only populated for items in shared drives." + }, + "hasThumbnail": { + "type": "boolean", + "description": "Whether this file has a thumbnail. This does not indicate whether the requesting app has access to the thumbnail. To check access, look for the presence of the thumbnailLink field." + }, + "headRevisionId": { + "type": "string", + "description": "The ID of the file's head revision. This is currently only available for files with binary content in Google Drive." + }, + "iconLink": { + "type": "string", + "description": "A static, unauthenticated link to the file's icon." + }, + "id": { + "type": "string", + "description": "The ID of the file." + }, + "imageMediaMetadata": { + "type": "object", + "description": "Additional metadata about image media, if available.", + "properties": { + "aperture": { + "type": "number", + "description": "The aperture used to create the photo (f-number).", + "format": "float" + }, + "cameraMake": { + "type": "string", + "description": "The make of the camera used to create the photo." + }, + "cameraModel": { + "type": "string", + "description": "The model of the camera used to create the photo." + }, + "colorSpace": { + "type": "string", + "description": "The color space of the photo." + }, + "exposureBias": { + "type": "number", + "description": "The exposure bias of the photo (APEX value).", + "format": "float" + }, + "exposureMode": { + "type": "string", + "description": "The exposure mode used to create the photo." + }, + "exposureTime": { + "type": "number", + "description": "The length of the exposure, in seconds.", + "format": "float" + }, + "flashUsed": { + "type": "boolean", + "description": "Whether a flash was used to create the photo." + }, + "focalLength": { + "type": "number", + "description": "The focal length used to create the photo, in millimeters.", + "format": "float" + }, + "height": { + "type": "integer", + "description": "The height of the image in pixels.", + "format": "int32" + }, + "isoSpeed": { + "type": "integer", + "description": "The ISO speed used to create the photo.", + "format": "int32" + }, + "lens": { + "type": "string", + "description": "The lens used to create the photo." + }, + "location": { + "type": "object", + "description": "Geographic location information stored in the image.", + "properties": { + "altitude": { + "type": "number", + "description": "The altitude stored in the image.", + "format": "double" + }, + "latitude": { + "type": "number", + "description": "The latitude stored in the image.", + "format": "double" + }, + "longitude": { + "type": "number", + "description": "The longitude stored in the image.", + "format": "double" + } + } + }, + "maxApertureValue": { + "type": "number", + "description": "The smallest f-number of the lens at the focal length used to create the photo (APEX value).", + "format": "float" + }, + "meteringMode": { + "type": "string", + "description": "The metering mode used to create the photo." + }, + "rotation": { + "type": "integer", + "description": "The number of clockwise 90 degree rotations applied from the image's original orientation.", + "format": "int32" + }, + "sensor": { + "type": "string", + "description": "The type of sensor used to create the photo." + }, + "subjectDistance": { + "type": "integer", + "description": "The distance to the subject of the photo, in meters.", + "format": "int32" + }, + "time": { + "type": "string", + "description": "The date and time the photo was taken (EXIF DateTime)." + }, + "whiteBalance": { + "type": "string", + "description": "The white balance mode used to create the photo." + }, + "width": { + "type": "integer", + "description": "The width of the image in pixels.", + "format": "int32" + } + } + }, + "isAppAuthorized": { + "type": "boolean", + "description": "Whether the file was created or opened by the requesting app." + }, + "kind": { + "type": "string", + "description": "Identifies what kind of resource this is. Value: the fixed string \"drive#file\".", + "default": "drive#file" + }, + "labelInfo": { + "type": "object", + "description": "An overview of the labels on the file.", + "properties": { + "labels": { + "type": "array", + "description": "The set of labels on the file as requested by the label IDs in the includeLabels parameter. By default, no labels are returned.", + "items": { + "$ref": "Label" + } + } + } + }, + "lastModifyingUser": { + "$ref": "User", + "description": "The last user to modify the file." + }, + "linkShareMetadata": { + "type": "object", + "description": "Contains details about the link URLs that clients are using to refer to this item.", + "properties": { + "securityUpdateEligible": { + "type": "boolean", + "description": "Whether the file is eligible for security update." + }, + "securityUpdateEnabled": { + "type": "boolean", + "description": "Whether the security update is enabled for this file." + } + } + }, + "md5Checksum": { + "type": "string", + "description": "The MD5 checksum for the content of the file. This is only applicable to files with binary content in Google Drive." + }, + "mimeType": { + "type": "string", + "description": "The MIME type of the file.\nGoogle Drive will attempt to automatically detect an appropriate value from uploaded content if no value is provided. The value cannot be changed unless a new revision is uploaded.\nIf a file is created with a Google Doc MIME type, the uploaded content will be imported if possible. The supported import formats are published in the About resource." + }, + "modifiedByMe": { + "type": "boolean", + "description": "Whether the file has been modified by this user." + }, + "modifiedByMeTime": { + "type": "string", + "description": "The last time the file was modified by the user (RFC 3339 date-time).", + "format": "date-time" + }, + "modifiedTime": { + "type": "string", + "description": "The last time the file was modified by anyone (RFC 3339 date-time).\nNote that setting modifiedTime will also update modifiedByMeTime for the user.", + "format": "date-time" + }, + "name": { + "type": "string", + "description": "The name of the file. This is not necessarily unique within a folder. Note that for immutable items such as the top level folders of shared drives, My Drive root folder, and Application Data folder the name is constant." + }, + "originalFilename": { + "type": "string", + "description": "The original filename of the uploaded content if available, or else the original value of the name field. This is only available for files with binary content in Google Drive." + }, + "ownedByMe": { + "type": "boolean", + "description": "Whether the user owns the file. Not populated for items in shared drives." + }, + "owners": { + "type": "array", + "description": "The owner of this file. Only certain legacy files may have more than one owner. This field isn't populated for items in shared drives.", + "items": { + "$ref": "User" + } + }, + "parents": { + "type": "array", + "description": "The IDs of the parent folders which contain the file.\nIf not specified as part of a create request, the file will be placed directly in the user's My Drive folder. If not specified as part of a copy request, the file will inherit any discoverable parents of the source file. Update requests must use the addParents and removeParents parameters to modify the parents list.", + "items": { + "type": "string" + } + }, + "permissionIds": { + "type": "array", + "description": "List of permission IDs for users with access to this file.", + "items": { + "type": "string" + } + }, + "permissions": { + "type": "array", + "description": "The full list of permissions for the file. This is only available if the requesting user can share the file. Not populated for items in shared drives.", + "items": { + "$ref": "Permission" + } + }, + "properties": { + "type": "object", + "description": "A collection of arbitrary key-value pairs which are visible to all apps.\nEntries with null values are cleared in update and copy requests.", + "additionalProperties": { + "type": "string" + } + }, + "quotaBytesUsed": { + "type": "string", + "description": "The number of storage quota bytes used by the file. This includes the head revision as well as previous revisions with keepForever enabled.", + "format": "int64" + }, + "resourceKey": { + "type": "string", + "description": "A key needed to access the item via a shared link." + }, + "sha1Checksum": { + "type": "string", + "description": "The SHA1 checksum associated with this file, if available. This field is only populated for files with content stored in Google Drive; it is not populated for Docs Editors or shortcut files." + }, + "sha256Checksum": { + "type": "string", + "description": "The SHA256 checksum associated with this file, if available. This field is only populated for files with content stored in Google Drive; it is not populated for Docs Editors or shortcut files." + }, + "shared": { + "type": "boolean", + "description": "Whether the file has been shared. Not populated for items in shared drives." + }, + "sharedWithMeTime": { + "type": "string", + "description": "The time at which the file was shared with the user, if applicable (RFC 3339 date-time).", + "format": "date-time" + }, + "sharingUser": { + "$ref": "User", + "description": "The user who shared the file with the requesting user, if applicable." + }, + "shortcutDetails": { + "type": "object", + "description": "Shortcut file details. Only populated for shortcut files, which have the mimeType field set to application/vnd.google-apps.shortcut.", + "properties": { + "targetId": { + "type": "string", + "description": "The ID of the file that this shortcut points to." + }, + "targetMimeType": { + "type": "string", + "description": "The MIME type of the file that this shortcut points to. The value of this field is a snapshot of the target's MIME type, captured when the shortcut is created." + }, + "targetResourceKey": { + "type": "string", + "description": "The ResourceKey for the target file." + } + } + }, + "size": { + "type": "string", + "description": "The size of the file's content in bytes. This is applicable to binary files in Google Drive and Google Docs files.", + "format": "int64" + }, + "spaces": { + "type": "array", + "description": "The list of spaces which contain the file. The currently supported values are 'drive', 'appDataFolder' and 'photos'.", + "items": { + "type": "string" + } + }, + "starred": { + "type": "boolean", + "description": "Whether the user has starred the file." + }, + "teamDriveId": { + "type": "string", + "description": "Deprecated - use driveId instead." + }, + "thumbnailLink": { + "type": "string", + "description": "A short-lived link to the file's thumbnail, if available. Typically lasts on the order of hours. Only populated when the requesting app can access the file's content. If the file isn't shared publicly, the URL returned in Files.thumbnailLink must be fetched using a credentialed request." + }, + "thumbnailVersion": { + "type": "string", + "description": "The thumbnail version for use in thumbnail cache invalidation.", + "format": "int64" + }, + "trashed": { + "type": "boolean", + "description": "Whether the file has been trashed, either explicitly or from a trashed parent folder. Only the owner may trash a file. The trashed item is excluded from all files.list responses returned for any user who does not own the file. However, all users with access to the file can see the trashed item metadata in an API response. All users with access can copy, download, export, and share the file." + }, + "trashedTime": { + "type": "string", + "description": "The time that the item was trashed (RFC 3339 date-time). Only populated for items in shared drives.", + "format": "date-time" + }, + "trashingUser": { + "$ref": "User", + "description": "If the file has been explicitly trashed, the user who trashed it. Only populated for items in shared drives." + }, + "version": { + "type": "string", + "description": "A monotonically increasing version number for the file. This reflects every change made to the file on the server, even those not visible to the user.", + "format": "int64" + }, + "videoMediaMetadata": { + "type": "object", + "description": "Additional metadata about video media. This may not be available immediately upon upload.", + "properties": { + "durationMillis": { + "type": "string", + "description": "The duration of the video in milliseconds.", + "format": "int64" + }, + "height": { + "type": "integer", + "description": "The height of the video in pixels.", + "format": "int32" + }, + "width": { + "type": "integer", + "description": "The width of the video in pixels.", + "format": "int32" + } + } + }, + "viewedByMe": { + "type": "boolean", + "description": "Whether the file has been viewed by this user." + }, + "viewedByMeTime": { + "type": "string", + "description": "The last time the file was viewed by the user (RFC 3339 date-time).", + "format": "date-time" + }, + "viewersCanCopyContent": { + "type": "boolean", + "description": "Deprecated - use copyRequiresWriterPermission instead." + }, + "webContentLink": { + "type": "string", + "description": "A link for downloading the content of the file in a browser. This is only available for files with binary content in Google Drive." + }, + "webViewLink": { + "type": "string", + "description": "A link for opening the file in a relevant Google editor or viewer in a browser." + }, + "writersCanShare": { + "type": "boolean", + "description": "Whether users with only writer permission can modify the file's permissions. Not populated for items in shared drives." + } + } + }, + "FileList": { + "id": "FileList", + "type": "object", + "description": "A list of files.", + "properties": { + "files": { + "type": "array", + "description": "The list of files. If nextPageToken is populated, then this list may be incomplete and an additional page of results should be fetched.", + "items": { + "$ref": "File" + } + }, + "incompleteSearch": { + "type": "boolean", + "description": "Whether the search process was incomplete. If true, then some search results may be missing, since all documents were not searched. This may occur when searching multiple drives with the \"allDrives\" corpora, but all corpora could not be searched. When this happens, it is suggested that clients narrow their query by choosing a different corpus such as \"user\" or \"drive\"." + }, + "kind": { + "type": "string", + "description": "Identifies what kind of resource this is. Value: the fixed string \"drive#fileList\".", + "default": "drive#fileList" + }, + "nextPageToken": { + "type": "string", + "description": "The page token for the next page of files. This will be absent if the end of the files list has been reached. If the token is rejected for any reason, it should be discarded, and pagination should be restarted from the first page of results." + } + } + }, + "GeneratedIds": { + "id": "GeneratedIds", + "type": "object", + "description": "A list of generated file IDs which can be provided in create requests.", + "properties": { + "ids": { + "type": "array", + "description": "The IDs generated for the requesting user in the specified space.", + "items": { + "type": "string" + } + }, + "kind": { + "type": "string", + "description": "Identifies what kind of resource this is. Value: the fixed string \"drive#generatedIds\".", + "default": "drive#generatedIds" + }, + "space": { + "type": "string", + "description": "The type of file that can be created with these IDs." + } + } + }, + "Label": { + "id": "Label", + "type": "object", + "description": "Representation of a label and its fields.", + "properties": { + "fields": { + "type": "object", + "description": "A map of the label's fields keyed by the field ID.", + "additionalProperties": { + "$ref": "LabelField" + } + }, + "id": { + "type": "string", + "description": "The ID of the label." + }, + "kind": { + "type": "string", + "description": "This is always drive#label", + "default": "drive#label" + }, + "revisionId": { + "type": "string", + "description": "The revision ID of the label." + } + } + }, + "LabelField": { + "id": "LabelField", + "type": "object", + "description": "Representation of a label field.", + "properties": { + "dateString": { + "type": "array", + "description": "Only present if valueType is dateString. RFC 3339 formatted date: YYYY-MM-DD.", + "items": { + "type": "string", + "format": "date" + } + }, + "id": { + "type": "string", + "description": "The identifier of this field." + }, + "integer": { + "type": "array", + "description": "Only present if valueType is integer.", + "items": { + "type": "string", + "format": "int64" + } + }, + "kind": { + "type": "string", + "description": "This is always drive#labelField.", + "default": "drive#labelField" + }, + "selection": { + "type": "array", + "description": "Only present if valueType is selection.", + "items": { + "type": "string" + } + }, + "text": { + "type": "array", + "description": "Only present if valueType is text.", + "items": { + "type": "string" + } + }, + "user": { + "type": "array", + "description": "Only present if valueType is user.", + "items": { + "$ref": "User" + } + }, + "valueType": { + "type": "string", + "description": "The field type. While new values may be supported in the future, the following are currently allowed: \n- dateString \n- integer \n- selection \n- text \n- user" + } + } + }, + "LabelFieldModification": { + "id": "LabelFieldModification", + "type": "object", + "description": "A modification to a label's field.", + "properties": { + "fieldId": { + "type": "string", + "description": "The ID of the Field to be modified." + }, + "kind": { + "type": "string", + "description": "This is always drive#labelFieldModification.", + "default": "drive#labelFieldModification" + }, + "setDateValues": { + "type": "array", + "description": "Replaces a dateString field with these new values. The values must be strings in the RFC 3339 full-date format: YYYY-MM-DD.", + "items": { + "type": "string", + "format": "date" + } + }, + "setIntegerValues": { + "type": "array", + "description": "Replaces an integer field with these new values.", + "items": { + "type": "string", + "format": "int64" + } + }, + "setSelectionValues": { + "type": "array", + "description": "Replaces a selection field with these new values.", + "items": { + "type": "string" + } + }, + "setTextValues": { + "type": "array", + "description": "Replaces a text field with these new values.", + "items": { + "type": "string" + } + }, + "setUserValues": { + "type": "array", + "description": "Replaces a user field with these new values. The values must be valid email addresses.", + "items": { + "type": "string" + } + }, + "unsetValues": { + "type": "boolean", + "description": "Unsets the values for this field." + } + } + }, + "LabelList": { + "id": "LabelList", + "type": "object", + "description": "A list of labels.", + "properties": { + "kind": { + "type": "string", + "description": "This is always drive#labelList", + "default": "drive#labelList" + }, + "labels": { + "type": "array", + "description": "The list of labels.", + "items": { + "$ref": "Label" + } + }, + "nextPageToken": { + "type": "string", + "description": "The page token for the next page of labels. This field will be absent if the end of the list has been reached. If the token is rejected for any reason, it should be discarded, and pagination should be restarted from the first page of results." + } + } + }, + "LabelModification": { + "id": "LabelModification", + "type": "object", + "description": "A modification to a label on a file. A LabelModification can be used to apply a label to a file, update an existing label on a file, or remove a label from a file.", + "properties": { + "fieldModifications": { + "type": "array", + "description": "The list of modifications to this label's fields.", + "items": { + "$ref": "LabelFieldModification" + } + }, + "kind": { + "type": "string", + "description": "This is always drive#labelModification.", + "default": "drive#labelModification" + }, + "labelId": { + "type": "string", + "description": "The ID of the label to modify.", + "annotations": { + "required": [ + "drive.files.modifyLabels" + ] + } + }, + "removeLabel": { + "type": "boolean", + "description": "If true, the label will be removed from the file." + } + } + }, + "ModifyLabelsRequest": { + "id": "ModifyLabelsRequest", + "type": "object", + "description": "A request to modify the set of labels on a file. This request may contain many modifications that will either all succeed or all fail transactionally.", + "properties": { + "kind": { + "type": "string", + "description": "This is always drive#modifyLabelsRequest", + "default": "drive#modifyLabelsRequest" + }, + "labelModifications": { + "type": "array", + "description": "The list of modifications to apply to the labels on the file.", + "items": { + "$ref": "LabelModification" + } + } + } + }, + "ModifyLabelsResponse": { + "id": "ModifyLabelsResponse", + "type": "object", + "description": "Response to a ModifyLabels request. This contains only those labels which were added or updated by the request.", + "properties": { + "kind": { + "type": "string", + "description": "This is always drive#modifyLabelsResponse", + "default": "drive#modifyLabelsResponse" + }, + "modifiedLabels": { + "type": "array", + "description": "The list of labels which were added or updated by the request.", + "items": { + "$ref": "Label" + } + } + } + }, + "Permission": { + "id": "Permission", + "type": "object", + "description": "A permission for a file. A permission grants a user, group, domain or the world access to a file or a folder hierarchy.", + "properties": { + "allowFileDiscovery": { + "type": "boolean", + "description": "Whether the permission allows the file to be discovered through search. This is only applicable for permissions of type domain or anyone." + }, + "deleted": { + "type": "boolean", + "description": "Whether the account associated with this permission has been deleted. This field only pertains to user and group permissions." + }, + "displayName": { + "type": "string", + "description": "The \"pretty\" name of the value of the permission. The following is a list of examples for each type of permission: \n- user - User's full name, as defined for their Google account, such as \"Joe Smith.\" \n- group - Name of the Google Group, such as \"The Company Administrators.\" \n- domain - String domain name, such as \"thecompany.com.\" \n- anyone - No displayName is present." + }, + "domain": { + "type": "string", + "description": "The domain to which this permission refers." + }, + "emailAddress": { + "type": "string", + "description": "The email address of the user or group to which this permission refers." + }, + "expirationTime": { + "type": "string", + "description": "The time at which this permission will expire (RFC 3339 date-time). Expiration times have the following restrictions: \n- They can only be set on user and group permissions \n- The time must be in the future \n- The time cannot be more than a year in the future", + "format": "date-time" + }, + "id": { + "type": "string", + "description": "The ID of this permission. This is a unique identifier for the grantee, and is published in User resources as permissionId. IDs should be treated as opaque values." + }, + "kind": { + "type": "string", + "description": "Identifies what kind of resource this is. Value: the fixed string \"drive#permission\".", + "default": "drive#permission" + }, + "pendingOwner": { + "type": "boolean", + "description": "Whether the account associated with this permission is a pending owner. Only populated for user type permissions for files that are not in a shared drive." + }, + "permissionDetails": { + "type": "array", + "description": "Details of whether the permissions on this shared drive item are inherited or directly on this item. This is an output-only field which is present only for shared drive items.", + "readOnly": true, + "items": { + "type": "object", + "properties": { + "inherited": { + "type": "boolean", + "description": "Whether this permission is inherited. This field is always populated. This is an output-only field." + }, + "inheritedFrom": { + "type": "string", + "description": "The ID of the item from which this permission is inherited. This is an output-only field." + }, + "permissionType": { + "type": "string", + "description": "The permission type for this user. While new values may be added in future, the following are currently possible: \n- file \n- member" + }, + "role": { + "type": "string", + "description": "The primary role for this user. While new values may be added in the future, the following are currently possible: \n- organizer \n- fileOrganizer \n- writer \n- commenter \n- reader" + } + } + } + }, + "photoLink": { + "type": "string", + "description": "A link to the user's profile photo, if available." + }, + "role": { + "type": "string", + "description": "The role granted by this permission. While new values may be supported in the future, the following are currently allowed: \n- owner \n- organizer \n- fileOrganizer \n- writer \n- commenter \n- reader", + "annotations": { + "required": [ + "drive.permissions.create" + ] + } + }, + "teamDrivePermissionDetails": { + "type": "array", + "description": "Deprecated - use permissionDetails instead.", + "readOnly": true, + "items": { + "type": "object", + "properties": { + "inherited": { + "type": "boolean", + "description": "Deprecated - use permissionDetails/inherited instead." + }, + "inheritedFrom": { + "type": "string", + "description": "Deprecated - use permissionDetails/inheritedFrom instead." + }, + "role": { + "type": "string", + "description": "Deprecated - use permissionDetails/role instead." + }, + "teamDrivePermissionType": { + "type": "string", + "description": "Deprecated - use permissionDetails/permissionType instead." + } + } + } + }, + "type": { + "type": "string", + "description": "The type of the grantee. Valid values are: \n- user \n- group \n- domain \n- anyone When creating a permission, if type is user or group, you must provide an emailAddress for the user or group. When type is domain, you must provide a domain. There isn't extra information required for a anyone type.", + "annotations": { + "required": [ + "drive.permissions.create" + ] + } + }, + "view": { + "type": "string", + "description": "Indicates the view for this permission. Only populated for permissions that belong to a view. published is the only supported value." + } + } + }, + "PermissionList": { + "id": "PermissionList", + "type": "object", + "description": "A list of permissions for a file.", + "properties": { + "kind": { + "type": "string", + "description": "Identifies what kind of resource this is. Value: the fixed string \"drive#permissionList\".", + "default": "drive#permissionList" + }, + "nextPageToken": { + "type": "string", + "description": "The page token for the next page of permissions. This field will be absent if the end of the permissions list has been reached. If the token is rejected for any reason, it should be discarded, and pagination should be restarted from the first page of results." + }, + "permissions": { + "type": "array", + "description": "The list of permissions. If nextPageToken is populated, then this list may be incomplete and an additional page of results should be fetched.", + "items": { + "$ref": "Permission" + } + } + } + }, + "Reply": { + "id": "Reply", + "type": "object", + "description": "A reply to a comment on a file.", + "properties": { + "action": { + "type": "string", + "description": "The action the reply performed to the parent comment. Valid values are: \n- resolve \n- reopen" + }, + "author": { + "$ref": "User", + "description": "The author of the reply. The author's email address and permission ID will not be populated." + }, + "content": { + "type": "string", + "description": "The plain text content of the reply. This field is used for setting the content, while htmlContent should be displayed. This is required on creates if no action is specified.", + "annotations": { + "required": [ + "drive.replies.update" + ] + } + }, + "createdTime": { + "type": "string", + "description": "The time at which the reply was created (RFC 3339 date-time).", + "format": "date-time" + }, + "deleted": { + "type": "boolean", + "description": "Whether the reply has been deleted. A deleted reply has no content." + }, + "htmlContent": { + "type": "string", + "description": "The content of the reply with HTML formatting." + }, + "id": { + "type": "string", + "description": "The ID of the reply." + }, + "kind": { + "type": "string", + "description": "Identifies what kind of resource this is. Value: the fixed string \"drive#reply\".", + "default": "drive#reply" + }, + "modifiedTime": { + "type": "string", + "description": "The last time the reply was modified (RFC 3339 date-time).", + "format": "date-time" + } + } + }, + "ReplyList": { + "id": "ReplyList", + "type": "object", + "description": "A list of replies to a comment on a file.", + "properties": { + "kind": { + "type": "string", + "description": "Identifies what kind of resource this is. Value: the fixed string \"drive#replyList\".", + "default": "drive#replyList" + }, + "nextPageToken": { + "type": "string", + "description": "The page token for the next page of replies. This will be absent if the end of the replies list has been reached. If the token is rejected for any reason, it should be discarded, and pagination should be restarted from the first page of results." + }, + "replies": { + "type": "array", + "description": "The list of replies. If nextPageToken is populated, then this list may be incomplete and an additional page of results should be fetched.", + "items": { + "$ref": "Reply" + } + } + } + }, + "Revision": { + "id": "Revision", + "type": "object", + "description": "The metadata for a revision to a file.", + "properties": { + "exportLinks": { + "type": "object", + "description": "Links for exporting Docs Editors files to specific formats.", + "additionalProperties": { + "type": "string", + "description": "A mapping from export format to URL" + } + }, + "id": { + "type": "string", + "description": "The ID of the revision." + }, + "keepForever": { + "type": "boolean", + "description": "Whether to keep this revision forever, even if it is no longer the head revision. If not set, the revision will be automatically purged 30 days after newer content is uploaded. This can be set on a maximum of 200 revisions for a file.\nThis field is only applicable to files with binary content in Drive." + }, + "kind": { + "type": "string", + "description": "Identifies what kind of resource this is. Value: the fixed string \"drive#revision\".", + "default": "drive#revision" + }, + "lastModifyingUser": { + "$ref": "User", + "description": "The last user to modify this revision." + }, + "md5Checksum": { + "type": "string", + "description": "The MD5 checksum of the revision's content. This is only applicable to files with binary content in Drive." + }, + "mimeType": { + "type": "string", + "description": "The MIME type of the revision." + }, + "modifiedTime": { + "type": "string", + "description": "The last time the revision was modified (RFC 3339 date-time).", + "format": "date-time" + }, + "originalFilename": { + "type": "string", + "description": "The original filename used to create this revision. This is only applicable to files with binary content in Drive." + }, + "publishAuto": { + "type": "boolean", + "description": "Whether subsequent revisions will be automatically republished. This is only applicable to Docs Editors files." + }, + "published": { + "type": "boolean", + "description": "Whether this revision is published. This is only applicable to Docs Editors files." + }, + "publishedLink": { + "type": "string", + "description": "A link to the published revision. This is only populated for Google Sites files." + }, + "publishedOutsideDomain": { + "type": "boolean", + "description": "Whether this revision is published outside the domain. This is only applicable to Docs Editors files." + }, + "size": { + "type": "string", + "description": "The size of the revision's content in bytes. This is only applicable to files with binary content in Drive.", + "format": "int64" + } + } + }, + "RevisionList": { + "id": "RevisionList", + "type": "object", + "description": "A list of revisions of a file.", + "properties": { + "kind": { + "type": "string", + "description": "Identifies what kind of resource this is. Value: the fixed string \"drive#revisionList\".", + "default": "drive#revisionList" + }, + "nextPageToken": { + "type": "string", + "description": "The page token for the next page of revisions. This will be absent if the end of the revisions list has been reached. If the token is rejected for any reason, it should be discarded, and pagination should be restarted from the first page of results." + }, + "revisions": { + "type": "array", + "description": "The list of revisions. If nextPageToken is populated, then this list may be incomplete and an additional page of results should be fetched.", + "items": { + "$ref": "Revision" + } + } + } + }, + "StartPageToken": { + "id": "StartPageToken", + "type": "object", + "properties": { + "kind": { + "type": "string", + "description": "Identifies what kind of resource this is. Value: the fixed string \"drive#startPageToken\".", + "default": "drive#startPageToken" + }, + "startPageToken": { + "type": "string", + "description": "The starting page token for listing changes." + } + } + }, + "TeamDrive": { + "id": "TeamDrive", + "type": "object", + "description": "Deprecated: use the drive collection instead.", + "properties": { + "backgroundImageFile": { + "type": "object", + "description": "An image file and cropping parameters from which a background image for this Team Drive is set. This is a write only field; it can only be set on drive.teamdrives.update requests that don't set themeId. When specified, all fields of the backgroundImageFile must be set.", + "properties": { + "id": { + "type": "string", + "description": "The ID of an image file in Drive to use for the background image." + }, + "width": { + "type": "number", + "description": "The width of the cropped image in the closed range of 0 to 1. This value represents the width of the cropped image divided by the width of the entire image. The height is computed by applying a width to height aspect ratio of 80 to 9. The resulting image must be at least 1280 pixels wide and 144 pixels high.", + "format": "float" + }, + "xCoordinate": { + "type": "number", + "description": "The X coordinate of the upper left corner of the cropping area in the background image. This is a value in the closed range of 0 to 1. This value represents the horizontal distance from the left side of the entire image to the left side of the cropping area divided by the width of the entire image.", + "format": "float" + }, + "yCoordinate": { + "type": "number", + "description": "The Y coordinate of the upper left corner of the cropping area in the background image. This is a value in the closed range of 0 to 1. This value represents the vertical distance from the top side of the entire image to the top side of the cropping area divided by the height of the entire image.", + "format": "float" + } + } + }, + "backgroundImageLink": { + "type": "string", + "description": "A short-lived link to this Team Drive's background image." + }, + "capabilities": { + "type": "object", + "description": "Capabilities the current user has on this Team Drive.", + "properties": { + "canAddChildren": { + "type": "boolean", + "description": "Whether the current user can add children to folders in this Team Drive." + }, + "canChangeCopyRequiresWriterPermissionRestriction": { + "type": "boolean", + "description": "Whether the current user can change the copyRequiresWriterPermission restriction of this Team Drive." + }, + "canChangeDomainUsersOnlyRestriction": { + "type": "boolean", + "description": "Whether the current user can change the domainUsersOnly restriction of this Team Drive." + }, + "canChangeTeamDriveBackground": { + "type": "boolean", + "description": "Whether the current user can change the background of this Team Drive." + }, + "canChangeTeamMembersOnlyRestriction": { + "type": "boolean", + "description": "Whether the current user can change the teamMembersOnly restriction of this Team Drive." + }, + "canComment": { + "type": "boolean", + "description": "Whether the current user can comment on files in this Team Drive." + }, + "canCopy": { + "type": "boolean", + "description": "Whether the current user can copy files in this Team Drive." + }, + "canDeleteChildren": { + "type": "boolean", + "description": "Whether the current user can delete children from folders in this Team Drive." + }, + "canDeleteTeamDrive": { + "type": "boolean", + "description": "Whether the current user can delete this Team Drive. Attempting to delete the Team Drive may still fail if there are untrashed items inside the Team Drive." + }, + "canDownload": { + "type": "boolean", + "description": "Whether the current user can download files in this Team Drive." + }, + "canEdit": { + "type": "boolean", + "description": "Whether the current user can edit files in this Team Drive" + }, + "canListChildren": { + "type": "boolean", + "description": "Whether the current user can list the children of folders in this Team Drive." + }, + "canManageMembers": { + "type": "boolean", + "description": "Whether the current user can add members to this Team Drive or remove them or change their role." + }, + "canReadRevisions": { + "type": "boolean", + "description": "Whether the current user can read the revisions resource of files in this Team Drive." + }, + "canRemoveChildren": { + "type": "boolean", + "description": "Deprecated - use canDeleteChildren or canTrashChildren instead." + }, + "canRename": { + "type": "boolean", + "description": "Whether the current user can rename files or folders in this Team Drive." + }, + "canRenameTeamDrive": { + "type": "boolean", + "description": "Whether the current user can rename this Team Drive." + }, + "canResetTeamDriveRestrictions": { + "type": "boolean", + "description": "Whether the current user can reset the Team Drive restrictions to defaults." + }, + "canShare": { + "type": "boolean", + "description": "Whether the current user can share files or folders in this Team Drive." + }, + "canTrashChildren": { + "type": "boolean", + "description": "Whether the current user can trash children from folders in this Team Drive." + } + } + }, + "colorRgb": { + "type": "string", + "description": "The color of this Team Drive as an RGB hex string. It can only be set on a drive.teamdrives.update request that does not set themeId." + }, + "createdTime": { + "type": "string", + "description": "The time at which the Team Drive was created (RFC 3339 date-time).", + "format": "date-time" + }, + "id": { + "type": "string", + "description": "The ID of this Team Drive which is also the ID of the top level folder of this Team Drive." + }, + "kind": { + "type": "string", + "description": "Identifies what kind of resource this is. Value: the fixed string \"drive#teamDrive\".", + "default": "drive#teamDrive" + }, + "name": { + "type": "string", + "description": "The name of this Team Drive.", + "annotations": { + "required": [ + "drive.teamdrives.create" + ] + } + }, + "orgUnitId": { + "type": "string", + "description": "The organizational unit of this shared drive. This field is only populated on drives.list responses when the useDomainAdminAccess parameter is set to true." + }, + "restrictions": { + "type": "object", + "description": "A set of restrictions that apply to this Team Drive or items inside this Team Drive.", + "properties": { + "adminManagedRestrictions": { + "type": "boolean", + "description": "Whether administrative privileges on this Team Drive are required to modify restrictions." + }, + "copyRequiresWriterPermission": { + "type": "boolean", + "description": "Whether the options to copy, print, or download files inside this Team Drive, should be disabled for readers and commenters. When this restriction is set to true, it will override the similarly named field to true for any file inside this Team Drive." + }, + "domainUsersOnly": { + "type": "boolean", + "description": "Whether access to this Team Drive and items inside this Team Drive is restricted to users of the domain to which this Team Drive belongs. This restriction may be overridden by other sharing policies controlled outside of this Team Drive." + }, + "teamMembersOnly": { + "type": "boolean", + "description": "Whether access to items inside this Team Drive is restricted to members of this Team Drive." + } + } + }, + "themeId": { + "type": "string", + "description": "The ID of the theme from which the background image and color will be set. The set of possible teamDriveThemes can be retrieved from a drive.about.get response. When not specified on a drive.teamdrives.create request, a random theme is chosen from which the background image and color are set. This is a write-only field; it can only be set on requests that don't set colorRgb or backgroundImageFile." + } + } + }, + "TeamDriveList": { + "id": "TeamDriveList", + "type": "object", + "description": "A list of Team Drives.", + "properties": { + "kind": { + "type": "string", + "description": "Identifies what kind of resource this is. Value: the fixed string \"drive#teamDriveList\".", + "default": "drive#teamDriveList" + }, + "nextPageToken": { + "type": "string", + "description": "The page token for the next page of Team Drives. This will be absent if the end of the Team Drives list has been reached. If the token is rejected for any reason, it should be discarded, and pagination should be restarted from the first page of results." + }, + "teamDrives": { + "type": "array", + "description": "The list of Team Drives. If nextPageToken is populated, then this list may be incomplete and an additional page of results should be fetched.", + "items": { + "$ref": "TeamDrive" + } + } + } + }, + "User": { + "id": "User", + "type": "object", + "description": "Information about a Drive user.", + "properties": { + "displayName": { + "type": "string", + "description": "A plain text displayable name for this user." + }, + "emailAddress": { + "type": "string", + "description": "The email address of the user. This may not be present in certain contexts if the user has not made their email address visible to the requester." + }, + "kind": { + "type": "string", + "description": "Identifies what kind of resource this is. Value: the fixed string \"drive#user\".", + "default": "drive#user" + }, + "me": { + "type": "boolean", + "description": "Whether this user is the requesting user." + }, + "permissionId": { + "type": "string", + "description": "The user's ID as visible in Permission resources." + }, + "photoLink": { + "type": "string", + "description": "A link to the user's profile photo, if available." + } + } + } + }, + "resources": { + "about": { + "methods": { + "get": { + "id": "drive.about.get", + "path": "about", + "httpMethod": "GET", + "description": "Gets information about the user, the user's Drive, and system capabilities.", + "response": { + "$ref": "About" + }, + "scopes": [ + "https://www.googleapis.com/auth/drive", + "https://www.googleapis.com/auth/drive.appdata", + "https://www.googleapis.com/auth/drive.file", + "https://www.googleapis.com/auth/drive.metadata", + "https://www.googleapis.com/auth/drive.metadata.readonly", + "https://www.googleapis.com/auth/drive.photos.readonly", + "https://www.googleapis.com/auth/drive.readonly" + ] + } + } + }, + "changes": { + "methods": { + "getStartPageToken": { + "id": "drive.changes.getStartPageToken", + "path": "changes/startPageToken", + "httpMethod": "GET", + "description": "Gets the starting pageToken for listing future changes.", + "parameters": { + "driveId": { + "type": "string", + "description": "The ID of the shared drive for which the starting pageToken for listing future changes from that shared drive is returned.", + "location": "query" + }, + "supportsAllDrives": { + "type": "boolean", + "description": "Whether the requesting application supports both My Drives and shared drives.", + "default": "false", + "location": "query" + }, + "supportsTeamDrives": { + "type": "boolean", + "description": "Deprecated use supportsAllDrives instead.", + "default": "false", + "location": "query" + }, + "teamDriveId": { + "type": "string", + "description": "Deprecated use driveId instead.", + "location": "query" + } + }, + "response": { + "$ref": "StartPageToken" + }, + "scopes": [ + "https://www.googleapis.com/auth/drive", + "https://www.googleapis.com/auth/drive.appdata", + "https://www.googleapis.com/auth/drive.file", + "https://www.googleapis.com/auth/drive.metadata", + "https://www.googleapis.com/auth/drive.metadata.readonly", + "https://www.googleapis.com/auth/drive.photos.readonly", + "https://www.googleapis.com/auth/drive.readonly" + ] + }, + "list": { + "id": "drive.changes.list", + "path": "changes", + "httpMethod": "GET", + "description": "Lists the changes for a user or shared drive.", + "parameters": { + "driveId": { + "type": "string", + "description": "The shared drive from which changes are returned. If specified the change IDs will be reflective of the shared drive; use the combined drive ID and change ID as an identifier.", + "location": "query" + }, + "includeCorpusRemovals": { + "type": "boolean", + "description": "Whether changes should include the file resource if the file is still accessible by the user at the time of the request, even when a file was removed from the list of changes and there will be no further change entries for this file.", + "default": "false", + "location": "query" + }, + "includeItemsFromAllDrives": { + "type": "boolean", + "description": "Whether both My Drive and shared drive items should be included in results.", + "default": "false", + "location": "query" + }, + "includeLabels": { + "type": "string", + "description": "A comma-separated list of IDs of labels to include in the labelInfo part of the response.", + "location": "query" + }, + "includePermissionsForView": { + "type": "string", + "description": "Specifies which additional view's permissions to include in the response. Only 'published' is supported.", + "location": "query" + }, + "includeRemoved": { + "type": "boolean", + "description": "Whether to include changes indicating that items have been removed from the list of changes, for example by deletion or loss of access.", + "default": "true", + "location": "query" + }, + "includeTeamDriveItems": { + "type": "boolean", + "description": "Deprecated use includeItemsFromAllDrives instead.", + "default": "false", + "location": "query" + }, + "pageSize": { + "type": "integer", + "description": "The maximum number of changes to return per page.", + "default": "100", + "format": "int32", + "minimum": "1", + "maximum": "1000", + "location": "query" + }, + "pageToken": { + "type": "string", + "description": "The token for continuing a previous list request on the next page. This should be set to the value of 'nextPageToken' from the previous response or to the response from the getStartPageToken method.", + "required": true, + "location": "query" + }, + "restrictToMyDrive": { + "type": "boolean", + "description": "Whether to restrict the results to changes inside the My Drive hierarchy. This omits changes to files such as those in the Application Data folder or shared files which have not been added to My Drive.", + "default": "false", + "location": "query" + }, + "spaces": { + "type": "string", + "description": "A comma-separated list of spaces to query within the user corpus. Supported values are 'drive', 'appDataFolder' and 'photos'.", + "default": "drive", + "location": "query" + }, + "supportsAllDrives": { + "type": "boolean", + "description": "Whether the requesting application supports both My Drives and shared drives.", + "default": "false", + "location": "query" + }, + "supportsTeamDrives": { + "type": "boolean", + "description": "Deprecated use supportsAllDrives instead.", + "default": "false", + "location": "query" + }, + "teamDriveId": { + "type": "string", + "description": "Deprecated use driveId instead.", + "location": "query" + } + }, + "parameterOrder": [ + "pageToken" + ], + "response": { + "$ref": "ChangeList" + }, + "scopes": [ + "https://www.googleapis.com/auth/drive", + "https://www.googleapis.com/auth/drive.appdata", + "https://www.googleapis.com/auth/drive.file", + "https://www.googleapis.com/auth/drive.metadata", + "https://www.googleapis.com/auth/drive.metadata.readonly", + "https://www.googleapis.com/auth/drive.photos.readonly", + "https://www.googleapis.com/auth/drive.readonly" + ], + "supportsSubscription": true + }, + "watch": { + "id": "drive.changes.watch", + "path": "changes/watch", + "httpMethod": "POST", + "description": "Subscribes to changes for a user.", + "parameters": { + "driveId": { + "type": "string", + "description": "The shared drive from which changes are returned. If specified the change IDs will be reflective of the shared drive; use the combined drive ID and change ID as an identifier.", + "location": "query" + }, + "includeCorpusRemovals": { + "type": "boolean", + "description": "Whether changes should include the file resource if the file is still accessible by the user at the time of the request, even when a file was removed from the list of changes and there will be no further change entries for this file.", + "default": "false", + "location": "query" + }, + "includeItemsFromAllDrives": { + "type": "boolean", + "description": "Whether both My Drive and shared drive items should be included in results.", + "default": "false", + "location": "query" + }, + "includeLabels": { + "type": "string", + "description": "A comma-separated list of IDs of labels to include in the labelInfo part of the response.", + "location": "query" + }, + "includePermissionsForView": { + "type": "string", + "description": "Specifies which additional view's permissions to include in the response. Only 'published' is supported.", + "location": "query" + }, + "includeRemoved": { + "type": "boolean", + "description": "Whether to include changes indicating that items have been removed from the list of changes, for example by deletion or loss of access.", + "default": "true", + "location": "query" + }, + "includeTeamDriveItems": { + "type": "boolean", + "description": "Deprecated use includeItemsFromAllDrives instead.", + "default": "false", + "location": "query" + }, + "pageSize": { + "type": "integer", + "description": "The maximum number of changes to return per page.", + "default": "100", + "format": "int32", + "minimum": "1", + "maximum": "1000", + "location": "query" + }, + "pageToken": { + "type": "string", + "description": "The token for continuing a previous list request on the next page. This should be set to the value of 'nextPageToken' from the previous response or to the response from the getStartPageToken method.", + "required": true, + "location": "query" + }, + "restrictToMyDrive": { + "type": "boolean", + "description": "Whether to restrict the results to changes inside the My Drive hierarchy. This omits changes to files such as those in the Application Data folder or shared files which have not been added to My Drive.", + "default": "false", + "location": "query" + }, + "spaces": { + "type": "string", + "description": "A comma-separated list of spaces to query within the user corpus. Supported values are 'drive', 'appDataFolder' and 'photos'.", + "default": "drive", + "location": "query" + }, + "supportsAllDrives": { + "type": "boolean", + "description": "Whether the requesting application supports both My Drives and shared drives.", + "default": "false", + "location": "query" + }, + "supportsTeamDrives": { + "type": "boolean", + "description": "Deprecated use supportsAllDrives instead.", + "default": "false", + "location": "query" + }, + "teamDriveId": { + "type": "string", + "description": "Deprecated use driveId instead.", + "location": "query" + } + }, + "parameterOrder": [ + "pageToken" + ], + "request": { + "$ref": "Channel", + "parameterName": "resource" + }, + "response": { + "$ref": "Channel" + }, + "scopes": [ + "https://www.googleapis.com/auth/drive", + "https://www.googleapis.com/auth/drive.appdata", + "https://www.googleapis.com/auth/drive.file", + "https://www.googleapis.com/auth/drive.metadata", + "https://www.googleapis.com/auth/drive.metadata.readonly", + "https://www.googleapis.com/auth/drive.photos.readonly", + "https://www.googleapis.com/auth/drive.readonly" + ], + "supportsSubscription": true + } + } + }, + "channels": { + "methods": { + "stop": { + "id": "drive.channels.stop", + "path": "channels/stop", + "httpMethod": "POST", + "description": "Stop watching resources through this channel", + "request": { + "$ref": "Channel", + "parameterName": "resource" + }, + "scopes": [ + "https://www.googleapis.com/auth/drive", + "https://www.googleapis.com/auth/drive.appdata", + "https://www.googleapis.com/auth/drive.file", + "https://www.googleapis.com/auth/drive.metadata", + "https://www.googleapis.com/auth/drive.metadata.readonly", + "https://www.googleapis.com/auth/drive.photos.readonly", + "https://www.googleapis.com/auth/drive.readonly" + ] + } + } + }, + "comments": { + "methods": { + "create": { + "id": "drive.comments.create", + "path": "files/{fileId}/comments", + "httpMethod": "POST", + "description": "Creates a new comment on a file.", + "parameters": { + "fileId": { + "type": "string", + "description": "The ID of the file.", + "required": true, + "location": "path" + } + }, + "parameterOrder": [ + "fileId" + ], + "request": { + "$ref": "Comment" + }, + "response": { + "$ref": "Comment" + }, + "scopes": [ + "https://www.googleapis.com/auth/drive", + "https://www.googleapis.com/auth/drive.file" + ] + }, + "delete": { + "id": "drive.comments.delete", + "path": "files/{fileId}/comments/{commentId}", + "httpMethod": "DELETE", + "description": "Deletes a comment.", + "parameters": { + "commentId": { + "type": "string", + "description": "The ID of the comment.", + "required": true, + "location": "path" + }, + "fileId": { + "type": "string", + "description": "The ID of the file.", + "required": true, + "location": "path" + } + }, + "parameterOrder": [ + "fileId", + "commentId" + ], + "scopes": [ + "https://www.googleapis.com/auth/drive", + "https://www.googleapis.com/auth/drive.file" + ] + }, + "get": { + "id": "drive.comments.get", + "path": "files/{fileId}/comments/{commentId}", + "httpMethod": "GET", + "description": "Gets a comment by ID.", + "parameters": { + "commentId": { + "type": "string", + "description": "The ID of the comment.", + "required": true, + "location": "path" + }, + "fileId": { + "type": "string", + "description": "The ID of the file.", + "required": true, + "location": "path" + }, + "includeDeleted": { + "type": "boolean", + "description": "Whether to return deleted comments. Deleted comments will not include their original content.", + "default": "false", + "location": "query" + } + }, + "parameterOrder": [ + "fileId", + "commentId" + ], + "response": { + "$ref": "Comment" + }, + "scopes": [ + "https://www.googleapis.com/auth/drive", + "https://www.googleapis.com/auth/drive.file", + "https://www.googleapis.com/auth/drive.readonly" + ] + }, + "list": { + "id": "drive.comments.list", + "path": "files/{fileId}/comments", + "httpMethod": "GET", + "description": "Lists a file's comments.", + "parameters": { + "fileId": { + "type": "string", + "description": "The ID of the file.", + "required": true, + "location": "path" + }, + "includeDeleted": { + "type": "boolean", + "description": "Whether to include deleted comments. Deleted comments will not include their original content.", + "default": "false", + "location": "query" + }, + "pageSize": { + "type": "integer", + "description": "The maximum number of comments to return per page.", + "default": "20", + "format": "int32", + "minimum": "1", + "maximum": "100", + "location": "query" + }, + "pageToken": { + "type": "string", + "description": "The token for continuing a previous list request on the next page. This should be set to the value of 'nextPageToken' from the previous response.", + "location": "query" + }, + "startModifiedTime": { + "type": "string", + "description": "The minimum value of 'modifiedTime' for the result comments (RFC 3339 date-time).", + "location": "query" + } + }, + "parameterOrder": [ + "fileId" + ], + "response": { + "$ref": "CommentList" + }, + "scopes": [ + "https://www.googleapis.com/auth/drive", + "https://www.googleapis.com/auth/drive.file", + "https://www.googleapis.com/auth/drive.readonly" + ] + }, + "update": { + "id": "drive.comments.update", + "path": "files/{fileId}/comments/{commentId}", + "httpMethod": "PATCH", + "description": "Updates a comment with patch semantics.", + "parameters": { + "commentId": { + "type": "string", + "description": "The ID of the comment.", + "required": true, + "location": "path" + }, + "fileId": { + "type": "string", + "description": "The ID of the file.", + "required": true, + "location": "path" + } + }, + "parameterOrder": [ + "fileId", + "commentId" + ], + "request": { + "$ref": "Comment" + }, + "response": { + "$ref": "Comment" + }, + "scopes": [ + "https://www.googleapis.com/auth/drive", + "https://www.googleapis.com/auth/drive.file" + ] + } + } + }, + "drives": { + "methods": { + "create": { + "id": "drive.drives.create", + "path": "drives", + "httpMethod": "POST", + "description": "Creates a new shared drive.", + "parameters": { + "requestId": { + "type": "string", + "description": "An ID, such as a random UUID, which uniquely identifies this user's request for idempotent creation of a shared drive. A repeated request by the same user and with the same request ID will avoid creating duplicates by attempting to create the same shared drive. If the shared drive already exists a 409 error will be returned.", + "required": true, + "location": "query" + } + }, + "parameterOrder": [ + "requestId" + ], + "request": { + "$ref": "Drive" + }, + "response": { + "$ref": "Drive" + }, + "scopes": [ + "https://www.googleapis.com/auth/drive" + ] + }, + "delete": { + "id": "drive.drives.delete", + "path": "drives/{driveId}", + "httpMethod": "DELETE", + "description": "Permanently deletes a shared drive for which the user is an organizer. The shared drive cannot contain any untrashed items.", + "parameters": { + "allowItemDeletion": { + "type": "boolean", + "description": "Whether any items inside the shared drive should also be deleted. This option is only supported when useDomainAdminAccess is also set to true.", + "default": "false", + "location": "query" + }, + "driveId": { + "type": "string", + "description": "The ID of the shared drive.", + "required": true, + "location": "path" + }, + "useDomainAdminAccess": { + "type": "boolean", + "description": "Issue the request as a domain administrator; if set to true, then the requester will be granted access if they are an administrator of the domain to which the shared drive belongs.", + "default": "false", + "location": "query" + } + }, + "parameterOrder": [ + "driveId" + ], + "scopes": [ + "https://www.googleapis.com/auth/drive" + ] + }, + "get": { + "id": "drive.drives.get", + "path": "drives/{driveId}", + "httpMethod": "GET", + "description": "Gets a shared drive's metadata by ID.", + "parameters": { + "driveId": { + "type": "string", + "description": "The ID of the shared drive.", + "required": true, + "location": "path" + }, + "useDomainAdminAccess": { + "type": "boolean", + "description": "Issue the request as a domain administrator; if set to true, then the requester will be granted access if they are an administrator of the domain to which the shared drive belongs.", + "default": "false", + "location": "query" + } + }, + "parameterOrder": [ + "driveId" + ], + "response": { + "$ref": "Drive" + }, + "scopes": [ + "https://www.googleapis.com/auth/drive", + "https://www.googleapis.com/auth/drive.readonly" + ] + }, + "hide": { + "id": "drive.drives.hide", + "path": "drives/{driveId}/hide", + "httpMethod": "POST", + "description": "Hides a shared drive from the default view.", + "parameters": { + "driveId": { + "type": "string", + "description": "The ID of the shared drive.", + "required": true, + "location": "path" + } + }, + "parameterOrder": [ + "driveId" + ], + "response": { + "$ref": "Drive" + }, + "scopes": [ + "https://www.googleapis.com/auth/drive" + ] + }, + "list": { + "id": "drive.drives.list", + "path": "drives", + "httpMethod": "GET", + "description": "Lists the user's shared drives.", + "parameters": { + "pageSize": { + "type": "integer", + "description": "Maximum number of shared drives to return per page.", + "default": "10", + "format": "int32", + "minimum": "1", + "maximum": "100", + "location": "query" + }, + "pageToken": { + "type": "string", + "description": "Page token for shared drives.", + "location": "query" + }, + "q": { + "type": "string", + "description": "Query string for searching shared drives.", + "location": "query" + }, + "useDomainAdminAccess": { + "type": "boolean", + "description": "Issue the request as a domain administrator; if set to true, then all shared drives of the domain in which the requester is an administrator are returned.", + "default": "false", + "location": "query" + } + }, + "response": { + "$ref": "DriveList" + }, + "scopes": [ + "https://www.googleapis.com/auth/drive", + "https://www.googleapis.com/auth/drive.readonly" + ] + }, + "unhide": { + "id": "drive.drives.unhide", + "path": "drives/{driveId}/unhide", + "httpMethod": "POST", + "description": "Restores a shared drive to the default view.", + "parameters": { + "driveId": { + "type": "string", + "description": "The ID of the shared drive.", + "required": true, + "location": "path" + } + }, + "parameterOrder": [ + "driveId" + ], + "response": { + "$ref": "Drive" + }, + "scopes": [ + "https://www.googleapis.com/auth/drive" + ] + }, + "update": { + "id": "drive.drives.update", + "path": "drives/{driveId}", + "httpMethod": "PATCH", + "description": "Updates the metadate for a shared drive.", + "parameters": { + "driveId": { + "type": "string", + "description": "The ID of the shared drive.", + "required": true, + "location": "path" + }, + "useDomainAdminAccess": { + "type": "boolean", + "description": "Issue the request as a domain administrator; if set to true, then the requester will be granted access if they are an administrator of the domain to which the shared drive belongs.", + "default": "false", + "location": "query" + } + }, + "parameterOrder": [ + "driveId" + ], + "request": { + "$ref": "Drive" + }, + "response": { + "$ref": "Drive" + }, + "scopes": [ + "https://www.googleapis.com/auth/drive" + ] + } + } + }, + "files": { + "methods": { + "copy": { + "id": "drive.files.copy", + "path": "files/{fileId}/copy", + "httpMethod": "POST", + "description": "Creates a copy of a file and applies any requested updates with patch semantics. Folders cannot be copied.", + "parameters": { + "enforceSingleParent": { + "type": "boolean", + "description": "Deprecated. Copying files into multiple folders is no longer supported. Use shortcuts instead.", + "default": "false", + "location": "query" + }, + "fileId": { + "type": "string", + "description": "The ID of the file.", + "required": true, + "location": "path" + }, + "ignoreDefaultVisibility": { + "type": "boolean", + "description": "Whether to ignore the domain's default visibility settings for the created file. Domain administrators can choose to make all uploaded files visible to the domain by default; this parameter bypasses that behavior for the request. Permissions are still inherited from parent folders.", + "default": "false", + "location": "query" + }, + "includeLabels": { + "type": "string", + "description": "A comma-separated list of IDs of labels to include in the labelInfo part of the response.", + "location": "query" + }, + "includePermissionsForView": { + "type": "string", + "description": "Specifies which additional view's permissions to include in the response. Only 'published' is supported.", + "location": "query" + }, + "keepRevisionForever": { + "type": "boolean", + "description": "Whether to set the 'keepForever' field in the new head revision. This is only applicable to files with binary content in Google Drive. Only 200 revisions for the file can be kept forever. If the limit is reached, try deleting pinned revisions.", + "default": "false", + "location": "query" + }, + "ocrLanguage": { + "type": "string", + "description": "A language hint for OCR processing during image import (ISO 639-1 code).", + "location": "query" + }, + "supportsAllDrives": { + "type": "boolean", + "description": "Whether the requesting application supports both My Drives and shared drives.", + "default": "false", + "location": "query" + }, + "supportsTeamDrives": { + "type": "boolean", + "description": "Deprecated use supportsAllDrives instead.", + "default": "false", + "location": "query" + } + }, + "parameterOrder": [ + "fileId" + ], + "request": { + "$ref": "File" + }, + "response": { + "$ref": "File" + }, + "scopes": [ + "https://www.googleapis.com/auth/drive", + "https://www.googleapis.com/auth/drive.appdata", + "https://www.googleapis.com/auth/drive.file", + "https://www.googleapis.com/auth/drive.photos.readonly" + ] + }, + "create": { + "id": "drive.files.create", + "path": "files", + "httpMethod": "POST", + "description": "Creates a new file.", + "parameters": { + "enforceSingleParent": { + "type": "boolean", + "description": "Deprecated. Creating files in multiple folders is no longer supported.", + "default": "false", + "location": "query" + }, + "ignoreDefaultVisibility": { + "type": "boolean", + "description": "Whether to ignore the domain's default visibility settings for the created file. Domain administrators can choose to make all uploaded files visible to the domain by default; this parameter bypasses that behavior for the request. Permissions are still inherited from parent folders.", + "default": "false", + "location": "query" + }, + "includeLabels": { + "type": "string", + "description": "A comma-separated list of IDs of labels to include in the labelInfo part of the response.", + "location": "query" + }, + "includePermissionsForView": { + "type": "string", + "description": "Specifies which additional view's permissions to include in the response. Only 'published' is supported.", + "location": "query" + }, + "keepRevisionForever": { + "type": "boolean", + "description": "Whether to set the 'keepForever' field in the new head revision. This is only applicable to files with binary content in Google Drive. Only 200 revisions for the file can be kept forever. If the limit is reached, try deleting pinned revisions.", + "default": "false", + "location": "query" + }, + "ocrLanguage": { + "type": "string", + "description": "A language hint for OCR processing during image import (ISO 639-1 code).", + "location": "query" + }, + "supportsAllDrives": { + "type": "boolean", + "description": "Whether the requesting application supports both My Drives and shared drives.", + "default": "false", + "location": "query" + }, + "supportsTeamDrives": { + "type": "boolean", + "description": "Deprecated use supportsAllDrives instead.", + "default": "false", + "location": "query" + }, + "useContentAsIndexableText": { + "type": "boolean", + "description": "Whether to use the uploaded content as indexable text.", + "default": "false", + "location": "query" + } + }, + "request": { + "$ref": "File" + }, + "response": { + "$ref": "File" + }, + "scopes": [ + "https://www.googleapis.com/auth/drive", + "https://www.googleapis.com/auth/drive.appdata", + "https://www.googleapis.com/auth/drive.file" + ], + "supportsMediaUpload": true, + "mediaUpload": { + "accept": [ + "*/*" + ], + "maxSize": "5120GB", + "protocols": { + "simple": { + "multipart": true, + "path": "/upload/drive/v3/files" + }, + "resumable": { + "multipart": true, + "path": "/resumable/upload/drive/v3/files" + } + } + }, + "supportsSubscription": true + }, + "delete": { + "id": "drive.files.delete", + "path": "files/{fileId}", + "httpMethod": "DELETE", + "description": "Permanently deletes a file owned by the user without moving it to the trash. If the file belongs to a shared drive the user must be an organizer on the parent. If the target is a folder, all descendants owned by the user are also deleted.", + "parameters": { + "enforceSingleParent": { + "type": "boolean", + "description": "Deprecated. If an item is not in a shared drive and its last parent is deleted but the item itself is not, the item will be placed under its owner's root.", + "default": "false", + "location": "query" + }, + "fileId": { + "type": "string", + "description": "The ID of the file.", + "required": true, + "location": "path" + }, + "supportsAllDrives": { + "type": "boolean", + "description": "Whether the requesting application supports both My Drives and shared drives.", + "default": "false", + "location": "query" + }, + "supportsTeamDrives": { + "type": "boolean", + "description": "Deprecated use supportsAllDrives instead.", + "default": "false", + "location": "query" + } + }, + "parameterOrder": [ + "fileId" + ], + "scopes": [ + "https://www.googleapis.com/auth/drive", + "https://www.googleapis.com/auth/drive.appdata", + "https://www.googleapis.com/auth/drive.file" + ] + }, + "emptyTrash": { + "id": "drive.files.emptyTrash", + "path": "files/trash", + "httpMethod": "DELETE", + "description": "Permanently deletes all of the user's trashed files.", + "parameters": { + "enforceSingleParent": { + "type": "boolean", + "description": "Deprecated. If an item is not in a shared drive and its last parent is deleted but the item itself is not, the item will be placed under its owner's root.", + "default": "false", + "location": "query" + } + }, + "scopes": [ + "https://www.googleapis.com/auth/drive" + ] + }, + "export": { + "id": "drive.files.export", + "path": "files/{fileId}/export", + "httpMethod": "GET", + "description": "Exports a Google Workspace document to the requested MIME type and returns exported byte content. Note that the exported content is limited to 10MB.", + "parameters": { + "fileId": { + "type": "string", + "description": "The ID of the file.", + "required": true, + "location": "path" + }, + "mimeType": { + "type": "string", + "description": "The MIME type of the format requested for this export.", + "required": true, + "location": "query" + } + }, + "parameterOrder": [ + "fileId", + "mimeType" + ], + "scopes": [ + "https://www.googleapis.com/auth/drive", + "https://www.googleapis.com/auth/drive.file", + "https://www.googleapis.com/auth/drive.readonly" + ], + "supportsMediaDownload": true + }, + "generateIds": { + "id": "drive.files.generateIds", + "path": "files/generateIds", + "httpMethod": "GET", + "description": "Generates a set of file IDs which can be provided in create or copy requests.", + "parameters": { + "count": { + "type": "integer", + "description": "The number of IDs to return.", + "default": "10", + "format": "int32", + "minimum": "1", + "maximum": "1000", + "location": "query" + }, + "space": { + "type": "string", + "description": "The space in which the IDs can be used to create new files. Supported values are 'drive' and 'appDataFolder'. (Default: 'drive')", + "default": "drive", + "location": "query" + }, + "type": { + "type": "string", + "description": "The type of items which the IDs can be used for. Supported values are 'files' and 'shortcuts'. Note that 'shortcuts' are only supported in the drive 'space'. (Default: 'files')", + "default": "files", + "location": "query" + } + }, + "response": { + "$ref": "GeneratedIds" + }, + "scopes": [ + "https://www.googleapis.com/auth/drive", + "https://www.googleapis.com/auth/drive.appdata", + "https://www.googleapis.com/auth/drive.file" + ] + }, + "get": { + "id": "drive.files.get", + "path": "files/{fileId}", + "httpMethod": "GET", + "description": "Gets a file's metadata or content by ID.", + "parameters": { + "acknowledgeAbuse": { + "type": "boolean", + "description": "Whether the user is acknowledging the risk of downloading known malware or other abusive files. This is only applicable when alt=media.", + "default": "false", + "location": "query" + }, + "fileId": { + "type": "string", + "description": "The ID of the file.", + "required": true, + "location": "path" + }, + "includeLabels": { + "type": "string", + "description": "A comma-separated list of IDs of labels to include in the labelInfo part of the response.", + "location": "query" + }, + "includePermissionsForView": { + "type": "string", + "description": "Specifies which additional view's permissions to include in the response. Only 'published' is supported.", + "location": "query" + }, + "supportsAllDrives": { + "type": "boolean", + "description": "Whether the requesting application supports both My Drives and shared drives.", + "default": "false", + "location": "query" + }, + "supportsTeamDrives": { + "type": "boolean", + "description": "Deprecated use supportsAllDrives instead.", + "default": "false", + "location": "query" + } + }, + "parameterOrder": [ + "fileId" + ], + "response": { + "$ref": "File" + }, + "scopes": [ + "https://www.googleapis.com/auth/drive", + "https://www.googleapis.com/auth/drive.appdata", + "https://www.googleapis.com/auth/drive.file", + "https://www.googleapis.com/auth/drive.metadata", + "https://www.googleapis.com/auth/drive.metadata.readonly", + "https://www.googleapis.com/auth/drive.photos.readonly", + "https://www.googleapis.com/auth/drive.readonly" + ], + "supportsMediaDownload": true, + "useMediaDownloadService": true, + "supportsSubscription": true + }, + "list": { + "id": "drive.files.list", + "path": "files", + "httpMethod": "GET", + "description": "Lists or searches files.", + "parameters": { + "corpora": { + "type": "string", + "description": "Groupings of files to which the query applies. Supported groupings are: 'user' (files created by, opened by, or shared directly with the user), 'drive' (files in the specified shared drive as indicated by the 'driveId'), 'domain' (files shared to the user's domain), and 'allDrives' (A combination of 'user' and 'drive' for all drives where the user is a member). When able, use 'user' or 'drive', instead of 'allDrives', for efficiency.", + "location": "query" + }, + "corpus": { + "type": "string", + "description": "The source of files to list. Deprecated: use 'corpora' instead.", + "enum": [ + "domain", + "user" + ], + "enumDescriptions": [ + "Files shared to the user's domain.", + "Files owned by or shared to the user. If a user has permissions on a Shared Drive, the files inside it won't be retrieved unless the user has created, opened, or shared the file." + ], + "location": "query" + }, + "driveId": { + "type": "string", + "description": "ID of the shared drive to search.", + "location": "query" + }, + "includeItemsFromAllDrives": { + "type": "boolean", + "description": "Whether both My Drive and shared drive items should be included in results.", + "default": "false", + "location": "query" + }, + "includeLabels": { + "type": "string", + "description": "A comma-separated list of IDs of labels to include in the labelInfo part of the response.", + "location": "query" + }, + "includePermissionsForView": { + "type": "string", + "description": "Specifies which additional view's permissions to include in the response. Only 'published' is supported.", + "location": "query" + }, + "includeTeamDriveItems": { + "type": "boolean", + "description": "Deprecated use includeItemsFromAllDrives instead.", + "default": "false", + "location": "query" + }, + "orderBy": { + "type": "string", + "description": "A comma-separated list of sort keys. Valid keys are 'createdTime', 'folder', 'modifiedByMeTime', 'modifiedTime', 'name', 'name_natural', 'quotaBytesUsed', 'recency', 'sharedWithMeTime', 'starred', and 'viewedByMeTime'. Each key sorts ascending by default, but may be reversed with the 'desc' modifier. Example usage: ?orderBy=folder,modifiedTime desc,name. Please note that there is a current limitation for users with approximately one million files in which the requested sort order is ignored.", + "location": "query" + }, + "pageSize": { + "type": "integer", + "description": "The maximum number of files to return per page. Partial or empty result pages are possible even before the end of the files list has been reached.", + "default": "100", + "format": "int32", + "minimum": "1", + "maximum": "1000", + "location": "query" + }, + "pageToken": { + "type": "string", + "description": "The token for continuing a previous list request on the next page. This should be set to the value of 'nextPageToken' from the previous response.", + "location": "query" + }, + "q": { + "type": "string", + "description": "A query for filtering the file results. See the \"Search for Files\" guide for supported syntax.", + "location": "query" + }, + "spaces": { + "type": "string", + "description": "A comma-separated list of spaces to query within the corpus. Supported values are 'drive' and 'appDataFolder'.", + "default": "drive", + "location": "query" + }, + "supportsAllDrives": { + "type": "boolean", + "description": "Whether the requesting application supports both My Drives and shared drives.", + "default": "false", + "location": "query" + }, + "supportsTeamDrives": { + "type": "boolean", + "description": "Deprecated use supportsAllDrives instead.", + "default": "false", + "location": "query" + }, + "teamDriveId": { + "type": "string", + "description": "Deprecated use driveId instead.", + "location": "query" + } + }, + "response": { + "$ref": "FileList" + }, + "scopes": [ + "https://www.googleapis.com/auth/drive", + "https://www.googleapis.com/auth/drive.appdata", + "https://www.googleapis.com/auth/drive.file", + "https://www.googleapis.com/auth/drive.metadata", + "https://www.googleapis.com/auth/drive.metadata.readonly", + "https://www.googleapis.com/auth/drive.photos.readonly", + "https://www.googleapis.com/auth/drive.readonly" + ] + }, + "listLabels": { + "id": "drive.files.listLabels", + "path": "files/{fileId}/listLabels", + "httpMethod": "GET", + "description": "Lists the labels on a file.", + "parameters": { + "fileId": { + "type": "string", + "description": "The ID of the file.", + "required": true, + "location": "path" + }, + "maxResults": { + "type": "integer", + "description": "The maximum number of labels to return per page. When not set, this defaults to 100.", + "default": "100", + "format": "int32", + "minimum": "1", + "maximum": "100", + "location": "query" + }, + "pageToken": { + "type": "string", + "description": "The token for continuing a previous list request on the next page. This should be set to the value of 'nextPageToken' from the previous response.", + "location": "query" + } + }, + "parameterOrder": [ + "fileId" + ], + "response": { + "$ref": "LabelList" + }, + "scopes": [ + "https://www.googleapis.com/auth/drive", + "https://www.googleapis.com/auth/drive.file", + "https://www.googleapis.com/auth/drive.metadata", + "https://www.googleapis.com/auth/drive.metadata.readonly", + "https://www.googleapis.com/auth/drive.readonly" + ] + }, + "modifyLabels": { + "id": "drive.files.modifyLabels", + "path": "files/{fileId}/modifyLabels", + "httpMethod": "POST", + "description": "Modifies the set of labels on a file.", + "parameters": { + "fileId": { + "type": "string", + "description": "The ID of the file for which the labels are modified.", + "required": true, + "location": "path" + } + }, + "parameterOrder": [ + "fileId" + ], + "request": { + "$ref": "ModifyLabelsRequest" + }, + "response": { + "$ref": "ModifyLabelsResponse" + }, + "scopes": [ + "https://www.googleapis.com/auth/drive", + "https://www.googleapis.com/auth/drive.file", + "https://www.googleapis.com/auth/drive.metadata" + ] + }, + "update": { + "id": "drive.files.update", + "path": "files/{fileId}", + "httpMethod": "PATCH", + "description": "Updates a file's metadata and/or content. When calling this method, only populate fields in the request that you want to modify. When updating fields, some fields might change automatically, such as modifiedDate. This method supports patch semantics.", + "parameters": { + "addParents": { + "type": "string", + "description": "A comma-separated list of parent IDs to add.", + "location": "query" + }, + "enforceSingleParent": { + "type": "boolean", + "description": "Deprecated. Adding files to multiple folders is no longer supported. Use shortcuts instead.", + "default": "false", + "location": "query" + }, + "fileId": { + "type": "string", + "description": "The ID of the file.", + "required": true, + "location": "path" + }, + "includeLabels": { + "type": "string", + "description": "A comma-separated list of IDs of labels to include in the labelInfo part of the response.", + "location": "query" + }, + "includePermissionsForView": { + "type": "string", + "description": "Specifies which additional view's permissions to include in the response. Only 'published' is supported.", + "location": "query" + }, + "keepRevisionForever": { + "type": "boolean", + "description": "Whether to set the 'keepForever' field in the new head revision. This is only applicable to files with binary content in Google Drive. Only 200 revisions for the file can be kept forever. If the limit is reached, try deleting pinned revisions.", + "default": "false", + "location": "query" + }, + "ocrLanguage": { + "type": "string", + "description": "A language hint for OCR processing during image import (ISO 639-1 code).", + "location": "query" + }, + "removeParents": { + "type": "string", + "description": "A comma-separated list of parent IDs to remove.", + "location": "query" + }, + "supportsAllDrives": { + "type": "boolean", + "description": "Whether the requesting application supports both My Drives and shared drives.", + "default": "false", + "location": "query" + }, + "supportsTeamDrives": { + "type": "boolean", + "description": "Deprecated use supportsAllDrives instead.", + "default": "false", + "location": "query" + }, + "useContentAsIndexableText": { + "type": "boolean", + "description": "Whether to use the uploaded content as indexable text.", + "default": "false", + "location": "query" + } + }, + "parameterOrder": [ + "fileId" + ], + "request": { + "$ref": "File" + }, + "response": { + "$ref": "File" + }, + "scopes": [ + "https://www.googleapis.com/auth/drive", + "https://www.googleapis.com/auth/drive.appdata", + "https://www.googleapis.com/auth/drive.file", + "https://www.googleapis.com/auth/drive.metadata", + "https://www.googleapis.com/auth/drive.scripts" + ], + "supportsMediaUpload": true, + "mediaUpload": { + "accept": [ + "*/*" + ], + "maxSize": "5120GB", + "protocols": { + "simple": { + "multipart": true, + "path": "/upload/drive/v3/files/{fileId}" + }, + "resumable": { + "multipart": true, + "path": "/resumable/upload/drive/v3/files/{fileId}" + } + } + } + }, + "watch": { + "id": "drive.files.watch", + "path": "files/{fileId}/watch", + "httpMethod": "POST", + "description": "Subscribes to changes to a file. While you can establish a channel for changes to a file on a shared drive, a change to a shared drive file won't create a notification.", + "parameters": { + "acknowledgeAbuse": { + "type": "boolean", + "description": "Whether the user is acknowledging the risk of downloading known malware or other abusive files. This is only applicable when alt=media.", + "default": "false", + "location": "query" + }, + "fileId": { + "type": "string", + "description": "The ID of the file.", + "required": true, + "location": "path" + }, + "includeLabels": { + "type": "string", + "description": "A comma-separated list of IDs of labels to include in the labelInfo part of the response.", + "location": "query" + }, + "includePermissionsForView": { + "type": "string", + "description": "Specifies which additional view's permissions to include in the response. Only 'published' is supported.", + "location": "query" + }, + "supportsAllDrives": { + "type": "boolean", + "description": "Whether the requesting application supports both My Drives and shared drives.", + "default": "false", + "location": "query" + }, + "supportsTeamDrives": { + "type": "boolean", + "description": "Deprecated use supportsAllDrives instead.", + "default": "false", + "location": "query" + } + }, + "parameterOrder": [ + "fileId" + ], + "request": { + "$ref": "Channel", + "parameterName": "resource" + }, + "response": { + "$ref": "Channel" + }, + "scopes": [ + "https://www.googleapis.com/auth/drive", + "https://www.googleapis.com/auth/drive.appdata", + "https://www.googleapis.com/auth/drive.file", + "https://www.googleapis.com/auth/drive.metadata", + "https://www.googleapis.com/auth/drive.metadata.readonly", + "https://www.googleapis.com/auth/drive.photos.readonly", + "https://www.googleapis.com/auth/drive.readonly" + ], + "supportsMediaDownload": true, + "useMediaDownloadService": true, + "supportsSubscription": true + } + } + }, + "permissions": { + "methods": { + "create": { + "id": "drive.permissions.create", + "path": "files/{fileId}/permissions", + "httpMethod": "POST", + "description": "Creates a permission for a file or shared drive.", + "parameters": { + "emailMessage": { + "type": "string", + "description": "A plain text custom message to include in the notification email.", + "location": "query" + }, + "enforceSingleParent": { + "type": "boolean", + "description": "Deprecated. See moveToNewOwnersRoot for details.", + "default": "false", + "location": "query" + }, + "fileId": { + "type": "string", + "description": "The ID of the file or shared drive.", + "required": true, + "location": "path" + }, + "moveToNewOwnersRoot": { + "type": "boolean", + "description": "This parameter will only take effect if the item is not in a shared drive and the request is attempting to transfer the ownership of the item. If set to true, the item will be moved to the new owner's My Drive root folder and all prior parents removed. If set to false, parents are not changed.", + "default": "false", + "location": "query" + }, + "sendNotificationEmail": { + "type": "boolean", + "description": "Whether to send a notification email when sharing to users or groups. This defaults to true for users and groups, and is not allowed for other requests. It must not be disabled for ownership transfers.", + "location": "query" + }, + "supportsAllDrives": { + "type": "boolean", + "description": "Whether the requesting application supports both My Drives and shared drives.", + "default": "false", + "location": "query" + }, + "supportsTeamDrives": { + "type": "boolean", + "description": "Deprecated use supportsAllDrives instead.", + "default": "false", + "location": "query" + }, + "transferOwnership": { + "type": "boolean", + "description": "Whether to transfer ownership to the specified user and downgrade the current owner to a writer. This parameter is required as an acknowledgement of the side effect. File owners can only transfer ownership of files existing on My Drive. Files existing in a shared drive are owned by the organization that owns that shared drive. Ownership transfers are not supported for files and folders in shared drives. Organizers of a shared drive can move items from that shared drive into their My Drive which transfers the ownership to them.", + "default": "false", + "location": "query" + }, + "useDomainAdminAccess": { + "type": "boolean", + "description": "Issue the request as a domain administrator; if set to true, then the requester will be granted access if the file ID parameter refers to a shared drive and the requester is an administrator of the domain to which the shared drive belongs.", + "default": "false", + "location": "query" + } + }, + "parameterOrder": [ + "fileId" + ], + "request": { + "$ref": "Permission" + }, + "response": { + "$ref": "Permission" + }, + "scopes": [ + "https://www.googleapis.com/auth/drive", + "https://www.googleapis.com/auth/drive.file" + ] + }, + "delete": { + "id": "drive.permissions.delete", + "path": "files/{fileId}/permissions/{permissionId}", + "httpMethod": "DELETE", + "description": "Deletes a permission.", + "parameters": { + "fileId": { + "type": "string", + "description": "The ID of the file or shared drive.", + "required": true, + "location": "path" + }, + "permissionId": { + "type": "string", + "description": "The ID of the permission.", + "required": true, + "location": "path" + }, + "supportsAllDrives": { + "type": "boolean", + "description": "Whether the requesting application supports both My Drives and shared drives.", + "default": "false", + "location": "query" + }, + "supportsTeamDrives": { + "type": "boolean", + "description": "Deprecated use supportsAllDrives instead.", + "default": "false", + "location": "query" + }, + "useDomainAdminAccess": { + "type": "boolean", + "description": "Issue the request as a domain administrator; if set to true, then the requester will be granted access if the file ID parameter refers to a shared drive and the requester is an administrator of the domain to which the shared drive belongs.", + "default": "false", + "location": "query" + } + }, + "parameterOrder": [ + "fileId", + "permissionId" + ], + "scopes": [ + "https://www.googleapis.com/auth/drive", + "https://www.googleapis.com/auth/drive.file" + ] + }, + "get": { + "id": "drive.permissions.get", + "path": "files/{fileId}/permissions/{permissionId}", + "httpMethod": "GET", + "description": "Gets a permission by ID.", + "parameters": { + "fileId": { + "type": "string", + "description": "The ID of the file.", + "required": true, + "location": "path" + }, + "permissionId": { + "type": "string", + "description": "The ID of the permission.", + "required": true, + "location": "path" + }, + "supportsAllDrives": { + "type": "boolean", + "description": "Whether the requesting application supports both My Drives and shared drives.", + "default": "false", + "location": "query" + }, + "supportsTeamDrives": { + "type": "boolean", + "description": "Deprecated use supportsAllDrives instead.", + "default": "false", + "location": "query" + }, + "useDomainAdminAccess": { + "type": "boolean", + "description": "Issue the request as a domain administrator; if set to true, then the requester will be granted access if the file ID parameter refers to a shared drive and the requester is an administrator of the domain to which the shared drive belongs.", + "default": "false", + "location": "query" + } + }, + "parameterOrder": [ + "fileId", + "permissionId" + ], + "response": { + "$ref": "Permission" + }, + "scopes": [ + "https://www.googleapis.com/auth/drive", + "https://www.googleapis.com/auth/drive.file", + "https://www.googleapis.com/auth/drive.metadata", + "https://www.googleapis.com/auth/drive.metadata.readonly", + "https://www.googleapis.com/auth/drive.photos.readonly", + "https://www.googleapis.com/auth/drive.readonly" + ] + }, + "list": { + "id": "drive.permissions.list", + "path": "files/{fileId}/permissions", + "httpMethod": "GET", + "description": "Lists a file's or shared drive's permissions.", + "parameters": { + "fileId": { + "type": "string", + "description": "The ID of the file or shared drive.", + "required": true, + "location": "path" + }, + "includePermissionsForView": { + "type": "string", + "description": "Specifies which additional view's permissions to include in the response. Only 'published' is supported.", + "location": "query" + }, + "pageSize": { + "type": "integer", + "description": "The maximum number of permissions to return per page. When not set for files in a shared drive, at most 100 results will be returned. When not set for files that are not in a shared drive, the entire list will be returned.", + "format": "int32", + "minimum": "1", + "maximum": "100", + "location": "query" + }, + "pageToken": { + "type": "string", + "description": "The token for continuing a previous list request on the next page. This should be set to the value of 'nextPageToken' from the previous response.", + "location": "query" + }, + "supportsAllDrives": { + "type": "boolean", + "description": "Whether the requesting application supports both My Drives and shared drives.", + "default": "false", + "location": "query" + }, + "supportsTeamDrives": { + "type": "boolean", + "description": "Deprecated use supportsAllDrives instead.", + "default": "false", + "location": "query" + }, + "useDomainAdminAccess": { + "type": "boolean", + "description": "Issue the request as a domain administrator; if set to true, then the requester will be granted access if the file ID parameter refers to a shared drive and the requester is an administrator of the domain to which the shared drive belongs.", + "default": "false", + "location": "query" + } + }, + "parameterOrder": [ + "fileId" + ], + "response": { + "$ref": "PermissionList" + }, + "scopes": [ + "https://www.googleapis.com/auth/drive", + "https://www.googleapis.com/auth/drive.file", + "https://www.googleapis.com/auth/drive.metadata", + "https://www.googleapis.com/auth/drive.metadata.readonly", + "https://www.googleapis.com/auth/drive.photos.readonly", + "https://www.googleapis.com/auth/drive.readonly" + ] + }, + "update": { + "id": "drive.permissions.update", + "path": "files/{fileId}/permissions/{permissionId}", + "httpMethod": "PATCH", + "description": "Updates a permission with patch semantics.", + "parameters": { + "fileId": { + "type": "string", + "description": "The ID of the file or shared drive.", + "required": true, + "location": "path" + }, + "permissionId": { + "type": "string", + "description": "The ID of the permission.", + "required": true, + "location": "path" + }, + "removeExpiration": { + "type": "boolean", + "description": "Whether to remove the expiration date.", + "default": "false", + "location": "query" + }, + "supportsAllDrives": { + "type": "boolean", + "description": "Whether the requesting application supports both My Drives and shared drives.", + "default": "false", + "location": "query" + }, + "supportsTeamDrives": { + "type": "boolean", + "description": "Deprecated use supportsAllDrives instead.", + "default": "false", + "location": "query" + }, + "transferOwnership": { + "type": "boolean", + "description": "Whether to transfer ownership to the specified user and downgrade the current owner to a writer. This parameter is required as an acknowledgement of the side effect. File owners can only transfer ownership of files existing on My Drive. Files existing in a shared drive are owned by the organization that owns that shared drive. Ownership transfers are not supported for files and folders in shared drives. Organizers of a shared drive can move items from that shared drive into their My Drive which transfers the ownership to them.", + "default": "false", + "location": "query" + }, + "useDomainAdminAccess": { + "type": "boolean", + "description": "Issue the request as a domain administrator; if set to true, then the requester will be granted access if the file ID parameter refers to a shared drive and the requester is an administrator of the domain to which the shared drive belongs.", + "default": "false", + "location": "query" + } + }, + "parameterOrder": [ + "fileId", + "permissionId" + ], + "request": { + "$ref": "Permission" + }, + "response": { + "$ref": "Permission" + }, + "scopes": [ + "https://www.googleapis.com/auth/drive", + "https://www.googleapis.com/auth/drive.file" + ] + } + } + }, + "replies": { + "methods": { + "create": { + "id": "drive.replies.create", + "path": "files/{fileId}/comments/{commentId}/replies", + "httpMethod": "POST", + "description": "Creates a new reply to a comment.", + "parameters": { + "commentId": { + "type": "string", + "description": "The ID of the comment.", + "required": true, + "location": "path" + }, + "fileId": { + "type": "string", + "description": "The ID of the file.", + "required": true, + "location": "path" + } + }, + "parameterOrder": [ + "fileId", + "commentId" + ], + "request": { + "$ref": "Reply" + }, + "response": { + "$ref": "Reply" + }, + "scopes": [ + "https://www.googleapis.com/auth/drive", + "https://www.googleapis.com/auth/drive.file" + ] + }, + "delete": { + "id": "drive.replies.delete", + "path": "files/{fileId}/comments/{commentId}/replies/{replyId}", + "httpMethod": "DELETE", + "description": "Deletes a reply.", + "parameters": { + "commentId": { + "type": "string", + "description": "The ID of the comment.", + "required": true, + "location": "path" + }, + "fileId": { + "type": "string", + "description": "The ID of the file.", + "required": true, + "location": "path" + }, + "replyId": { + "type": "string", + "description": "The ID of the reply.", + "required": true, + "location": "path" + } + }, + "parameterOrder": [ + "fileId", + "commentId", + "replyId" + ], + "scopes": [ + "https://www.googleapis.com/auth/drive", + "https://www.googleapis.com/auth/drive.file" + ] + }, + "get": { + "id": "drive.replies.get", + "path": "files/{fileId}/comments/{commentId}/replies/{replyId}", + "httpMethod": "GET", + "description": "Gets a reply by ID.", + "parameters": { + "commentId": { + "type": "string", + "description": "The ID of the comment.", + "required": true, + "location": "path" + }, + "fileId": { + "type": "string", + "description": "The ID of the file.", + "required": true, + "location": "path" + }, + "includeDeleted": { + "type": "boolean", + "description": "Whether to return deleted replies. Deleted replies will not include their original content.", + "default": "false", + "location": "query" + }, + "replyId": { + "type": "string", + "description": "The ID of the reply.", + "required": true, + "location": "path" + } + }, + "parameterOrder": [ + "fileId", + "commentId", + "replyId" + ], + "response": { + "$ref": "Reply" + }, + "scopes": [ + "https://www.googleapis.com/auth/drive", + "https://www.googleapis.com/auth/drive.file", + "https://www.googleapis.com/auth/drive.readonly" + ] + }, + "list": { + "id": "drive.replies.list", + "path": "files/{fileId}/comments/{commentId}/replies", + "httpMethod": "GET", + "description": "Lists a comment's replies.", + "parameters": { + "commentId": { + "type": "string", + "description": "The ID of the comment.", + "required": true, + "location": "path" + }, + "fileId": { + "type": "string", + "description": "The ID of the file.", + "required": true, + "location": "path" + }, + "includeDeleted": { + "type": "boolean", + "description": "Whether to include deleted replies. Deleted replies will not include their original content.", + "default": "false", + "location": "query" + }, + "pageSize": { + "type": "integer", + "description": "The maximum number of replies to return per page.", + "default": "20", + "format": "int32", + "minimum": "1", + "maximum": "100", + "location": "query" + }, + "pageToken": { + "type": "string", + "description": "The token for continuing a previous list request on the next page. This should be set to the value of 'nextPageToken' from the previous response.", + "location": "query" + } + }, + "parameterOrder": [ + "fileId", + "commentId" + ], + "response": { + "$ref": "ReplyList" + }, + "scopes": [ + "https://www.googleapis.com/auth/drive", + "https://www.googleapis.com/auth/drive.file", + "https://www.googleapis.com/auth/drive.readonly" + ] + }, + "update": { + "id": "drive.replies.update", + "path": "files/{fileId}/comments/{commentId}/replies/{replyId}", + "httpMethod": "PATCH", + "description": "Updates a reply with patch semantics.", + "parameters": { + "commentId": { + "type": "string", + "description": "The ID of the comment.", + "required": true, + "location": "path" + }, + "fileId": { + "type": "string", + "description": "The ID of the file.", + "required": true, + "location": "path" + }, + "replyId": { + "type": "string", + "description": "The ID of the reply.", + "required": true, + "location": "path" + } + }, + "parameterOrder": [ + "fileId", + "commentId", + "replyId" + ], + "request": { + "$ref": "Reply" + }, + "response": { + "$ref": "Reply" + }, + "scopes": [ + "https://www.googleapis.com/auth/drive", + "https://www.googleapis.com/auth/drive.file" + ] + } + } + }, + "revisions": { + "methods": { + "delete": { + "id": "drive.revisions.delete", + "path": "files/{fileId}/revisions/{revisionId}", + "httpMethod": "DELETE", + "description": "Permanently deletes a file version. You can only delete revisions for files with binary content in Google Drive, like images or videos. Revisions for other files, like Google Docs or Sheets, and the last remaining file version can't be deleted.", + "parameters": { + "fileId": { + "type": "string", + "description": "The ID of the file.", + "required": true, + "location": "path" + }, + "revisionId": { + "type": "string", + "description": "The ID of the revision.", + "required": true, + "location": "path" + } + }, + "parameterOrder": [ + "fileId", + "revisionId" + ], + "scopes": [ + "https://www.googleapis.com/auth/drive", + "https://www.googleapis.com/auth/drive.appdata", + "https://www.googleapis.com/auth/drive.file" + ] + }, + "get": { + "id": "drive.revisions.get", + "path": "files/{fileId}/revisions/{revisionId}", + "httpMethod": "GET", + "description": "Gets a revision's metadata or content by ID.", + "parameters": { + "acknowledgeAbuse": { + "type": "boolean", + "description": "Whether the user is acknowledging the risk of downloading known malware or other abusive files. This is only applicable when alt=media.", + "default": "false", + "location": "query" + }, + "fileId": { + "type": "string", + "description": "The ID of the file.", + "required": true, + "location": "path" + }, + "revisionId": { + "type": "string", + "description": "The ID of the revision.", + "required": true, + "location": "path" + } + }, + "parameterOrder": [ + "fileId", + "revisionId" + ], + "response": { + "$ref": "Revision" + }, + "scopes": [ + "https://www.googleapis.com/auth/drive", + "https://www.googleapis.com/auth/drive.appdata", + "https://www.googleapis.com/auth/drive.file", + "https://www.googleapis.com/auth/drive.metadata", + "https://www.googleapis.com/auth/drive.metadata.readonly", + "https://www.googleapis.com/auth/drive.photos.readonly", + "https://www.googleapis.com/auth/drive.readonly" + ], + "supportsMediaDownload": true, + "useMediaDownloadService": true + }, + "list": { + "id": "drive.revisions.list", + "path": "files/{fileId}/revisions", + "httpMethod": "GET", + "description": "Lists a file's revisions.", + "parameters": { + "fileId": { + "type": "string", + "description": "The ID of the file.", + "required": true, + "location": "path" + }, + "pageSize": { + "type": "integer", + "description": "The maximum number of revisions to return per page.", + "default": "200", + "format": "int32", + "minimum": "1", + "maximum": "1000", + "location": "query" + }, + "pageToken": { + "type": "string", + "description": "The token for continuing a previous list request on the next page. This should be set to the value of 'nextPageToken' from the previous response.", + "location": "query" + } + }, + "parameterOrder": [ + "fileId" + ], + "response": { + "$ref": "RevisionList" + }, + "scopes": [ + "https://www.googleapis.com/auth/drive", + "https://www.googleapis.com/auth/drive.appdata", + "https://www.googleapis.com/auth/drive.file", + "https://www.googleapis.com/auth/drive.metadata", + "https://www.googleapis.com/auth/drive.metadata.readonly", + "https://www.googleapis.com/auth/drive.photos.readonly", + "https://www.googleapis.com/auth/drive.readonly" + ] + }, + "update": { + "id": "drive.revisions.update", + "path": "files/{fileId}/revisions/{revisionId}", + "httpMethod": "PATCH", + "description": "Updates a revision with patch semantics.", + "parameters": { + "fileId": { + "type": "string", + "description": "The ID of the file.", + "required": true, + "location": "path" + }, + "revisionId": { + "type": "string", + "description": "The ID of the revision.", + "required": true, + "location": "path" + } + }, + "parameterOrder": [ + "fileId", + "revisionId" + ], + "request": { + "$ref": "Revision" + }, + "response": { + "$ref": "Revision" + }, + "scopes": [ + "https://www.googleapis.com/auth/drive", + "https://www.googleapis.com/auth/drive.appdata", + "https://www.googleapis.com/auth/drive.file" + ] + } + } + }, + "teamdrives": { + "methods": { + "create": { + "id": "drive.teamdrives.create", + "path": "teamdrives", + "httpMethod": "POST", + "description": "Deprecated use drives.create instead.", + "parameters": { + "requestId": { + "type": "string", + "description": "An ID, such as a random UUID, which uniquely identifies this user's request for idempotent creation of a Team Drive. A repeated request by the same user and with the same request ID will avoid creating duplicates by attempting to create the same Team Drive. If the Team Drive already exists a 409 error will be returned.", + "required": true, + "location": "query" + } + }, + "parameterOrder": [ + "requestId" + ], + "request": { + "$ref": "TeamDrive" + }, + "response": { + "$ref": "TeamDrive" + }, + "scopes": [ + "https://www.googleapis.com/auth/drive" + ] + }, + "delete": { + "id": "drive.teamdrives.delete", + "path": "teamdrives/{teamDriveId}", + "httpMethod": "DELETE", + "description": "Deprecated use drives.delete instead.", + "parameters": { + "teamDriveId": { + "type": "string", + "description": "The ID of the Team Drive", + "required": true, + "location": "path" + } + }, + "parameterOrder": [ + "teamDriveId" + ], + "scopes": [ + "https://www.googleapis.com/auth/drive" + ] + }, + "get": { + "id": "drive.teamdrives.get", + "path": "teamdrives/{teamDriveId}", + "httpMethod": "GET", + "description": "Deprecated use drives.get instead.", + "parameters": { + "teamDriveId": { + "type": "string", + "description": "The ID of the Team Drive", + "required": true, + "location": "path" + }, + "useDomainAdminAccess": { + "type": "boolean", + "description": "Issue the request as a domain administrator; if set to true, then the requester will be granted access if they are an administrator of the domain to which the Team Drive belongs.", + "default": "false", + "location": "query" + } + }, + "parameterOrder": [ + "teamDriveId" + ], + "response": { + "$ref": "TeamDrive" + }, + "scopes": [ + "https://www.googleapis.com/auth/drive", + "https://www.googleapis.com/auth/drive.readonly" + ] + }, + "list": { + "id": "drive.teamdrives.list", + "path": "teamdrives", + "httpMethod": "GET", + "description": "Deprecated use drives.list instead.", + "parameters": { + "pageSize": { + "type": "integer", + "description": "Maximum number of Team Drives to return.", + "default": "10", + "format": "int32", + "minimum": "1", + "maximum": "100", + "location": "query" + }, + "pageToken": { + "type": "string", + "description": "Page token for Team Drives.", + "location": "query" + }, + "q": { + "type": "string", + "description": "Query string for searching Team Drives.", + "location": "query" + }, + "useDomainAdminAccess": { + "type": "boolean", + "description": "Issue the request as a domain administrator; if set to true, then all Team Drives of the domain in which the requester is an administrator are returned.", + "default": "false", + "location": "query" + } + }, + "response": { + "$ref": "TeamDriveList" + }, + "scopes": [ + "https://www.googleapis.com/auth/drive", + "https://www.googleapis.com/auth/drive.readonly" + ] + }, + "update": { + "id": "drive.teamdrives.update", + "path": "teamdrives/{teamDriveId}", + "httpMethod": "PATCH", + "description": "Deprecated use drives.update instead", + "parameters": { + "teamDriveId": { + "type": "string", + "description": "The ID of the Team Drive", + "required": true, + "location": "path" + }, + "useDomainAdminAccess": { + "type": "boolean", + "description": "Issue the request as a domain administrator; if set to true, then the requester will be granted access if they are an administrator of the domain to which the Team Drive belongs.", + "default": "false", + "location": "query" + } + }, + "parameterOrder": [ + "teamDriveId" + ], + "request": { + "$ref": "TeamDrive" + }, + "response": { + "$ref": "TeamDrive" + }, + "scopes": [ + "https://www.googleapis.com/auth/drive" + ] + } + } + } + } +} diff --git a/venv/lib/python3.10/site-packages/pygsheets/data/sheets_discovery.json b/venv/lib/python3.10/site-packages/pygsheets/data/sheets_discovery.json new file mode 100644 index 0000000000000000000000000000000000000000..bf82cfaa736898a98ea7cbfd4dfeb0cd4f37bf78 --- /dev/null +++ b/venv/lib/python3.10/site-packages/pygsheets/data/sheets_discovery.json @@ -0,0 +1,7821 @@ +{ + "ownerName": "Google", + "auth": { + "oauth2": { + "scopes": { + "https://www.googleapis.com/auth/spreadsheets": { + "description": "See, edit, create, and delete your spreadsheets in Google Drive" + }, + "https://www.googleapis.com/auth/drive": { + "description": "See, edit, create, and delete all of your Google Drive files" + }, + "https://www.googleapis.com/auth/spreadsheets.readonly": { + "description": "View your Google Spreadsheets" + }, + "https://www.googleapis.com/auth/drive.readonly": { + "description": "See and download all your Google Drive files" + }, + "https://www.googleapis.com/auth/drive.file": { + "description": "View and manage Google Drive files and folders that you have opened or created with this app" + } + } + } + }, + "kind": "discovery#restDescription", + "mtlsRootUrl": "https://sheets.mtls.googleapis.com/", + "name": "sheets", + "documentationLink": "https://developers.google.com/sheets/", + "canonicalName": "Sheets", + "ownerDomain": "google.com", + "version": "v4", + "id": "sheets:v4", + "revision": "20201130", + "parameters": { + "access_token": { + "type": "string", + "location": "query", + "description": "OAuth access token." + }, + "upload_protocol": { + "description": "Upload protocol for media (e.g. \"raw\", \"multipart\").", + "location": "query", + "type": "string" + }, + "$.xgafv": { + "type": "string", + "enumDescriptions": [ + "v1 error format", + "v2 error format" + ], + "location": "query", + "enum": [ + "1", + "2" + ], + "description": "V1 error format." + }, + "alt": { + "location": "query", + "type": "string", + "enum": [ + "json", + "media", + "proto" + ], + "description": "Data format for response.", + "enumDescriptions": [ + "Responses with Content-Type of application/json", + "Media download with context-dependent Content-Type", + "Responses with Content-Type of application/x-protobuf" + ], + "default": "json" + }, + "key": { + "type": "string", + "location": "query", + "description": "API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token." + }, + "fields": { + "location": "query", + "type": "string", + "description": "Selector specifying which fields to include in a partial response." + }, + "prettyPrint": { + "type": "boolean", + "default": "true", + "description": "Returns response with indentations and line breaks.", + "location": "query" + }, + "callback": { + "location": "query", + "description": "JSONP", + "type": "string" + }, + "oauth_token": { + "location": "query", + "description": "OAuth 2.0 token for the current user.", + "type": "string" + }, + "uploadType": { + "description": "Legacy upload protocol for media (e.g. \"media\", \"multipart\").", + "location": "query", + "type": "string" + }, + "quotaUser": { + "type": "string", + "description": "Available to use for quota purposes for server-side applications. Can be any arbitrary string assigned to a user, but should not exceed 40 characters.", + "location": "query" + } + }, + "fullyEncodeReservedExpansion": true, + "title": "Google Sheets API", + "version_module": true, + "icons": { + "x32": "http://www.google.com/images/icons/product/search-32.gif", + "x16": "http://www.google.com/images/icons/product/search-16.gif" + }, + "protocol": "rest", + "baseUrl": "https://sheets.googleapis.com/", + "servicePath": "", + "basePath": "", + "description": "Reads and writes Google Sheets.", + "discoveryVersion": "v1", + "schemas": { + "IterativeCalculationSettings": { + "description": "Settings to control how circular dependencies are resolved with iterative calculation.", + "id": "IterativeCalculationSettings", + "properties": { + "maxIterations": { + "description": "When iterative calculation is enabled, the maximum number of calculation rounds to perform.", + "type": "integer", + "format": "int32" + }, + "convergenceThreshold": { + "type": "number", + "description": "When iterative calculation is enabled and successive results differ by less than this threshold value, the calculation rounds stop.", + "format": "double" + } + }, + "type": "object" + }, + "CreateDeveloperMetadataResponse": { + "id": "CreateDeveloperMetadataResponse", + "type": "object", + "properties": { + "developerMetadata": { + "$ref": "DeveloperMetadata", + "description": "The developer metadata that was created." + } + }, + "description": "The response from creating developer metadata." + }, + "TreemapChartSpec": { + "description": "A Treemap chart.", + "type": "object", + "properties": { + "levels": { + "format": "int32", + "type": "integer", + "description": "The number of data levels to show on the treemap chart. These levels are interactive and are shown with their labels. Defaults to 2 if not specified." + }, + "maxValue": { + "format": "double", + "description": "The maximum possible data value. Cells with values greater than this will have the same color as cells with this value. If not specified, defaults to the actual maximum value from color_data, or the maximum value from size_data if color_data is not specified.", + "type": "number" + }, + "colorScale": { + "description": "The color scale for data cells in the treemap chart. Data cells are assigned colors based on their color values. These color values come from color_data, or from size_data if color_data is not specified. Cells with color values less than or equal to min_value will have minValueColor as their background color. Cells with color values greater than or equal to max_value will have maxValueColor as their background color. Cells with color values between min_value and max_value will have background colors on a gradient between minValueColor and maxValueColor, the midpoint of the gradient being midValueColor. Cells with missing or non-numeric color values will have noDataColor as their background color.", + "$ref": "TreemapChartColorScale" + }, + "headerColor": { + "$ref": "Color", + "description": "The background color for header cells." + }, + "hintedLevels": { + "description": "The number of additional data levels beyond the labeled levels to be shown on the treemap chart. These levels are not interactive and are shown without their labels. Defaults to 0 if not specified.", + "format": "int32", + "type": "integer" + }, + "sizeData": { + "description": "The data that determines the size of each treemap data cell. This data is expected to be numeric. The cells corresponding to non-numeric or missing data will not be rendered. If color_data is not specified, this data is used to determine data cell background colors as well.", + "$ref": "ChartData" + }, + "parentLabels": { + "$ref": "ChartData", + "description": "The data the contains the treemap cells' parent labels." + }, + "colorData": { + "$ref": "ChartData", + "description": "The data that determines the background color of each treemap data cell. This field is optional. If not specified, size_data is used to determine background colors. If specified, the data is expected to be numeric. color_scale will determine how the values in this data map to data cell background colors." + }, + "labels": { + "$ref": "ChartData", + "description": "The data that contains the treemap cell labels." + }, + "hideTooltips": { + "type": "boolean", + "description": "True to hide tooltips." + }, + "minValue": { + "description": "The minimum possible data value. Cells with values less than this will have the same color as cells with this value. If not specified, defaults to the actual minimum value from color_data, or the minimum value from size_data if color_data is not specified.", + "format": "double", + "type": "number" + }, + "textFormat": { + "description": "The text format for all labels on the chart.", + "$ref": "TextFormat" + }, + "headerColorStyle": { + "$ref": "ColorStyle", + "description": "The background color for header cells. If header_color is also set, this field takes precedence." + } + }, + "id": "TreemapChartSpec" + }, + "FilterView": { + "type": "object", + "id": "FilterView", + "properties": { + "range": { + "$ref": "GridRange", + "description": "The range this filter view covers. When writing, only one of range or named_range_id may be set." + }, + "filterViewId": { + "description": "The ID of the filter view.", + "type": "integer", + "format": "int32" + }, + "namedRangeId": { + "description": "The named range this filter view is backed by, if any. When writing, only one of range or named_range_id may be set.", + "type": "string" + }, + "title": { + "type": "string", + "description": "The name of the filter view." + }, + "filterSpecs": { + "items": { + "$ref": "FilterSpec" + }, + "description": "The filter criteria for showing/hiding values per column. Both criteria and filter_specs are populated in responses. If both fields are specified in an update request, this field takes precedence.", + "type": "array" + }, + "sortSpecs": { + "type": "array", + "items": { + "$ref": "SortSpec" + }, + "description": "The sort order per column. Later specifications are used when values are equal in the earlier specifications." + }, + "criteria": { + "description": "The criteria for showing/hiding values per column. The map's key is the column index, and the value is the criteria for that column. This field is deprecated in favor of filter_specs.", + "type": "object", + "additionalProperties": { + "$ref": "FilterCriteria" + } + } + }, + "description": "A filter view." + }, + "MoveDimensionRequest": { + "properties": { + "destinationIndex": { + "type": "integer", + "format": "int32", + "description": "The zero-based start index of where to move the source data to, based on the coordinates *before* the source data is removed from the grid. Existing data will be shifted down or right (depending on the dimension) to make room for the moved dimensions. The source dimensions are removed from the grid, so the the data may end up in a different index than specified. For example, given `A1..A5` of `0, 1, 2, 3, 4` and wanting to move `\"1\"` and `\"2\"` to between `\"3\"` and `\"4\"`, the source would be `ROWS [1..3)`,and the destination index would be `\"4\"` (the zero-based index of row 5). The end result would be `A1..A5` of `0, 3, 1, 2, 4`." + }, + "source": { + "$ref": "DimensionRange", + "description": "The source dimensions to move." + } + }, + "type": "object", + "id": "MoveDimensionRequest", + "description": "Moves one or more rows or columns." + }, + "BasicChartSeries": { + "id": "BasicChartSeries", + "description": "A single series of data in a chart. For example, if charting stock prices over time, multiple series may exist, one for the \"Open Price\", \"High Price\", \"Low Price\" and \"Close Price\".", + "type": "object", + "properties": { + "pointStyle": { + "$ref": "PointStyle", + "description": "The style for points associated with this series. Valid only if the chartType is AREA, LINE, or SCATTER. COMBO charts are also supported if the series chart type is AREA, LINE, or SCATTER. If empty, a default point style is used." + }, + "color": { + "$ref": "Color", + "description": "The color for elements (such as bars, lines, and points) associated with this series. If empty, a default color is used." + }, + "styleOverrides": { + "type": "array", + "description": "Style override settings for series data points.", + "items": { + "$ref": "BasicSeriesDataPointStyleOverride" + } + }, + "colorStyle": { + "description": "The color for elements (such as bars, lines, and points) associated with this series. If empty, a default color is used. If color is also set, this field takes precedence.", + "$ref": "ColorStyle" + }, + "dataLabel": { + "description": "Information about the data labels for this series.", + "$ref": "DataLabel" + }, + "series": { + "description": "The data being visualized in this chart series.", + "$ref": "ChartData" + }, + "targetAxis": { + "type": "string", + "enumDescriptions": [ + "Default value, do not use.", + "The axis rendered at the bottom of a chart. For most charts, this is the standard major axis. For bar charts, this is a minor axis.", + "The axis rendered at the left of a chart. For most charts, this is a minor axis. For bar charts, this is the standard major axis.", + "The axis rendered at the right of a chart. For most charts, this is a minor axis. For bar charts, this is an unusual major axis." + ], + "description": "The minor axis that will specify the range of values for this series. For example, if charting stocks over time, the \"Volume\" series may want to be pinned to the right with the prices pinned to the left, because the scale of trading volume is different than the scale of prices. It is an error to specify an axis that isn't a valid minor axis for the chart's type.", + "enum": [ + "BASIC_CHART_AXIS_POSITION_UNSPECIFIED", + "BOTTOM_AXIS", + "LEFT_AXIS", + "RIGHT_AXIS" + ] + }, + "lineStyle": { + "$ref": "LineStyle", + "description": "The line style of this series. Valid only if the chartType is AREA, LINE, or SCATTER. COMBO charts are also supported if the series chart type is AREA or LINE." + }, + "type": { + "enumDescriptions": [ + "Default value, do not use.", + "A bar chart.", + "A line chart.", + "An area chart.", + "A column chart.", + "A scatter chart.", + "A combo chart.", + "A stepped area chart." + ], + "description": "The type of this series. Valid only if the chartType is COMBO. Different types will change the way the series is visualized. Only LINE, AREA, and COLUMN are supported.", + "type": "string", + "enum": [ + "BASIC_CHART_TYPE_UNSPECIFIED", + "BAR", + "LINE", + "AREA", + "COLUMN", + "SCATTER", + "COMBO", + "STEPPED_AREA" + ] + } + } + }, + "BatchClearValuesResponse": { + "description": "The response when clearing a range of values in a spreadsheet.", + "type": "object", + "properties": { + "spreadsheetId": { + "description": "The spreadsheet the updates were applied to.", + "type": "string" + }, + "clearedRanges": { + "type": "array", + "description": "The ranges that were cleared, in A1 notation. If the requests are for an unbounded range or a ranger larger than the bounds of the sheet, this is the actual ranges that were cleared, bounded to the sheet's limits.", + "items": { + "type": "string" + } + } + }, + "id": "BatchClearValuesResponse" + }, + "DuplicateFilterViewRequest": { + "properties": { + "filterId": { + "description": "The ID of the filter being duplicated.", + "format": "int32", + "type": "integer" + } + }, + "type": "object", + "id": "DuplicateFilterViewRequest", + "description": "Duplicates a particular filter view." + }, + "DataSourceColumnReference": { + "type": "object", + "id": "DataSourceColumnReference", + "description": "An unique identifier that references a data source column.", + "properties": { + "name": { + "type": "string", + "description": "The display name of the column. It should be unique within a data source." + } + } + }, + "ScorecardChartSpec": { + "properties": { + "aggregateType": { + "enumDescriptions": [ + "Default value, do not use.", + "Average aggregate function.", + "Count aggregate function.", + "Maximum aggregate function.", + "Median aggregate function.", + "Minimum aggregate function.", + "Sum aggregate function." + ], + "enum": [ + "CHART_AGGREGATE_TYPE_UNSPECIFIED", + "AVERAGE", + "COUNT", + "MAX", + "MEDIAN", + "MIN", + "SUM" + ], + "type": "string", + "description": "The aggregation type for key and baseline chart data in scorecard chart. This field is not supported for data source charts. Use the ChartData.aggregateType field of the key_value_data or baseline_value_data instead for data source charts. This field is optional." + }, + "customFormatOptions": { + "$ref": "ChartCustomNumberFormatOptions", + "description": "Custom formatting options for numeric key/baseline values in scorecard chart. This field is used only when number_format_source is set to CUSTOM. This field is optional." + }, + "keyValueFormat": { + "$ref": "KeyValueFormat", + "description": "Formatting options for key value." + }, + "baselineValueFormat": { + "$ref": "BaselineValueFormat", + "description": "Formatting options for baseline value. This field is needed only if baseline_value_data is specified." + }, + "scaleFactor": { + "description": "Value to scale scorecard key and baseline value. For example, a factor of 10 can be used to divide all values in the chart by 10. This field is optional.", + "format": "double", + "type": "number" + }, + "baselineValueData": { + "description": "The data for scorecard baseline value. This field is optional.", + "$ref": "ChartData" + }, + "keyValueData": { + "$ref": "ChartData", + "description": "The data for scorecard key value." + }, + "numberFormatSource": { + "description": "The number format source used in the scorecard chart. This field is optional.", + "type": "string", + "enum": [ + "CHART_NUMBER_FORMAT_SOURCE_UNDEFINED", + "FROM_DATA", + "CUSTOM" + ], + "enumDescriptions": [ + "Default value, do not use.", + "Inherit number formatting from data.", + "Apply custom formatting as specified by ChartCustomNumberFormatOptions." + ] + } + }, + "id": "ScorecardChartSpec", + "description": "A scorecard chart. Scorecard charts are used to highlight key performance indicators, known as KPIs, on the spreadsheet. A scorecard chart can represent things like total sales, average cost, or a top selling item. You can specify a single data value, or aggregate over a range of data. Percentage or absolute difference from a baseline value can be highlighted, like changes over time.", + "type": "object" + }, + "PivotGroupLimit": { + "id": "PivotGroupLimit", + "properties": { + "applyOrder": { + "description": "The order in which the group limit is applied to the pivot table. Pivot group limits are applied from lower to higher order number. Order numbers are normalized to consecutive integers from 0. For write request, to fully customize the applying orders, all pivot group limits should have this field set with an unique number. Otherwise, the order is determined by the index in the PivotTable.rows list and then the PivotTable.columns list.", + "format": "int32", + "type": "integer" + }, + "countLimit": { + "format": "int32", + "type": "integer", + "description": "The count limit." + } + }, + "description": "The count limit on rows or columns in the pivot group.", + "type": "object" + }, + "SlicerSpec": { + "properties": { + "columnIndex": { + "format": "int32", + "description": "The column index in the data table on which the filter is applied to.", + "type": "integer" + }, + "applyToPivotTables": { + "description": "True if the filter should apply to pivot tables. If not set, default to `True`.", + "type": "boolean" + }, + "horizontalAlignment": { + "enumDescriptions": [ + "The horizontal alignment is not specified. Do not use this.", + "The text is explicitly aligned to the left of the cell.", + "The text is explicitly aligned to the center of the cell.", + "The text is explicitly aligned to the right of the cell." + ], + "type": "string", + "enum": [ + "HORIZONTAL_ALIGN_UNSPECIFIED", + "LEFT", + "CENTER", + "RIGHT" + ], + "description": "The horizontal alignment of title in the slicer. If unspecified, defaults to `LEFT`" + }, + "backgroundColorStyle": { + "description": "The background color of the slicer. If background_color is also set, this field takes precedence.", + "$ref": "ColorStyle" + }, + "textFormat": { + "description": "The text format of title in the slicer.", + "$ref": "TextFormat" + }, + "filterCriteria": { + "description": "The filtering criteria of the slicer.", + "$ref": "FilterCriteria" + }, + "dataRange": { + "description": "The data range of the slicer.", + "$ref": "GridRange" + }, + "title": { + "type": "string", + "description": "The title of the slicer." + }, + "backgroundColor": { + "$ref": "Color", + "description": "The background color of the slicer." + } + }, + "description": "The specifications of a slicer.", + "id": "SlicerSpec", + "type": "object" + }, + "BatchUpdateSpreadsheetRequest": { + "properties": { + "responseIncludeGridData": { + "description": "True if grid data should be returned. Meaningful only if include_spreadsheet_in_response is 'true'. This parameter is ignored if a field mask was set in the request.", + "type": "boolean" + }, + "includeSpreadsheetInResponse": { + "type": "boolean", + "description": "Determines if the update response should include the spreadsheet resource." + }, + "responseRanges": { + "items": { + "type": "string" + }, + "type": "array", + "description": "Limits the ranges included in the response spreadsheet. Meaningful only if include_spreadsheet_in_response is 'true'." + }, + "requests": { + "items": { + "$ref": "Request" + }, + "type": "array", + "description": "A list of updates to apply to the spreadsheet. Requests will be applied in the order they are specified. If any request is not valid, no requests will be applied." + } + }, + "description": "The request for updating any aspect of a spreadsheet.", + "id": "BatchUpdateSpreadsheetRequest", + "type": "object" + }, + "BatchClearValuesRequest": { + "description": "The request for clearing more than one range of values in a spreadsheet.", + "id": "BatchClearValuesRequest", + "type": "object", + "properties": { + "ranges": { + "type": "array", + "description": "The ranges to clear, in A1 notation.", + "items": { + "type": "string" + } + } + } + }, + "CopyPasteRequest": { + "id": "CopyPasteRequest", + "properties": { + "destination": { + "description": "The location to paste to. If the range covers a span that's a multiple of the source's height or width, then the data will be repeated to fill in the destination range. If the range is smaller than the source range, the entire source data will still be copied (beyond the end of the destination range).", + "$ref": "GridRange" + }, + "pasteType": { + "description": "What kind of data to paste.", + "enumDescriptions": [ + "Paste values, formulas, formats, and merges.", + "Paste the values ONLY without formats, formulas, or merges.", + "Paste the format and data validation only.", + "Like PASTE_NORMAL but without borders.", + "Paste the formulas only.", + "Paste the data validation only.", + "Paste the conditional formatting rules only." + ], + "enum": [ + "PASTE_NORMAL", + "PASTE_VALUES", + "PASTE_FORMAT", + "PASTE_NO_BORDERS", + "PASTE_FORMULA", + "PASTE_DATA_VALIDATION", + "PASTE_CONDITIONAL_FORMATTING" + ], + "type": "string" + }, + "pasteOrientation": { + "description": "How that data should be oriented when pasting.", + "enum": [ + "NORMAL", + "TRANSPOSE" + ], + "type": "string", + "enumDescriptions": [ + "Paste normally.", + "Paste transposed, where all rows become columns and vice versa." + ] + }, + "source": { + "description": "The source range to copy.", + "$ref": "GridRange" + } + }, + "description": "Copies data from the source to the destination.", + "type": "object" + }, + "UpdateDeveloperMetadataRequest": { + "properties": { + "developerMetadata": { + "$ref": "DeveloperMetadata", + "description": "The value that all metadata matched by the data filters will be updated to." + }, + "dataFilters": { + "type": "array", + "description": "The filters matching the developer metadata entries to update.", + "items": { + "$ref": "DataFilter" + } + }, + "fields": { + "type": "string", + "description": "The fields that should be updated. At least one field must be specified. The root `developerMetadata` is implied and should not be specified. A single `\"*\"` can be used as short-hand for listing every field.", + "format": "google-fieldmask" + } + }, + "description": "A request to update properties of developer metadata. Updates the properties of the developer metadata selected by the filters to the values provided in the DeveloperMetadata resource. Callers must specify the properties they wish to update in the fields parameter, as well as specify at least one DataFilter matching the metadata they wish to update.", + "id": "UpdateDeveloperMetadataRequest", + "type": "object" + }, + "AddDataSourceResponse": { + "properties": { + "dataExecutionStatus": { + "description": "The data execution status.", + "$ref": "DataExecutionStatus" + }, + "dataSource": { + "$ref": "DataSource", + "description": "The data source that was created." + } + }, + "description": "The result of adding a data source.", + "type": "object", + "id": "AddDataSourceResponse" + }, + "GridData": { + "properties": { + "rowData": { + "type": "array", + "items": { + "$ref": "RowData" + }, + "description": "The data in the grid, one entry per row, starting with the row in startRow. The values in RowData will correspond to columns starting at start_column." + }, + "startColumn": { + "description": "The first column this GridData refers to, zero-based.", + "type": "integer", + "format": "int32" + }, + "startRow": { + "format": "int32", + "description": "The first row this GridData refers to, zero-based.", + "type": "integer" + }, + "rowMetadata": { + "items": { + "$ref": "DimensionProperties" + }, + "type": "array", + "description": "Metadata about the requested rows in the grid, starting with the row in start_row." + }, + "columnMetadata": { + "type": "array", + "description": "Metadata about the requested columns in the grid, starting with the column in start_column.", + "items": { + "$ref": "DimensionProperties" + } + } + }, + "description": "Data in the grid, as well as metadata about the dimensions.", + "type": "object", + "id": "GridData" + }, + "TimeOfDay": { + "properties": { + "minutes": { + "type": "integer", + "description": "Minutes of hour of day. Must be from 0 to 59.", + "format": "int32" + }, + "hours": { + "type": "integer", + "description": "Hours of day in 24 hour format. Should be from 0 to 23. An API may choose to allow the value \"24:00:00\" for scenarios like business closing time.", + "format": "int32" + }, + "seconds": { + "type": "integer", + "format": "int32", + "description": "Seconds of minutes of the time. Must normally be from 0 to 59. An API may allow the value 60 if it allows leap-seconds." + }, + "nanos": { + "format": "int32", + "type": "integer", + "description": "Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999." + } + }, + "id": "TimeOfDay", + "type": "object", + "description": "Represents a time of day. The date and time zone are either not significant or are specified elsewhere. An API may choose to allow leap seconds. Related types are google.type.Date and `google.protobuf.Timestamp`." + }, + "SortRangeRequest": { + "type": "object", + "description": "Sorts data in rows based on a sort order per column.", + "properties": { + "sortSpecs": { + "type": "array", + "description": "The sort order per column. Later specifications are used when values are equal in the earlier specifications.", + "items": { + "$ref": "SortSpec" + } + }, + "range": { + "$ref": "GridRange", + "description": "The range to sort." + } + }, + "id": "SortRangeRequest" + }, + "UpdateDataSourceRequest": { + "properties": { + "fields": { + "format": "google-fieldmask", + "type": "string", + "description": "The fields that should be updated. At least one field must be specified. The root `dataSource` is implied and should not be specified. A single `\"*\"` can be used as short-hand for listing every field." + }, + "dataSource": { + "$ref": "DataSource", + "description": "The data source to update." + } + }, + "description": "Updates a data source. After the data source is updated successfully, an execution is triggered to refresh the associated DATA_SOURCE sheet to read data from the updated data source. The request requires an additional `bigquery.readonly` OAuth scope.", + "id": "UpdateDataSourceRequest", + "type": "object" + }, + "TrimWhitespaceResponse": { + "id": "TrimWhitespaceResponse", + "description": "The result of trimming whitespace in cells.", + "properties": { + "cellsChangedCount": { + "type": "integer", + "format": "int32", + "description": "The number of cells that were trimmed of whitespace." + } + }, + "type": "object" + }, + "TextFormat": { + "type": "object", + "id": "TextFormat", + "description": "The format of a run of text in a cell. Absent values indicate that the field isn't specified.", + "properties": { + "foregroundColor": { + "description": "The foreground color of the text.", + "$ref": "Color" + }, + "fontFamily": { + "type": "string", + "description": "The font family." + }, + "fontSize": { + "type": "integer", + "format": "int32", + "description": "The size of the font." + }, + "underline": { + "type": "boolean", + "description": "True if the text is underlined." + }, + "bold": { + "type": "boolean", + "description": "True if the text is bold." + }, + "italic": { + "type": "boolean", + "description": "True if the text is italicized." + }, + "strikethrough": { + "type": "boolean", + "description": "True if the text has a strikethrough." + }, + "foregroundColorStyle": { + "description": "The foreground color of the text. If foreground_color is also set, this field takes precedence.", + "$ref": "ColorStyle" + } + } + }, + "PivotGroupValueMetadata": { + "id": "PivotGroupValueMetadata", + "properties": { + "collapsed": { + "description": "True if the data corresponding to the value is collapsed.", + "type": "boolean" + }, + "value": { + "description": "The calculated value the metadata corresponds to. (Note that formulaValue is not valid, because the values will be calculated.)", + "$ref": "ExtendedValue" + } + }, + "type": "object", + "description": "Metadata about a value in a pivot grouping." + }, + "DeveloperMetadataLocation": { + "description": "A location where metadata may be associated in a spreadsheet.", + "type": "object", + "properties": { + "sheetId": { + "type": "integer", + "format": "int32", + "description": "The ID of the sheet when metadata is associated with an entire sheet." + }, + "spreadsheet": { + "type": "boolean", + "description": "True when metadata is associated with an entire spreadsheet." + }, + "dimensionRange": { + "description": "Represents the row or column when metadata is associated with a dimension. The specified DimensionRange must represent a single row or column; it cannot be unbounded or span multiple rows or columns.", + "$ref": "DimensionRange" + }, + "locationType": { + "description": "The type of location this object represents. This field is read-only.", + "type": "string", + "enum": [ + "DEVELOPER_METADATA_LOCATION_TYPE_UNSPECIFIED", + "ROW", + "COLUMN", + "SHEET", + "SPREADSHEET" + ], + "enumDescriptions": [ + "Default value.", + "Developer metadata associated on an entire row dimension.", + "Developer metadata associated on an entire column dimension.", + "Developer metadata associated on an entire sheet.", + "Developer metadata associated on the entire spreadsheet." + ] + } + }, + "id": "DeveloperMetadataLocation" + }, + "AppendValuesResponse": { + "type": "object", + "description": "The response when updating a range of values in a spreadsheet.", + "id": "AppendValuesResponse", + "properties": { + "spreadsheetId": { + "description": "The spreadsheet the updates were applied to.", + "type": "string" + }, + "tableRange": { + "description": "The range (in A1 notation) of the table that values are being appended to (before the values were appended). Empty if no table was found.", + "type": "string" + }, + "updates": { + "$ref": "UpdateValuesResponse", + "description": "Information about the updates that were applied." + } + } + }, + "ChartCustomNumberFormatOptions": { + "description": "Custom number formatting options for chart attributes.", + "properties": { + "suffix": { + "description": "Custom suffix to be appended to the chart attribute. This field is optional.", + "type": "string" + }, + "prefix": { + "type": "string", + "description": "Custom prefix to be prepended to the chart attribute. This field is optional." + } + }, + "type": "object", + "id": "ChartCustomNumberFormatOptions" + }, + "DeleteRangeRequest": { + "type": "object", + "description": "Deletes a range of cells, shifting other cells into the deleted area.", + "properties": { + "shiftDimension": { + "enumDescriptions": [ + "The default value, do not use.", + "Operates on the rows of a sheet.", + "Operates on the columns of a sheet." + ], + "type": "string", + "description": "The dimension from which deleted cells will be replaced with. If ROWS, existing cells will be shifted upward to replace the deleted cells. If COLUMNS, existing cells will be shifted left to replace the deleted cells.", + "enum": [ + "DIMENSION_UNSPECIFIED", + "ROWS", + "COLUMNS" + ] + }, + "range": { + "description": "The range of cells to delete.", + "$ref": "GridRange" + } + }, + "id": "DeleteRangeRequest" + }, + "UpdateDataSourceResponse": { + "description": "The response from updating data source.", + "id": "UpdateDataSourceResponse", + "type": "object", + "properties": { + "dataExecutionStatus": { + "$ref": "DataExecutionStatus", + "description": "The data execution status." + }, + "dataSource": { + "description": "The updated data source.", + "$ref": "DataSource" + } + } + }, + "ChartGroupRule": { + "description": "An optional setting on the ChartData of the domain of a data source chart that defines buckets for the values in the domain rather than breaking out each individual value. For example, when plotting a data source chart, you can specify a histogram rule on the domain (it should only contain numeric values), grouping its values into buckets. Any values of a chart series that fall into the same bucket are aggregated based on the aggregate_type.", + "id": "ChartGroupRule", + "properties": { + "dateTimeRule": { + "$ref": "ChartDateTimeRule", + "description": "A ChartDateTimeRule." + }, + "histogramRule": { + "$ref": "ChartHistogramRule", + "description": "A ChartHistogramRule" + } + }, + "type": "object" + }, + "DeleteDimensionGroupResponse": { + "properties": { + "dimensionGroups": { + "description": "All groups of a dimension after deleting a group from that dimension.", + "type": "array", + "items": { + "$ref": "DimensionGroup" + } + } + }, + "id": "DeleteDimensionGroupResponse", + "type": "object", + "description": "The result of deleting a group." + }, + "CandlestickDomain": { + "type": "object", + "id": "CandlestickDomain", + "properties": { + "data": { + "$ref": "ChartData", + "description": "The data of the CandlestickDomain." + }, + "reversed": { + "type": "boolean", + "description": "True to reverse the order of the domain values (horizontal axis)." + } + }, + "description": "The domain of a CandlestickChart." + }, + "TextRotation": { + "id": "TextRotation", + "properties": { + "vertical": { + "description": "If true, text reads top to bottom, but the orientation of individual characters is unchanged. For example: | V | | e | | r | | t | | i | | c | | a | | l |", + "type": "boolean" + }, + "angle": { + "description": "The angle between the standard orientation and the desired orientation. Measured in degrees. Valid values are between -90 and 90. Positive angles are angled upwards, negative are angled downwards. Note: For LTR text direction positive angles are in the counterclockwise direction, whereas for RTL they are in the clockwise direction", + "format": "int32", + "type": "integer" + } + }, + "type": "object", + "description": "The rotation applied to text in a cell." + }, + "UpdateSheetPropertiesRequest": { + "description": "Updates properties of the sheet with the specified sheetId.", + "type": "object", + "properties": { + "fields": { + "description": "The fields that should be updated. At least one field must be specified. The root `properties` is implied and should not be specified. A single `\"*\"` can be used as short-hand for listing every field.", + "format": "google-fieldmask", + "type": "string" + }, + "properties": { + "$ref": "SheetProperties", + "description": "The properties to update." + } + }, + "id": "UpdateSheetPropertiesRequest" + }, + "UpdateCellsRequest": { + "type": "object", + "id": "UpdateCellsRequest", + "properties": { + "rows": { + "type": "array", + "description": "The data to write.", + "items": { + "$ref": "RowData" + } + }, + "fields": { + "description": "The fields of CellData that should be updated. At least one field must be specified. The root is the CellData; 'row.values.' should not be specified. A single `\"*\"` can be used as short-hand for listing every field.", + "format": "google-fieldmask", + "type": "string" + }, + "start": { + "description": "The coordinate to start writing data at. Any number of rows and columns (including a different number of columns per row) may be written.", + "$ref": "GridCoordinate" + }, + "range": { + "$ref": "GridRange", + "description": "The range to write data to. If the data in rows does not cover the entire requested range, the fields matching those set in fields will be cleared." + } + }, + "description": "Updates all cells in a range with new data." + }, + "DataSourceFormula": { + "type": "object", + "id": "DataSourceFormula", + "properties": { + "dataSourceId": { + "description": "The ID of the data source the formula is associated with.", + "type": "string" + }, + "dataExecutionStatus": { + "readOnly": true, + "$ref": "DataExecutionStatus", + "description": "Output only. The data execution status." + } + }, + "description": "A data source formula." + }, + "BatchUpdateSpreadsheetResponse": { + "description": "The reply for batch updating a spreadsheet.", + "type": "object", + "id": "BatchUpdateSpreadsheetResponse", + "properties": { + "spreadsheetId": { + "type": "string", + "description": "The spreadsheet the updates were applied to." + }, + "updatedSpreadsheet": { + "$ref": "Spreadsheet", + "description": "The spreadsheet after updates were applied. This is only set if [BatchUpdateSpreadsheetRequest.include_spreadsheet_in_response] is `true`." + }, + "replies": { + "type": "array", + "items": { + "$ref": "Response" + }, + "description": "The reply of the updates. This maps 1:1 with the updates, although replies to some requests may be empty." + } + } + }, + "UpdateProtectedRangeRequest": { + "id": "UpdateProtectedRangeRequest", + "description": "Updates an existing protected range with the specified protectedRangeId.", + "properties": { + "protectedRange": { + "description": "The protected range to update with the new properties.", + "$ref": "ProtectedRange" + }, + "fields": { + "format": "google-fieldmask", + "type": "string", + "description": "The fields that should be updated. At least one field must be specified. The root `protectedRange` is implied and should not be specified. A single `\"*\"` can be used as short-hand for listing every field." + } + }, + "type": "object" + }, + "InsertRangeRequest": { + "properties": { + "range": { + "description": "The range to insert new cells into.", + "$ref": "GridRange" + }, + "shiftDimension": { + "type": "string", + "description": "The dimension which will be shifted when inserting cells. If ROWS, existing cells will be shifted down. If COLUMNS, existing cells will be shifted right.", + "enumDescriptions": [ + "The default value, do not use.", + "Operates on the rows of a sheet.", + "Operates on the columns of a sheet." + ], + "enum": [ + "DIMENSION_UNSPECIFIED", + "ROWS", + "COLUMNS" + ] + } + }, + "type": "object", + "id": "InsertRangeRequest", + "description": "Inserts cells into a range, shifting the existing cells over or down." + }, + "AddFilterViewRequest": { + "type": "object", + "description": "Adds a filter view.", + "properties": { + "filter": { + "$ref": "FilterView", + "description": "The filter to add. The filterViewId field is optional; if one is not set, an id will be randomly generated. (It is an error to specify the ID of a filter that already exists.)" + } + }, + "id": "AddFilterViewRequest" + }, + "AddSheetRequest": { + "type": "object", + "description": "Adds a new sheet. When a sheet is added at a given index, all subsequent sheets' indexes are incremented. To add an object sheet, use AddChartRequest instead and specify EmbeddedObjectPosition.sheetId or EmbeddedObjectPosition.newSheet.", + "id": "AddSheetRequest", + "properties": { + "properties": { + "description": "The properties the new sheet should have. All properties are optional. The sheetId field is optional; if one is not set, an id will be randomly generated. (It is an error to specify the ID of a sheet that already exists.)", + "$ref": "SheetProperties" + } + } + }, + "DeleteDeveloperMetadataRequest": { + "description": "A request to delete developer metadata.", + "type": "object", + "properties": { + "dataFilter": { + "$ref": "DataFilter", + "description": "The data filter describing the criteria used to select which developer metadata entry to delete." + } + }, + "id": "DeleteDeveloperMetadataRequest" + }, + "CutPasteRequest": { + "id": "CutPasteRequest", + "type": "object", + "properties": { + "destination": { + "$ref": "GridCoordinate", + "description": "The top-left coordinate where the data should be pasted." + }, + "source": { + "description": "The source data to cut.", + "$ref": "GridRange" + }, + "pasteType": { + "enumDescriptions": [ + "Paste values, formulas, formats, and merges.", + "Paste the values ONLY without formats, formulas, or merges.", + "Paste the format and data validation only.", + "Like PASTE_NORMAL but without borders.", + "Paste the formulas only.", + "Paste the data validation only.", + "Paste the conditional formatting rules only." + ], + "description": "What kind of data to paste. All the source data will be cut, regardless of what is pasted.", + "enum": [ + "PASTE_NORMAL", + "PASTE_VALUES", + "PASTE_FORMAT", + "PASTE_NO_BORDERS", + "PASTE_FORMULA", + "PASTE_DATA_VALIDATION", + "PASTE_CONDITIONAL_FORMATTING" + ], + "type": "string" + } + }, + "description": "Moves data from the source to the destination." + }, + "ChartAxisViewWindowOptions": { + "id": "ChartAxisViewWindowOptions", + "properties": { + "viewWindowMax": { + "type": "number", + "format": "double", + "description": "The maximum numeric value to be shown in this view window. If unset, will automatically determine a maximum value that looks good for the data." + }, + "viewWindowMode": { + "type": "string", + "enum": [ + "DEFAULT_VIEW_WINDOW_MODE", + "VIEW_WINDOW_MODE_UNSUPPORTED", + "EXPLICIT", + "PRETTY" + ], + "enumDescriptions": [ + "The default view window mode used in the Sheets editor for this chart type. In most cases, if set, the default mode is equivalent to `PRETTY`.", + "Do not use. Represents that the currently set mode is not supported by the API.", + "Follows the min and max exactly if specified. If a value is unspecified, it will fall back to the `PRETTY` value.", + "Chooses a min and max that make the chart look good. Both min and max are ignored in this mode." + ], + "description": "The view window's mode." + }, + "viewWindowMin": { + "type": "number", + "description": "The minimum numeric value to be shown in this view window. If unset, will automatically determine a minimum value that looks good for the data.", + "format": "double" + } + }, + "description": "The options that define a \"view window\" for a chart (such as the visible values in an axis).", + "type": "object" + }, + "DeleteEmbeddedObjectRequest": { + "properties": { + "objectId": { + "type": "integer", + "description": "The ID of the embedded object to delete.", + "format": "int32" + } + }, + "type": "object", + "id": "DeleteEmbeddedObjectRequest", + "description": "Deletes the embedded object with the given ID." + }, + "MatchedDeveloperMetadata": { + "type": "object", + "description": "A developer metadata entry and the data filters specified in the original request that matched it.", + "properties": { + "developerMetadata": { + "description": "The developer metadata matching the specified filters.", + "$ref": "DeveloperMetadata" + }, + "dataFilters": { + "items": { + "$ref": "DataFilter" + }, + "description": "All filters matching the returned developer metadata.", + "type": "array" + } + }, + "id": "MatchedDeveloperMetadata" + }, + "CopySheetToAnotherSpreadsheetRequest": { + "properties": { + "destinationSpreadsheetId": { + "description": "The ID of the spreadsheet to copy the sheet to.", + "type": "string" + } + }, + "description": "The request to copy a sheet across spreadsheets.", + "id": "CopySheetToAnotherSpreadsheetRequest", + "type": "object" + }, + "WaterfallChartSpec": { + "id": "WaterfallChartSpec", + "properties": { + "connectorLineStyle": { + "description": "The line style for the connector lines.", + "$ref": "LineStyle" + }, + "totalDataLabel": { + "$ref": "DataLabel", + "description": "Controls whether to display additional data labels on stacked charts which sum the total value of all stacked values at each value along the domain axis. stacked_type must be STACKED and neither CUSTOM nor placement can be set on the total_data_label." + }, + "stackedType": { + "description": "The stacked type.", + "enum": [ + "WATERFALL_STACKED_TYPE_UNSPECIFIED", + "STACKED", + "SEQUENTIAL" + ], + "enumDescriptions": [ + "Default value, do not use.", + "Values corresponding to the same domain (horizontal axis) value will be stacked vertically.", + "Series will spread out along the horizontal axis." + ], + "type": "string" + }, + "domain": { + "$ref": "WaterfallChartDomain", + "description": "The domain data (horizontal axis) for the waterfall chart." + }, + "hideConnectorLines": { + "description": "True to hide connector lines between columns.", + "type": "boolean" + }, + "firstValueIsTotal": { + "type": "boolean", + "description": "True to interpret the first value as a total." + }, + "series": { + "type": "array", + "items": { + "$ref": "WaterfallChartSeries" + }, + "description": "The data this waterfall chart is visualizing." + } + }, + "type": "object", + "description": "A waterfall chart." + }, + "ClearBasicFilterRequest": { + "id": "ClearBasicFilterRequest", + "description": "Clears the basic filter, if any exists on the sheet.", + "properties": { + "sheetId": { + "format": "int32", + "type": "integer", + "description": "The sheet ID on which the basic filter should be cleared." + } + }, + "type": "object" + }, + "BandingProperties": { + "description": "Properties referring a single dimension (either row or column). If both BandedRange.row_properties and BandedRange.column_properties are set, the fill colors are applied to cells according to the following rules: * header_color and footer_color take priority over band colors. * first_band_color takes priority over second_band_color. * row_properties takes priority over column_properties. For example, the first row color takes priority over the first column color, but the first column color takes priority over the second row color. Similarly, the row header takes priority over the column header in the top left cell, but the column header takes priority over the first row color if the row header is not set.", + "id": "BandingProperties", + "type": "object", + "properties": { + "headerColorStyle": { + "$ref": "ColorStyle", + "description": "The color of the first row or column. If this field is set, the first row or column is filled with this color and the colors alternate between first_band_color and second_band_color starting from the second row or column. Otherwise, the first row or column is filled with first_band_color and the colors proceed to alternate as they normally would. If header_color is also set, this field takes precedence." + }, + "footerColor": { + "$ref": "Color", + "description": "The color of the last row or column. If this field is not set, the last row or column is filled with either first_band_color or second_band_color, depending on the color of the previous row or column." + }, + "secondBandColor": { + "description": "The second color that is alternating. (Required)", + "$ref": "Color" + }, + "firstBandColorStyle": { + "description": "The first color that is alternating. (Required) If first_band_color is also set, this field takes precedence.", + "$ref": "ColorStyle" + }, + "footerColorStyle": { + "$ref": "ColorStyle", + "description": "The color of the last row or column. If this field is not set, the last row or column is filled with either first_band_color or second_band_color, depending on the color of the previous row or column. If footer_color is also set, this field takes precedence." + }, + "firstBandColor": { + "$ref": "Color", + "description": "The first color that is alternating. (Required)" + }, + "headerColor": { + "description": "The color of the first row or column. If this field is set, the first row or column is filled with this color and the colors alternate between first_band_color and second_band_color starting from the second row or column. Otherwise, the first row or column is filled with first_band_color and the colors proceed to alternate as they normally would.", + "$ref": "Color" + }, + "secondBandColorStyle": { + "$ref": "ColorStyle", + "description": "The second color that is alternating. (Required) If second_band_color is also set, this field takes precedence." + } + } + }, + "BatchGetValuesByDataFilterResponse": { + "description": "The response when retrieving more than one range of values in a spreadsheet selected by DataFilters.", + "type": "object", + "properties": { + "spreadsheetId": { + "type": "string", + "description": "The ID of the spreadsheet the data was retrieved from." + }, + "valueRanges": { + "items": { + "$ref": "MatchedValueRange" + }, + "type": "array", + "description": "The requested values with the list of data filters that matched them." + } + }, + "id": "BatchGetValuesByDataFilterResponse" + }, + "BatchUpdateValuesRequest": { + "id": "BatchUpdateValuesRequest", + "type": "object", + "properties": { + "responseDateTimeRenderOption": { + "enumDescriptions": [ + "Instructs date, time, datetime, and duration fields to be output as doubles in \"serial number\" format, as popularized by Lotus 1-2-3. The whole number portion of the value (left of the decimal) counts the days since December 30th 1899. The fractional portion (right of the decimal) counts the time as a fraction of the day. For example, January 1st 1900 at noon would be 2.5, 2 because it's 2 days after December 30st 1899, and .5 because noon is half a day. February 1st 1900 at 3pm would be 33.625. This correctly treats the year 1900 as not a leap year.", + "Instructs date, time, datetime, and duration fields to be output as strings in their given number format (which is dependent on the spreadsheet locale)." + ], + "enum": [ + "SERIAL_NUMBER", + "FORMATTED_STRING" + ], + "description": "Determines how dates, times, and durations in the response should be rendered. This is ignored if response_value_render_option is FORMATTED_VALUE. The default dateTime render option is DateTimeRenderOption.SERIAL_NUMBER.", + "type": "string" + }, + "includeValuesInResponse": { + "type": "boolean", + "description": "Determines if the update response should include the values of the cells that were updated. By default, responses do not include the updated values. The `updatedData` field within each of the BatchUpdateValuesResponse.responses contains the updated values. If the range to write was larger than the range actually written, the response includes all values in the requested range (excluding trailing empty rows and columns)." + }, + "responseValueRenderOption": { + "enumDescriptions": [ + "Values will be calculated & formatted in the reply according to the cell's formatting. Formatting is based on the spreadsheet's locale, not the requesting user's locale. For example, if `A1` is `1.23` and `A2` is `=A1` and formatted as currency, then `A2` would return `\"$1.23\"`.", + "Values will be calculated, but not formatted in the reply. For example, if `A1` is `1.23` and `A2` is `=A1` and formatted as currency, then `A2` would return the number `1.23`.", + "Values will not be calculated. The reply will include the formulas. For example, if `A1` is `1.23` and `A2` is `=A1` and formatted as currency, then A2 would return `\"=A1\"`." + ], + "type": "string", + "description": "Determines how values in the response should be rendered. The default render option is ValueRenderOption.FORMATTED_VALUE.", + "enum": [ + "FORMATTED_VALUE", + "UNFORMATTED_VALUE", + "FORMULA" + ] + }, + "data": { + "items": { + "$ref": "ValueRange" + }, + "description": "The new values to apply to the spreadsheet.", + "type": "array" + }, + "valueInputOption": { + "enum": [ + "INPUT_VALUE_OPTION_UNSPECIFIED", + "RAW", + "USER_ENTERED" + ], + "description": "How the input data should be interpreted.", + "enumDescriptions": [ + "Default input value. This value must not be used.", + "The values the user has entered will not be parsed and will be stored as-is.", + "The values will be parsed as if the user typed them into the UI. Numbers will stay as numbers, but strings may be converted to numbers, dates, etc. following the same rules that are applied when entering text into a cell via the Google Sheets UI." + ], + "type": "string" + } + }, + "description": "The request for updating more than one range of values in a spreadsheet." + }, + "SpreadsheetTheme": { + "description": "Represents spreadsheet theme", + "id": "SpreadsheetTheme", + "properties": { + "themeColors": { + "items": { + "$ref": "ThemeColorPair" + }, + "description": "The spreadsheet theme color pairs. To update you must provide all theme color pairs.", + "type": "array" + }, + "primaryFontFamily": { + "type": "string", + "description": "Name of the primary font family." + } + }, + "type": "object" + }, + "InterpolationPoint": { + "id": "InterpolationPoint", + "type": "object", + "description": "A single interpolation point on a gradient conditional format. These pin the gradient color scale according to the color, type and value chosen.", + "properties": { + "color": { + "description": "The color this interpolation point should use.", + "$ref": "Color" + }, + "colorStyle": { + "$ref": "ColorStyle", + "description": "The color this interpolation point should use. If color is also set, this field takes precedence." + }, + "value": { + "type": "string", + "description": "The value this interpolation point uses. May be a formula. Unused if type is MIN or MAX." + }, + "type": { + "type": "string", + "description": "How the value should be interpreted.", + "enum": [ + "INTERPOLATION_POINT_TYPE_UNSPECIFIED", + "MIN", + "MAX", + "NUMBER", + "PERCENT", + "PERCENTILE" + ], + "enumDescriptions": [ + "The default value, do not use.", + "The interpolation point uses the minimum value in the cells over the range of the conditional format.", + "The interpolation point uses the maximum value in the cells over the range of the conditional format.", + "The interpolation point uses exactly the value in InterpolationPoint.value.", + "The interpolation point is the given percentage over all the cells in the range of the conditional format. This is equivalent to NUMBER if the value was: `=(MAX(FLATTEN(range)) * (value / 100)) + (MIN(FLATTEN(range)) * (1 - (value / 100)))` (where errors in the range are ignored when flattening).", + "The interpolation point is the given percentile over all the cells in the range of the conditional format. This is equivalent to NUMBER if the value was: `=PERCENTILE(FLATTEN(range), value / 100)` (where errors in the range are ignored when flattening)." + ] + } + } + }, + "WaterfallChartCustomSubtotal": { + "properties": { + "label": { + "type": "string", + "description": "A label for the subtotal column." + }, + "dataIsSubtotal": { + "description": "True if the data point at subtotal_index is the subtotal. If false, the subtotal will be computed and appear after the data point.", + "type": "boolean" + }, + "subtotalIndex": { + "type": "integer", + "description": "The 0-based index of a data point within the series. If data_is_subtotal is true, the data point at this index is the subtotal. Otherwise, the subtotal appears after the data point with this index. A series can have multiple subtotals at arbitrary indices, but subtotals do not affect the indices of the data points. For example, if a series has three data points, their indices will always be 0, 1, and 2, regardless of how many subtotals exist on the series or what data points they are associated with.", + "format": "int32" + } + }, + "id": "WaterfallChartCustomSubtotal", + "description": "A custom subtotal column for a waterfall chart series.", + "type": "object" + }, + "DataSourceRefreshWeeklySchedule": { + "id": "DataSourceRefreshWeeklySchedule", + "description": "A weekly schedule for data to refresh on specific days in a given time interval.", + "type": "object", + "properties": { + "startTime": { + "description": "The start time of a time interval in which a data source refresh is scheduled. Only `hours` part is used. The time interval size defaults to that in the Sheets editor.", + "$ref": "TimeOfDay" + }, + "daysOfWeek": { + "description": "Days of the week to refresh. At least one day must be specified.", + "type": "array", + "items": { + "enumDescriptions": [ + "The day of the week is unspecified.", + "Monday", + "Tuesday", + "Wednesday", + "Thursday", + "Friday", + "Saturday", + "Sunday" + ], + "type": "string", + "enum": [ + "DAY_OF_WEEK_UNSPECIFIED", + "MONDAY", + "TUESDAY", + "WEDNESDAY", + "THURSDAY", + "FRIDAY", + "SATURDAY", + "SUNDAY" + ] + } + } + } + }, + "UpdateValuesResponse": { + "description": "The response when updating a range of values in a spreadsheet.", + "properties": { + "spreadsheetId": { + "type": "string", + "description": "The spreadsheet the updates were applied to." + }, + "updatedColumns": { + "type": "integer", + "format": "int32", + "description": "The number of columns where at least one cell in the column was updated." + }, + "updatedRange": { + "type": "string", + "description": "The range (in A1 notation) that updates were applied to." + }, + "updatedCells": { + "type": "integer", + "description": "The number of cells updated.", + "format": "int32" + }, + "updatedRows": { + "format": "int32", + "type": "integer", + "description": "The number of rows where at least one cell in the row was updated." + }, + "updatedData": { + "description": "The values of the cells after updates were applied. This is only included if the request's `includeValuesInResponse` field was `true`.", + "$ref": "ValueRange" + } + }, + "type": "object", + "id": "UpdateValuesResponse" + }, + "DataFilter": { + "id": "DataFilter", + "properties": { + "gridRange": { + "description": "Selects data that matches the range described by the GridRange.", + "$ref": "GridRange" + }, + "developerMetadataLookup": { + "$ref": "DeveloperMetadataLookup", + "description": "Selects data associated with the developer metadata matching the criteria described by this DeveloperMetadataLookup." + }, + "a1Range": { + "type": "string", + "description": "Selects data that matches the specified A1 range." + } + }, + "description": "Filter that describes what data should be selected or returned from a request.", + "type": "object" + }, + "ClearValuesResponse": { + "id": "ClearValuesResponse", + "properties": { + "spreadsheetId": { + "type": "string", + "description": "The spreadsheet the updates were applied to." + }, + "clearedRange": { + "type": "string", + "description": "The range (in A1 notation) that was cleared. (If the request was for an unbounded range or a ranger larger than the bounds of the sheet, this will be the actual range that was cleared, bounded to the sheet's limits.)" + } + }, + "type": "object", + "description": "The response when clearing a range of values in a spreadsheet." + }, + "AddProtectedRangeResponse": { + "type": "object", + "id": "AddProtectedRangeResponse", + "description": "The result of adding a new protected range.", + "properties": { + "protectedRange": { + "$ref": "ProtectedRange", + "description": "The newly added protected range." + } + } + }, + "SheetProperties": { + "properties": { + "hidden": { + "description": "True if the sheet is hidden in the UI, false if it's visible.", + "type": "boolean" + }, + "gridProperties": { + "$ref": "GridProperties", + "description": "Additional properties of the sheet if this sheet is a grid. (If the sheet is an object sheet, containing a chart or image, then this field will be absent.) When writing it is an error to set any grid properties on non-grid sheets. If this sheet is a DATA_SOURCE sheet, this field is output only but contains the properties that reflect how a data source sheet is rendered in the UI, e.g. row_count." + }, + "title": { + "type": "string", + "description": "The name of the sheet." + }, + "tabColorStyle": { + "description": "The color of the tab in the UI. If tab_color is also set, this field takes precedence.", + "$ref": "ColorStyle" + }, + "rightToLeft": { + "type": "boolean", + "description": "True if the sheet is an RTL sheet instead of an LTR sheet." + }, + "dataSourceSheetProperties": { + "$ref": "DataSourceSheetProperties", + "description": "Output only. If present, the field contains DATA_SOURCE sheet specific properties.", + "readOnly": true + }, + "index": { + "type": "integer", + "description": "The index of the sheet within the spreadsheet. When adding or updating sheet properties, if this field is excluded then the sheet is added or moved to the end of the sheet list. When updating sheet indices or inserting sheets, movement is considered in \"before the move\" indexes. For example, if there were 3 sheets (S1, S2, S3) in order to move S1 ahead of S2 the index would have to be set to 2. A sheet index update request is ignored if the requested index is identical to the sheets current index or if the requested new index is equal to the current sheet index + 1.", + "format": "int32" + }, + "sheetId": { + "description": "The ID of the sheet. Must be non-negative. This field cannot be changed once set.", + "format": "int32", + "type": "integer" + }, + "tabColor": { + "description": "The color of the tab in the UI.", + "$ref": "Color" + }, + "sheetType": { + "type": "string", + "enum": [ + "SHEET_TYPE_UNSPECIFIED", + "GRID", + "OBJECT", + "DATA_SOURCE" + ], + "enumDescriptions": [ + "Default value, do not use.", + "The sheet is a grid.", + "The sheet has no grid and instead has an object like a chart or image.", + "The sheet connects with an external DataSource and shows the preview of data." + ], + "description": "The type of sheet. Defaults to GRID. This field cannot be changed once set." + } + }, + "type": "object", + "id": "SheetProperties", + "description": "Properties of a sheet." + }, + "ChartSpec": { + "description": "The specifications of a chart.", + "id": "ChartSpec", + "properties": { + "candlestickChart": { + "$ref": "CandlestickChartSpec", + "description": "A candlestick chart specification." + }, + "backgroundColorStyle": { + "description": "The background color of the entire chart. Not applicable to Org charts. If background_color is also set, this field takes precedence.", + "$ref": "ColorStyle" + }, + "basicChart": { + "description": "A basic chart specification, can be one of many kinds of charts. See BasicChartType for the list of all charts this supports.", + "$ref": "BasicChartSpec" + }, + "titleTextFormat": { + "$ref": "TextFormat", + "description": "The title text format. Strikethrough and underline are not supported." + }, + "subtitle": { + "type": "string", + "description": "The subtitle of the chart." + }, + "treemapChart": { + "description": "A treemap chart specification.", + "$ref": "TreemapChartSpec" + }, + "subtitleTextPosition": { + "$ref": "TextPosition", + "description": "The subtitle text position. This field is optional." + }, + "bubbleChart": { + "description": "A bubble chart specification.", + "$ref": "BubbleChartSpec" + }, + "waterfallChart": { + "description": "A waterfall chart specification.", + "$ref": "WaterfallChartSpec" + }, + "pieChart": { + "description": "A pie chart specification.", + "$ref": "PieChartSpec" + }, + "histogramChart": { + "$ref": "HistogramChartSpec", + "description": "A histogram chart specification." + }, + "hiddenDimensionStrategy": { + "description": "Determines how the charts will use hidden rows or columns.", + "enum": [ + "CHART_HIDDEN_DIMENSION_STRATEGY_UNSPECIFIED", + "SKIP_HIDDEN_ROWS_AND_COLUMNS", + "SKIP_HIDDEN_ROWS", + "SKIP_HIDDEN_COLUMNS", + "SHOW_ALL" + ], + "type": "string", + "enumDescriptions": [ + "Default value, do not use.", + "Charts will skip hidden rows and columns.", + "Charts will skip hidden rows only.", + "Charts will skip hidden columns only.", + "Charts will not skip any hidden rows or columns." + ] + }, + "dataSourceChartProperties": { + "$ref": "DataSourceChartProperties", + "description": "If present, the field contains data source chart specific properties." + }, + "altText": { + "type": "string", + "description": "The alternative text that describes the chart. This is often used for accessibility." + }, + "maximized": { + "description": "True to make a chart fill the entire space in which it's rendered with minimum padding. False to use the default padding. (Not applicable to Geo and Org charts.)", + "type": "boolean" + }, + "fontName": { + "description": "The name of the font to use by default for all chart text (e.g. title, axis labels, legend). If a font is specified for a specific part of the chart it will override this font name.", + "type": "string" + }, + "backgroundColor": { + "$ref": "Color", + "description": "The background color of the entire chart. Not applicable to Org charts." + }, + "subtitleTextFormat": { + "$ref": "TextFormat", + "description": "The subtitle text format. Strikethrough and underline are not supported." + }, + "titleTextPosition": { + "$ref": "TextPosition", + "description": "The title text position. This field is optional." + }, + "sortSpecs": { + "type": "array", + "description": "The order to sort the chart data by. Only a single sort spec is supported. Only supported for data source charts.", + "items": { + "$ref": "SortSpec" + } + }, + "scorecardChart": { + "description": "A scorecard chart specification.", + "$ref": "ScorecardChartSpec" + }, + "orgChart": { + "description": "An org chart specification.", + "$ref": "OrgChartSpec" + }, + "filterSpecs": { + "items": { + "$ref": "FilterSpec" + }, + "type": "array", + "description": "The filters applied to the source data of the chart. Only supported for data source charts." + }, + "title": { + "type": "string", + "description": "The title of the chart." + } + }, + "type": "object" + }, + "UpdateConditionalFormatRuleRequest": { + "type": "object", + "description": "Updates a conditional format rule at the given index, or moves a conditional format rule to another index.", + "properties": { + "rule": { + "description": "The rule that should replace the rule at the given index.", + "$ref": "ConditionalFormatRule" + }, + "sheetId": { + "format": "int32", + "description": "The sheet of the rule to move. Required if new_index is set, unused otherwise.", + "type": "integer" + }, + "index": { + "format": "int32", + "description": "The zero-based index of the rule that should be replaced or moved.", + "type": "integer" + }, + "newIndex": { + "type": "integer", + "description": "The zero-based new index the rule should end up at.", + "format": "int32" + } + }, + "id": "UpdateConditionalFormatRuleRequest" + }, + "UpdateBordersRequest": { + "properties": { + "top": { + "$ref": "Border", + "description": "The border to put at the top of the range." + }, + "range": { + "$ref": "GridRange", + "description": "The range whose borders should be updated." + }, + "right": { + "$ref": "Border", + "description": "The border to put at the right of the range." + }, + "innerVertical": { + "$ref": "Border", + "description": "The vertical border to put within the range." + }, + "left": { + "description": "The border to put at the left of the range.", + "$ref": "Border" + }, + "bottom": { + "description": "The border to put at the bottom of the range.", + "$ref": "Border" + }, + "innerHorizontal": { + "description": "The horizontal border to put within the range.", + "$ref": "Border" + } + }, + "id": "UpdateBordersRequest", + "description": "Updates the borders of a range. If a field is not set in the request, that means the border remains as-is. For example, with two subsequent UpdateBordersRequest: 1. range: A1:A5 `{ top: RED, bottom: WHITE }` 2. range: A1:A5 `{ left: BLUE }` That would result in A1:A5 having a borders of `{ top: RED, bottom: WHITE, left: BLUE }`. If you want to clear a border, explicitly set the style to NONE.", + "type": "object" + }, + "AddDimensionGroupResponse": { + "type": "object", + "id": "AddDimensionGroupResponse", + "description": "The result of adding a group.", + "properties": { + "dimensionGroups": { + "description": "All groups of a dimension after adding a group to that dimension.", + "items": { + "$ref": "DimensionGroup" + }, + "type": "array" + } + } + }, + "CellFormat": { + "description": "The format of a cell.", + "id": "CellFormat", + "properties": { + "textRotation": { + "$ref": "TextRotation", + "description": "The rotation applied to text in a cell" + }, + "padding": { + "$ref": "Padding", + "description": "The padding of the cell." + }, + "backgroundColor": { + "description": "The background color of the cell.", + "$ref": "Color" + }, + "wrapStrategy": { + "description": "The wrap strategy for the value in the cell.", + "enum": [ + "WRAP_STRATEGY_UNSPECIFIED", + "OVERFLOW_CELL", + "LEGACY_WRAP", + "CLIP", + "WRAP" + ], + "type": "string", + "enumDescriptions": [ + "The default value, do not use.", + "Lines that are longer than the cell width will be written in the next cell over, so long as that cell is empty. If the next cell over is non-empty, this behaves the same as CLIP. The text will never wrap to the next line unless the user manually inserts a new line. Example: | First sentence. | | Manual newline that is very long. \u003c- Text continues into next cell | Next newline. |", + "This wrap strategy represents the old Google Sheets wrap strategy where words that are longer than a line are clipped rather than broken. This strategy is not supported on all platforms and is being phased out. Example: | Cell has a | | loooooooooo| \u003c- Word is clipped. | word. |", + "Lines that are longer than the cell width will be clipped. The text will never wrap to the next line unless the user manually inserts a new line. Example: | First sentence. | | Manual newline t| \u003c- Text is clipped | Next newline. |", + "Words that are longer than a line are wrapped at the character level rather than clipped. Example: | Cell has a | | loooooooooo| \u003c- Word is broken. | ong word. |" + ] + }, + "horizontalAlignment": { + "description": "The horizontal alignment of the value in the cell.", + "type": "string", + "enumDescriptions": [ + "The horizontal alignment is not specified. Do not use this.", + "The text is explicitly aligned to the left of the cell.", + "The text is explicitly aligned to the center of the cell.", + "The text is explicitly aligned to the right of the cell." + ], + "enum": [ + "HORIZONTAL_ALIGN_UNSPECIFIED", + "LEFT", + "CENTER", + "RIGHT" + ] + }, + "textDirection": { + "type": "string", + "enumDescriptions": [ + "The text direction is not specified. Do not use this.", + "The text direction of left-to-right was set by the user.", + "The text direction of right-to-left was set by the user." + ], + "description": "The direction of the text in the cell.", + "enum": [ + "TEXT_DIRECTION_UNSPECIFIED", + "LEFT_TO_RIGHT", + "RIGHT_TO_LEFT" + ] + }, + "verticalAlignment": { + "description": "The vertical alignment of the value in the cell.", + "type": "string", + "enum": [ + "VERTICAL_ALIGN_UNSPECIFIED", + "TOP", + "MIDDLE", + "BOTTOM" + ], + "enumDescriptions": [ + "The vertical alignment is not specified. Do not use this.", + "The text is explicitly aligned to the top of the cell.", + "The text is explicitly aligned to the middle of the cell.", + "The text is explicitly aligned to the bottom of the cell." + ] + }, + "textFormat": { + "description": "The format of the text in the cell (unless overridden by a format run).", + "$ref": "TextFormat" + }, + "backgroundColorStyle": { + "description": "The background color of the cell. If background_color is also set, this field takes precedence.", + "$ref": "ColorStyle" + }, + "numberFormat": { + "description": "A format describing how number values should be represented to the user.", + "$ref": "NumberFormat" + }, + "borders": { + "$ref": "Borders", + "description": "The borders of the cell." + }, + "hyperlinkDisplayType": { + "type": "string", + "description": "How a hyperlink, if it exists, should be displayed in the cell.", + "enum": [ + "HYPERLINK_DISPLAY_TYPE_UNSPECIFIED", + "LINKED", + "PLAIN_TEXT" + ], + "enumDescriptions": [ + "The default value: the hyperlink is rendered. Do not use this.", + "A hyperlink should be explicitly rendered.", + "A hyperlink should not be rendered." + ] + } + }, + "type": "object" + }, + "DeleteConditionalFormatRuleRequest": { + "id": "DeleteConditionalFormatRuleRequest", + "properties": { + "sheetId": { + "description": "The sheet the rule is being deleted from.", + "format": "int32", + "type": "integer" + }, + "index": { + "format": "int32", + "description": "The zero-based index of the rule to be deleted.", + "type": "integer" + } + }, + "type": "object", + "description": "Deletes a conditional format rule at the given index. All subsequent rules' indexes are decremented." + }, + "WaterfallChartColumnStyle": { + "properties": { + "label": { + "type": "string", + "description": "The label of the column's legend." + }, + "color": { + "$ref": "Color", + "description": "The color of the column." + }, + "colorStyle": { + "$ref": "ColorStyle", + "description": "The color of the column. If color is also set, this field takes precedence." + } + }, + "type": "object", + "description": "Styles for a waterfall chart column.", + "id": "WaterfallChartColumnStyle" + }, + "UpdateBandingRequest": { + "description": "Updates properties of the supplied banded range.", + "id": "UpdateBandingRequest", + "properties": { + "fields": { + "format": "google-fieldmask", + "description": "The fields that should be updated. At least one field must be specified. The root `bandedRange` is implied and should not be specified. A single `\"*\"` can be used as short-hand for listing every field.", + "type": "string" + }, + "bandedRange": { + "description": "The banded range to update with the new properties.", + "$ref": "BandedRange" + } + }, + "type": "object" + }, + "BasicSeriesDataPointStyleOverride": { + "id": "BasicSeriesDataPointStyleOverride", + "properties": { + "color": { + "description": "Color of the series data point. If empty, the series default is used.", + "$ref": "Color" + }, + "pointStyle": { + "$ref": "PointStyle", + "description": "Point style of the series data point. Valid only if the chartType is AREA, LINE, or SCATTER. COMBO charts are also supported if the series chart type is AREA, LINE, or SCATTER. If empty, the series default is used." + }, + "index": { + "format": "int32", + "type": "integer", + "description": "Zero based index of the series data point." + }, + "colorStyle": { + "$ref": "ColorStyle", + "description": "Color of the series data point. If empty, the series default is used. If color is also set, this field takes precedence." + } + }, + "type": "object", + "description": "Style override settings for a single series data point." + }, + "DataSourceObjectReference": { + "type": "object", + "properties": { + "dataSourceTableAnchorCell": { + "description": "References to a DataSourceTable anchored at the cell.", + "$ref": "GridCoordinate" + }, + "dataSourceFormulaCell": { + "description": "References to a cell containing DataSourceFormula.", + "$ref": "GridCoordinate" + }, + "sheetId": { + "type": "string", + "description": "References to a DATA_SOURCE sheet." + }, + "dataSourcePivotTableAnchorCell": { + "description": "References to a data source PivotTable anchored at the cell.", + "$ref": "GridCoordinate" + }, + "chartId": { + "type": "integer", + "description": "References to a data source chart.", + "format": "int32" + } + }, + "description": "Reference to a data source object.", + "id": "DataSourceObjectReference" + }, + "PivotValue": { + "description": "The definition of how a value in a pivot table should be calculated.", + "id": "PivotValue", + "type": "object", + "properties": { + "name": { + "type": "string", + "description": "A name to use for the value." + }, + "calculatedDisplayType": { + "type": "string", + "enum": [ + "PIVOT_VALUE_CALCULATED_DISPLAY_TYPE_UNSPECIFIED", + "PERCENT_OF_ROW_TOTAL", + "PERCENT_OF_COLUMN_TOTAL", + "PERCENT_OF_GRAND_TOTAL" + ], + "enumDescriptions": [ + "Default value, do not use.", + "Shows the pivot values as percentage of the row total values.", + "Shows the pivot values as percentage of the column total values.", + "Shows the pivot values as percentage of the grand total values." + ], + "description": "If specified, indicates that pivot values should be displayed as the result of a calculation with another pivot value. For example, if calculated_display_type is specified as PERCENT_OF_GRAND_TOTAL, all the pivot values are displayed as the percentage of the grand total. In the Sheets editor, this is referred to as \"Show As\" in the value section of a pivot table." + }, + "sourceColumnOffset": { + "format": "int32", + "description": "The column offset of the source range that this value reads from. For example, if the source was `C10:E15`, a `sourceColumnOffset` of `0` means this value refers to column `C`, whereas the offset `1` would refer to column `D`.", + "type": "integer" + }, + "formula": { + "description": "A custom formula to calculate the value. The formula must start with an `=` character.", + "type": "string" + }, + "summarizeFunction": { + "type": "string", + "enum": [ + "PIVOT_STANDARD_VALUE_FUNCTION_UNSPECIFIED", + "SUM", + "COUNTA", + "COUNT", + "COUNTUNIQUE", + "AVERAGE", + "MAX", + "MIN", + "MEDIAN", + "PRODUCT", + "STDEV", + "STDEVP", + "VAR", + "VARP", + "CUSTOM" + ], + "enumDescriptions": [ + "The default, do not use.", + "Corresponds to the `SUM` function.", + "Corresponds to the `COUNTA` function.", + "Corresponds to the `COUNT` function.", + "Corresponds to the `COUNTUNIQUE` function.", + "Corresponds to the `AVERAGE` function.", + "Corresponds to the `MAX` function.", + "Corresponds to the `MIN` function.", + "Corresponds to the `MEDIAN` function.", + "Corresponds to the `PRODUCT` function.", + "Corresponds to the `STDEV` function.", + "Corresponds to the `STDEVP` function.", + "Corresponds to the `VAR` function.", + "Corresponds to the `VARP` function.", + "Indicates the formula should be used as-is. Only valid if PivotValue.formula was set." + ], + "description": "A function to summarize the value. If formula is set, the only supported values are SUM and CUSTOM. If sourceColumnOffset is set, then `CUSTOM` is not supported." + }, + "dataSourceColumnReference": { + "description": "The reference to the data source column that this value reads from.", + "$ref": "DataSourceColumnReference" + } + } + }, + "DataLabel": { + "description": "Settings for one set of data labels. Data labels are annotations that appear next to a set of data, such as the points on a line chart, and provide additional information about what the data represents, such as a text representation of the value behind that point on the graph.", + "type": "object", + "properties": { + "type": { + "description": "The type of the data label.", + "enum": [ + "DATA_LABEL_TYPE_UNSPECIFIED", + "NONE", + "DATA", + "CUSTOM" + ], + "type": "string", + "enumDescriptions": [ + "The data label type is not specified and will be interpreted depending on the context of the data label within the chart.", + "The data label is not displayed.", + "The data label is displayed using values from the series data.", + "The data label is displayed using values from a custom data source indicated by customLabelData." + ] + }, + "textFormat": { + "$ref": "TextFormat", + "description": "The text format used for the data label." + }, + "placement": { + "enum": [ + "DATA_LABEL_PLACEMENT_UNSPECIFIED", + "CENTER", + "LEFT", + "RIGHT", + "ABOVE", + "BELOW", + "INSIDE_END", + "INSIDE_BASE", + "OUTSIDE_END" + ], + "enumDescriptions": [ + "The positioning is determined automatically by the renderer.", + "Center within a bar or column, both horizontally and vertically.", + "To the left of a data point.", + "To the right of a data point.", + "Above a data point.", + "Below a data point.", + "Inside a bar or column at the end (top if positive, bottom if negative).", + "Inside a bar or column at the base.", + "Outside a bar or column at the end." + ], + "description": "The placement of the data label relative to the labeled data.", + "type": "string" + }, + "customLabelData": { + "description": "Data to use for custom labels. Only used if type is set to CUSTOM. This data must be the same length as the series or other element this data label is applied to. In addition, if the series is split into multiple source ranges, this source data must come from the next column in the source data. For example, if the series is B2:B4,E6:E8 then this data must come from C2:C4,F6:F8.", + "$ref": "ChartData" + } + }, + "id": "DataLabel" + }, + "AddDataSourceRequest": { + "id": "AddDataSourceRequest", + "properties": { + "dataSource": { + "$ref": "DataSource", + "description": "The data source to add." + } + }, + "type": "object", + "description": "Adds a data source. After the data source is added successfully, an associated DATA_SOURCE sheet is created and an execution is triggered to refresh the sheet to read data from the data source. The request requires an additional `bigquery.readonly` OAuth scope." + }, + "UpdateValuesByDataFilterResponse": { + "properties": { + "updatedColumns": { + "format": "int32", + "description": "The number of columns where at least one cell in the column was updated.", + "type": "integer" + }, + "updatedData": { + "description": "The values of the cells in the range matched by the dataFilter after all updates were applied. This is only included if the request's `includeValuesInResponse` field was `true`.", + "$ref": "ValueRange" + }, + "dataFilter": { + "$ref": "DataFilter", + "description": "The data filter that selected the range that was updated." + }, + "updatedRange": { + "description": "The range (in A1 notation) that updates were applied to.", + "type": "string" + }, + "updatedRows": { + "description": "The number of rows where at least one cell in the row was updated.", + "type": "integer", + "format": "int32" + }, + "updatedCells": { + "description": "The number of cells updated.", + "type": "integer", + "format": "int32" + } + }, + "description": "The response when updating a range of values by a data filter in a spreadsheet.", + "type": "object", + "id": "UpdateValuesByDataFilterResponse" + }, + "SetDataValidationRequest": { + "id": "SetDataValidationRequest", + "properties": { + "rule": { + "description": "The data validation rule to set on each cell in the range, or empty to clear the data validation in the range.", + "$ref": "DataValidationRule" + }, + "range": { + "description": "The range the data validation rule should apply to.", + "$ref": "GridRange" + } + }, + "description": "Sets a data validation rule to every cell in the range. To clear validation in a range, call this with no rule specified.", + "type": "object" + }, + "PivotFilterSpec": { + "id": "PivotFilterSpec", + "type": "object", + "description": "The pivot table filter criteria associated with a specific source column offset.", + "properties": { + "dataSourceColumnReference": { + "description": "The reference to the data source column.", + "$ref": "DataSourceColumnReference" + }, + "filterCriteria": { + "$ref": "PivotFilterCriteria", + "description": "The criteria for the column." + }, + "columnOffsetIndex": { + "type": "integer", + "format": "int32", + "description": "The column offset of the source range." + } + } + }, + "BatchUpdateValuesResponse": { + "type": "object", + "id": "BatchUpdateValuesResponse", + "description": "The response when updating a range of values in a spreadsheet.", + "properties": { + "totalUpdatedCells": { + "format": "int32", + "description": "The total number of cells updated.", + "type": "integer" + }, + "spreadsheetId": { + "type": "string", + "description": "The spreadsheet the updates were applied to." + }, + "responses": { + "items": { + "$ref": "UpdateValuesResponse" + }, + "description": "One UpdateValuesResponse per requested range, in the same order as the requests appeared.", + "type": "array" + }, + "totalUpdatedColumns": { + "format": "int32", + "description": "The total number of columns where at least one cell in the column was updated.", + "type": "integer" + }, + "totalUpdatedRows": { + "type": "integer", + "description": "The total number of rows where at least one cell in the row was updated.", + "format": "int32" + }, + "totalUpdatedSheets": { + "format": "int32", + "description": "The total number of sheets where at least one cell in the sheet was updated.", + "type": "integer" + } + } + }, + "BooleanRule": { + "id": "BooleanRule", + "description": "A rule that may or may not match, depending on the condition.", + "properties": { + "condition": { + "$ref": "BooleanCondition", + "description": "The condition of the rule. If the condition evaluates to true, the format is applied." + }, + "format": { + "description": "The format to apply. Conditional formatting can only apply a subset of formatting: bold, italic, strikethrough, foreground color & background color.", + "$ref": "CellFormat" + } + }, + "type": "object" + }, + "UpdateDimensionPropertiesRequest": { + "type": "object", + "properties": { + "dataSourceSheetRange": { + "description": "The columns on a data source sheet to update.", + "$ref": "DataSourceSheetDimensionRange" + }, + "range": { + "description": "The rows or columns to update.", + "$ref": "DimensionRange" + }, + "properties": { + "description": "Properties to update.", + "$ref": "DimensionProperties" + }, + "fields": { + "description": "The fields that should be updated. At least one field must be specified. The root `properties` is implied and should not be specified. A single `\"*\"` can be used as short-hand for listing every field.", + "format": "google-fieldmask", + "type": "string" + } + }, + "id": "UpdateDimensionPropertiesRequest", + "description": "Updates properties of dimensions within the specified range." + }, + "UpdateSpreadsheetPropertiesRequest": { + "properties": { + "fields": { + "format": "google-fieldmask", + "description": "The fields that should be updated. At least one field must be specified. The root 'properties' is implied and should not be specified. A single `\"*\"` can be used as short-hand for listing every field.", + "type": "string" + }, + "properties": { + "$ref": "SpreadsheetProperties", + "description": "The properties to update." + } + }, + "type": "object", + "id": "UpdateSpreadsheetPropertiesRequest", + "description": "Updates properties of a spreadsheet." + }, + "PasteDataRequest": { + "properties": { + "html": { + "type": "boolean", + "description": "True if the data is HTML." + }, + "data": { + "type": "string", + "description": "The data to insert." + }, + "delimiter": { + "type": "string", + "description": "The delimiter in the data." + }, + "type": { + "enumDescriptions": [ + "Paste values, formulas, formats, and merges.", + "Paste the values ONLY without formats, formulas, or merges.", + "Paste the format and data validation only.", + "Like PASTE_NORMAL but without borders.", + "Paste the formulas only.", + "Paste the data validation only.", + "Paste the conditional formatting rules only." + ], + "enum": [ + "PASTE_NORMAL", + "PASTE_VALUES", + "PASTE_FORMAT", + "PASTE_NO_BORDERS", + "PASTE_FORMULA", + "PASTE_DATA_VALIDATION", + "PASTE_CONDITIONAL_FORMATTING" + ], + "type": "string", + "description": "How the data should be pasted." + }, + "coordinate": { + "$ref": "GridCoordinate", + "description": "The coordinate at which the data should start being inserted." + } + }, + "type": "object", + "id": "PasteDataRequest", + "description": "Inserts data into the spreadsheet starting at the specified coordinate." + }, + "ValueRange": { + "id": "ValueRange", + "description": "Data within a range of the spreadsheet.", + "type": "object", + "properties": { + "values": { + "items": { + "items": { + "type": "any" + }, + "type": "array" + }, + "type": "array", + "description": "The data that was read or to be written. This is an array of arrays, the outer array representing all the data and each inner array representing a major dimension. Each item in the inner array corresponds with one cell. For output, empty trailing rows and columns will not be included. For input, supported value types are: bool, string, and double. Null values will be skipped. To set a cell to an empty value, set the string value to an empty string." + }, + "majorDimension": { + "description": "The major dimension of the values. For output, if the spreadsheet data is: `A1=1,B1=2,A2=3,B2=4`, then requesting `range=A1:B2,majorDimension=ROWS` will return `[[1,2],[3,4]]`, whereas requesting `range=A1:B2,majorDimension=COLUMNS` will return `[[1,3],[2,4]]`. For input, with `range=A1:B2,majorDimension=ROWS` then `[[1,2],[3,4]]` will set `A1=1,B1=2,A2=3,B2=4`. With `range=A1:B2,majorDimension=COLUMNS` then `[[1,2],[3,4]]` will set `A1=1,B1=3,A2=2,B2=4`. When writing, if this field is not set, it defaults to ROWS.", + "enum": [ + "DIMENSION_UNSPECIFIED", + "ROWS", + "COLUMNS" + ], + "enumDescriptions": [ + "The default value, do not use.", + "Operates on the rows of a sheet.", + "Operates on the columns of a sheet." + ], + "type": "string" + }, + "range": { + "type": "string", + "description": "The range the values cover, in A1 notation. For output, this range indicates the entire requested range, even though the values will exclude trailing rows and columns. When appending values, this field represents the range to search for a table, after which values will be appended." + } + } + }, + "ProtectedRange": { + "properties": { + "editors": { + "description": "The users and groups with edit access to the protected range. This field is only visible to users with edit access to the protected range and the document. Editors are not supported with warning_only protection.", + "$ref": "Editors" + }, + "range": { + "description": "The range that is being protected. The range may be fully unbounded, in which case this is considered a protected sheet. When writing, only one of range or named_range_id may be set.", + "$ref": "GridRange" + }, + "protectedRangeId": { + "description": "The ID of the protected range. This field is read-only.", + "format": "int32", + "type": "integer" + }, + "warningOnly": { + "type": "boolean", + "description": "True if this protected range will show a warning when editing. Warning-based protection means that every user can edit data in the protected range, except editing will prompt a warning asking the user to confirm the edit. When writing: if this field is true, then editors is ignored. Additionally, if this field is changed from true to false and the `editors` field is not set (nor included in the field mask), then the editors will be set to all the editors in the document." + }, + "requestingUserCanEdit": { + "description": "True if the user who requested this protected range can edit the protected area. This field is read-only.", + "type": "boolean" + }, + "unprotectedRanges": { + "description": "The list of unprotected ranges within a protected sheet. Unprotected ranges are only supported on protected sheets.", + "items": { + "$ref": "GridRange" + }, + "type": "array" + }, + "namedRangeId": { + "description": "The named range this protected range is backed by, if any. When writing, only one of range or named_range_id may be set.", + "type": "string" + }, + "description": { + "type": "string", + "description": "The description of this protected range." + } + }, + "type": "object", + "description": "A protected range.", + "id": "ProtectedRange" + }, + "DataSourceObjectReferences": { + "description": "A list of references to data source objects.", + "properties": { + "references": { + "items": { + "$ref": "DataSourceObjectReference" + }, + "type": "array", + "description": "The references." + } + }, + "id": "DataSourceObjectReferences", + "type": "object" + }, + "AddNamedRangeResponse": { + "id": "AddNamedRangeResponse", + "properties": { + "namedRange": { + "description": "The named range to add.", + "$ref": "NamedRange" + } + }, + "description": "The result of adding a named range.", + "type": "object" + }, + "BigQueryDataSourceSpec": { + "description": "The specification of a BigQuery data source that's connected to a sheet.", + "id": "BigQueryDataSourceSpec", + "type": "object", + "properties": { + "querySpec": { + "$ref": "BigQueryQuerySpec", + "description": "A BigQueryQuerySpec." + }, + "projectId": { + "type": "string", + "description": "The ID of a BigQuery enabled GCP project with a billing account attached. For any queries executed against the data source, the project is charged." + }, + "tableSpec": { + "description": "A BigQueryTableSpec.", + "$ref": "BigQueryTableSpec" + } + } + }, + "DeleteProtectedRangeRequest": { + "type": "object", + "properties": { + "protectedRangeId": { + "type": "integer", + "format": "int32", + "description": "The ID of the protected range to delete." + } + }, + "id": "DeleteProtectedRangeRequest", + "description": "Deletes the protected range with the given ID." + }, + "PivotFilterCriteria": { + "type": "object", + "description": "Criteria for showing/hiding rows in a pivot table.", + "id": "PivotFilterCriteria", + "properties": { + "condition": { + "description": "A condition that must be true for values to be shown. (`visibleValues` does not override this -- even if a value is listed there, it is still hidden if it does not meet the condition.) Condition values that refer to ranges in A1-notation are evaluated relative to the pivot table sheet. References are treated absolutely, so are not filled down the pivot table. For example, a condition value of `=A1` on \"Pivot Table 1\" is treated as `'Pivot Table 1'!$A$1`. The source data of the pivot table can be referenced by column header name. For example, if the source data has columns named \"Revenue\" and \"Cost\" and a condition is applied to the \"Revenue\" column with type `NUMBER_GREATER` and value `=Cost`, then only columns where \"Revenue\" \u003e \"Cost\" are included.", + "$ref": "BooleanCondition" + }, + "visibleByDefault": { + "description": "Whether values are visible by default. If true, the visible_values are ignored, all values that meet condition (if specified) are shown. If false, values that are both in visible_values and meet condition are shown.", + "type": "boolean" + }, + "visibleValues": { + "type": "array", + "items": { + "type": "string" + }, + "description": "Values that should be included. Values not listed here are excluded." + } + } + }, + "UpdateDeveloperMetadataResponse": { + "description": "The response from updating developer metadata.", + "properties": { + "developerMetadata": { + "description": "The updated developer metadata.", + "type": "array", + "items": { + "$ref": "DeveloperMetadata" + } + } + }, + "type": "object", + "id": "UpdateDeveloperMetadataResponse" + }, + "UpdateFilterViewRequest": { + "properties": { + "filter": { + "$ref": "FilterView", + "description": "The new properties of the filter view." + }, + "fields": { + "description": "The fields that should be updated. At least one field must be specified. The root `filter` is implied and should not be specified. A single `\"*\"` can be used as short-hand for listing every field.", + "format": "google-fieldmask", + "type": "string" + } + }, + "id": "UpdateFilterViewRequest", + "type": "object", + "description": "Updates properties of the filter view." + }, + "PieChartSpec": { + "properties": { + "threeDimensional": { + "description": "True if the pie is three dimensional.", + "type": "boolean" + }, + "pieHole": { + "type": "number", + "format": "double", + "description": "The size of the hole in the pie chart." + }, + "domain": { + "$ref": "ChartData", + "description": "The data that covers the domain of the pie chart." + }, + "series": { + "description": "The data that covers the one and only series of the pie chart.", + "$ref": "ChartData" + }, + "legendPosition": { + "description": "Where the legend of the pie chart should be drawn.", + "enum": [ + "PIE_CHART_LEGEND_POSITION_UNSPECIFIED", + "BOTTOM_LEGEND", + "LEFT_LEGEND", + "RIGHT_LEGEND", + "TOP_LEGEND", + "NO_LEGEND", + "LABELED_LEGEND" + ], + "enumDescriptions": [ + "Default value, do not use.", + "The legend is rendered on the bottom of the chart.", + "The legend is rendered on the left of the chart.", + "The legend is rendered on the right of the chart.", + "The legend is rendered on the top of the chart.", + "No legend is rendered.", + "Each pie slice has a label attached to it." + ], + "type": "string" + } + }, + "type": "object", + "description": "A pie chart.", + "id": "PieChartSpec" + }, + "DimensionProperties": { + "id": "DimensionProperties", + "properties": { + "hiddenByFilter": { + "type": "boolean", + "description": "True if this dimension is being filtered. This field is read-only." + }, + "developerMetadata": { + "description": "The developer metadata associated with a single row or column.", + "items": { + "$ref": "DeveloperMetadata" + }, + "type": "array" + }, + "dataSourceColumnReference": { + "$ref": "DataSourceColumnReference", + "description": "Output only. If set, this is a column in a data source sheet.", + "readOnly": true + }, + "pixelSize": { + "description": "The height (if a row) or width (if a column) of the dimension in pixels.", + "type": "integer", + "format": "int32" + }, + "hiddenByUser": { + "description": "True if this dimension is explicitly hidden.", + "type": "boolean" + } + }, + "description": "Properties about a dimension.", + "type": "object" + }, + "AddFilterViewResponse": { + "id": "AddFilterViewResponse", + "properties": { + "filter": { + "description": "The newly added filter view.", + "$ref": "FilterView" + } + }, + "type": "object", + "description": "The result of adding a filter view." + }, + "ConditionalFormatRule": { + "properties": { + "booleanRule": { + "$ref": "BooleanRule", + "description": "The formatting is either \"on\" or \"off\" according to the rule." + }, + "gradientRule": { + "description": "The formatting will vary based on the gradients in the rule.", + "$ref": "GradientRule" + }, + "ranges": { + "description": "The ranges that are formatted if the condition is true. All the ranges must be on the same grid.", + "type": "array", + "items": { + "$ref": "GridRange" + } + } + }, + "type": "object", + "id": "ConditionalFormatRule", + "description": "A rule describing a conditional format." + }, + "Sheet": { + "type": "object", + "description": "A sheet in a spreadsheet.", + "id": "Sheet", + "properties": { + "filterViews": { + "description": "The filter views in this sheet.", + "type": "array", + "items": { + "$ref": "FilterView" + } + }, + "columnGroups": { + "type": "array", + "items": { + "$ref": "DimensionGroup" + }, + "description": "All column groups on this sheet, ordered by increasing range start index, then by group depth." + }, + "bandedRanges": { + "items": { + "$ref": "BandedRange" + }, + "description": "The banded (alternating colors) ranges on this sheet.", + "type": "array" + }, + "basicFilter": { + "$ref": "BasicFilter", + "description": "The filter on this sheet, if any." + }, + "developerMetadata": { + "type": "array", + "items": { + "$ref": "DeveloperMetadata" + }, + "description": "The developer metadata associated with a sheet." + }, + "properties": { + "$ref": "SheetProperties", + "description": "The properties of the sheet." + }, + "merges": { + "items": { + "$ref": "GridRange" + }, + "type": "array", + "description": "The ranges that are merged together." + }, + "protectedRanges": { + "items": { + "$ref": "ProtectedRange" + }, + "description": "The protected ranges in this sheet.", + "type": "array" + }, + "rowGroups": { + "items": { + "$ref": "DimensionGroup" + }, + "type": "array", + "description": "All row groups on this sheet, ordered by increasing range start index, then by group depth." + }, + "slicers": { + "type": "array", + "description": "The slicers on this sheet.", + "items": { + "$ref": "Slicer" + } + }, + "data": { + "items": { + "$ref": "GridData" + }, + "type": "array", + "description": "Data in the grid, if this is a grid sheet. The number of GridData objects returned is dependent on the number of ranges requested on this sheet. For example, if this is representing `Sheet1`, and the spreadsheet was requested with ranges `Sheet1!A1:C10` and `Sheet1!D15:E20`, then the first GridData will have a startRow/startColumn of `0`, while the second one will have `startRow 14` (zero-based row 15), and `startColumn 3` (zero-based column D). For a DATA_SOURCE sheet, you can not request a specific range, the GridData contains all the values." + }, + "conditionalFormats": { + "items": { + "$ref": "ConditionalFormatRule" + }, + "description": "The conditional format rules in this sheet.", + "type": "array" + }, + "charts": { + "items": { + "$ref": "EmbeddedChart" + }, + "description": "The specifications of every chart on this sheet.", + "type": "array" + } + } + }, + "BasicChartAxis": { + "type": "object", + "properties": { + "position": { + "enum": [ + "BASIC_CHART_AXIS_POSITION_UNSPECIFIED", + "BOTTOM_AXIS", + "LEFT_AXIS", + "RIGHT_AXIS" + ], + "enumDescriptions": [ + "Default value, do not use.", + "The axis rendered at the bottom of a chart. For most charts, this is the standard major axis. For bar charts, this is a minor axis.", + "The axis rendered at the left of a chart. For most charts, this is a minor axis. For bar charts, this is the standard major axis.", + "The axis rendered at the right of a chart. For most charts, this is a minor axis. For bar charts, this is an unusual major axis." + ], + "type": "string", + "description": "The position of this axis." + }, + "titleTextPosition": { + "$ref": "TextPosition", + "description": "The axis title text position." + }, + "format": { + "$ref": "TextFormat", + "description": "The format of the title. Only valid if the axis is not associated with the domain." + }, + "viewWindowOptions": { + "$ref": "ChartAxisViewWindowOptions", + "description": "The view window options for this axis." + }, + "title": { + "description": "The title of this axis. If set, this overrides any title inferred from headers of the data.", + "type": "string" + } + }, + "id": "BasicChartAxis", + "description": "An axis of the chart. A chart may not have more than one axis per axis position." + }, + "DataSourceChartProperties": { + "description": "Properties of a data source chart.", + "type": "object", + "id": "DataSourceChartProperties", + "properties": { + "dataExecutionStatus": { + "description": "Output only. The data execution status.", + "$ref": "DataExecutionStatus", + "readOnly": true + }, + "dataSourceId": { + "type": "string", + "description": "ID of the data source that the chart is associated with." + } + } + }, + "Editors": { + "description": "The editors of a protected range.", + "properties": { + "domainUsersCanEdit": { + "description": "True if anyone in the document's domain has edit access to the protected range. Domain protection is only supported on documents within a domain.", + "type": "boolean" + }, + "users": { + "description": "The email addresses of users with edit access to the protected range.", + "items": { + "type": "string" + }, + "type": "array" + }, + "groups": { + "items": { + "type": "string" + }, + "description": "The email addresses of groups with edit access to the protected range.", + "type": "array" + } + }, + "id": "Editors", + "type": "object" + }, + "RefreshDataSourceRequest": { + "type": "object", + "id": "RefreshDataSourceRequest", + "properties": { + "force": { + "description": "Refreshes the data source objects regardless of the current state. If not set and a referenced data source object was in error state, the refresh will fail immediately.", + "type": "boolean" + }, + "isAll": { + "description": "Refreshes all existing data source objects in the spreadsheet.", + "type": "boolean" + }, + "references": { + "description": "References to data source objects to refresh.", + "$ref": "DataSourceObjectReferences" + }, + "dataSourceId": { + "description": "Reference to a DataSource. If specified, refreshes all associated data source objects for the data source.", + "type": "string" + } + }, + "description": "Refreshes one or multiple data source objects in the spreadsheet by the specified references. The request requires an additional `bigquery.readonly` OAuth scope. If there are multiple refresh requests referencing the same data source objects in one batch, only the last refresh request is processed, and all those requests will have the same response accordingly." + }, + "DuplicateSheetRequest": { + "description": "Duplicates the contents of a sheet.", + "type": "object", + "id": "DuplicateSheetRequest", + "properties": { + "sourceSheetId": { + "format": "int32", + "type": "integer", + "description": "The sheet to duplicate. If the source sheet is of DATA_SOURCE type, its backing DataSource is also duplicated and associated with the new copy of the sheet. No data execution is triggered, the grid data of this sheet is also copied over but only available after the batch request completes." + }, + "newSheetName": { + "description": "The name of the new sheet. If empty, a new name is chosen for you.", + "type": "string" + }, + "insertSheetIndex": { + "type": "integer", + "description": "The zero-based index where the new sheet should be inserted. The index of all sheets after this are incremented.", + "format": "int32" + }, + "newSheetId": { + "format": "int32", + "description": "If set, the ID of the new sheet. If not set, an ID is chosen. If set, the ID must not conflict with any existing sheet ID. If set, it must be non-negative.", + "type": "integer" + } + } + }, + "UpdateEmbeddedObjectPositionRequest": { + "type": "object", + "description": "Update an embedded object's position (such as a moving or resizing a chart or image).", + "properties": { + "newPosition": { + "description": "An explicit position to move the embedded object to. If newPosition.sheetId is set, a new sheet with that ID will be created. If newPosition.newSheet is set to true, a new sheet will be created with an ID that will be chosen for you.", + "$ref": "EmbeddedObjectPosition" + }, + "objectId": { + "format": "int32", + "description": "The ID of the object to moved.", + "type": "integer" + }, + "fields": { + "format": "google-fieldmask", + "description": "The fields of OverlayPosition that should be updated when setting a new position. Used only if newPosition.overlayPosition is set, in which case at least one field must be specified. The root `newPosition.overlayPosition` is implied and should not be specified. A single `\"*\"` can be used as short-hand for listing every field.", + "type": "string" + } + }, + "id": "UpdateEmbeddedObjectPositionRequest" + }, + "OrgChartSpec": { + "description": "An org chart. Org charts require a unique set of labels in labels and may optionally include parent_labels and tooltips. parent_labels contain, for each node, the label identifying the parent node. tooltips contain, for each node, an optional tooltip. For example, to describe an OrgChart with Alice as the CEO, Bob as the President (reporting to Alice) and Cathy as VP of Sales (also reporting to Alice), have labels contain \"Alice\", \"Bob\", \"Cathy\", parent_labels contain \"\", \"Alice\", \"Alice\" and tooltips contain \"CEO\", \"President\", \"VP Sales\".", + "properties": { + "selectedNodeColor": { + "description": "The color of the selected org chart nodes.", + "$ref": "Color" + }, + "nodeSize": { + "enum": [ + "ORG_CHART_LABEL_SIZE_UNSPECIFIED", + "SMALL", + "MEDIUM", + "LARGE" + ], + "type": "string", + "description": "The size of the org chart nodes.", + "enumDescriptions": [ + "Default value, do not use.", + "The small org chart node size.", + "The medium org chart node size.", + "The large org chart node size." + ] + }, + "tooltips": { + "description": "The data containing the tooltip for the corresponding node. A blank value results in no tooltip being displayed for the node. This field is optional.", + "$ref": "ChartData" + }, + "labels": { + "description": "The data containing the labels for all the nodes in the chart. Labels must be unique.", + "$ref": "ChartData" + }, + "selectedNodeColorStyle": { + "$ref": "ColorStyle", + "description": "The color of the selected org chart nodes. If selected_node_color is also set, this field takes precedence." + }, + "parentLabels": { + "description": "The data containing the label of the parent for the corresponding node. A blank value indicates that the node has no parent and is a top-level node. This field is optional.", + "$ref": "ChartData" + }, + "nodeColorStyle": { + "description": "The color of the org chart nodes. If node_color is also set, this field takes precedence.", + "$ref": "ColorStyle" + }, + "nodeColor": { + "$ref": "Color", + "description": "The color of the org chart nodes." + } + }, + "id": "OrgChartSpec", + "type": "object" + }, + "DeleteDuplicatesRequest": { + "id": "DeleteDuplicatesRequest", + "type": "object", + "description": "Removes rows within this range that contain values in the specified columns that are duplicates of values in any previous row. Rows with identical values but different letter cases, formatting, or formulas are considered to be duplicates. This request also removes duplicate rows hidden from view (for example, due to a filter). When removing duplicates, the first instance of each duplicate row scanning from the top downwards is kept in the resulting range. Content outside of the specified range isn't removed, and rows considered duplicates do not have to be adjacent to each other in the range.", + "properties": { + "range": { + "$ref": "GridRange", + "description": "The range to remove duplicates rows from." + }, + "comparisonColumns": { + "items": { + "$ref": "DimensionRange" + }, + "type": "array", + "description": "The columns in the range to analyze for duplicate values. If no columns are selected then all columns are analyzed for duplicates." + } + } + }, + "ChartHistogramRule": { + "id": "ChartHistogramRule", + "description": "Allows you to organize numeric values in a source data column into buckets of constant size.", + "type": "object", + "properties": { + "minValue": { + "type": "number", + "description": "The minimum value at which items are placed into buckets. Values that are less than the minimum are grouped into a single bucket. If omitted, it is determined by the minimum item value.", + "format": "double" + }, + "maxValue": { + "format": "double", + "description": "The maximum value at which items are placed into buckets. Values greater than the maximum are grouped into a single bucket. If omitted, it is determined by the maximum item value.", + "type": "number" + }, + "intervalSize": { + "format": "double", + "description": "The size of the buckets that are created. Must be positive.", + "type": "number" + } + } + }, + "DataSourceSheetDimensionRange": { + "properties": { + "columnReferences": { + "type": "array", + "items": { + "$ref": "DataSourceColumnReference" + }, + "description": "The columns on the data source sheet." + }, + "sheetId": { + "description": "The ID of the data source sheet the range is on.", + "format": "int32", + "type": "integer" + } + }, + "description": "A range along a single dimension on a DATA_SOURCE sheet.", + "id": "DataSourceSheetDimensionRange", + "type": "object" + }, + "AddConditionalFormatRuleRequest": { + "type": "object", + "description": "Adds a new conditional format rule at the given index. All subsequent rules' indexes are incremented.", + "id": "AddConditionalFormatRuleRequest", + "properties": { + "rule": { + "description": "The rule to add.", + "$ref": "ConditionalFormatRule" + }, + "index": { + "format": "int32", + "type": "integer", + "description": "The zero-based index where the rule should be inserted." + } + } + }, + "Response": { + "description": "A single response from an update.", + "id": "Response", + "type": "object", + "properties": { + "duplicateFilterView": { + "$ref": "DuplicateFilterViewResponse", + "description": "A reply from duplicating a filter view." + }, + "addNamedRange": { + "$ref": "AddNamedRangeResponse", + "description": "A reply from adding a named range." + }, + "refreshDataSource": { + "$ref": "RefreshDataSourceResponse", + "description": "A reply from refreshing data source objects." + }, + "findReplace": { + "description": "A reply from doing a find/replace.", + "$ref": "FindReplaceResponse" + }, + "updateConditionalFormatRule": { + "description": "A reply from updating a conditional format rule.", + "$ref": "UpdateConditionalFormatRuleResponse" + }, + "addDataSource": { + "$ref": "AddDataSourceResponse", + "description": "A reply from adding a data source." + }, + "addSheet": { + "$ref": "AddSheetResponse", + "description": "A reply from adding a sheet." + }, + "trimWhitespace": { + "description": "A reply from trimming whitespace.", + "$ref": "TrimWhitespaceResponse" + }, + "addSlicer": { + "$ref": "AddSlicerResponse", + "description": "A reply from adding a slicer." + }, + "addProtectedRange": { + "$ref": "AddProtectedRangeResponse", + "description": "A reply from adding a protected range." + }, + "updateEmbeddedObjectPosition": { + "$ref": "UpdateEmbeddedObjectPositionResponse", + "description": "A reply from updating an embedded object's position." + }, + "updateDeveloperMetadata": { + "$ref": "UpdateDeveloperMetadataResponse", + "description": "A reply from updating a developer metadata entry." + }, + "addFilterView": { + "$ref": "AddFilterViewResponse", + "description": "A reply from adding a filter view." + }, + "deleteDeveloperMetadata": { + "description": "A reply from deleting a developer metadata entry.", + "$ref": "DeleteDeveloperMetadataResponse" + }, + "deleteDuplicates": { + "$ref": "DeleteDuplicatesResponse", + "description": "A reply from removing rows containing duplicate values." + }, + "addDimensionGroup": { + "$ref": "AddDimensionGroupResponse", + "description": "A reply from adding a dimension group." + }, + "addBanding": { + "description": "A reply from adding a banded range.", + "$ref": "AddBandingResponse" + }, + "deleteConditionalFormatRule": { + "$ref": "DeleteConditionalFormatRuleResponse", + "description": "A reply from deleting a conditional format rule." + }, + "addChart": { + "description": "A reply from adding a chart.", + "$ref": "AddChartResponse" + }, + "createDeveloperMetadata": { + "$ref": "CreateDeveloperMetadataResponse", + "description": "A reply from creating a developer metadata entry." + }, + "deleteDimensionGroup": { + "description": "A reply from deleting a dimension group.", + "$ref": "DeleteDimensionGroupResponse" + }, + "updateDataSource": { + "$ref": "UpdateDataSourceResponse", + "description": "A reply from updating a data source." + }, + "duplicateSheet": { + "description": "A reply from duplicating a sheet.", + "$ref": "DuplicateSheetResponse" + } + } + }, + "BaselineValueFormat": { + "description": "Formatting options for baseline value.", + "properties": { + "negativeColorStyle": { + "description": "Color to be used, in case baseline value represents a negative change for key value. This field is optional. If negative_color is also set, this field takes precedence.", + "$ref": "ColorStyle" + }, + "positiveColorStyle": { + "description": "Color to be used, in case baseline value represents a positive change for key value. This field is optional. If positive_color is also set, this field takes precedence.", + "$ref": "ColorStyle" + }, + "position": { + "description": "Specifies the horizontal text positioning of baseline value. This field is optional. If not specified, default positioning is used.", + "$ref": "TextPosition" + }, + "negativeColor": { + "description": "Color to be used, in case baseline value represents a negative change for key value. This field is optional.", + "$ref": "Color" + }, + "positiveColor": { + "$ref": "Color", + "description": "Color to be used, in case baseline value represents a positive change for key value. This field is optional." + }, + "description": { + "type": "string", + "description": "Description which is appended after the baseline value. This field is optional." + }, + "textFormat": { + "$ref": "TextFormat", + "description": "Text formatting options for baseline value." + }, + "comparisonType": { + "enumDescriptions": [ + "Default value, do not use.", + "Use absolute difference between key and baseline value.", + "Use percentage difference between key and baseline value." + ], + "type": "string", + "enum": [ + "COMPARISON_TYPE_UNDEFINED", + "ABSOLUTE_DIFFERENCE", + "PERCENTAGE_DIFFERENCE" + ], + "description": "The comparison type of key value with baseline value." + } + }, + "type": "object", + "id": "BaselineValueFormat" + }, + "ExtendedValue": { + "id": "ExtendedValue", + "type": "object", + "description": "The kinds of value that a cell in a spreadsheet can have.", + "properties": { + "stringValue": { + "description": "Represents a string value. Leading single quotes are not included. For example, if the user typed `'123` into the UI, this would be represented as a `stringValue` of `\"123\"`.", + "type": "string" + }, + "formulaValue": { + "type": "string", + "description": "Represents a formula." + }, + "boolValue": { + "type": "boolean", + "description": "Represents a boolean value." + }, + "errorValue": { + "description": "Represents an error. This field is read-only.", + "$ref": "ErrorValue" + }, + "numberValue": { + "format": "double", + "type": "number", + "description": "Represents a double value. Note: Dates, Times and DateTimes are represented as doubles in \"serial number\" format." + } + } + }, + "Interval": { + "type": "object", + "description": "Represents a time interval, encoded as a Timestamp start (inclusive) and a Timestamp end (exclusive). The start must be less than or equal to the end. When the start equals the end, the interval is empty (matches no time). When both start and end are unspecified, the interval matches any time.", + "properties": { + "startTime": { + "type": "string", + "description": "Optional. Inclusive start of the interval. If specified, a Timestamp matching this interval will have to be the same or after the start.", + "format": "google-datetime" + }, + "endTime": { + "description": "Optional. Exclusive end of the interval. If specified, a Timestamp matching this interval will have to be before the end.", + "type": "string", + "format": "google-datetime" + } + }, + "id": "Interval" + }, + "CandlestickChartSpec": { + "id": "CandlestickChartSpec", + "description": "A candlestick chart.", + "type": "object", + "properties": { + "data": { + "items": { + "$ref": "CandlestickData" + }, + "type": "array", + "description": "The Candlestick chart data. Only one CandlestickData is supported." + }, + "domain": { + "$ref": "CandlestickDomain", + "description": "The domain data (horizontal axis) for the candlestick chart. String data will be treated as discrete labels, other data will be treated as continuous values." + } + } + }, + "FilterCriteria": { + "properties": { + "visibleForegroundColorStyle": { + "description": "The foreground color to filter by; only cells with this foreground color are shown. This field is mutually exclusive with visible_background_color, and must be set to an RGB-type color. If visible_foreground_color is also set, this field takes precedence.", + "$ref": "ColorStyle" + }, + "hiddenValues": { + "items": { + "type": "string" + }, + "description": "Values that should be hidden.", + "type": "array" + }, + "visibleBackgroundColorStyle": { + "$ref": "ColorStyle", + "description": "The background fill color to filter by; only cells with this fill color are shown. This field is mutually exclusive with visible_foreground_color, and must be set to an RGB-type color. If visible_background_color is also set, this field takes precedence." + }, + "visibleBackgroundColor": { + "$ref": "Color", + "description": "The background fill color to filter by; only cells with this fill color are shown. Mutually exclusive with visible_foreground_color." + }, + "visibleForegroundColor": { + "$ref": "Color", + "description": "The foreground color to filter by; only cells with this foreground color are shown. Mutually exclusive with visible_background_color." + }, + "condition": { + "$ref": "BooleanCondition", + "description": "A condition that must be true for values to be shown. (This does not override hidden_values -- if a value is listed there, it will still be hidden.)" + } + }, + "id": "FilterCriteria", + "description": "Criteria for showing/hiding rows in a filter or filter view.", + "type": "object" + }, + "DataSource": { + "description": "Information about an external data source in the spreadsheet.", + "id": "DataSource", + "properties": { + "dataSourceId": { + "description": "The spreadsheet-scoped unique ID that identifies the data source. Example: 1080547365.", + "type": "string" + }, + "spec": { + "description": "The DataSourceSpec for the data source connected with this spreadsheet.", + "$ref": "DataSourceSpec" + }, + "sheetId": { + "type": "integer", + "description": "The ID of the Sheet connected with the data source. The field cannot be changed once set. When creating a data source, an associated DATA_SOURCE sheet is also created, if the field is not specified, the ID of the created sheet will be randomly generated.", + "format": "int32" + }, + "calculatedColumns": { + "items": { + "$ref": "DataSourceColumn" + }, + "description": "All calculated columns in the data source.", + "type": "array" + } + }, + "type": "object" + }, + "BasicChartSpec": { + "properties": { + "totalDataLabel": { + "$ref": "DataLabel", + "description": "Controls whether to display additional data labels on stacked charts which sum the total value of all stacked values at each value along the domain axis. These data labels can only be set when chart_type is one of AREA, BAR, COLUMN, COMBO or STEPPED_AREA and stacked_type is either STACKED or PERCENT_STACKED. In addition, for COMBO, this will only be supported if there is only one type of stackable series type or one type has more series than the others and each of the other types have no more than one series. For example, if a chart has two stacked bar series and one area series, the total data labels will be supported. If it has three bar series and two area series, total data labels are not allowed. Neither CUSTOM nor placement can be set on the total_data_label." + }, + "headerCount": { + "format": "int32", + "description": "The number of rows or columns in the data that are \"headers\". If not set, Google Sheets will guess how many rows are headers based on the data. (Note that BasicChartAxis.title may override the axis title inferred from the header values.)", + "type": "integer" + }, + "series": { + "description": "The data this chart is visualizing.", + "type": "array", + "items": { + "$ref": "BasicChartSeries" + } + }, + "compareMode": { + "type": "string", + "description": "The behavior of tooltips and data highlighting when hovering on data and chart area.", + "enumDescriptions": [ + "Default value, do not use.", + "Only the focused data element is highlighted and shown in the tooltip.", + "All data elements with the same category (e.g., domain value) are highlighted and shown in the tooltip." + ], + "enum": [ + "BASIC_CHART_COMPARE_MODE_UNSPECIFIED", + "DATUM", + "CATEGORY" + ] + }, + "threeDimensional": { + "description": "True to make the chart 3D. Applies to Bar and Column charts.", + "type": "boolean" + }, + "interpolateNulls": { + "description": "If some values in a series are missing, gaps may appear in the chart (e.g, segments of lines in a line chart will be missing). To eliminate these gaps set this to true. Applies to Line, Area, and Combo charts.", + "type": "boolean" + }, + "chartType": { + "description": "The type of the chart.", + "enum": [ + "BASIC_CHART_TYPE_UNSPECIFIED", + "BAR", + "LINE", + "AREA", + "COLUMN", + "SCATTER", + "COMBO", + "STEPPED_AREA" + ], + "enumDescriptions": [ + "Default value, do not use.", + "A bar chart.", + "A line chart.", + "An area chart.", + "A column chart.", + "A scatter chart.", + "A combo chart.", + "A stepped area chart." + ], + "type": "string" + }, + "legendPosition": { + "type": "string", + "enumDescriptions": [ + "Default value, do not use.", + "The legend is rendered on the bottom of the chart.", + "The legend is rendered on the left of the chart.", + "The legend is rendered on the right of the chart.", + "The legend is rendered on the top of the chart.", + "No legend is rendered." + ], + "description": "The position of the chart legend.", + "enum": [ + "BASIC_CHART_LEGEND_POSITION_UNSPECIFIED", + "BOTTOM_LEGEND", + "LEFT_LEGEND", + "RIGHT_LEGEND", + "TOP_LEGEND", + "NO_LEGEND" + ] + }, + "stackedType": { + "enum": [ + "BASIC_CHART_STACKED_TYPE_UNSPECIFIED", + "NOT_STACKED", + "STACKED", + "PERCENT_STACKED" + ], + "description": "The stacked type for charts that support vertical stacking. Applies to Area, Bar, Column, Combo, and Stepped Area charts.", + "type": "string", + "enumDescriptions": [ + "Default value, do not use.", + "Series are not stacked.", + "Series values are stacked, each value is rendered vertically beginning from the top of the value below it.", + "Vertical stacks are stretched to reach the top of the chart, with values laid out as percentages of each other." + ] + }, + "domains": { + "items": { + "$ref": "BasicChartDomain" + }, + "description": "The domain of data this is charting. Only a single domain is supported.", + "type": "array" + }, + "axis": { + "description": "The axis on the chart.", + "type": "array", + "items": { + "$ref": "BasicChartAxis" + } + }, + "lineSmoothing": { + "description": "Gets whether all lines should be rendered smooth or straight by default. Applies to Line charts.", + "type": "boolean" + } + }, + "description": "The specification for a basic chart. See BasicChartType for the list of charts this supports.", + "type": "object", + "id": "BasicChartSpec" + }, + "GradientRule": { + "properties": { + "midpoint": { + "$ref": "InterpolationPoint", + "description": "An optional midway interpolation point." + }, + "minpoint": { + "description": "The starting interpolation point.", + "$ref": "InterpolationPoint" + }, + "maxpoint": { + "description": "The final interpolation point.", + "$ref": "InterpolationPoint" + } + }, + "description": "A rule that applies a gradient color scale format, based on the interpolation points listed. The format of a cell will vary based on its contents as compared to the values of the interpolation points.", + "type": "object", + "id": "GradientRule" + }, + "DataSourceRefreshSchedule": { + "id": "DataSourceRefreshSchedule", + "type": "object", + "properties": { + "monthlySchedule": { + "description": "Monthly refresh schedule.", + "$ref": "DataSourceRefreshMonthlySchedule" + }, + "nextRun": { + "readOnly": true, + "description": "Output only. The time interval of the next run.", + "$ref": "Interval" + }, + "enabled": { + "description": "True if the refresh schedule is enabled, or false otherwise.", + "type": "boolean" + }, + "dailySchedule": { + "$ref": "DataSourceRefreshDailySchedule", + "description": "Daily refresh schedule." + }, + "refreshScope": { + "enumDescriptions": [ + "Default value, do not use.", + "Refreshes all data sources and their associated data source objects in the spreadsheet." + ], + "enum": [ + "DATA_SOURCE_REFRESH_SCOPE_UNSPECIFIED", + "ALL_DATA_SOURCES" + ], + "description": "The scope of the refresh. Must be ALL_DATA_SOURCES.", + "type": "string" + }, + "weeklySchedule": { + "description": "Weekly refresh schedule.", + "$ref": "DataSourceRefreshWeeklySchedule" + } + }, + "description": "Schedule for refreshing the data source. Data sources in the spreadsheet are refreshed within a time interval. You can specify the start time by clicking the Scheduled Refresh button in the Sheets editor, but the interval is fixed at 4 hours. For example, if you specify a start time of 8am , the refresh will take place between 8am and 12pm every day." + }, + "CreateDeveloperMetadataRequest": { + "type": "object", + "properties": { + "developerMetadata": { + "$ref": "DeveloperMetadata", + "description": "The developer metadata to create." + } + }, + "id": "CreateDeveloperMetadataRequest", + "description": "A request to create developer metadata." + }, + "TrimWhitespaceRequest": { + "id": "TrimWhitespaceRequest", + "description": "Trims the whitespace (such as spaces, tabs, or new lines) in every cell in the specified range. This request removes all whitespace from the start and end of each cell's text, and reduces any subsequence of remaining whitespace characters to a single space. If the resulting trimmed text starts with a '+' or '=' character, the text remains as a string value and isn't interpreted as a formula.", + "type": "object", + "properties": { + "range": { + "$ref": "GridRange", + "description": "The range whose cells to trim." + } + } + }, + "RepeatCellRequest": { + "id": "RepeatCellRequest", + "type": "object", + "description": "Updates all cells in the range to the values in the given Cell object. Only the fields listed in the fields field are updated; others are unchanged. If writing a cell with a formula, the formula's ranges will automatically increment for each field in the range. For example, if writing a cell with formula `=A1` into range B2:C4, B2 would be `=A1`, B3 would be `=A2`, B4 would be `=A3`, C2 would be `=B1`, C3 would be `=B2`, C4 would be `=B3`. To keep the formula's ranges static, use the `$` indicator. For example, use the formula `=$A$1` to prevent both the row and the column from incrementing.", + "properties": { + "range": { + "$ref": "GridRange", + "description": "The range to repeat the cell in." + }, + "cell": { + "description": "The data to write.", + "$ref": "CellData" + }, + "fields": { + "type": "string", + "description": "The fields that should be updated. At least one field must be specified. The root `cell` is implied and should not be specified. A single `\"*\"` can be used as short-hand for listing every field.", + "format": "google-fieldmask" + } + } + }, + "DateTimeRule": { + "id": "DateTimeRule", + "description": "Allows you to organize the date-time values in a source data column into buckets based on selected parts of their date or time values. For example, consider a pivot table showing sales transactions by date: +----------+--------------+ | Date | SUM of Sales | +----------+--------------+ | 1/1/2017 | $621.14 | | 2/3/2017 | $708.84 | | 5/8/2017 | $326.84 | ... +----------+--------------+ Applying a date-time group rule with a DateTimeRuleType of YEAR_MONTH results in the following pivot table. +--------------+--------------+ | Grouped Date | SUM of Sales | +--------------+--------------+ | 2017-Jan | $53,731.78 | | 2017-Feb | $83,475.32 | | 2017-Mar | $94,385.05 | ... +--------------+--------------+", + "type": "object", + "properties": { + "type": { + "type": "string", + "enum": [ + "DATE_TIME_RULE_TYPE_UNSPECIFIED", + "SECOND", + "MINUTE", + "HOUR", + "HOUR_MINUTE", + "HOUR_MINUTE_AMPM", + "DAY_OF_WEEK", + "DAY_OF_YEAR", + "DAY_OF_MONTH", + "DAY_MONTH", + "MONTH", + "QUARTER", + "YEAR", + "YEAR_MONTH", + "YEAR_QUARTER", + "YEAR_MONTH_DAY" + ], + "description": "The type of date-time grouping to apply.", + "enumDescriptions": [ + "The default type, do not use.", + "Group dates by second, from 0 to 59.", + "Group dates by minute, from 0 to 59.", + "Group dates by hour using a 24-hour system, from 0 to 23.", + "Group dates by hour and minute using a 24-hour system, for example 19:45.", + "Group dates by hour and minute using a 12-hour system, for example 7:45 PM. The AM/PM designation is translated based on the spreadsheet locale.", + "Group dates by day of week, for example Sunday. The days of the week will be translated based on the spreadsheet locale.", + "Group dates by day of year, from 1 to 366. Note that dates after Feb. 29 fall in different buckets in leap years than in non-leap years.", + "Group dates by day of month, from 1 to 31.", + "Group dates by day and month, for example 22-Nov. The month is translated based on the spreadsheet locale.", + "Group dates by month, for example Nov. The month is translated based on the spreadsheet locale.", + "Group dates by quarter, for example Q1 (which represents Jan-Mar).", + "Group dates by year, for example 2008.", + "Group dates by year and month, for example 2008-Nov. The month is translated based on the spreadsheet locale.", + "Group dates by year and quarter, for example 2008 Q4.", + "Group dates by year, month, and day, for example 2008-11-22." + ] + } + } + }, + "DimensionGroup": { + "id": "DimensionGroup", + "properties": { + "depth": { + "description": "The depth of the group, representing how many groups have a range that wholly contains the range of this group.", + "format": "int32", + "type": "integer" + }, + "range": { + "$ref": "DimensionRange", + "description": "The range over which this group exists." + }, + "collapsed": { + "description": "This field is true if this group is collapsed. A collapsed group remains collapsed if an overlapping group at a shallower depth is expanded. A true value does not imply that all dimensions within the group are hidden, since a dimension's visibility can change independently from this group property. However, when this property is updated, all dimensions within it are set to hidden if this field is true, or set to visible if this field is false.", + "type": "boolean" + } + }, + "description": "A group over an interval of rows or columns on a sheet, which can contain or be contained within other groups. A group can be collapsed or expanded as a unit on the sheet.", + "type": "object" + }, + "SetBasicFilterRequest": { + "id": "SetBasicFilterRequest", + "properties": { + "filter": { + "$ref": "BasicFilter", + "description": "The filter to set." + } + }, + "type": "object", + "description": "Sets the basic filter associated with a sheet." + }, + "DataSourceTable": { + "properties": { + "columnSelectionType": { + "enumDescriptions": [ + "The default column selection type, do not use.", + "Select columns specified by columns field.", + "Sync all current and future columns in the data source. If set, the data source table fetches all the columns in the data source at the time of refresh." + ], + "description": "The type to select columns for the data source table. Defaults to SELECTED.", + "enum": [ + "DATA_SOURCE_TABLE_COLUMN_SELECTION_TYPE_UNSPECIFIED", + "SELECTED", + "SYNC_ALL" + ], + "type": "string" + }, + "dataSourceId": { + "type": "string", + "description": "The ID of the data source the data source table is associated with." + }, + "columns": { + "items": { + "$ref": "DataSourceColumnReference" + }, + "description": "Columns selected for the data source table. The column_selection_type must be SELECTED.", + "type": "array" + }, + "sortSpecs": { + "description": "Sort specifications in the data source table. The result of the data source table is sorted based on the sort specifications in order.", + "type": "array", + "items": { + "$ref": "SortSpec" + } + }, + "filterSpecs": { + "description": "Filter specifications in the data source table.", + "items": { + "$ref": "FilterSpec" + }, + "type": "array" + }, + "rowLimit": { + "description": "The limit of rows to return. If not set, a default limit is applied. Please refer to the Sheets editor for the default and max limit.", + "format": "int32", + "type": "integer" + }, + "dataExecutionStatus": { + "$ref": "DataExecutionStatus", + "readOnly": true, + "description": "Output only. The data execution status." + } + }, + "id": "DataSourceTable", + "type": "object", + "description": "A data source table, which allows the user to import a static table of data from the DataSource into Sheets. This is also known as \"Extract\" in the Sheets editor." + }, + "CandlestickSeries": { + "description": "The series of a CandlestickData.", + "type": "object", + "id": "CandlestickSeries", + "properties": { + "data": { + "$ref": "ChartData", + "description": "The data of the CandlestickSeries." + } + } + }, + "Border": { + "id": "Border", + "type": "object", + "description": "A border along a cell.", + "properties": { + "colorStyle": { + "$ref": "ColorStyle", + "description": "The color of the border. If color is also set, this field takes precedence." + }, + "style": { + "description": "The style of the border.", + "enum": [ + "STYLE_UNSPECIFIED", + "DOTTED", + "DASHED", + "SOLID", + "SOLID_MEDIUM", + "SOLID_THICK", + "NONE", + "DOUBLE" + ], + "enumDescriptions": [ + "The style is not specified. Do not use this.", + "The border is dotted.", + "The border is dashed.", + "The border is a thin solid line.", + "The border is a medium solid line.", + "The border is a thick solid line.", + "No border. Used only when updating a border in order to erase it.", + "The border is two solid lines." + ], + "type": "string" + }, + "color": { + "description": "The color of the border.", + "$ref": "Color" + }, + "width": { + "format": "int32", + "description": "The width of the border, in pixels. Deprecated; the width is determined by the \"style\" field.", + "type": "integer" + } + } + }, + "GridRange": { + "type": "object", + "id": "GridRange", + "properties": { + "startRowIndex": { + "type": "integer", + "description": "The start row (inclusive) of the range, or not set if unbounded.", + "format": "int32" + }, + "sheetId": { + "type": "integer", + "format": "int32", + "description": "The sheet this range is on." + }, + "endColumnIndex": { + "type": "integer", + "description": "The end column (exclusive) of the range, or not set if unbounded.", + "format": "int32" + }, + "endRowIndex": { + "format": "int32", + "description": "The end row (exclusive) of the range, or not set if unbounded.", + "type": "integer" + }, + "startColumnIndex": { + "description": "The start column (inclusive) of the range, or not set if unbounded.", + "format": "int32", + "type": "integer" + } + }, + "description": "A range on a sheet. All indexes are zero-based. Indexes are half open, i.e. the start index is inclusive and the end index is exclusive -- [start_index, end_index). Missing indexes indicate the range is unbounded on that side. For example, if `\"Sheet1\"` is sheet ID 0, then: `Sheet1!A1:A1 == sheet_id: 0, start_row_index: 0, end_row_index: 1, start_column_index: 0, end_column_index: 1` `Sheet1!A3:B4 == sheet_id: 0, start_row_index: 2, end_row_index: 4, start_column_index: 0, end_column_index: 2` `Sheet1!A:B == sheet_id: 0, start_column_index: 0, end_column_index: 2` `Sheet1!A5:B == sheet_id: 0, start_row_index: 4, start_column_index: 0, end_column_index: 2` `Sheet1 == sheet_id:0` The start index must always be less than or equal to the end index. If the start index equals the end index, then the range is empty. Empty ranges are typically not meaningful and are usually rendered in the UI as `#REF!`." + }, + "FindReplaceRequest": { + "id": "FindReplaceRequest", + "description": "Finds and replaces data in cells over a range, sheet, or all sheets.", + "properties": { + "matchCase": { + "description": "True if the search is case sensitive.", + "type": "boolean" + }, + "searchByRegex": { + "description": "True if the find value is a regex. The regular expression and replacement should follow Java regex rules at https://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html. The replacement string is allowed to refer to capturing groups. For example, if one cell has the contents `\"Google Sheets\"` and another has `\"Google Docs\"`, then searching for `\"o.* (.*)\"` with a replacement of `\"$1 Rocks\"` would change the contents of the cells to `\"GSheets Rocks\"` and `\"GDocs Rocks\"` respectively.", + "type": "boolean" + }, + "sheetId": { + "description": "The sheet to find/replace over.", + "type": "integer", + "format": "int32" + }, + "find": { + "description": "The value to search.", + "type": "string" + }, + "includeFormulas": { + "type": "boolean", + "description": "True if the search should include cells with formulas. False to skip cells with formulas." + }, + "range": { + "$ref": "GridRange", + "description": "The range to find/replace over." + }, + "allSheets": { + "type": "boolean", + "description": "True to find/replace over all sheets." + }, + "matchEntireCell": { + "type": "boolean", + "description": "True if the find value should match the entire cell." + }, + "replacement": { + "type": "string", + "description": "The value to use as the replacement." + } + }, + "type": "object" + }, + "HistogramRule": { + "type": "object", + "properties": { + "start": { + "format": "double", + "description": "The minimum value at which items are placed into buckets of constant size. Values below start are lumped into a single bucket. This field is optional.", + "type": "number" + }, + "end": { + "format": "double", + "type": "number", + "description": "The maximum value at which items are placed into buckets of constant size. Values above end are lumped into a single bucket. This field is optional." + }, + "interval": { + "description": "The size of the buckets that are created. Must be positive.", + "type": "number", + "format": "double" + } + }, + "description": "Allows you to organize the numeric values in a source data column into buckets of a constant size. All values from HistogramRule.start to HistogramRule.end are placed into groups of size HistogramRule.interval. In addition, all values below HistogramRule.start are placed in one group, and all values above HistogramRule.end are placed in another. Only HistogramRule.interval is required, though if HistogramRule.start and HistogramRule.end are both provided, HistogramRule.start must be less than HistogramRule.end. For example, a pivot table showing average purchase amount by age that has 50+ rows: +-----+-------------------+ | Age | AVERAGE of Amount | +-----+-------------------+ | 16 | $27.13 | | 17 | $5.24 | | 18 | $20.15 | ... +-----+-------------------+ could be turned into a pivot table that looks like the one below by applying a histogram group rule with a HistogramRule.start of 25, an HistogramRule.interval of 20, and an HistogramRule.end of 65. +-------------+-------------------+ | Grouped Age | AVERAGE of Amount | +-------------+-------------------+ | \u003c 25 | $19.34 | | 25-45 | $31.43 | | 45-65 | $35.87 | | \u003e 65 | $27.55 | +-------------+-------------------+ | Grand Total | $29.12 | +-------------+-------------------+", + "id": "HistogramRule" + }, + "BatchClearValuesByDataFilterResponse": { + "description": "The response when clearing a range of values selected with DataFilters in a spreadsheet.", + "properties": { + "spreadsheetId": { + "description": "The spreadsheet the updates were applied to.", + "type": "string" + }, + "clearedRanges": { + "items": { + "type": "string" + }, + "type": "array", + "description": "The ranges that were cleared, in A1 notation. If the requests are for an unbounded range or a ranger larger than the bounds of the sheet, this is the actual ranges that were cleared, bounded to the sheet's limits." + } + }, + "id": "BatchClearValuesByDataFilterResponse", + "type": "object" + }, + "AutoResizeDimensionsRequest": { + "properties": { + "dataSourceSheetDimensions": { + "description": "The dimensions on a data source sheet to automatically resize.", + "$ref": "DataSourceSheetDimensionRange" + }, + "dimensions": { + "description": "The dimensions to automatically resize.", + "$ref": "DimensionRange" + } + }, + "id": "AutoResizeDimensionsRequest", + "description": "Automatically resizes one or more dimensions based on the contents of the cells in that dimension.", + "type": "object" + }, + "Request": { + "id": "Request", + "properties": { + "createDeveloperMetadata": { + "description": "Creates new developer metadata", + "$ref": "CreateDeveloperMetadataRequest" + }, + "addNamedRange": { + "$ref": "AddNamedRangeRequest", + "description": "Adds a named range." + }, + "insertRange": { + "$ref": "InsertRangeRequest", + "description": "Inserts new cells in a sheet, shifting the existing cells." + }, + "addFilterView": { + "description": "Adds a filter view.", + "$ref": "AddFilterViewRequest" + }, + "textToColumns": { + "description": "Converts a column of text into many columns of text.", + "$ref": "TextToColumnsRequest" + }, + "duplicateFilterView": { + "$ref": "DuplicateFilterViewRequest", + "description": "Duplicates a filter view." + }, + "randomizeRange": { + "description": "Randomizes the order of the rows in a range.", + "$ref": "RandomizeRangeRequest" + }, + "updateSpreadsheetProperties": { + "$ref": "UpdateSpreadsheetPropertiesRequest", + "description": "Updates the spreadsheet's properties." + }, + "updateDeveloperMetadata": { + "description": "Updates an existing developer metadata entry", + "$ref": "UpdateDeveloperMetadataRequest" + }, + "repeatCell": { + "$ref": "RepeatCellRequest", + "description": "Repeats a single cell across a range." + }, + "deleteFilterView": { + "$ref": "DeleteFilterViewRequest", + "description": "Deletes a filter view from a sheet." + }, + "updateSlicerSpec": { + "description": "Updates a slicer's specifications.", + "$ref": "UpdateSlicerSpecRequest" + }, + "duplicateSheet": { + "$ref": "DuplicateSheetRequest", + "description": "Duplicates a sheet." + }, + "updateEmbeddedObjectPosition": { + "description": "Updates an embedded object's (e.g. chart, image) position.", + "$ref": "UpdateEmbeddedObjectPositionRequest" + }, + "deleteNamedRange": { + "description": "Deletes a named range.", + "$ref": "DeleteNamedRangeRequest" + }, + "mergeCells": { + "$ref": "MergeCellsRequest", + "description": "Merges cells together." + }, + "autoFill": { + "$ref": "AutoFillRequest", + "description": "Automatically fills in more data based on existing data." + }, + "autoResizeDimensions": { + "description": "Automatically resizes one or more dimensions based on the contents of the cells in that dimension.", + "$ref": "AutoResizeDimensionsRequest" + }, + "appendDimension": { + "description": "Appends dimensions to the end of a sheet.", + "$ref": "AppendDimensionRequest" + }, + "insertDimension": { + "$ref": "InsertDimensionRequest", + "description": "Inserts new rows or columns in a sheet." + }, + "updateCells": { + "$ref": "UpdateCellsRequest", + "description": "Updates many cells at once." + }, + "deleteDeveloperMetadata": { + "$ref": "DeleteDeveloperMetadataRequest", + "description": "Deletes developer metadata" + }, + "pasteData": { + "description": "Pastes data (HTML or delimited) into a sheet.", + "$ref": "PasteDataRequest" + }, + "deleteSheet": { + "description": "Deletes a sheet.", + "$ref": "DeleteSheetRequest" + }, + "deleteRange": { + "$ref": "DeleteRangeRequest", + "description": "Deletes a range of cells from a sheet, shifting the remaining cells." + }, + "trimWhitespace": { + "$ref": "TrimWhitespaceRequest", + "description": "Trims cells of whitespace (such as spaces, tabs, or new lines)." + }, + "deleteBanding": { + "$ref": "DeleteBandingRequest", + "description": "Removes a banded range" + }, + "findReplace": { + "$ref": "FindReplaceRequest", + "description": "Finds and replaces occurrences of some text with other text." + }, + "deleteConditionalFormatRule": { + "$ref": "DeleteConditionalFormatRuleRequest", + "description": "Deletes an existing conditional format rule." + }, + "updateChartSpec": { + "$ref": "UpdateChartSpecRequest", + "description": "Updates a chart's specifications." + }, + "updateDimensionProperties": { + "description": "Updates dimensions' properties.", + "$ref": "UpdateDimensionPropertiesRequest" + }, + "updateDataSource": { + "$ref": "UpdateDataSourceRequest", + "description": "Updates a data source." + }, + "addSheet": { + "description": "Adds a sheet.", + "$ref": "AddSheetRequest" + }, + "updateProtectedRange": { + "description": "Updates a protected range.", + "$ref": "UpdateProtectedRangeRequest" + }, + "addSlicer": { + "description": "Adds a slicer.", + "$ref": "AddSlicerRequest" + }, + "deleteDimensionGroup": { + "$ref": "DeleteDimensionGroupRequest", + "description": "Deletes a group over the specified range." + }, + "deleteDuplicates": { + "$ref": "DeleteDuplicatesRequest", + "description": "Removes rows containing duplicate values in specified columns of a cell range." + }, + "updateEmbeddedObjectBorder": { + "$ref": "UpdateEmbeddedObjectBorderRequest", + "description": "Updates an embedded object's border." + }, + "appendCells": { + "$ref": "AppendCellsRequest", + "description": "Appends cells after the last row with data in a sheet." + }, + "updateBorders": { + "$ref": "UpdateBordersRequest", + "description": "Updates the borders in a range of cells." + }, + "cutPaste": { + "$ref": "CutPasteRequest", + "description": "Cuts data from one area and pastes it to another." + }, + "copyPaste": { + "description": "Copies data from one area and pastes it to another.", + "$ref": "CopyPasteRequest" + }, + "addDimensionGroup": { + "description": "Creates a group over the specified range.", + "$ref": "AddDimensionGroupRequest" + }, + "setBasicFilter": { + "description": "Sets the basic filter on a sheet.", + "$ref": "SetBasicFilterRequest" + }, + "updateDimensionGroup": { + "description": "Updates the state of the specified group.", + "$ref": "UpdateDimensionGroupRequest" + }, + "addDataSource": { + "$ref": "AddDataSourceRequest", + "description": "Adds a data source." + }, + "deleteDataSource": { + "$ref": "DeleteDataSourceRequest", + "description": "Deletes a data source." + }, + "updateBanding": { + "description": "Updates a banded range", + "$ref": "UpdateBandingRequest" + }, + "updateSheetProperties": { + "$ref": "UpdateSheetPropertiesRequest", + "description": "Updates a sheet's properties." + }, + "clearBasicFilter": { + "$ref": "ClearBasicFilterRequest", + "description": "Clears the basic filter on a sheet." + }, + "addConditionalFormatRule": { + "description": "Adds a new conditional format rule.", + "$ref": "AddConditionalFormatRuleRequest" + }, + "updateFilterView": { + "description": "Updates the properties of a filter view.", + "$ref": "UpdateFilterViewRequest" + }, + "deleteDimension": { + "$ref": "DeleteDimensionRequest", + "description": "Deletes rows or columns in a sheet." + }, + "setDataValidation": { + "description": "Sets data validation for one or more cells.", + "$ref": "SetDataValidationRequest" + }, + "sortRange": { + "$ref": "SortRangeRequest", + "description": "Sorts data in a range." + }, + "updateConditionalFormatRule": { + "$ref": "UpdateConditionalFormatRuleRequest", + "description": "Updates an existing conditional format rule." + }, + "updateNamedRange": { + "description": "Updates a named range.", + "$ref": "UpdateNamedRangeRequest" + }, + "unmergeCells": { + "$ref": "UnmergeCellsRequest", + "description": "Unmerges merged cells." + }, + "moveDimension": { + "$ref": "MoveDimensionRequest", + "description": "Moves rows or columns to another location in a sheet." + }, + "refreshDataSource": { + "$ref": "RefreshDataSourceRequest", + "description": "Refreshs one or multiple data sources and associated dbobjects." + }, + "deleteEmbeddedObject": { + "description": "Deletes an embedded object (e.g, chart, image) in a sheet.", + "$ref": "DeleteEmbeddedObjectRequest" + }, + "addProtectedRange": { + "description": "Adds a protected range.", + "$ref": "AddProtectedRangeRequest" + }, + "deleteProtectedRange": { + "description": "Deletes a protected range.", + "$ref": "DeleteProtectedRangeRequest" + }, + "addBanding": { + "$ref": "AddBandingRequest", + "description": "Adds a new banded range" + }, + "addChart": { + "$ref": "AddChartRequest", + "description": "Adds a chart." + } + }, + "description": "A single kind of update to apply to a spreadsheet.", + "type": "object" + }, + "PivotGroupRule": { + "id": "PivotGroupRule", + "properties": { + "manualRule": { + "description": "A ManualRule.", + "$ref": "ManualRule" + }, + "histogramRule": { + "description": "A HistogramRule.", + "$ref": "HistogramRule" + }, + "dateTimeRule": { + "$ref": "DateTimeRule", + "description": "A DateTimeRule." + } + }, + "description": "An optional setting on a PivotGroup that defines buckets for the values in the source data column rather than breaking out each individual value. Only one PivotGroup with a group rule may be added for each column in the source data, though on any given column you may add both a PivotGroup that has a rule and a PivotGroup that does not.", + "type": "object" + }, + "UpdateEmbeddedObjectPositionResponse": { + "type": "object", + "id": "UpdateEmbeddedObjectPositionResponse", + "description": "The result of updating an embedded object's position.", + "properties": { + "position": { + "description": "The new position of the embedded object.", + "$ref": "EmbeddedObjectPosition" + } + } + }, + "DeveloperMetadata": { + "id": "DeveloperMetadata", + "type": "object", + "description": "Developer metadata associated with a location or object in a spreadsheet. Developer metadata may be used to associate arbitrary data with various parts of a spreadsheet and will remain associated at those locations as they move around and the spreadsheet is edited. For example, if developer metadata is associated with row 5 and another row is then subsequently inserted above row 5, that original metadata will still be associated with the row it was first associated with (what is now row 6). If the associated object is deleted its metadata is deleted too.", + "properties": { + "metadataId": { + "description": "The spreadsheet-scoped unique ID that identifies the metadata. IDs may be specified when metadata is created, otherwise one will be randomly generated and assigned. Must be positive.", + "type": "integer", + "format": "int32" + }, + "visibility": { + "type": "string", + "description": "The metadata visibility. Developer metadata must always have a visibility specified.", + "enumDescriptions": [ + "Default value.", + "Document-visible metadata is accessible from any developer project with access to the document.", + "Project-visible metadata is only visible to and accessible by the developer project that created the metadata." + ], + "enum": [ + "DEVELOPER_METADATA_VISIBILITY_UNSPECIFIED", + "DOCUMENT", + "PROJECT" + ] + }, + "metadataValue": { + "type": "string", + "description": "Data associated with the metadata's key." + }, + "location": { + "description": "The location where the metadata is associated.", + "$ref": "DeveloperMetadataLocation" + }, + "metadataKey": { + "type": "string", + "description": "The metadata key. There may be multiple metadata in a spreadsheet with the same key. Developer metadata must always have a key specified." + } + } + }, + "WaterfallChartSeries": { + "properties": { + "hideTrailingSubtotal": { + "description": "True to hide the subtotal column from the end of the series. By default, a subtotal column will appear at the end of each series. Setting this field to true will hide that subtotal column for this series.", + "type": "boolean" + }, + "data": { + "description": "The data being visualized in this series.", + "$ref": "ChartData" + }, + "negativeColumnsStyle": { + "$ref": "WaterfallChartColumnStyle", + "description": "Styles for all columns in this series with negative values." + }, + "dataLabel": { + "$ref": "DataLabel", + "description": "Information about the data labels for this series." + }, + "positiveColumnsStyle": { + "description": "Styles for all columns in this series with positive values.", + "$ref": "WaterfallChartColumnStyle" + }, + "subtotalColumnsStyle": { + "$ref": "WaterfallChartColumnStyle", + "description": "Styles for all subtotal columns in this series." + }, + "customSubtotals": { + "description": "Custom subtotal columns appearing in this series. The order in which subtotals are defined is not significant. Only one subtotal may be defined for each data point.", + "type": "array", + "items": { + "$ref": "WaterfallChartCustomSubtotal" + } + } + }, + "description": "A single series of data for a waterfall chart.", + "id": "WaterfallChartSeries", + "type": "object" + }, + "DataSourceParameter": { + "properties": { + "name": { + "type": "string", + "description": "Named parameter. Must be a legitimate identifier for the DataSource that supports it. For example, [BigQuery identifier](https://cloud.google.com/bigquery/docs/reference/standard-sql/lexical#identifiers)." + }, + "range": { + "$ref": "GridRange", + "description": "A range that contains the value of the parameter. Its size must be 1x1." + }, + "namedRangeId": { + "description": "ID of a NamedRange. Its size must be 1x1.", + "type": "string" + } + }, + "type": "object", + "id": "DataSourceParameter", + "description": "A parameter in a data source's query. The parameter allows the user to pass in values from the spreadsheet into a query." + }, + "ChartSourceRange": { + "description": "Source ranges for a chart.", + "properties": { + "sources": { + "items": { + "$ref": "GridRange" + }, + "description": "The ranges of data for a series or domain. Exactly one dimension must have a length of 1, and all sources in the list must have the same dimension with length 1. The domain (if it exists) & all series must have the same number of source ranges. If using more than one source range, then the source range at a given offset must be in order and contiguous across the domain and series. For example, these are valid configurations: domain sources: A1:A5 series1 sources: B1:B5 series2 sources: D6:D10 domain sources: A1:A5, C10:C12 series1 sources: B1:B5, D10:D12 series2 sources: C1:C5, E10:E12", + "type": "array" + } + }, + "id": "ChartSourceRange", + "type": "object" + }, + "PivotGroupSortValueBucket": { + "type": "object", + "description": "Information about which values in a pivot group should be used for sorting.", + "id": "PivotGroupSortValueBucket", + "properties": { + "buckets": { + "items": { + "$ref": "ExtendedValue" + }, + "description": "Determines the bucket from which values are chosen to sort. For example, in a pivot table with one row group & two column groups, the row group can list up to two values. The first value corresponds to a value within the first column group, and the second value corresponds to a value in the second column group. If no values are listed, this would indicate that the row should be sorted according to the \"Grand Total\" over the column groups. If a single value is listed, this would correspond to using the \"Total\" of that bucket.", + "type": "array" + }, + "valuesIndex": { + "description": "The offset in the PivotTable.values list which the values in this grouping should be sorted by.", + "type": "integer", + "format": "int32" + } + } + }, + "GetSpreadsheetByDataFilterRequest": { + "type": "object", + "description": "The request for retrieving a Spreadsheet.", + "properties": { + "includeGridData": { + "type": "boolean", + "description": "True if grid data should be returned. This parameter is ignored if a field mask was set in the request." + }, + "dataFilters": { + "type": "array", + "description": "The DataFilters used to select which ranges to retrieve from the spreadsheet.", + "items": { + "$ref": "DataFilter" + } + } + }, + "id": "GetSpreadsheetByDataFilterRequest" + }, + "BatchClearValuesByDataFilterRequest": { + "id": "BatchClearValuesByDataFilterRequest", + "properties": { + "dataFilters": { + "type": "array", + "items": { + "$ref": "DataFilter" + }, + "description": "The DataFilters used to determine which ranges to clear." + } + }, + "type": "object", + "description": "The request for clearing more than one range selected by a DataFilter in a spreadsheet." + }, + "UnmergeCellsRequest": { + "properties": { + "range": { + "$ref": "GridRange", + "description": "The range within which all cells should be unmerged. If the range spans multiple merges, all will be unmerged. The range must not partially span any merge." + } + }, + "id": "UnmergeCellsRequest", + "description": "Unmerges cells in the given range.", + "type": "object" + }, + "DeleteDataSourceRequest": { + "properties": { + "dataSourceId": { + "description": "The ID of the data source to delete.", + "type": "string" + } + }, + "type": "object", + "id": "DeleteDataSourceRequest", + "description": "Deletes a data source. The request also deletes the associated data source sheet, and unlinks all associated data source objects." + }, + "SpreadsheetProperties": { + "id": "SpreadsheetProperties", + "type": "object", + "properties": { + "timeZone": { + "type": "string", + "description": "The time zone of the spreadsheet, in CLDR format such as `America/New_York`. If the time zone isn't recognized, this may be a custom time zone such as `GMT-07:00`." + }, + "locale": { + "type": "string", + "description": "The locale of the spreadsheet in one of the following formats: * an ISO 639-1 language code such as `en` * an ISO 639-2 language code such as `fil`, if no 639-1 code exists * a combination of the ISO language code and country code, such as `en_US` Note: when updating this field, not all locales/languages are supported." + }, + "autoRecalc": { + "description": "The amount of time to wait before volatile functions are recalculated.", + "enumDescriptions": [ + "Default value. This value must not be used.", + "Volatile functions are updated on every change.", + "Volatile functions are updated on every change and every minute.", + "Volatile functions are updated on every change and hourly." + ], + "enum": [ + "RECALCULATION_INTERVAL_UNSPECIFIED", + "ON_CHANGE", + "MINUTE", + "HOUR" + ], + "type": "string" + }, + "spreadsheetTheme": { + "description": "Theme applied to the spreadsheet.", + "$ref": "SpreadsheetTheme" + }, + "iterativeCalculationSettings": { + "description": "Determines whether and how circular references are resolved with iterative calculation. Absence of this field means that circular references result in calculation errors.", + "$ref": "IterativeCalculationSettings" + }, + "title": { + "type": "string", + "description": "The title of the spreadsheet." + }, + "defaultFormat": { + "description": "The default format of all cells in the spreadsheet. CellData.effectiveFormat will not be set if the cell's format is equal to this default format. This field is read-only.", + "$ref": "CellFormat" + } + }, + "description": "Properties of a spreadsheet." + }, + "LineStyle": { + "properties": { + "type": { + "description": "The dash type of the line.", + "type": "string", + "enumDescriptions": [ + "Default value, do not use.", + "No dash type, which is equivalent to a non-visible line.", + "A custom dash for a line. Modifying the exact custom dash style is currently unsupported.", + "A solid line.", + "A dotted line.", + "A dashed line where the dashes have \"medium\" length.", + "A line that alternates between a \"medium\" dash and a dot.", + "A dashed line where the dashes have \"long\" length.", + "A line that alternates between a \"long\" dash and a dot." + ], + "enum": [ + "LINE_DASH_TYPE_UNSPECIFIED", + "INVISIBLE", + "CUSTOM", + "SOLID", + "DOTTED", + "MEDIUM_DASHED", + "MEDIUM_DASHED_DOTTED", + "LONG_DASHED", + "LONG_DASHED_DOTTED" + ] + }, + "width": { + "format": "int32", + "type": "integer", + "description": "The thickness of the line, in px." + } + }, + "id": "LineStyle", + "description": "Properties that describe the style of a line.", + "type": "object" + }, + "MatchedValueRange": { + "description": "A value range that was matched by one or more data filers.", + "properties": { + "dataFilters": { + "type": "array", + "description": "The DataFilters from the request that matched the range of values.", + "items": { + "$ref": "DataFilter" + } + }, + "valueRange": { + "description": "The values matched by the DataFilter.", + "$ref": "ValueRange" + } + }, + "id": "MatchedValueRange", + "type": "object" + }, + "DuplicateFilterViewResponse": { + "type": "object", + "description": "The result of a filter view being duplicated.", + "id": "DuplicateFilterViewResponse", + "properties": { + "filter": { + "$ref": "FilterView", + "description": "The newly created filter." + } + } + }, + "RandomizeRangeRequest": { + "id": "RandomizeRangeRequest", + "type": "object", + "properties": { + "range": { + "$ref": "GridRange", + "description": "The range to randomize." + } + }, + "description": "Randomizes the order of the rows in a range." + }, + "DeleteBandingRequest": { + "properties": { + "bandedRangeId": { + "type": "integer", + "format": "int32", + "description": "The ID of the banded range to delete." + } + }, + "description": "Removes the banded range with the given ID from the spreadsheet.", + "id": "DeleteBandingRequest", + "type": "object" + }, + "ErrorValue": { + "properties": { + "message": { + "description": "A message with more information about the error (in the spreadsheet's locale).", + "type": "string" + }, + "type": { + "description": "The type of error.", + "type": "string", + "enumDescriptions": [ + "The default error type, do not use this.", + "Corresponds to the `#ERROR!` error.", + "Corresponds to the `#NULL!` error.", + "Corresponds to the `#DIV/0` error.", + "Corresponds to the `#VALUE!` error.", + "Corresponds to the `#REF!` error.", + "Corresponds to the `#NAME?` error.", + "Corresponds to the `#NUM!` error.", + "Corresponds to the `#N/A` error.", + "Corresponds to the `Loading...` state." + ], + "enum": [ + "ERROR_TYPE_UNSPECIFIED", + "ERROR", + "NULL_VALUE", + "DIVIDE_BY_ZERO", + "VALUE", + "REF", + "NAME", + "NUM", + "N_A", + "LOADING" + ] + } + }, + "description": "An error in a cell.", + "id": "ErrorValue", + "type": "object" + }, + "ChartData": { + "id": "ChartData", + "description": "The data included in a domain or series.", + "properties": { + "groupRule": { + "$ref": "ChartGroupRule", + "description": "The rule to group the data by if the ChartData backs the domain of a data source chart. Not supported for regular charts." + }, + "columnReference": { + "description": "The reference to the data source column that the data reads from.", + "$ref": "DataSourceColumnReference" + }, + "aggregateType": { + "type": "string", + "description": "The aggregation type for the series of a data source chart. Not supported for regular charts.", + "enumDescriptions": [ + "Default value, do not use.", + "Average aggregate function.", + "Count aggregate function.", + "Maximum aggregate function.", + "Median aggregate function.", + "Minimum aggregate function.", + "Sum aggregate function." + ], + "enum": [ + "CHART_AGGREGATE_TYPE_UNSPECIFIED", + "AVERAGE", + "COUNT", + "MAX", + "MEDIAN", + "MIN", + "SUM" + ] + }, + "sourceRange": { + "$ref": "ChartSourceRange", + "description": "The source ranges of the data." + } + }, + "type": "object" + }, + "BasicFilter": { + "id": "BasicFilter", + "properties": { + "criteria": { + "type": "object", + "description": "The criteria for showing/hiding values per column. The map's key is the column index, and the value is the criteria for that column. This field is deprecated in favor of filter_specs.", + "additionalProperties": { + "$ref": "FilterCriteria" + } + }, + "range": { + "description": "The range the filter covers.", + "$ref": "GridRange" + }, + "sortSpecs": { + "description": "The sort order per column. Later specifications are used when values are equal in the earlier specifications.", + "items": { + "$ref": "SortSpec" + }, + "type": "array" + }, + "filterSpecs": { + "description": "The filter criteria per column. Both criteria and filter_specs are populated in responses. If both fields are specified in an update request, this field takes precedence.", + "type": "array", + "items": { + "$ref": "FilterSpec" + } + } + }, + "type": "object", + "description": "The default filter associated with a sheet." + }, + "DeleteFilterViewRequest": { + "description": "Deletes a particular filter view.", + "properties": { + "filterId": { + "description": "The ID of the filter to delete.", + "format": "int32", + "type": "integer" + } + }, + "type": "object", + "id": "DeleteFilterViewRequest" + }, + "DeveloperMetadataLookup": { + "description": "Selects DeveloperMetadata that matches all of the specified fields. For example, if only a metadata ID is specified this considers the DeveloperMetadata with that particular unique ID. If a metadata key is specified, this considers all developer metadata with that key. If a key, visibility, and location type are all specified, this considers all developer metadata with that key and visibility that are associated with a location of that type. In general, this selects all DeveloperMetadata that matches the intersection of all the specified fields; any field or combination of fields may be specified.", + "id": "DeveloperMetadataLookup", + "type": "object", + "properties": { + "locationMatchingStrategy": { + "type": "string", + "description": "Determines how this lookup matches the location. If this field is specified as EXACT, only developer metadata associated on the exact location specified is matched. If this field is specified to INTERSECTING, developer metadata associated on intersecting locations is also matched. If left unspecified, this field assumes a default value of INTERSECTING. If this field is specified, a metadataLocation must also be specified.", + "enumDescriptions": [ + "Default value. This value must not be used.", + "Indicates that a specified location should be matched exactly. For example, if row three were specified as a location this matching strategy would only match developer metadata also associated on row three. Metadata associated on other locations would not be considered.", + "Indicates that a specified location should match that exact location as well as any intersecting locations. For example, if row three were specified as a location this matching strategy would match developer metadata associated on row three as well as metadata associated on locations that intersect row three. If, for instance, there was developer metadata associated on column B, this matching strategy would also match that location because column B intersects row three." + ], + "enum": [ + "DEVELOPER_METADATA_LOCATION_MATCHING_STRATEGY_UNSPECIFIED", + "EXACT_LOCATION", + "INTERSECTING_LOCATION" + ] + }, + "metadataKey": { + "description": "Limits the selected developer metadata to that which has a matching DeveloperMetadata.metadata_key.", + "type": "string" + }, + "metadataId": { + "type": "integer", + "description": "Limits the selected developer metadata to that which has a matching DeveloperMetadata.metadata_id.", + "format": "int32" + }, + "metadataLocation": { + "description": "Limits the selected developer metadata to those entries associated with the specified location. This field either matches exact locations or all intersecting locations according the specified locationMatchingStrategy.", + "$ref": "DeveloperMetadataLocation" + }, + "locationType": { + "description": "Limits the selected developer metadata to those entries which are associated with locations of the specified type. For example, when this field is specified as ROW this lookup only considers developer metadata associated on rows. If the field is left unspecified, all location types are considered. This field cannot be specified as SPREADSHEET when the locationMatchingStrategy is specified as INTERSECTING or when the metadataLocation is specified as a non-spreadsheet location: spreadsheet metadata cannot intersect any other developer metadata location. This field also must be left unspecified when the locationMatchingStrategy is specified as EXACT.", + "enum": [ + "DEVELOPER_METADATA_LOCATION_TYPE_UNSPECIFIED", + "ROW", + "COLUMN", + "SHEET", + "SPREADSHEET" + ], + "type": "string", + "enumDescriptions": [ + "Default value.", + "Developer metadata associated on an entire row dimension.", + "Developer metadata associated on an entire column dimension.", + "Developer metadata associated on an entire sheet.", + "Developer metadata associated on the entire spreadsheet." + ] + }, + "visibility": { + "description": "Limits the selected developer metadata to that which has a matching DeveloperMetadata.visibility. If left unspecified, all developer metadata visibile to the requesting project is considered.", + "type": "string", + "enumDescriptions": [ + "Default value.", + "Document-visible metadata is accessible from any developer project with access to the document.", + "Project-visible metadata is only visible to and accessible by the developer project that created the metadata." + ], + "enum": [ + "DEVELOPER_METADATA_VISIBILITY_UNSPECIFIED", + "DOCUMENT", + "PROJECT" + ] + }, + "metadataValue": { + "description": "Limits the selected developer metadata to that which has a matching DeveloperMetadata.metadata_value.", + "type": "string" + } + } + }, + "ConditionValue": { + "description": "The value of the condition.", + "type": "object", + "properties": { + "relativeDate": { + "enum": [ + "RELATIVE_DATE_UNSPECIFIED", + "PAST_YEAR", + "PAST_MONTH", + "PAST_WEEK", + "YESTERDAY", + "TODAY", + "TOMORROW" + ], + "type": "string", + "enumDescriptions": [ + "Default value, do not use.", + "The value is one year before today.", + "The value is one month before today.", + "The value is one week before today.", + "The value is yesterday.", + "The value is today.", + "The value is tomorrow." + ], + "description": "A relative date (based on the current date). Valid only if the type is DATE_BEFORE, DATE_AFTER, DATE_ON_OR_BEFORE or DATE_ON_OR_AFTER. Relative dates are not supported in data validation. They are supported only in conditional formatting and conditional filters." + }, + "userEnteredValue": { + "description": "A value the condition is based on. The value is parsed as if the user typed into a cell. Formulas are supported (and must begin with an `=` or a '+').", + "type": "string" + } + }, + "id": "ConditionValue" + }, + "EmbeddedObjectPosition": { + "properties": { + "newSheet": { + "description": "If true, the embedded object is put on a new sheet whose ID is chosen for you. Used only when writing.", + "type": "boolean" + }, + "sheetId": { + "format": "int32", + "description": "The sheet this is on. Set only if the embedded object is on its own sheet. Must be non-negative.", + "type": "integer" + }, + "overlayPosition": { + "description": "The position at which the object is overlaid on top of a grid.", + "$ref": "OverlayPosition" + } + }, + "type": "object", + "id": "EmbeddedObjectPosition", + "description": "The position of an embedded object such as a chart." + }, + "AddNamedRangeRequest": { + "properties": { + "namedRange": { + "$ref": "NamedRange", + "description": "The named range to add. The namedRangeId field is optional; if one is not set, an id will be randomly generated. (It is an error to specify the ID of a range that already exists.)" + } + }, + "description": "Adds a named range to the spreadsheet.", + "id": "AddNamedRangeRequest", + "type": "object" + }, + "DeleteDuplicatesResponse": { + "properties": { + "duplicatesRemovedCount": { + "description": "The number of duplicate rows removed.", + "type": "integer", + "format": "int32" + } + }, + "id": "DeleteDuplicatesResponse", + "description": "The result of removing duplicates in a range.", + "type": "object" + }, + "RefreshDataSourceObjectExecutionStatus": { + "properties": { + "reference": { + "$ref": "DataSourceObjectReference", + "description": "Reference to a data source object being refreshed." + }, + "dataExecutionStatus": { + "description": "The data execution status.", + "$ref": "DataExecutionStatus" + } + }, + "description": "The execution status of refreshing one data source object.", + "type": "object", + "id": "RefreshDataSourceObjectExecutionStatus" + }, + "BubbleChartSpec": { + "type": "object", + "id": "BubbleChartSpec", + "properties": { + "bubbleLabels": { + "description": "The data containing the bubble labels. These do not need to be unique.", + "$ref": "ChartData" + }, + "bubbleSizes": { + "description": "The data contianing the bubble sizes. Bubble sizes are used to draw the bubbles at different sizes relative to each other. If specified, group_ids must also be specified. This field is optional.", + "$ref": "ChartData" + }, + "domain": { + "$ref": "ChartData", + "description": "The data containing the bubble x-values. These values locate the bubbles in the chart horizontally." + }, + "series": { + "$ref": "ChartData", + "description": "The data contianing the bubble y-values. These values locate the bubbles in the chart vertically." + }, + "legendPosition": { + "description": "Where the legend of the chart should be drawn.", + "enumDescriptions": [ + "Default value, do not use.", + "The legend is rendered on the bottom of the chart.", + "The legend is rendered on the left of the chart.", + "The legend is rendered on the right of the chart.", + "The legend is rendered on the top of the chart.", + "No legend is rendered.", + "The legend is rendered inside the chart area." + ], + "enum": [ + "BUBBLE_CHART_LEGEND_POSITION_UNSPECIFIED", + "BOTTOM_LEGEND", + "LEFT_LEGEND", + "RIGHT_LEGEND", + "TOP_LEGEND", + "NO_LEGEND", + "INSIDE_LEGEND" + ], + "type": "string" + }, + "bubbleOpacity": { + "format": "float", + "description": "The opacity of the bubbles between 0 and 1.0. 0 is fully transparent and 1 is fully opaque.", + "type": "number" + }, + "bubbleMaxRadiusSize": { + "type": "integer", + "description": "The max radius size of the bubbles, in pixels. If specified, the field must be a positive value.", + "format": "int32" + }, + "bubbleMinRadiusSize": { + "format": "int32", + "type": "integer", + "description": "The minimum radius size of the bubbles, in pixels. If specific, the field must be a positive value." + }, + "bubbleTextStyle": { + "$ref": "TextFormat", + "description": "The format of the text inside the bubbles. Strikethrough and underline are not supported." + }, + "bubbleBorderColor": { + "$ref": "Color", + "description": "The bubble border color." + }, + "groupIds": { + "$ref": "ChartData", + "description": "The data containing the bubble group IDs. All bubbles with the same group ID are drawn in the same color. If bubble_sizes is specified then this field must also be specified but may contain blank values. This field is optional." + }, + "bubbleBorderColorStyle": { + "description": "The bubble border color. If bubble_border_color is also set, this field takes precedence.", + "$ref": "ColorStyle" + } + }, + "description": "A bubble chart." + }, + "AppendDimensionRequest": { + "id": "AppendDimensionRequest", + "properties": { + "sheetId": { + "format": "int32", + "type": "integer", + "description": "The sheet to append rows or columns to." + }, + "dimension": { + "enum": [ + "DIMENSION_UNSPECIFIED", + "ROWS", + "COLUMNS" + ], + "description": "Whether rows or columns should be appended.", + "enumDescriptions": [ + "The default value, do not use.", + "Operates on the rows of a sheet.", + "Operates on the columns of a sheet." + ], + "type": "string" + }, + "length": { + "type": "integer", + "description": "The number of rows or columns to append.", + "format": "int32" + } + }, + "type": "object", + "description": "Appends rows or columns to the end of a sheet." + }, + "AddBandingResponse": { + "type": "object", + "description": "The result of adding a banded range.", + "properties": { + "bandedRange": { + "description": "The banded range that was added.", + "$ref": "BandedRange" + } + }, + "id": "AddBandingResponse" + }, + "DataSourceRefreshMonthlySchedule": { + "properties": { + "daysOfMonth": { + "description": "Days of the month to refresh. Only 1-28 are supported, mapping to the 1st to the 28th day. At lesat one day must be specified.", + "items": { + "format": "int32", + "type": "integer" + }, + "type": "array" + }, + "startTime": { + "$ref": "TimeOfDay", + "description": "The start time of a time interval in which a data source refresh is scheduled. Only `hours` part is used. The time interval size defaults to that in the Sheets editor." + } + }, + "type": "object", + "description": "A monthly schedule for data to refresh on specific days in the month in a given time interval.", + "id": "DataSourceRefreshMonthlySchedule" + }, + "EmbeddedObjectBorder": { + "properties": { + "color": { + "$ref": "Color", + "description": "The color of the border." + }, + "colorStyle": { + "$ref": "ColorStyle", + "description": "The color of the border. If color is also set, this field takes precedence." + } + }, + "type": "object", + "id": "EmbeddedObjectBorder", + "description": "A border along an embedded object." + }, + "Slicer": { + "properties": { + "position": { + "description": "The position of the slicer. Note that slicer can be positioned only on existing sheet. Also, width and height of slicer can be automatically adjusted to keep it within permitted limits.", + "$ref": "EmbeddedObjectPosition" + }, + "slicerId": { + "format": "int32", + "type": "integer", + "description": "The ID of the slicer." + }, + "spec": { + "$ref": "SlicerSpec", + "description": "The specification of the slicer." + } + }, + "description": "A slicer in a sheet.", + "id": "Slicer", + "type": "object" + }, + "WaterfallChartDomain": { + "description": "The domain of a waterfall chart.", + "properties": { + "data": { + "description": "The data of the WaterfallChartDomain.", + "$ref": "ChartData" + }, + "reversed": { + "type": "boolean", + "description": "True to reverse the order of the domain values (horizontal axis)." + } + }, + "id": "WaterfallChartDomain", + "type": "object" + }, + "UpdateSlicerSpecRequest": { + "type": "object", + "properties": { + "slicerId": { + "description": "The id of the slicer to update.", + "type": "integer", + "format": "int32" + }, + "fields": { + "type": "string", + "description": "The fields that should be updated. At least one field must be specified. The root `SlicerSpec` is implied and should not be specified. A single \"*\"` can be used as short-hand for listing every field.", + "format": "google-fieldmask" + }, + "spec": { + "$ref": "SlicerSpec", + "description": "The specification to apply to the slicer." + } + }, + "id": "UpdateSlicerSpecRequest", + "description": "Updates a slicer's specifications. (This does not move or resize a slicer. To move or resize a slicer use UpdateEmbeddedObjectPositionRequest." + }, + "BasicChartDomain": { + "type": "object", + "properties": { + "reversed": { + "description": "True to reverse the order of the domain values (horizontal axis).", + "type": "boolean" + }, + "domain": { + "description": "The data of the domain. For example, if charting stock prices over time, this is the data representing the dates.", + "$ref": "ChartData" + } + }, + "id": "BasicChartDomain", + "description": "The domain of a chart. For example, if charting stock prices over time, this would be the date." + }, + "HistogramSeries": { + "type": "object", + "description": "A histogram series containing the series color and data.", + "properties": { + "data": { + "$ref": "ChartData", + "description": "The data for this histogram series." + }, + "barColor": { + "$ref": "Color", + "description": "The color of the column representing this series in each bucket. This field is optional." + }, + "barColorStyle": { + "description": "The color of the column representing this series in each bucket. This field is optional. If bar_color is also set, this field takes precedence.", + "$ref": "ColorStyle" + } + }, + "id": "HistogramSeries" + }, + "FindReplaceResponse": { + "properties": { + "rowsChanged": { + "description": "The number of rows changed.", + "type": "integer", + "format": "int32" + }, + "sheetsChanged": { + "type": "integer", + "description": "The number of sheets changed.", + "format": "int32" + }, + "formulasChanged": { + "description": "The number of formula cells changed.", + "type": "integer", + "format": "int32" + }, + "valuesChanged": { + "type": "integer", + "format": "int32", + "description": "The number of non-formula cells changed." + }, + "occurrencesChanged": { + "description": "The number of occurrences (possibly multiple within a cell) changed. For example, if replacing `\"e\"` with `\"o\"` in `\"Google Sheets\"`, this would be `\"3\"` because `\"Google Sheets\"` -\u003e `\"Googlo Shoots\"`.", + "format": "int32", + "type": "integer" + } + }, + "id": "FindReplaceResponse", + "type": "object", + "description": "The result of the find/replace." + }, + "UpdateConditionalFormatRuleResponse": { + "properties": { + "newIndex": { + "description": "The index of the new rule.", + "format": "int32", + "type": "integer" + }, + "oldIndex": { + "description": "The old index of the rule. Not set if a rule was replaced (because it is the same as new_index).", + "format": "int32", + "type": "integer" + }, + "newRule": { + "$ref": "ConditionalFormatRule", + "description": "The new rule that replaced the old rule (if replacing), or the rule that was moved (if moved)" + }, + "oldRule": { + "$ref": "ConditionalFormatRule", + "description": "The old (deleted) rule. Not set if a rule was moved (because it is the same as new_rule)." + } + }, + "type": "object", + "id": "UpdateConditionalFormatRuleResponse", + "description": "The result of updating a conditional format rule." + }, + "MergeCellsRequest": { + "properties": { + "range": { + "$ref": "GridRange", + "description": "The range of cells to merge." + }, + "mergeType": { + "type": "string", + "description": "How the cells should be merged.", + "enum": [ + "MERGE_ALL", + "MERGE_COLUMNS", + "MERGE_ROWS" + ], + "enumDescriptions": [ + "Create a single merge from the range", + "Create a merge for each column in the range", + "Create a merge for each row in the range" + ] + } + }, + "type": "object", + "id": "MergeCellsRequest", + "description": "Merges all cells in the range." + }, + "DimensionRange": { + "type": "object", + "description": "A range along a single dimension on a sheet. All indexes are zero-based. Indexes are half open: the start index is inclusive and the end index is exclusive. Missing indexes indicate the range is unbounded on that side.", + "id": "DimensionRange", + "properties": { + "dimension": { + "description": "The dimension of the span.", + "enumDescriptions": [ + "The default value, do not use.", + "Operates on the rows of a sheet.", + "Operates on the columns of a sheet." + ], + "enum": [ + "DIMENSION_UNSPECIFIED", + "ROWS", + "COLUMNS" + ], + "type": "string" + }, + "sheetId": { + "type": "integer", + "format": "int32", + "description": "The sheet this span is on." + }, + "startIndex": { + "description": "The start (inclusive) of the span, or not set if unbounded.", + "format": "int32", + "type": "integer" + }, + "endIndex": { + "description": "The end (exclusive) of the span, or not set if unbounded.", + "format": "int32", + "type": "integer" + } + } + }, + "DeleteDeveloperMetadataResponse": { + "type": "object", + "id": "DeleteDeveloperMetadataResponse", + "description": "The response from deleting developer metadata.", + "properties": { + "deletedDeveloperMetadata": { + "type": "array", + "description": "The metadata that was deleted.", + "items": { + "$ref": "DeveloperMetadata" + } + } + } + }, + "UpdateEmbeddedObjectBorderRequest": { + "description": "Updates an embedded object's border property.", + "properties": { + "border": { + "$ref": "EmbeddedObjectBorder", + "description": "The border that applies to the embedded object." + }, + "fields": { + "format": "google-fieldmask", + "description": "The fields that should be updated. At least one field must be specified. The root `border` is implied and should not be specified. A single `\"*\"` can be used as short-hand for listing every field.", + "type": "string" + }, + "objectId": { + "description": "The ID of the embedded object to update.", + "format": "int32", + "type": "integer" + } + }, + "type": "object", + "id": "UpdateEmbeddedObjectBorderRequest" + }, + "DataSourceSpec": { + "description": "This specifies the details of the data source. For example, for BigQuery, this specifies information about the BigQuery source.", + "properties": { + "bigQuery": { + "$ref": "BigQueryDataSourceSpec", + "description": "A BigQueryDataSourceSpec." + }, + "parameters": { + "description": "The parameters of the data source, used when querying the data source.", + "type": "array", + "items": { + "$ref": "DataSourceParameter" + } + } + }, + "id": "DataSourceSpec", + "type": "object" + }, + "TextFormatRun": { + "properties": { + "format": { + "$ref": "TextFormat", + "description": "The format of this run. Absent values inherit the cell's format." + }, + "startIndex": { + "type": "integer", + "description": "The character index where this run starts.", + "format": "int32" + } + }, + "id": "TextFormatRun", + "type": "object", + "description": "A run of a text format. The format of this run continues until the start index of the next run. When updating, all fields must be set." + }, + "InsertDimensionRequest": { + "type": "object", + "properties": { + "range": { + "description": "The dimensions to insert. Both the start and end indexes must be bounded.", + "$ref": "DimensionRange" + }, + "inheritFromBefore": { + "description": "Whether dimension properties should be extended from the dimensions before or after the newly inserted dimensions. True to inherit from the dimensions before (in which case the start index must be greater than 0), and false to inherit from the dimensions after. For example, if row index 0 has red background and row index 1 has a green background, then inserting 2 rows at index 1 can inherit either the green or red background. If `inheritFromBefore` is true, the two new rows will be red (because the row before the insertion point was red), whereas if `inheritFromBefore` is false, the two new rows will be green (because the row after the insertion point was green).", + "type": "boolean" + } + }, + "description": "Inserts rows or columns in a sheet at a particular index.", + "id": "InsertDimensionRequest" + }, + "DuplicateSheetResponse": { + "type": "object", + "description": "The result of duplicating a sheet.", + "properties": { + "properties": { + "$ref": "SheetProperties", + "description": "The properties of the duplicate sheet." + } + }, + "id": "DuplicateSheetResponse" + }, + "DeleteDimensionGroupRequest": { + "description": "Deletes a group over the specified range by decrementing the depth of the dimensions in the range. For example, assume the sheet has a depth-1 group over B:E and a depth-2 group over C:D. Deleting a group over D:E leaves the sheet with a depth-1 group over B:D and a depth-2 group over C:C.", + "properties": { + "range": { + "description": "The range of the group to be deleted.", + "$ref": "DimensionRange" + } + }, + "id": "DeleteDimensionGroupRequest", + "type": "object" + }, + "NamedRange": { + "properties": { + "name": { + "description": "The name of the named range.", + "type": "string" + }, + "namedRangeId": { + "description": "The ID of the named range.", + "type": "string" + }, + "range": { + "description": "The range this represents.", + "$ref": "GridRange" + } + }, + "description": "A named range.", + "type": "object", + "id": "NamedRange" + }, + "NumberFormat": { + "id": "NumberFormat", + "type": "object", + "properties": { + "type": { + "description": "The type of the number format. When writing, this field must be set.", + "enum": [ + "NUMBER_FORMAT_TYPE_UNSPECIFIED", + "TEXT", + "NUMBER", + "PERCENT", + "CURRENCY", + "DATE", + "TIME", + "DATE_TIME", + "SCIENTIFIC" + ], + "type": "string", + "enumDescriptions": [ + "The number format is not specified and is based on the contents of the cell. Do not explicitly use this.", + "Text formatting, e.g `1000.12`", + "Number formatting, e.g, `1,000.12`", + "Percent formatting, e.g `10.12%`", + "Currency formatting, e.g `$1,000.12`", + "Date formatting, e.g `9/26/2008`", + "Time formatting, e.g `3:59:00 PM`", + "Date+Time formatting, e.g `9/26/08 15:59:00`", + "Scientific number formatting, e.g `1.01E+03`" + ] + }, + "pattern": { + "type": "string", + "description": "Pattern string used for formatting. If not set, a default pattern based on the user's locale will be used if necessary for the given type. See the [Date and Number Formats guide](/sheets/api/guides/formats) for more information about the supported patterns." + } + }, + "description": "The number format of a cell." + }, + "AddSlicerResponse": { + "type": "object", + "properties": { + "slicer": { + "description": "The newly added slicer.", + "$ref": "Slicer" + } + }, + "id": "AddSlicerResponse", + "description": "The result of adding a slicer to a spreadsheet." + }, + "HistogramChartSpec": { + "id": "HistogramChartSpec", + "description": "A histogram chart. A histogram chart groups data items into bins, displaying each bin as a column of stacked items. Histograms are used to display the distribution of a dataset. Each column of items represents a range into which those items fall. The number of bins can be chosen automatically or specified explicitly.", + "properties": { + "legendPosition": { + "description": "The position of the chart legend.", + "type": "string", + "enumDescriptions": [ + "Default value, do not use.", + "The legend is rendered on the bottom of the chart.", + "The legend is rendered on the left of the chart.", + "The legend is rendered on the right of the chart.", + "The legend is rendered on the top of the chart.", + "No legend is rendered.", + "The legend is rendered inside the chart area." + ], + "enum": [ + "HISTOGRAM_CHART_LEGEND_POSITION_UNSPECIFIED", + "BOTTOM_LEGEND", + "LEFT_LEGEND", + "RIGHT_LEGEND", + "TOP_LEGEND", + "NO_LEGEND", + "INSIDE_LEGEND" + ] + }, + "series": { + "items": { + "$ref": "HistogramSeries" + }, + "description": "The series for a histogram may be either a single series of values to be bucketed or multiple series, each of the same length, containing the name of the series followed by the values to be bucketed for that series.", + "type": "array" + }, + "bucketSize": { + "type": "number", + "description": "By default the bucket size (the range of values stacked in a single column) is chosen automatically, but it may be overridden here. E.g., A bucket size of 1.5 results in buckets from 0 - 1.5, 1.5 - 3.0, etc. Cannot be negative. This field is optional.", + "format": "double" + }, + "outlierPercentile": { + "format": "double", + "description": "The outlier percentile is used to ensure that outliers do not adversely affect the calculation of bucket sizes. For example, setting an outlier percentile of 0.05 indicates that the top and bottom 5% of values when calculating buckets. The values are still included in the chart, they will be added to the first or last buckets instead of their own buckets. Must be between 0.0 and 0.5.", + "type": "number" + }, + "showItemDividers": { + "description": "Whether horizontal divider lines should be displayed between items in each column.", + "type": "boolean" + } + }, + "type": "object" + }, + "DeleteSheetRequest": { + "description": "Deletes the requested sheet.", + "type": "object", + "id": "DeleteSheetRequest", + "properties": { + "sheetId": { + "type": "integer", + "description": "The ID of the sheet to delete. If the sheet is of SheetType.DATA_SOURCE type, the associated DataSource is also deleted.", + "format": "int32" + } + } + }, + "ChartDateTimeRule": { + "type": "object", + "properties": { + "type": { + "enumDescriptions": [ + "The default type, do not use.", + "Group dates by second, from 0 to 59.", + "Group dates by minute, from 0 to 59.", + "Group dates by hour using a 24-hour system, from 0 to 23.", + "Group dates by hour and minute using a 24-hour system, for example 19:45.", + "Group dates by hour and minute using a 12-hour system, for example 7:45 PM. The AM/PM designation is translated based on the spreadsheet locale.", + "Group dates by day of week, for example Sunday. The days of the week will be translated based on the spreadsheet locale.", + "Group dates by day of year, from 1 to 366. Note that dates after Feb. 29 fall in different buckets in leap years than in non-leap years.", + "Group dates by day of month, from 1 to 31.", + "Group dates by day and month, for example 22-Nov. The month is translated based on the spreadsheet locale.", + "Group dates by month, for example Nov. The month is translated based on the spreadsheet locale.", + "Group dates by quarter, for example Q1 (which represents Jan-Mar).", + "Group dates by year, for example 2008.", + "Group dates by year and month, for example 2008-Nov. The month is translated based on the spreadsheet locale.", + "Group dates by year and quarter, for example 2008 Q4.", + "Group dates by year, month, and day, for example 2008-11-22." + ], + "description": "The type of date-time grouping to apply.", + "enum": [ + "CHART_DATE_TIME_RULE_TYPE_UNSPECIFIED", + "SECOND", + "MINUTE", + "HOUR", + "HOUR_MINUTE", + "HOUR_MINUTE_AMPM", + "DAY_OF_WEEK", + "DAY_OF_YEAR", + "DAY_OF_MONTH", + "DAY_MONTH", + "MONTH", + "QUARTER", + "YEAR", + "YEAR_MONTH", + "YEAR_QUARTER", + "YEAR_MONTH_DAY" + ], + "type": "string" + } + }, + "id": "ChartDateTimeRule", + "description": "Allows you to organize the date-time values in a source data column into buckets based on selected parts of their date or time values." + }, + "ManualRule": { + "type": "object", + "properties": { + "groups": { + "type": "array", + "description": "The list of group names and the corresponding items from the source data that map to each group name.", + "items": { + "$ref": "ManualRuleGroup" + } + } + }, + "id": "ManualRule", + "description": "Allows you to manually organize the values in a source data column into buckets with names of your choosing. For example, a pivot table that aggregates population by state: +-------+-------------------+ | State | SUM of Population | +-------+-------------------+ | AK | 0.7 | | AL | 4.8 | | AR | 2.9 | ... +-------+-------------------+ could be turned into a pivot table that aggregates population by time zone by providing a list of groups (for example, groupName = 'Central', items = ['AL', 'AR', 'IA', ...]) to a manual group rule. Note that a similar effect could be achieved by adding a time zone column to the source data and adjusting the pivot table. +-----------+-------------------+ | Time Zone | SUM of Population | +-----------+-------------------+ | Central | 106.3 | | Eastern | 151.9 | | Mountain | 17.4 | ... +-----------+-------------------+" + }, + "BooleanCondition": { + "type": "object", + "id": "BooleanCondition", + "properties": { + "type": { + "type": "string", + "enum": [ + "CONDITION_TYPE_UNSPECIFIED", + "NUMBER_GREATER", + "NUMBER_GREATER_THAN_EQ", + "NUMBER_LESS", + "NUMBER_LESS_THAN_EQ", + "NUMBER_EQ", + "NUMBER_NOT_EQ", + "NUMBER_BETWEEN", + "NUMBER_NOT_BETWEEN", + "TEXT_CONTAINS", + "TEXT_NOT_CONTAINS", + "TEXT_STARTS_WITH", + "TEXT_ENDS_WITH", + "TEXT_EQ", + "TEXT_IS_EMAIL", + "TEXT_IS_URL", + "DATE_EQ", + "DATE_BEFORE", + "DATE_AFTER", + "DATE_ON_OR_BEFORE", + "DATE_ON_OR_AFTER", + "DATE_BETWEEN", + "DATE_NOT_BETWEEN", + "DATE_IS_VALID", + "ONE_OF_RANGE", + "ONE_OF_LIST", + "BLANK", + "NOT_BLANK", + "CUSTOM_FORMULA", + "BOOLEAN", + "TEXT_NOT_EQ", + "DATE_NOT_EQ" + ], + "enumDescriptions": [ + "The default value, do not use.", + "The cell's value must be greater than the condition's value. Supported by data validation, conditional formatting and filters. Requires a single ConditionValue.", + "The cell's value must be greater than or equal to the condition's value. Supported by data validation, conditional formatting and filters. Requires a single ConditionValue.", + "The cell's value must be less than the condition's value. Supported by data validation, conditional formatting and filters. Requires a single ConditionValue.", + "The cell's value must be less than or equal to the condition's value. Supported by data validation, conditional formatting and filters. Requires a single ConditionValue.", + "The cell's value must be equal to the condition's value. Supported by data validation, conditional formatting and filters. Requires a single ConditionValue for data validation, conditional formatting, and filters on non-data source objects and at least one ConditionValue for filters on data source objects.", + "The cell's value must be not equal to the condition's value. Supported by data validation, conditional formatting and filters. Requires a single ConditionValue for data validation, conditional formatting, and filters on non-data source objects and at least one ConditionValue for filters on data source objects.", + "The cell's value must be between the two condition values. Supported by data validation, conditional formatting and filters. Requires exactly two ConditionValues.", + "The cell's value must not be between the two condition values. Supported by data validation, conditional formatting and filters. Requires exactly two ConditionValues.", + "The cell's value must contain the condition's value. Supported by data validation, conditional formatting and filters. Requires a single ConditionValue.", + "The cell's value must not contain the condition's value. Supported by data validation, conditional formatting and filters. Requires a single ConditionValue.", + "The cell's value must start with the condition's value. Supported by conditional formatting and filters. Requires a single ConditionValue.", + "The cell's value must end with the condition's value. Supported by conditional formatting and filters. Requires a single ConditionValue.", + "The cell's value must be exactly the condition's value. Supported by data validation, conditional formatting and filters. Requires a single ConditionValue for data validation, conditional formatting, and filters on non-data source objects and at least one ConditionValue for filters on data source objects.", + "The cell's value must be a valid email address. Supported by data validation. Requires no ConditionValues.", + "The cell's value must be a valid URL. Supported by data validation. Requires no ConditionValues.", + "The cell's value must be the same date as the condition's value. Supported by data validation, conditional formatting and filters. Requires a single ConditionValue for data validation, conditional formatting, and filters on non-data source objects and at least one ConditionValue for filters on data source objects.", + "The cell's value must be before the date of the condition's value. Supported by data validation, conditional formatting and filters. Requires a single ConditionValue that may be a relative date.", + "The cell's value must be after the date of the condition's value. Supported by data validation, conditional formatting and filters. Requires a single ConditionValue that may be a relative date.", + "The cell's value must be on or before the date of the condition's value. Supported by data validation. Requires a single ConditionValue that may be a relative date.", + "The cell's value must be on or after the date of the condition's value. Supported by data validation. Requires a single ConditionValue that may be a relative date.", + "The cell's value must be between the dates of the two condition values. Supported by data validation. Requires exactly two ConditionValues.", + "The cell's value must be outside the dates of the two condition values. Supported by data validation. Requires exactly two ConditionValues.", + "The cell's value must be a date. Supported by data validation. Requires no ConditionValues.", + "The cell's value must be listed in the grid in condition value's range. Supported by data validation. Requires a single ConditionValue, and the value must be a valid range in A1 notation.", + "The cell's value must be in the list of condition values. Supported by data validation. Supports any number of condition values, one per item in the list. Formulas are not supported in the values.", + "The cell's value must be empty. Supported by conditional formatting and filters. Requires no ConditionValues.", + "The cell's value must not be empty. Supported by conditional formatting and filters. Requires no ConditionValues.", + "The condition's formula must evaluate to true. Supported by data validation, conditional formatting and filters. Not supported by data source sheet filters. Requires a single ConditionValue.", + "The cell's value must be TRUE/FALSE or in the list of condition values. Supported by data validation. Renders as a cell checkbox. Supports zero, one or two ConditionValues. No values indicates the cell must be TRUE or FALSE, where TRUE renders as checked and FALSE renders as unchecked. One value indicates the cell will render as checked when it contains that value and unchecked when it is blank. Two values indicate that the cell will render as checked when it contains the first value and unchecked when it contains the second value. For example, [\"Yes\",\"No\"] indicates that the cell will render a checked box when it has the value \"Yes\" and an unchecked box when it has the value \"No\".", + "The cell's value must be exactly not the condition's value. Supported by filters on data source objects. Requires at least one ConditionValue.", + "The cell's value must be exactly not the condition's value. Supported by filters on data source objects. Requires at least one ConditionValue." + ], + "description": "The type of condition." + }, + "values": { + "description": "The values of the condition. The number of supported values depends on the condition type. Some support zero values, others one or two values, and ConditionType.ONE_OF_LIST supports an arbitrary number of values.", + "type": "array", + "items": { + "$ref": "ConditionValue" + } + } + }, + "description": "A condition that can evaluate to true or false. BooleanConditions are used by conditional formatting, data validation, and the criteria in filters." + }, + "SourceAndDestination": { + "properties": { + "dimension": { + "enumDescriptions": [ + "The default value, do not use.", + "Operates on the rows of a sheet.", + "Operates on the columns of a sheet." + ], + "description": "The dimension that data should be filled into.", + "enum": [ + "DIMENSION_UNSPECIFIED", + "ROWS", + "COLUMNS" + ], + "type": "string" + }, + "fillLength": { + "description": "The number of rows or columns that data should be filled into. Positive numbers expand beyond the last row or last column of the source. Negative numbers expand before the first row or first column of the source.", + "type": "integer", + "format": "int32" + }, + "source": { + "description": "The location of the data to use as the source of the autofill.", + "$ref": "GridRange" + } + }, + "type": "object", + "description": "A combination of a source range and how to extend that source.", + "id": "SourceAndDestination" + }, + "ThemeColorPair": { + "id": "ThemeColorPair", + "properties": { + "color": { + "$ref": "ColorStyle", + "description": "The concrete color corresponding to the theme color type." + }, + "colorType": { + "type": "string", + "enumDescriptions": [ + "Unspecified theme color", + "Represents the primary text color", + "Represents the primary background color", + "Represents the first accent color", + "Represents the second accent color", + "Represents the third accent color", + "Represents the fourth accent color", + "Represents the fifth accent color", + "Represents the sixth accent color", + "Represents the color to use for hyperlinks" + ], + "description": "The type of the spreadsheet theme color.", + "enum": [ + "THEME_COLOR_TYPE_UNSPECIFIED", + "TEXT", + "BACKGROUND", + "ACCENT1", + "ACCENT2", + "ACCENT3", + "ACCENT4", + "ACCENT5", + "ACCENT6", + "LINK" + ] + } + }, + "type": "object", + "description": "A pair mapping a spreadsheet theme color type to the concrete color it represents." + }, + "FilterSpec": { + "id": "FilterSpec", + "description": "The filter criteria associated with a specific column.", + "type": "object", + "properties": { + "dataSourceColumnReference": { + "$ref": "DataSourceColumnReference", + "description": "Reference to a data source column." + }, + "columnIndex": { + "format": "int32", + "type": "integer", + "description": "The column index." + }, + "filterCriteria": { + "$ref": "FilterCriteria", + "description": "The criteria for the column." + } + } + }, + "PointStyle": { + "id": "PointStyle", + "description": "The style of a point on the chart.", + "properties": { + "shape": { + "enum": [ + "POINT_SHAPE_UNSPECIFIED", + "CIRCLE", + "DIAMOND", + "HEXAGON", + "PENTAGON", + "SQUARE", + "STAR", + "TRIANGLE", + "X_MARK" + ], + "description": "The point shape. If empty or unspecified, a default shape is used.", + "type": "string", + "enumDescriptions": [ + "Default value.", + "A circle shape.", + "A diamond shape.", + "A hexagon shape.", + "A pentagon shape.", + "A square shape.", + "A star shape.", + "A triangle shape.", + "An x-mark shape." + ] + }, + "size": { + "type": "number", + "description": "The point size. If empty, a default size is used.", + "format": "double" + } + }, + "type": "object" + }, + "DeleteNamedRangeRequest": { + "properties": { + "namedRangeId": { + "type": "string", + "description": "The ID of the named range to delete." + } + }, + "type": "object", + "id": "DeleteNamedRangeRequest", + "description": "Removes the named range with the given ID from the spreadsheet." + }, + "SearchDeveloperMetadataResponse": { + "properties": { + "matchedDeveloperMetadata": { + "items": { + "$ref": "MatchedDeveloperMetadata" + }, + "description": "The metadata matching the criteria of the search request.", + "type": "array" + } + }, + "id": "SearchDeveloperMetadataResponse", + "description": "A reply to a developer metadata search request.", + "type": "object" + }, + "RefreshDataSourceResponse": { + "description": "The response from refreshing one or multiple data source objects.", + "properties": { + "statuses": { + "items": { + "$ref": "RefreshDataSourceObjectExecutionStatus" + }, + "type": "array", + "description": "All the refresh status for the data source object references specified in the request. If is_all is specified, the field contains only those in failure status." + } + }, + "id": "RefreshDataSourceResponse", + "type": "object" + }, + "AddBandingRequest": { + "id": "AddBandingRequest", + "description": "Adds a new banded range to the spreadsheet.", + "properties": { + "bandedRange": { + "$ref": "BandedRange", + "description": "The banded range to add. The bandedRangeId field is optional; if one is not set, an id will be randomly generated. (It is an error to specify the ID of a range that already exists.)" + } + }, + "type": "object" + }, + "GridProperties": { + "id": "GridProperties", + "type": "object", + "description": "Properties of a grid.", + "properties": { + "hideGridlines": { + "type": "boolean", + "description": "True if the grid isn't showing gridlines in the UI." + }, + "frozenColumnCount": { + "type": "integer", + "description": "The number of columns that are frozen in the grid.", + "format": "int32" + }, + "rowCount": { + "description": "The number of rows in the grid.", + "type": "integer", + "format": "int32" + }, + "columnGroupControlAfter": { + "type": "boolean", + "description": "True if the column grouping control toggle is shown after the group." + }, + "columnCount": { + "format": "int32", + "description": "The number of columns in the grid.", + "type": "integer" + }, + "frozenRowCount": { + "type": "integer", + "format": "int32", + "description": "The number of rows that are frozen in the grid." + }, + "rowGroupControlAfter": { + "description": "True if the row grouping control toggle is shown after the group.", + "type": "boolean" + } + } + }, + "UpdateNamedRangeRequest": { + "type": "object", + "properties": { + "fields": { + "type": "string", + "description": "The fields that should be updated. At least one field must be specified. The root `namedRange` is implied and should not be specified. A single `\"*\"` can be used as short-hand for listing every field.", + "format": "google-fieldmask" + }, + "namedRange": { + "description": "The named range to update with the new properties.", + "$ref": "NamedRange" + } + }, + "id": "UpdateNamedRangeRequest", + "description": "Updates properties of the named range with the specified namedRangeId." + }, + "TextToColumnsRequest": { + "id": "TextToColumnsRequest", + "description": "Splits a column of text into multiple columns, based on a delimiter in each cell.", + "properties": { + "delimiter": { + "description": "The delimiter to use. Used only if delimiterType is CUSTOM.", + "type": "string" + }, + "source": { + "$ref": "GridRange", + "description": "The source data range. This must span exactly one column." + }, + "delimiterType": { + "enum": [ + "DELIMITER_TYPE_UNSPECIFIED", + "COMMA", + "SEMICOLON", + "PERIOD", + "SPACE", + "CUSTOM", + "AUTODETECT" + ], + "type": "string", + "enumDescriptions": [ + "Default value. This value must not be used.", + "\",\"", + "\";\"", + "\".\"", + "\" \"", + "A custom value as defined in delimiter.", + "Automatically detect columns." + ], + "description": "The delimiter type to use." + } + }, + "type": "object" + }, + "DataSourceSheetProperties": { + "id": "DataSourceSheetProperties", + "description": "Additional properties of a DATA_SOURCE sheet.", + "properties": { + "dataExecutionStatus": { + "description": "The data execution status.", + "$ref": "DataExecutionStatus" + }, + "columns": { + "type": "array", + "items": { + "$ref": "DataSourceColumn" + }, + "description": "The columns displayed on the sheet, corresponding to the values in RowData." + }, + "dataSourceId": { + "description": "ID of the DataSource the sheet is connected to.", + "type": "string" + } + }, + "type": "object" + }, + "DataValidationRule": { + "description": "A data validation rule.", + "type": "object", + "id": "DataValidationRule", + "properties": { + "condition": { + "$ref": "BooleanCondition", + "description": "The condition that data in the cell must match." + }, + "inputMessage": { + "type": "string", + "description": "A message to show the user when adding data to the cell." + }, + "strict": { + "type": "boolean", + "description": "True if invalid data should be rejected." + }, + "showCustomUi": { + "description": "True if the UI should be customized based on the kind of condition. If true, \"List\" conditions will show a dropdown.", + "type": "boolean" + } + } + }, + "UpdateDimensionGroupRequest": { + "id": "UpdateDimensionGroupRequest", + "description": "Updates the state of the specified group.", + "type": "object", + "properties": { + "fields": { + "format": "google-fieldmask", + "description": "The fields that should be updated. At least one field must be specified. The root `dimensionGroup` is implied and should not be specified. A single `\"*\"` can be used as short-hand for listing every field.", + "type": "string" + }, + "dimensionGroup": { + "$ref": "DimensionGroup", + "description": "The group whose state should be updated. The range and depth of the group should specify a valid group on the sheet, and all other fields updated." + } + } + }, + "DeleteDimensionRequest": { + "properties": { + "range": { + "$ref": "DimensionRange", + "description": "The dimensions to delete from the sheet." + } + }, + "type": "object", + "id": "DeleteDimensionRequest", + "description": "Deletes the dimensions from the sheet." + }, + "DeleteConditionalFormatRuleResponse": { + "description": "The result of deleting a conditional format rule.", + "properties": { + "rule": { + "$ref": "ConditionalFormatRule", + "description": "The rule that was deleted." + } + }, + "id": "DeleteConditionalFormatRuleResponse", + "type": "object" + }, + "BatchGetValuesByDataFilterRequest": { + "id": "BatchGetValuesByDataFilterRequest", + "description": "The request for retrieving a range of values in a spreadsheet selected by a set of DataFilters.", + "type": "object", + "properties": { + "dateTimeRenderOption": { + "description": "How dates, times, and durations should be represented in the output. This is ignored if value_render_option is FORMATTED_VALUE. The default dateTime render option is [DateTimeRenderOption.SERIAL_NUMBER].", + "enumDescriptions": [ + "Instructs date, time, datetime, and duration fields to be output as doubles in \"serial number\" format, as popularized by Lotus 1-2-3. The whole number portion of the value (left of the decimal) counts the days since December 30th 1899. The fractional portion (right of the decimal) counts the time as a fraction of the day. For example, January 1st 1900 at noon would be 2.5, 2 because it's 2 days after December 30st 1899, and .5 because noon is half a day. February 1st 1900 at 3pm would be 33.625. This correctly treats the year 1900 as not a leap year.", + "Instructs date, time, datetime, and duration fields to be output as strings in their given number format (which is dependent on the spreadsheet locale)." + ], + "type": "string", + "enum": [ + "SERIAL_NUMBER", + "FORMATTED_STRING" + ] + }, + "majorDimension": { + "type": "string", + "enum": [ + "DIMENSION_UNSPECIFIED", + "ROWS", + "COLUMNS" + ], + "description": "The major dimension that results should use. For example, if the spreadsheet data is: `A1=1,B1=2,A2=3,B2=4`, then a request that selects that range and sets `majorDimension=ROWS` returns `[[1,2],[3,4]]`, whereas a request that sets `majorDimension=COLUMNS` returns `[[1,3],[2,4]]`.", + "enumDescriptions": [ + "The default value, do not use.", + "Operates on the rows of a sheet.", + "Operates on the columns of a sheet." + ] + }, + "dataFilters": { + "items": { + "$ref": "DataFilter" + }, + "type": "array", + "description": "The data filters used to match the ranges of values to retrieve. Ranges that match any of the specified data filters are included in the response." + }, + "valueRenderOption": { + "enum": [ + "FORMATTED_VALUE", + "UNFORMATTED_VALUE", + "FORMULA" + ], + "description": "How values should be represented in the output. The default render option is ValueRenderOption.FORMATTED_VALUE.", + "enumDescriptions": [ + "Values will be calculated & formatted in the reply according to the cell's formatting. Formatting is based on the spreadsheet's locale, not the requesting user's locale. For example, if `A1` is `1.23` and `A2` is `=A1` and formatted as currency, then `A2` would return `\"$1.23\"`.", + "Values will be calculated, but not formatted in the reply. For example, if `A1` is `1.23` and `A2` is `=A1` and formatted as currency, then `A2` would return the number `1.23`.", + "Values will not be calculated. The reply will include the formulas. For example, if `A1` is `1.23` and `A2` is `=A1` and formatted as currency, then A2 would return `\"=A1\"`." + ], + "type": "string" + } + } + }, + "AutoFillRequest": { + "description": "Fills in more data based on existing data.", + "properties": { + "sourceAndDestination": { + "$ref": "SourceAndDestination", + "description": "The source and destination areas to autofill. This explicitly lists the source of the autofill and where to extend that data." + }, + "useAlternateSeries": { + "type": "boolean", + "description": "True if we should generate data with the \"alternate\" series. This differs based on the type and amount of source data." + }, + "range": { + "description": "The range to autofill. This will examine the range and detect the location that has data and automatically fill that data in to the rest of the range.", + "$ref": "GridRange" + } + }, + "type": "object", + "id": "AutoFillRequest" + }, + "SortSpec": { + "properties": { + "dataSourceColumnReference": { + "$ref": "DataSourceColumnReference", + "description": "Reference to a data source column." + }, + "backgroundColorStyle": { + "$ref": "ColorStyle", + "description": "The background fill color to sort by; cells with this fill color are sorted to the top. Mutually exclusive with foreground_color, and must be an RGB-type color. If background_color is also set, this field takes precedence." + }, + "dimensionIndex": { + "type": "integer", + "format": "int32", + "description": "The dimension the sort should be applied to." + }, + "backgroundColor": { + "$ref": "Color", + "description": "The background fill color to sort by; cells with this fill color are sorted to the top. Mutually exclusive with foreground_color." + }, + "sortOrder": { + "type": "string", + "enumDescriptions": [ + "Default value, do not use this.", + "Sort ascending.", + "Sort descending." + ], + "enum": [ + "SORT_ORDER_UNSPECIFIED", + "ASCENDING", + "DESCENDING" + ], + "description": "The order data should be sorted." + }, + "foregroundColor": { + "$ref": "Color", + "description": "The foreground color to sort by; cells with this foreground color are sorted to the top. Mutually exclusive with background_color." + }, + "foregroundColorStyle": { + "$ref": "ColorStyle", + "description": "The foreground color to sort by; cells with this foreground color are sorted to the top. Mutually exclusive with background_color, and must be an RGB-type color. If foreground_color is also set, this field takes precedence." + } + }, + "type": "object", + "description": "A sort order associated with a specific column or row.", + "id": "SortSpec" + }, + "CandlestickData": { + "id": "CandlestickData", + "type": "object", + "description": "The Candlestick chart data, each containing the low, open, close, and high values for a series.", + "properties": { + "closeSeries": { + "description": "The range data (vertical axis) for the close/final value for each candle. This is the top of the candle body. If greater than the open value the candle will be filled. Otherwise the candle will be hollow.", + "$ref": "CandlestickSeries" + }, + "openSeries": { + "description": "The range data (vertical axis) for the open/initial value for each candle. This is the bottom of the candle body. If less than the close value the candle will be filled. Otherwise the candle will be hollow.", + "$ref": "CandlestickSeries" + }, + "highSeries": { + "description": "The range data (vertical axis) for the high/maximum value for each candle. This is the top of the candle's center line.", + "$ref": "CandlestickSeries" + }, + "lowSeries": { + "$ref": "CandlestickSeries", + "description": "The range data (vertical axis) for the low/minimum value for each candle. This is the bottom of the candle's center line." + } + } + }, + "Color": { + "id": "Color", + "properties": { + "red": { + "type": "number", + "description": "The amount of red in the color as a value in the interval [0, 1].", + "format": "float" + }, + "alpha": { + "type": "number", + "description": "The fraction of this color that should be applied to the pixel. That is, the final pixel color is defined by the equation: pixel color = alpha * (this color) + (1.0 - alpha) * (background color) This means that a value of 1.0 corresponds to a solid color, whereas a value of 0.0 corresponds to a completely transparent color. This uses a wrapper message rather than a simple float scalar so that it is possible to distinguish between a default value and the value being unset. If omitted, this color object is to be rendered as a solid color (as if the alpha value had been explicitly given with a value of 1.0).", + "format": "float" + }, + "blue": { + "format": "float", + "description": "The amount of blue in the color as a value in the interval [0, 1].", + "type": "number" + }, + "green": { + "format": "float", + "description": "The amount of green in the color as a value in the interval [0, 1].", + "type": "number" + } + }, + "description": "Represents a color in the RGBA color space. This representation is designed for simplicity of conversion to/from color representations in various languages over compactness; for example, the fields of this representation can be trivially provided to the constructor of \"java.awt.Color\" in Java; it can also be trivially provided to UIColor's \"+colorWithRed:green:blue:alpha\" method in iOS; and, with just a little work, it can be easily formatted into a CSS \"rgba()\" string in JavaScript, as well. Note: this proto does not carry information about the absolute color space that should be used to interpret the RGB value (e.g. sRGB, Adobe RGB, DCI-P3, BT.2020, etc.). By default, applications SHOULD assume the sRGB color space. Note: when color equality needs to be decided, implementations, unless documented otherwise, will treat two colors to be equal if all their red, green, blue and alpha values each differ by at most 1e-5. Example (Java): import com.google.type.Color; // ... public static java.awt.Color fromProto(Color protocolor) { float alpha = protocolor.hasAlpha() ? protocolor.getAlpha().getValue() : 1.0; return new java.awt.Color( protocolor.getRed(), protocolor.getGreen(), protocolor.getBlue(), alpha); } public static Color toProto(java.awt.Color color) { float red = (float) color.getRed(); float green = (float) color.getGreen(); float blue = (float) color.getBlue(); float denominator = 255.0; Color.Builder resultBuilder = Color .newBuilder() .setRed(red / denominator) .setGreen(green / denominator) .setBlue(blue / denominator); int alpha = color.getAlpha(); if (alpha != 255) { result.setAlpha( FloatValue .newBuilder() .setValue(((float) alpha) / denominator) .build()); } return resultBuilder.build(); } // ... Example (iOS / Obj-C): // ... static UIColor* fromProto(Color* protocolor) { float red = [protocolor red]; float green = [protocolor green]; float blue = [protocolor blue]; FloatValue* alpha_wrapper = [protocolor alpha]; float alpha = 1.0; if (alpha_wrapper != nil) { alpha = [alpha_wrapper value]; } return [UIColor colorWithRed:red green:green blue:blue alpha:alpha]; } static Color* toProto(UIColor* color) { CGFloat red, green, blue, alpha; if (![color getRed:&red green:&green blue:&blue alpha:&alpha]) { return nil; } Color* result = [[Color alloc] init]; [result setRed:red]; [result setGreen:green]; [result setBlue:blue]; if (alpha \u003c= 0.9999) { [result setAlpha:floatWrapperWithValue(alpha)]; } [result autorelease]; return result; } // ... Example (JavaScript): // ... var protoToCssColor = function(rgb_color) { var redFrac = rgb_color.red || 0.0; var greenFrac = rgb_color.green || 0.0; var blueFrac = rgb_color.blue || 0.0; var red = Math.floor(redFrac * 255); var green = Math.floor(greenFrac * 255); var blue = Math.floor(blueFrac * 255); if (!('alpha' in rgb_color)) { return rgbToCssColor_(red, green, blue); } var alphaFrac = rgb_color.alpha.value || 0.0; var rgbParams = [red, green, blue].join(','); return ['rgba(', rgbParams, ',', alphaFrac, ')'].join(''); }; var rgbToCssColor_ = function(red, green, blue) { var rgbNumber = new Number((red \u003c\u003c 16) | (green \u003c\u003c 8) | blue); var hexString = rgbNumber.toString(16); var missingZeros = 6 - hexString.length; var resultBuilder = ['#']; for (var i = 0; i \u003c missingZeros; i++) { resultBuilder.push('0'); } resultBuilder.push(hexString); return resultBuilder.join(''); }; // ...", + "type": "object" + }, + "AddProtectedRangeRequest": { + "type": "object", + "description": "Adds a new protected range.", + "id": "AddProtectedRangeRequest", + "properties": { + "protectedRange": { + "$ref": "ProtectedRange", + "description": "The protected range to be added. The protectedRangeId field is optional; if one is not set, an id will be randomly generated. (It is an error to specify the ID of a range that already exists.)" + } + } + }, + "OverlayPosition": { + "type": "object", + "description": "The location an object is overlaid on top of a grid.", + "properties": { + "offsetYPixels": { + "description": "The vertical offset, in pixels, that the object is offset from the anchor cell.", + "format": "int32", + "type": "integer" + }, + "widthPixels": { + "format": "int32", + "type": "integer", + "description": "The width of the object, in pixels. Defaults to 600." + }, + "heightPixels": { + "description": "The height of the object, in pixels. Defaults to 371.", + "format": "int32", + "type": "integer" + }, + "offsetXPixels": { + "description": "The horizontal offset, in pixels, that the object is offset from the anchor cell.", + "type": "integer", + "format": "int32" + }, + "anchorCell": { + "description": "The cell the object is anchored to.", + "$ref": "GridCoordinate" + } + }, + "id": "OverlayPosition" + }, + "AddChartResponse": { + "id": "AddChartResponse", + "description": "The result of adding a chart to a spreadsheet.", + "properties": { + "chart": { + "description": "The newly added chart.", + "$ref": "EmbeddedChart" + } + }, + "type": "object" + }, + "AddSheetResponse": { + "description": "The result of adding a sheet.", + "id": "AddSheetResponse", + "type": "object", + "properties": { + "properties": { + "$ref": "SheetProperties", + "description": "The properties of the newly added sheet." + } + } + }, + "Borders": { + "type": "object", + "id": "Borders", + "description": "The borders of the cell.", + "properties": { + "top": { + "description": "The top border of the cell.", + "$ref": "Border" + }, + "right": { + "description": "The right border of the cell.", + "$ref": "Border" + }, + "left": { + "$ref": "Border", + "description": "The left border of the cell." + }, + "bottom": { + "$ref": "Border", + "description": "The bottom border of the cell." + } + } + }, + "ManualRuleGroup": { + "type": "object", + "properties": { + "groupName": { + "description": "The group name, which must be a string. Each group in a given ManualRule must have a unique group name.", + "$ref": "ExtendedValue" + }, + "items": { + "description": "The items in the source data that should be placed into this group. Each item may be a string, number, or boolean. Items may appear in at most one group within a given ManualRule. Items that do not appear in any group will appear on their own.", + "type": "array", + "items": { + "$ref": "ExtendedValue" + } + } + }, + "id": "ManualRuleGroup", + "description": "A group name and a list of items from the source data that should be placed in the group with this name." + }, + "DataFilterValueRange": { + "properties": { + "majorDimension": { + "enum": [ + "DIMENSION_UNSPECIFIED", + "ROWS", + "COLUMNS" + ], + "enumDescriptions": [ + "The default value, do not use.", + "Operates on the rows of a sheet.", + "Operates on the columns of a sheet." + ], + "type": "string", + "description": "The major dimension of the values." + }, + "values": { + "items": { + "type": "array", + "items": { + "type": "any" + } + }, + "description": "The data to be written. If the provided values exceed any of the ranges matched by the data filter then the request fails. If the provided values are less than the matched ranges only the specified values are written, existing values in the matched ranges remain unaffected.", + "type": "array" + }, + "dataFilter": { + "$ref": "DataFilter", + "description": "The data filter describing the location of the values in the spreadsheet." + } + }, + "type": "object", + "id": "DataFilterValueRange", + "description": "A range of values whose location is specified by a DataFilter." + }, + "BigQueryQuerySpec": { + "id": "BigQueryQuerySpec", + "properties": { + "rawQuery": { + "type": "string", + "description": "The raw query string." + } + }, + "type": "object", + "description": "Specifies a custom BigQuery query." + }, + "AddDimensionGroupRequest": { + "id": "AddDimensionGroupRequest", + "type": "object", + "description": "Creates a group over the specified range. If the requested range is a superset of the range of an existing group G, then the depth of G is incremented and this new group G' has the depth of that group. For example, a group [C:D, depth 1] + [B:E] results in groups [B:E, depth 1] and [C:D, depth 2]. If the requested range is a subset of the range of an existing group G, then the depth of the new group G' becomes one greater than the depth of G. For example, a group [B:E, depth 1] + [C:D] results in groups [B:E, depth 1] and [C:D, depth 2]. If the requested range starts before and ends within, or starts within and ends after, the range of an existing group G, then the range of the existing group G becomes the union of the ranges, and the new group G' has depth one greater than the depth of G and range as the intersection of the ranges. For example, a group [B:D, depth 1] + [C:E] results in groups [B:E, depth 1] and [C:D, depth 2].", + "properties": { + "range": { + "description": "The range over which to create a group.", + "$ref": "DimensionRange" + } + } + }, + "Padding": { + "properties": { + "top": { + "type": "integer", + "format": "int32", + "description": "The top padding of the cell." + }, + "bottom": { + "format": "int32", + "type": "integer", + "description": "The bottom padding of the cell." + }, + "right": { + "type": "integer", + "description": "The right padding of the cell.", + "format": "int32" + }, + "left": { + "type": "integer", + "description": "The left padding of the cell.", + "format": "int32" + } + }, + "description": "The amount of padding around the cell, in pixels. When updating padding, every field must be specified.", + "id": "Padding", + "type": "object" + }, + "AddChartRequest": { + "id": "AddChartRequest", + "properties": { + "chart": { + "description": "The chart that should be added to the spreadsheet, including the position where it should be placed. The chartId field is optional; if one is not set, an id will be randomly generated. (It is an error to specify the ID of an embedded object that already exists.)", + "$ref": "EmbeddedChart" + } + }, + "type": "object", + "description": "Adds a chart to a sheet in the spreadsheet." + }, + "TextPosition": { + "description": "Position settings for text.", + "type": "object", + "id": "TextPosition", + "properties": { + "horizontalAlignment": { + "enum": [ + "HORIZONTAL_ALIGN_UNSPECIFIED", + "LEFT", + "CENTER", + "RIGHT" + ], + "description": "Horizontal alignment setting for the piece of text.", + "type": "string", + "enumDescriptions": [ + "The horizontal alignment is not specified. Do not use this.", + "The text is explicitly aligned to the left of the cell.", + "The text is explicitly aligned to the center of the cell.", + "The text is explicitly aligned to the right of the cell." + ] + } + } + }, + "BatchUpdateValuesByDataFilterResponse": { + "id": "BatchUpdateValuesByDataFilterResponse", + "properties": { + "totalUpdatedCells": { + "format": "int32", + "type": "integer", + "description": "The total number of cells updated." + }, + "totalUpdatedSheets": { + "format": "int32", + "description": "The total number of sheets where at least one cell in the sheet was updated.", + "type": "integer" + }, + "totalUpdatedColumns": { + "type": "integer", + "format": "int32", + "description": "The total number of columns where at least one cell in the column was updated." + }, + "responses": { + "items": { + "$ref": "UpdateValuesByDataFilterResponse" + }, + "type": "array", + "description": "The response for each range updated." + }, + "totalUpdatedRows": { + "description": "The total number of rows where at least one cell in the row was updated.", + "format": "int32", + "type": "integer" + }, + "spreadsheetId": { + "type": "string", + "description": "The spreadsheet the updates were applied to." + } + }, + "description": "The response when updating a range of values in a spreadsheet.", + "type": "object" + }, + "AddSlicerRequest": { + "description": "Adds a slicer to a sheet in the spreadsheet.", + "id": "AddSlicerRequest", + "type": "object", + "properties": { + "slicer": { + "description": "The slicer that should be added to the spreadsheet, including the position where it should be placed. The slicerId field is optional; if one is not set, an id will be randomly generated. (It is an error to specify the ID of a slicer that already exists.)", + "$ref": "Slicer" + } + } + }, + "SearchDeveloperMetadataRequest": { + "id": "SearchDeveloperMetadataRequest", + "properties": { + "dataFilters": { + "type": "array", + "description": "The data filters describing the criteria used to determine which DeveloperMetadata entries to return. DeveloperMetadata matching any of the specified filters are included in the response.", + "items": { + "$ref": "DataFilter" + } + } + }, + "description": "A request to retrieve all developer metadata matching the set of specified criteria.", + "type": "object" + }, + "KeyValueFormat": { + "description": "Formatting options for key value.", + "properties": { + "textFormat": { + "description": "Text formatting options for key value.", + "$ref": "TextFormat" + }, + "position": { + "description": "Specifies the horizontal text positioning of key value. This field is optional. If not specified, default positioning is used.", + "$ref": "TextPosition" + } + }, + "id": "KeyValueFormat", + "type": "object" + }, + "DataSourceColumn": { + "properties": { + "formula": { + "description": "The formula of the calculated column.", + "type": "string" + }, + "reference": { + "description": "The column reference.", + "$ref": "DataSourceColumnReference" + } + }, + "id": "DataSourceColumn", + "type": "object", + "description": "A column in a data source." + }, + "AppendCellsRequest": { + "description": "Adds new cells after the last row with data in a sheet, inserting new rows into the sheet if necessary.", + "id": "AppendCellsRequest", + "type": "object", + "properties": { + "rows": { + "description": "The data to append.", + "type": "array", + "items": { + "$ref": "RowData" + } + }, + "fields": { + "description": "The fields of CellData that should be updated. At least one field must be specified. The root is the CellData; 'row.values.' should not be specified. A single `\"*\"` can be used as short-hand for listing every field.", + "format": "google-fieldmask", + "type": "string" + }, + "sheetId": { + "format": "int32", + "description": "The sheet ID to append the data to.", + "type": "integer" + } + } + }, + "BandedRange": { + "description": "A banded (alternating colors) range in a sheet.", + "properties": { + "range": { + "$ref": "GridRange", + "description": "The range over which these properties are applied." + }, + "columnProperties": { + "$ref": "BandingProperties", + "description": "Properties for column bands. These properties are applied on a column- by-column basis throughout all the columns in the range. At least one of row_properties or column_properties must be specified." + }, + "rowProperties": { + "description": "Properties for row bands. These properties are applied on a row-by-row basis throughout all the rows in the range. At least one of row_properties or column_properties must be specified.", + "$ref": "BandingProperties" + }, + "bandedRangeId": { + "description": "The id of the banded range.", + "type": "integer", + "format": "int32" + } + }, + "type": "object", + "id": "BandedRange" + }, + "TreemapChartColorScale": { + "description": "A color scale for a treemap chart.", + "type": "object", + "properties": { + "noDataColor": { + "description": "The background color for cells that have no color data associated with them. Defaults to #000000 if not specified.", + "$ref": "Color" + }, + "midValueColorStyle": { + "$ref": "ColorStyle", + "description": "The background color for cells with a color value at the midpoint between minValue and maxValue. Defaults to #efe6dc if not specified. If mid_value_color is also set, this field takes precedence." + }, + "minValueColorStyle": { + "$ref": "ColorStyle", + "description": "The background color for cells with a color value less than or equal to minValue. Defaults to #dc3912 if not specified. If min_value_color is also set, this field takes precedence." + }, + "noDataColorStyle": { + "$ref": "ColorStyle", + "description": "The background color for cells that have no color data associated with them. Defaults to #000000 if not specified. If no_data_color is also set, this field takes precedence." + }, + "minValueColor": { + "description": "The background color for cells with a color value less than or equal to minValue. Defaults to #dc3912 if not specified.", + "$ref": "Color" + }, + "midValueColor": { + "$ref": "Color", + "description": "The background color for cells with a color value at the midpoint between minValue and maxValue. Defaults to #efe6dc if not specified." + }, + "maxValueColorStyle": { + "$ref": "ColorStyle", + "description": "The background color for cells with a color value greater than or equal to maxValue. Defaults to #109618 if not specified. If max_value_color is also set, this field takes precedence." + }, + "maxValueColor": { + "$ref": "Color", + "description": "The background color for cells with a color value greater than or equal to maxValue. Defaults to #109618 if not specified." + } + }, + "id": "TreemapChartColorScale" + }, + "BatchGetValuesResponse": { + "description": "The response when retrieving more than one range of values in a spreadsheet.", + "id": "BatchGetValuesResponse", + "type": "object", + "properties": { + "spreadsheetId": { + "type": "string", + "description": "The ID of the spreadsheet the data was retrieved from." + }, + "valueRanges": { + "type": "array", + "items": { + "$ref": "ValueRange" + }, + "description": "The requested values. The order of the ValueRanges is the same as the order of the requested ranges." + } + } + }, + "ColorStyle": { + "description": "A color value.", + "type": "object", + "id": "ColorStyle", + "properties": { + "themeColor": { + "type": "string", + "enumDescriptions": [ + "Unspecified theme color", + "Represents the primary text color", + "Represents the primary background color", + "Represents the first accent color", + "Represents the second accent color", + "Represents the third accent color", + "Represents the fourth accent color", + "Represents the fifth accent color", + "Represents the sixth accent color", + "Represents the color to use for hyperlinks" + ], + "enum": [ + "THEME_COLOR_TYPE_UNSPECIFIED", + "TEXT", + "BACKGROUND", + "ACCENT1", + "ACCENT2", + "ACCENT3", + "ACCENT4", + "ACCENT5", + "ACCENT6", + "LINK" + ], + "description": "Theme color." + }, + "rgbColor": { + "description": "RGB color.", + "$ref": "Color" + } + } + }, + "BigQueryTableSpec": { + "type": "object", + "id": "BigQueryTableSpec", + "description": "Specifies a BigQuery table definition. Only [native tables](https://cloud.google.com/bigquery/docs/tables-intro) is allowed.", + "properties": { + "tableProjectId": { + "description": "The ID of a BigQuery project the table belongs to. If not specified, the project_id is assumed.", + "type": "string" + }, + "datasetId": { + "type": "string", + "description": "The BigQuery dataset id." + }, + "tableId": { + "description": "The BigQuery table id.", + "type": "string" + } + } + }, + "DataExecutionStatus": { + "description": "The data execution status. A data execution is created to sync a data source object with the latest data from a DataSource. It is usually scheduled to run at background, you can check its state to tell if an execution completes There are several scenarios where a data execution is triggered to run: * Adding a data source creates an associated data source sheet as well as a data execution to sync the data from the data source to the sheet. * Updating a data source creates a data execution to refresh the associated data source sheet similarly. * You can send refresh request to explicitly refresh one or multiple data source objects.", + "properties": { + "errorMessage": { + "description": "The error message, which may be empty.", + "type": "string" + }, + "lastRefreshTime": { + "description": "Gets the time the data last successfully refreshed.", + "format": "google-datetime", + "type": "string" + }, + "state": { + "enum": [ + "DATA_EXECUTION_STATE_UNSPECIFIED", + "NOT_STARTED", + "RUNNING", + "SUCCEEDED", + "FAILED" + ], + "description": "The state of the data execution.", + "enumDescriptions": [ + "Default value, do not use.", + "The data execution has not started.", + "The data execution has started and is running.", + "The data execution has completed successfully.", + "The data execution has completed with errors." + ], + "type": "string" + }, + "errorCode": { + "description": "The error code.", + "enum": [ + "DATA_EXECUTION_ERROR_CODE_UNSPECIFIED", + "TIMED_OUT", + "TOO_MANY_ROWS", + "TOO_MANY_CELLS", + "ENGINE", + "PARAMETER_INVALID", + "UNSUPPORTED_DATA_TYPE", + "DUPLICATE_COLUMN_NAMES", + "INTERRUPTED", + "CONCURRENT_QUERY", + "OTHER", + "TOO_MANY_CHARS_PER_CELL", + "DATA_NOT_FOUND", + "PERMISSION_DENIED", + "MISSING_COLUMN_ALIAS", + "OBJECT_NOT_FOUND", + "OBJECT_IN_ERROR_STATE", + "OBJECT_SPEC_INVALID" + ], + "enumDescriptions": [ + "Default value, do not use.", + "The data execution timed out.", + "The data execution returns more rows than the limit.", + "The data execution returns more cells than the limit.", + "Error is received from the backend data execution engine (e.g. BigQuery). Check error_message for details.", + "One or some of the provided data source parameters are invalid.", + "The data execution returns an unsupported data type.", + "The data execution returns duplicate column names or aliases.", + "The data execution is interrupted. Please refresh later.", + "The data execution is currently in progress, can not be refreshed until it completes.", + "Other errors.", + "The data execution returns values that exceed the maximum characters allowed in a single cell.", + "The database referenced by the data source is not found. */", + "The user does not have access to the database referenced by the data source.", + "The data execution returns columns with missing aliases.", + "The data source object does not exist.", + "The data source object is currently in error state. To force refresh, set force in RefreshDataSourceRequest.", + "The data source object specification is invalid." + ], + "type": "string" + } + }, + "type": "object", + "id": "DataExecutionStatus" + }, + "ClearValuesRequest": { + "properties": {}, + "description": "The request for clearing a range of values in a spreadsheet.", + "id": "ClearValuesRequest", + "type": "object" + }, + "PivotGroup": { + "type": "object", + "properties": { + "valueMetadata": { + "items": { + "$ref": "PivotGroupValueMetadata" + }, + "description": "Metadata about values in the grouping.", + "type": "array" + }, + "groupRule": { + "description": "The group rule to apply to this row/column group.", + "$ref": "PivotGroupRule" + }, + "sortOrder": { + "description": "The order the values in this group should be sorted.", + "enumDescriptions": [ + "Default value, do not use this.", + "Sort ascending.", + "Sort descending." + ], + "enum": [ + "SORT_ORDER_UNSPECIFIED", + "ASCENDING", + "DESCENDING" + ], + "type": "string" + }, + "dataSourceColumnReference": { + "description": "The reference to the data source column this grouping is based on.", + "$ref": "DataSourceColumnReference" + }, + "showTotals": { + "description": "True if the pivot table should include the totals for this grouping.", + "type": "boolean" + }, + "sourceColumnOffset": { + "format": "int32", + "description": "The column offset of the source range that this grouping is based on. For example, if the source was `C10:E15`, a `sourceColumnOffset` of `0` means this group refers to column `C`, whereas the offset `1` would refer to column `D`.", + "type": "integer" + }, + "label": { + "description": "The labels to use for the row/column groups which can be customized. For example, in the following pivot table, the row label is `Region` (which could be renamed to `State`) and the column label is `Product` (which could be renamed `Item`). Pivot tables created before December 2017 do not have header labels. If you'd like to add header labels to an existing pivot table, please delete the existing pivot table and then create a new pivot table with same parameters. +--------------+---------+-------+ | SUM of Units | Product | | | Region | Pen | Paper | +--------------+---------+-------+ | New York | 345 | 98 | | Oregon | 234 | 123 | | Tennessee | 531 | 415 | +--------------+---------+-------+ | Grand Total | 1110 | 636 | +--------------+---------+-------+", + "type": "string" + }, + "groupLimit": { + "description": "The count limit on rows or columns to apply to this pivot group.", + "$ref": "PivotGroupLimit" + }, + "valueBucket": { + "$ref": "PivotGroupSortValueBucket", + "description": "The bucket of the opposite pivot group to sort by. If not specified, sorting is alphabetical by this group's values." + }, + "repeatHeadings": { + "type": "boolean", + "description": "True if the headings in this pivot group should be repeated. This is only valid for row groupings and is ignored by columns. By default, we minimize repitition of headings by not showing higher level headings where they are the same. For example, even though the third row below corresponds to \"Q1 Mar\", \"Q1\" is not shown because it is redundant with previous rows. Setting repeat_headings to true would cause \"Q1\" to be repeated for \"Feb\" and \"Mar\". +--------------+ | Q1 | Jan | | | Feb | | | Mar | +--------+-----+ | Q1 Total | +--------------+" + } + }, + "id": "PivotGroup", + "description": "A single grouping (either row or column) in a pivot table." + }, + "DataSourceRefreshDailySchedule": { + "properties": { + "startTime": { + "description": "The start time of a time interval in which a data source refresh is scheduled. Only `hours` part is used. The time interval size defaults to that in the Sheets editor.", + "$ref": "TimeOfDay" + } + }, + "description": "A schedule for data to refresh every day in a given time interval.", + "type": "object", + "id": "DataSourceRefreshDailySchedule" + }, + "PivotTable": { + "id": "PivotTable", + "type": "object", + "properties": { + "dataExecutionStatus": { + "$ref": "DataExecutionStatus", + "readOnly": true, + "description": "Output only. The data execution status for data source pivot tables." + }, + "columns": { + "description": "Each column grouping in the pivot table.", + "type": "array", + "items": { + "$ref": "PivotGroup" + } + }, + "values": { + "description": "A list of values to include in the pivot table.", + "items": { + "$ref": "PivotValue" + }, + "type": "array" + }, + "filterSpecs": { + "type": "array", + "description": "The filters applied to the source columns before aggregating data for the pivot table. Both criteria and filter_specs are populated in responses. If both fields are specified in an update request, this field takes precedence.", + "items": { + "$ref": "PivotFilterSpec" + } + }, + "source": { + "description": "The range the pivot table is reading data from.", + "$ref": "GridRange" + }, + "valueLayout": { + "description": "Whether values should be listed horizontally (as columns) or vertically (as rows).", + "enumDescriptions": [ + "Values are laid out horizontally (as columns).", + "Values are laid out vertically (as rows)." + ], + "type": "string", + "enum": [ + "HORIZONTAL", + "VERTICAL" + ] + }, + "rows": { + "items": { + "$ref": "PivotGroup" + }, + "type": "array", + "description": "Each row grouping in the pivot table." + }, + "dataSourceId": { + "description": "The ID of the data source the pivot table is reading data from.", + "type": "string" + }, + "criteria": { + "description": "An optional mapping of filters per source column offset. The filters are applied before aggregating data into the pivot table. The map's key is the column offset of the source range that you want to filter, and the value is the criteria for that column. For example, if the source was `C10:E15`, a key of `0` will have the filter for column `C`, whereas the key `1` is for column `D`. This field is deprecated in favor of filter_specs.", + "additionalProperties": { + "$ref": "PivotFilterCriteria" + }, + "type": "object" + } + }, + "description": "A pivot table." + }, + "EmbeddedChart": { + "type": "object", + "description": "A chart embedded in a sheet.", + "id": "EmbeddedChart", + "properties": { + "spec": { + "$ref": "ChartSpec", + "description": "The specification of the chart." + }, + "chartId": { + "type": "integer", + "description": "The ID of the chart.", + "format": "int32" + }, + "position": { + "$ref": "EmbeddedObjectPosition", + "description": "The position of the chart." + }, + "border": { + "description": "The border of the chart.", + "$ref": "EmbeddedObjectBorder" + } + } + }, + "UpdateChartSpecRequest": { + "id": "UpdateChartSpecRequest", + "type": "object", + "properties": { + "spec": { + "description": "The specification to apply to the chart.", + "$ref": "ChartSpec" + }, + "chartId": { + "format": "int32", + "type": "integer", + "description": "The ID of the chart to update." + } + }, + "description": "Updates a chart's specifications. (This does not move or resize a chart. To move or resize a chart, use UpdateEmbeddedObjectPositionRequest.)" + }, + "RowData": { + "description": "Data about each cell in a row.", + "type": "object", + "properties": { + "values": { + "description": "The values in the row, one per column.", + "items": { + "$ref": "CellData" + }, + "type": "array" + } + }, + "id": "RowData" + }, + "GridCoordinate": { + "type": "object", + "description": "A coordinate in a sheet. All indexes are zero-based.", + "id": "GridCoordinate", + "properties": { + "columnIndex": { + "format": "int32", + "type": "integer", + "description": "The column index of the coordinate." + }, + "sheetId": { + "format": "int32", + "type": "integer", + "description": "The sheet this coordinate is on." + }, + "rowIndex": { + "description": "The row index of the coordinate.", + "format": "int32", + "type": "integer" + } + } + }, + "Spreadsheet": { + "properties": { + "dataSources": { + "items": { + "$ref": "DataSource" + }, + "type": "array", + "description": "A list of external data sources connected with the spreadsheet." + }, + "spreadsheetUrl": { + "description": "The url of the spreadsheet. This field is read-only.", + "type": "string" + }, + "sheets": { + "description": "The sheets that are part of a spreadsheet.", + "type": "array", + "items": { + "$ref": "Sheet" + } + }, + "properties": { + "description": "Overall properties of a spreadsheet.", + "$ref": "SpreadsheetProperties" + }, + "spreadsheetId": { + "description": "The ID of the spreadsheet. This field is read-only.", + "type": "string" + }, + "namedRanges": { + "description": "The named ranges defined in a spreadsheet.", + "type": "array", + "items": { + "$ref": "NamedRange" + } + }, + "developerMetadata": { + "items": { + "$ref": "DeveloperMetadata" + }, + "description": "The developer metadata associated with a spreadsheet.", + "type": "array" + }, + "dataSourceSchedules": { + "readOnly": true, + "description": "Output only. A list of data source refresh schedules.", + "type": "array", + "items": { + "$ref": "DataSourceRefreshSchedule" + } + } + }, + "id": "Spreadsheet", + "description": "Resource that represents a spreadsheet.", + "type": "object" + }, + "BatchUpdateValuesByDataFilterRequest": { + "properties": { + "responseDateTimeRenderOption": { + "enumDescriptions": [ + "Instructs date, time, datetime, and duration fields to be output as doubles in \"serial number\" format, as popularized by Lotus 1-2-3. The whole number portion of the value (left of the decimal) counts the days since December 30th 1899. The fractional portion (right of the decimal) counts the time as a fraction of the day. For example, January 1st 1900 at noon would be 2.5, 2 because it's 2 days after December 30st 1899, and .5 because noon is half a day. February 1st 1900 at 3pm would be 33.625. This correctly treats the year 1900 as not a leap year.", + "Instructs date, time, datetime, and duration fields to be output as strings in their given number format (which is dependent on the spreadsheet locale)." + ], + "enum": [ + "SERIAL_NUMBER", + "FORMATTED_STRING" + ], + "description": "Determines how dates, times, and durations in the response should be rendered. This is ignored if response_value_render_option is FORMATTED_VALUE. The default dateTime render option is DateTimeRenderOption.SERIAL_NUMBER.", + "type": "string" + }, + "valueInputOption": { + "type": "string", + "enum": [ + "INPUT_VALUE_OPTION_UNSPECIFIED", + "RAW", + "USER_ENTERED" + ], + "enumDescriptions": [ + "Default input value. This value must not be used.", + "The values the user has entered will not be parsed and will be stored as-is.", + "The values will be parsed as if the user typed them into the UI. Numbers will stay as numbers, but strings may be converted to numbers, dates, etc. following the same rules that are applied when entering text into a cell via the Google Sheets UI." + ], + "description": "How the input data should be interpreted." + }, + "responseValueRenderOption": { + "description": "Determines how values in the response should be rendered. The default render option is ValueRenderOption.FORMATTED_VALUE.", + "enum": [ + "FORMATTED_VALUE", + "UNFORMATTED_VALUE", + "FORMULA" + ], + "enumDescriptions": [ + "Values will be calculated & formatted in the reply according to the cell's formatting. Formatting is based on the spreadsheet's locale, not the requesting user's locale. For example, if `A1` is `1.23` and `A2` is `=A1` and formatted as currency, then `A2` would return `\"$1.23\"`.", + "Values will be calculated, but not formatted in the reply. For example, if `A1` is `1.23` and `A2` is `=A1` and formatted as currency, then `A2` would return the number `1.23`.", + "Values will not be calculated. The reply will include the formulas. For example, if `A1` is `1.23` and `A2` is `=A1` and formatted as currency, then A2 would return `\"=A1\"`." + ], + "type": "string" + }, + "includeValuesInResponse": { + "type": "boolean", + "description": "Determines if the update response should include the values of the cells that were updated. By default, responses do not include the updated values. The `updatedData` field within each of the BatchUpdateValuesResponse.responses contains the updated values. If the range to write was larger than the range actually written, the response includes all values in the requested range (excluding trailing empty rows and columns)." + }, + "data": { + "items": { + "$ref": "DataFilterValueRange" + }, + "description": "The new values to apply to the spreadsheet. If more than one range is matched by the specified DataFilter the specified values are applied to all of those ranges.", + "type": "array" + } + }, + "type": "object", + "id": "BatchUpdateValuesByDataFilterRequest", + "description": "The request for updating more than one range of values in a spreadsheet." + }, + "CellData": { + "id": "CellData", + "description": "Data about a specific cell.", + "type": "object", + "properties": { + "pivotTable": { + "$ref": "PivotTable", + "description": "A pivot table anchored at this cell. The size of pivot table itself is computed dynamically based on its data, grouping, filters, values, etc. Only the top-left cell of the pivot table contains the pivot table definition. The other cells will contain the calculated values of the results of the pivot in their effective_value fields." + }, + "dataSourceFormula": { + "readOnly": true, + "$ref": "DataSourceFormula", + "description": "Output only. Information about a data source formula on the cell. The field is set if user_entered_value is a formula referencing some DATA_SOURCE sheet, e.g `=SUM(DataSheet!Column)`." + }, + "hyperlink": { + "description": "A hyperlink this cell points to, if any. If the cell contains multiple hyperlinks, this field will be empty. This field is read-only. To set it, use a `=HYPERLINK` formula in the userEnteredValue.formulaValue field.", + "type": "string" + }, + "textFormatRuns": { + "type": "array", + "description": "Runs of rich text applied to subsections of the cell. Runs are only valid on user entered strings, not formulas, bools, or numbers. Properties of a run start at a specific index in the text and continue until the next run. Runs will inherit the properties of the cell unless explicitly changed. When writing, the new runs will overwrite any prior runs. When writing a new user_entered_value, previous runs are erased.", + "items": { + "$ref": "TextFormatRun" + } + }, + "note": { + "description": "Any note on the cell.", + "type": "string" + }, + "userEnteredFormat": { + "description": "The format the user entered for the cell. When writing, the new format will be merged with the existing format.", + "$ref": "CellFormat" + }, + "effectiveValue": { + "description": "The effective value of the cell. For cells with formulas, this is the calculated value. For cells with literals, this is the same as the user_entered_value. This field is read-only.", + "$ref": "ExtendedValue" + }, + "userEnteredValue": { + "$ref": "ExtendedValue", + "description": "The value the user entered in the cell. e.g, `1234`, `'Hello'`, or `=NOW()` Note: Dates, Times and DateTimes are represented as doubles in serial number format." + }, + "formattedValue": { + "description": "The formatted value of the cell. This is the value as it's shown to the user. This field is read-only.", + "type": "string" + }, + "effectiveFormat": { + "$ref": "CellFormat", + "description": "The effective format being used by the cell. This includes the results of applying any conditional formatting and, if the cell contains a formula, the computed number format. If the effective format is the default format, effective format will not be written. This field is read-only." + }, + "dataValidation": { + "$ref": "DataValidationRule", + "description": "A data validation rule on the cell, if any. When writing, the new data validation rule will overwrite any prior rule." + }, + "dataSourceTable": { + "description": "A data source table anchored at this cell. The size of data source table itself is computed dynamically based on its configuration. Only the first cell of the data source table contains the data source table definition. The other cells will contain the display values of the data source table result in their effective_value fields.", + "$ref": "DataSourceTable" + } + } + } + }, + "batchPath": "batch", + "rootUrl": "https://sheets.googleapis.com/", + "resources": { + "spreadsheets": { + "resources": { + "values": { + "methods": { + "append": { + "scopes": [ + "https://www.googleapis.com/auth/drive", + "https://www.googleapis.com/auth/drive.file", + "https://www.googleapis.com/auth/spreadsheets" + ], + "request": { + "$ref": "ValueRange" + }, + "httpMethod": "POST", + "id": "sheets.spreadsheets.values.append", + "path": "v4/spreadsheets/{spreadsheetId}/values/{range}:append", + "response": { + "$ref": "AppendValuesResponse" + }, + "parameterOrder": [ + "spreadsheetId", + "range" + ], + "flatPath": "v4/spreadsheets/{spreadsheetId}/values/{range}:append", + "description": "Appends values to a spreadsheet. The input range is used to search for existing data and find a \"table\" within that range. Values will be appended to the next row of the table, starting with the first column of the table. See the [guide](/sheets/api/guides/values#appending_values) and [sample code](/sheets/api/samples/writing#append_values) for specific details of how tables are detected and data is appended. The caller must specify the spreadsheet ID, range, and a valueInputOption. The `valueInputOption` only controls how the input data will be added to the sheet (column-wise or row-wise), it does not influence what cell the data starts being written to.", + "parameters": { + "valueInputOption": { + "enum": [ + "INPUT_VALUE_OPTION_UNSPECIFIED", + "RAW", + "USER_ENTERED" + ], + "location": "query", + "type": "string", + "enumDescriptions": [ + "Default input value. This value must not be used.", + "The values the user has entered will not be parsed and will be stored as-is.", + "The values will be parsed as if the user typed them into the UI. Numbers will stay as numbers, but strings may be converted to numbers, dates, etc. following the same rules that are applied when entering text into a cell via the Google Sheets UI." + ], + "description": "How the input data should be interpreted." + }, + "range": { + "required": true, + "location": "path", + "description": "The A1 notation of a range to search for a logical table of data. Values are appended after the last row of the table.", + "type": "string" + }, + "includeValuesInResponse": { + "type": "boolean", + "location": "query", + "description": "Determines if the update response should include the values of the cells that were appended. By default, responses do not include the updated values." + }, + "responseValueRenderOption": { + "description": "Determines how values in the response should be rendered. The default render option is ValueRenderOption.FORMATTED_VALUE.", + "enum": [ + "FORMATTED_VALUE", + "UNFORMATTED_VALUE", + "FORMULA" + ], + "type": "string", + "location": "query", + "enumDescriptions": [ + "Values will be calculated & formatted in the reply according to the cell's formatting. Formatting is based on the spreadsheet's locale, not the requesting user's locale. For example, if `A1` is `1.23` and `A2` is `=A1` and formatted as currency, then `A2` would return `\"$1.23\"`.", + "Values will be calculated, but not formatted in the reply. For example, if `A1` is `1.23` and `A2` is `=A1` and formatted as currency, then `A2` would return the number `1.23`.", + "Values will not be calculated. The reply will include the formulas. For example, if `A1` is `1.23` and `A2` is `=A1` and formatted as currency, then A2 would return `\"=A1\"`." + ] + }, + "spreadsheetId": { + "location": "path", + "description": "The ID of the spreadsheet to update.", + "required": true, + "type": "string" + }, + "responseDateTimeRenderOption": { + "description": "Determines how dates, times, and durations in the response should be rendered. This is ignored if response_value_render_option is FORMATTED_VALUE. The default dateTime render option is [DateTimeRenderOption.SERIAL_NUMBER].", + "enum": [ + "SERIAL_NUMBER", + "FORMATTED_STRING" + ], + "enumDescriptions": [ + "Instructs date, time, datetime, and duration fields to be output as doubles in \"serial number\" format, as popularized by Lotus 1-2-3. The whole number portion of the value (left of the decimal) counts the days since December 30th 1899. The fractional portion (right of the decimal) counts the time as a fraction of the day. For example, January 1st 1900 at noon would be 2.5, 2 because it's 2 days after December 30st 1899, and .5 because noon is half a day. February 1st 1900 at 3pm would be 33.625. This correctly treats the year 1900 as not a leap year.", + "Instructs date, time, datetime, and duration fields to be output as strings in their given number format (which is dependent on the spreadsheet locale)." + ], + "type": "string", + "location": "query" + }, + "insertDataOption": { + "type": "string", + "location": "query", + "enum": [ + "OVERWRITE", + "INSERT_ROWS" + ], + "description": "How the input data should be inserted.", + "enumDescriptions": [ + "The new data overwrites existing data in the areas it is written. (Note: adding data to the end of the sheet will still insert new rows or columns so the data can be written.)", + "Rows are inserted for the new data." + ] + } + } + }, + "batchUpdateByDataFilter": { + "parameterOrder": [ + "spreadsheetId" + ], + "flatPath": "v4/spreadsheets/{spreadsheetId}/values:batchUpdateByDataFilter", + "path": "v4/spreadsheets/{spreadsheetId}/values:batchUpdateByDataFilter", + "parameters": { + "spreadsheetId": { + "required": true, + "description": "The ID of the spreadsheet to update.", + "location": "path", + "type": "string" + } + }, + "request": { + "$ref": "BatchUpdateValuesByDataFilterRequest" + }, + "scopes": [ + "https://www.googleapis.com/auth/drive", + "https://www.googleapis.com/auth/drive.file", + "https://www.googleapis.com/auth/spreadsheets" + ], + "description": "Sets values in one or more ranges of a spreadsheet. The caller must specify the spreadsheet ID, a valueInputOption, and one or more DataFilterValueRanges.", + "httpMethod": "POST", + "id": "sheets.spreadsheets.values.batchUpdateByDataFilter", + "response": { + "$ref": "BatchUpdateValuesByDataFilterResponse" + } + }, + "batchClear": { + "httpMethod": "POST", + "parameterOrder": [ + "spreadsheetId" + ], + "description": "Clears one or more ranges of values from a spreadsheet. The caller must specify the spreadsheet ID and one or more ranges. Only values are cleared -- all other properties of the cell (such as formatting, data validation, etc..) are kept.", + "response": { + "$ref": "BatchClearValuesResponse" + }, + "scopes": [ + "https://www.googleapis.com/auth/drive", + "https://www.googleapis.com/auth/drive.file", + "https://www.googleapis.com/auth/spreadsheets" + ], + "path": "v4/spreadsheets/{spreadsheetId}/values:batchClear", + "parameters": { + "spreadsheetId": { + "type": "string", + "location": "path", + "required": true, + "description": "The ID of the spreadsheet to update." + } + }, + "flatPath": "v4/spreadsheets/{spreadsheetId}/values:batchClear", + "id": "sheets.spreadsheets.values.batchClear", + "request": { + "$ref": "BatchClearValuesRequest" + } + }, + "batchGetByDataFilter": { + "response": { + "$ref": "BatchGetValuesByDataFilterResponse" + }, + "description": "Returns one or more ranges of values that match the specified data filters. The caller must specify the spreadsheet ID and one or more DataFilters. Ranges that match any of the data filters in the request will be returned.", + "request": { + "$ref": "BatchGetValuesByDataFilterRequest" + }, + "path": "v4/spreadsheets/{spreadsheetId}/values:batchGetByDataFilter", + "parameterOrder": [ + "spreadsheetId" + ], + "scopes": [ + "https://www.googleapis.com/auth/drive", + "https://www.googleapis.com/auth/drive.file", + "https://www.googleapis.com/auth/spreadsheets" + ], + "flatPath": "v4/spreadsheets/{spreadsheetId}/values:batchGetByDataFilter", + "id": "sheets.spreadsheets.values.batchGetByDataFilter", + "parameters": { + "spreadsheetId": { + "description": "The ID of the spreadsheet to retrieve data from.", + "required": true, + "type": "string", + "location": "path" + } + }, + "httpMethod": "POST" + }, + "update": { + "description": "Sets values in a range of a spreadsheet. The caller must specify the spreadsheet ID, range, and a valueInputOption.", + "request": { + "$ref": "ValueRange" + }, + "response": { + "$ref": "UpdateValuesResponse" + }, + "scopes": [ + "https://www.googleapis.com/auth/drive", + "https://www.googleapis.com/auth/drive.file", + "https://www.googleapis.com/auth/spreadsheets" + ], + "parameters": { + "range": { + "type": "string", + "location": "path", + "required": true, + "description": "The A1 notation of the values to update." + }, + "includeValuesInResponse": { + "type": "boolean", + "description": "Determines if the update response should include the values of the cells that were updated. By default, responses do not include the updated values. If the range to write was larger than the range actually written, the response includes all values in the requested range (excluding trailing empty rows and columns).", + "location": "query" + }, + "spreadsheetId": { + "type": "string", + "description": "The ID of the spreadsheet to update.", + "location": "path", + "required": true + }, + "responseDateTimeRenderOption": { + "enumDescriptions": [ + "Instructs date, time, datetime, and duration fields to be output as doubles in \"serial number\" format, as popularized by Lotus 1-2-3. The whole number portion of the value (left of the decimal) counts the days since December 30th 1899. The fractional portion (right of the decimal) counts the time as a fraction of the day. For example, January 1st 1900 at noon would be 2.5, 2 because it's 2 days after December 30st 1899, and .5 because noon is half a day. February 1st 1900 at 3pm would be 33.625. This correctly treats the year 1900 as not a leap year.", + "Instructs date, time, datetime, and duration fields to be output as strings in their given number format (which is dependent on the spreadsheet locale)." + ], + "description": "Determines how dates, times, and durations in the response should be rendered. This is ignored if response_value_render_option is FORMATTED_VALUE. The default dateTime render option is DateTimeRenderOption.SERIAL_NUMBER.", + "type": "string", + "enum": [ + "SERIAL_NUMBER", + "FORMATTED_STRING" + ], + "location": "query" + }, + "responseValueRenderOption": { + "enum": [ + "FORMATTED_VALUE", + "UNFORMATTED_VALUE", + "FORMULA" + ], + "description": "Determines how values in the response should be rendered. The default render option is ValueRenderOption.FORMATTED_VALUE.", + "location": "query", + "type": "string", + "enumDescriptions": [ + "Values will be calculated & formatted in the reply according to the cell's formatting. Formatting is based on the spreadsheet's locale, not the requesting user's locale. For example, if `A1` is `1.23` and `A2` is `=A1` and formatted as currency, then `A2` would return `\"$1.23\"`.", + "Values will be calculated, but not formatted in the reply. For example, if `A1` is `1.23` and `A2` is `=A1` and formatted as currency, then `A2` would return the number `1.23`.", + "Values will not be calculated. The reply will include the formulas. For example, if `A1` is `1.23` and `A2` is `=A1` and formatted as currency, then A2 would return `\"=A1\"`." + ] + }, + "valueInputOption": { + "enumDescriptions": [ + "Default input value. This value must not be used.", + "The values the user has entered will not be parsed and will be stored as-is.", + "The values will be parsed as if the user typed them into the UI. Numbers will stay as numbers, but strings may be converted to numbers, dates, etc. following the same rules that are applied when entering text into a cell via the Google Sheets UI." + ], + "description": "How the input data should be interpreted.", + "enum": [ + "INPUT_VALUE_OPTION_UNSPECIFIED", + "RAW", + "USER_ENTERED" + ], + "type": "string", + "location": "query" + } + }, + "httpMethod": "PUT", + "parameterOrder": [ + "spreadsheetId", + "range" + ], + "path": "v4/spreadsheets/{spreadsheetId}/values/{range}", + "flatPath": "v4/spreadsheets/{spreadsheetId}/values/{range}", + "id": "sheets.spreadsheets.values.update" + }, + "get": { + "id": "sheets.spreadsheets.values.get", + "parameterOrder": [ + "spreadsheetId", + "range" + ], + "path": "v4/spreadsheets/{spreadsheetId}/values/{range}", + "flatPath": "v4/spreadsheets/{spreadsheetId}/values/{range}", + "description": "Returns a range of values from a spreadsheet. The caller must specify the spreadsheet ID and a range.", + "scopes": [ + "https://www.googleapis.com/auth/drive", + "https://www.googleapis.com/auth/drive.file", + "https://www.googleapis.com/auth/drive.readonly", + "https://www.googleapis.com/auth/spreadsheets", + "https://www.googleapis.com/auth/spreadsheets.readonly" + ], + "httpMethod": "GET", + "response": { + "$ref": "ValueRange" + }, + "parameters": { + "range": { + "type": "string", + "required": true, + "description": "The A1 notation of the values to retrieve.", + "location": "path" + }, + "spreadsheetId": { + "description": "The ID of the spreadsheet to retrieve data from.", + "location": "path", + "type": "string", + "required": true + }, + "majorDimension": { + "enumDescriptions": [ + "The default value, do not use.", + "Operates on the rows of a sheet.", + "Operates on the columns of a sheet." + ], + "location": "query", + "enum": [ + "DIMENSION_UNSPECIFIED", + "ROWS", + "COLUMNS" + ], + "type": "string", + "description": "The major dimension that results should use. For example, if the spreadsheet data is: `A1=1,B1=2,A2=3,B2=4`, then requesting `range=A1:B2,majorDimension=ROWS` returns `[[1,2],[3,4]]`, whereas requesting `range=A1:B2,majorDimension=COLUMNS` returns `[[1,3],[2,4]]`." + }, + "dateTimeRenderOption": { + "location": "query", + "type": "string", + "enumDescriptions": [ + "Instructs date, time, datetime, and duration fields to be output as doubles in \"serial number\" format, as popularized by Lotus 1-2-3. The whole number portion of the value (left of the decimal) counts the days since December 30th 1899. The fractional portion (right of the decimal) counts the time as a fraction of the day. For example, January 1st 1900 at noon would be 2.5, 2 because it's 2 days after December 30st 1899, and .5 because noon is half a day. February 1st 1900 at 3pm would be 33.625. This correctly treats the year 1900 as not a leap year.", + "Instructs date, time, datetime, and duration fields to be output as strings in their given number format (which is dependent on the spreadsheet locale)." + ], + "enum": [ + "SERIAL_NUMBER", + "FORMATTED_STRING" + ], + "description": "How dates, times, and durations should be represented in the output. This is ignored if value_render_option is FORMATTED_VALUE. The default dateTime render option is [DateTimeRenderOption.SERIAL_NUMBER]." + }, + "valueRenderOption": { + "type": "string", + "enumDescriptions": [ + "Values will be calculated & formatted in the reply according to the cell's formatting. Formatting is based on the spreadsheet's locale, not the requesting user's locale. For example, if `A1` is `1.23` and `A2` is `=A1` and formatted as currency, then `A2` would return `\"$1.23\"`.", + "Values will be calculated, but not formatted in the reply. For example, if `A1` is `1.23` and `A2` is `=A1` and formatted as currency, then `A2` would return the number `1.23`.", + "Values will not be calculated. The reply will include the formulas. For example, if `A1` is `1.23` and `A2` is `=A1` and formatted as currency, then A2 would return `\"=A1\"`." + ], + "location": "query", + "description": "How values should be represented in the output. The default render option is ValueRenderOption.FORMATTED_VALUE.", + "enum": [ + "FORMATTED_VALUE", + "UNFORMATTED_VALUE", + "FORMULA" + ] + } + } + }, + "batchGet": { + "description": "Returns one or more ranges of values from a spreadsheet. The caller must specify the spreadsheet ID and one or more ranges.", + "httpMethod": "GET", + "response": { + "$ref": "BatchGetValuesResponse" + }, + "scopes": [ + "https://www.googleapis.com/auth/drive", + "https://www.googleapis.com/auth/drive.file", + "https://www.googleapis.com/auth/drive.readonly", + "https://www.googleapis.com/auth/spreadsheets", + "https://www.googleapis.com/auth/spreadsheets.readonly" + ], + "parameterOrder": [ + "spreadsheetId" + ], + "flatPath": "v4/spreadsheets/{spreadsheetId}/values:batchGet", + "parameters": { + "valueRenderOption": { + "enum": [ + "FORMATTED_VALUE", + "UNFORMATTED_VALUE", + "FORMULA" + ], + "location": "query", + "description": "How values should be represented in the output. The default render option is ValueRenderOption.FORMATTED_VALUE.", + "enumDescriptions": [ + "Values will be calculated & formatted in the reply according to the cell's formatting. Formatting is based on the spreadsheet's locale, not the requesting user's locale. For example, if `A1` is `1.23` and `A2` is `=A1` and formatted as currency, then `A2` would return `\"$1.23\"`.", + "Values will be calculated, but not formatted in the reply. For example, if `A1` is `1.23` and `A2` is `=A1` and formatted as currency, then `A2` would return the number `1.23`.", + "Values will not be calculated. The reply will include the formulas. For example, if `A1` is `1.23` and `A2` is `=A1` and formatted as currency, then A2 would return `\"=A1\"`." + ], + "type": "string" + }, + "spreadsheetId": { + "description": "The ID of the spreadsheet to retrieve data from.", + "location": "path", + "type": "string", + "required": true + }, + "ranges": { + "type": "string", + "repeated": true, + "location": "query", + "description": "The A1 notation of the values to retrieve." + }, + "majorDimension": { + "type": "string", + "enumDescriptions": [ + "The default value, do not use.", + "Operates on the rows of a sheet.", + "Operates on the columns of a sheet." + ], + "enum": [ + "DIMENSION_UNSPECIFIED", + "ROWS", + "COLUMNS" + ], + "description": "The major dimension that results should use. For example, if the spreadsheet data is: `A1=1,B1=2,A2=3,B2=4`, then requesting `range=A1:B2,majorDimension=ROWS` returns `[[1,2],[3,4]]`, whereas requesting `range=A1:B2,majorDimension=COLUMNS` returns `[[1,3],[2,4]]`.", + "location": "query" + }, + "dateTimeRenderOption": { + "type": "string", + "enum": [ + "SERIAL_NUMBER", + "FORMATTED_STRING" + ], + "description": "How dates, times, and durations should be represented in the output. This is ignored if value_render_option is FORMATTED_VALUE. The default dateTime render option is [DateTimeRenderOption.SERIAL_NUMBER].", + "location": "query", + "enumDescriptions": [ + "Instructs date, time, datetime, and duration fields to be output as doubles in \"serial number\" format, as popularized by Lotus 1-2-3. The whole number portion of the value (left of the decimal) counts the days since December 30th 1899. The fractional portion (right of the decimal) counts the time as a fraction of the day. For example, January 1st 1900 at noon would be 2.5, 2 because it's 2 days after December 30st 1899, and .5 because noon is half a day. February 1st 1900 at 3pm would be 33.625. This correctly treats the year 1900 as not a leap year.", + "Instructs date, time, datetime, and duration fields to be output as strings in their given number format (which is dependent on the spreadsheet locale)." + ] + } + }, + "path": "v4/spreadsheets/{spreadsheetId}/values:batchGet", + "id": "sheets.spreadsheets.values.batchGet" + }, + "batchUpdate": { + "parameterOrder": [ + "spreadsheetId" + ], + "scopes": [ + "https://www.googleapis.com/auth/drive", + "https://www.googleapis.com/auth/drive.file", + "https://www.googleapis.com/auth/spreadsheets" + ], + "path": "v4/spreadsheets/{spreadsheetId}/values:batchUpdate", + "parameters": { + "spreadsheetId": { + "description": "The ID of the spreadsheet to update.", + "location": "path", + "required": true, + "type": "string" + } + }, + "response": { + "$ref": "BatchUpdateValuesResponse" + }, + "flatPath": "v4/spreadsheets/{spreadsheetId}/values:batchUpdate", + "request": { + "$ref": "BatchUpdateValuesRequest" + }, + "id": "sheets.spreadsheets.values.batchUpdate", + "description": "Sets values in one or more ranges of a spreadsheet. The caller must specify the spreadsheet ID, a valueInputOption, and one or more ValueRanges.", + "httpMethod": "POST" + }, + "clear": { + "description": "Clears values from a spreadsheet. The caller must specify the spreadsheet ID and range. Only values are cleared -- all other properties of the cell (such as formatting, data validation, etc..) are kept.", + "response": { + "$ref": "ClearValuesResponse" + }, + "request": { + "$ref": "ClearValuesRequest" + }, + "httpMethod": "POST", + "flatPath": "v4/spreadsheets/{spreadsheetId}/values/{range}:clear", + "id": "sheets.spreadsheets.values.clear", + "scopes": [ + "https://www.googleapis.com/auth/drive", + "https://www.googleapis.com/auth/drive.file", + "https://www.googleapis.com/auth/spreadsheets" + ], + "parameterOrder": [ + "spreadsheetId", + "range" + ], + "path": "v4/spreadsheets/{spreadsheetId}/values/{range}:clear", + "parameters": { + "range": { + "required": true, + "description": "The A1 notation of the values to clear.", + "location": "path", + "type": "string" + }, + "spreadsheetId": { + "required": true, + "type": "string", + "location": "path", + "description": "The ID of the spreadsheet to update." + } + } + }, + "batchClearByDataFilter": { + "httpMethod": "POST", + "id": "sheets.spreadsheets.values.batchClearByDataFilter", + "request": { + "$ref": "BatchClearValuesByDataFilterRequest" + }, + "parameters": { + "spreadsheetId": { + "location": "path", + "description": "The ID of the spreadsheet to update.", + "type": "string", + "required": true + } + }, + "description": "Clears one or more ranges of values from a spreadsheet. The caller must specify the spreadsheet ID and one or more DataFilters. Ranges matching any of the specified data filters will be cleared. Only values are cleared -- all other properties of the cell (such as formatting, data validation, etc..) are kept.", + "scopes": [ + "https://www.googleapis.com/auth/drive", + "https://www.googleapis.com/auth/drive.file", + "https://www.googleapis.com/auth/spreadsheets" + ], + "path": "v4/spreadsheets/{spreadsheetId}/values:batchClearByDataFilter", + "response": { + "$ref": "BatchClearValuesByDataFilterResponse" + }, + "parameterOrder": [ + "spreadsheetId" + ], + "flatPath": "v4/spreadsheets/{spreadsheetId}/values:batchClearByDataFilter" + } + } + }, + "developerMetadata": { + "methods": { + "search": { + "flatPath": "v4/spreadsheets/{spreadsheetId}/developerMetadata:search", + "id": "sheets.spreadsheets.developerMetadata.search", + "request": { + "$ref": "SearchDeveloperMetadataRequest" + }, + "parameterOrder": [ + "spreadsheetId" + ], + "scopes": [ + "https://www.googleapis.com/auth/drive", + "https://www.googleapis.com/auth/drive.file", + "https://www.googleapis.com/auth/spreadsheets" + ], + "parameters": { + "spreadsheetId": { + "description": "The ID of the spreadsheet to retrieve metadata from.", + "location": "path", + "required": true, + "type": "string" + } + }, + "path": "v4/spreadsheets/{spreadsheetId}/developerMetadata:search", + "response": { + "$ref": "SearchDeveloperMetadataResponse" + }, + "httpMethod": "POST", + "description": "Returns all developer metadata matching the specified DataFilter. If the provided DataFilter represents a DeveloperMetadataLookup object, this will return all DeveloperMetadata entries selected by it. If the DataFilter represents a location in a spreadsheet, this will return all developer metadata associated with locations intersecting that region." + }, + "get": { + "parameters": { + "metadataId": { + "location": "path", + "format": "int32", + "type": "integer", + "description": "The ID of the developer metadata to retrieve.", + "required": true + }, + "spreadsheetId": { + "location": "path", + "description": "The ID of the spreadsheet to retrieve metadata from.", + "type": "string", + "required": true + } + }, + "path": "v4/spreadsheets/{spreadsheetId}/developerMetadata/{metadataId}", + "flatPath": "v4/spreadsheets/{spreadsheetId}/developerMetadata/{metadataId}", + "scopes": [ + "https://www.googleapis.com/auth/drive", + "https://www.googleapis.com/auth/drive.file", + "https://www.googleapis.com/auth/spreadsheets" + ], + "id": "sheets.spreadsheets.developerMetadata.get", + "description": "Returns the developer metadata with the specified ID. The caller must specify the spreadsheet ID and the developer metadata's unique metadataId.", + "httpMethod": "GET", + "response": { + "$ref": "DeveloperMetadata" + }, + "parameterOrder": [ + "spreadsheetId", + "metadataId" + ] + } + } + }, + "sheets": { + "methods": { + "copyTo": { + "flatPath": "v4/spreadsheets/{spreadsheetId}/sheets/{sheetId}:copyTo", + "request": { + "$ref": "CopySheetToAnotherSpreadsheetRequest" + }, + "parameterOrder": [ + "spreadsheetId", + "sheetId" + ], + "path": "v4/spreadsheets/{spreadsheetId}/sheets/{sheetId}:copyTo", + "response": { + "$ref": "SheetProperties" + }, + "id": "sheets.spreadsheets.sheets.copyTo", + "parameters": { + "spreadsheetId": { + "required": true, + "type": "string", + "location": "path", + "description": "The ID of the spreadsheet containing the sheet to copy." + }, + "sheetId": { + "type": "integer", + "format": "int32", + "required": true, + "location": "path", + "description": "The ID of the sheet to copy." + } + }, + "scopes": [ + "https://www.googleapis.com/auth/drive", + "https://www.googleapis.com/auth/drive.file", + "https://www.googleapis.com/auth/spreadsheets" + ], + "httpMethod": "POST", + "description": "Copies a single sheet from a spreadsheet to another spreadsheet. Returns the properties of the newly created sheet." + } + } + } + }, + "methods": { + "batchUpdate": { + "parameterOrder": [ + "spreadsheetId" + ], + "description": "Applies one or more updates to the spreadsheet. Each request is validated before being applied. If any request is not valid then the entire request will fail and nothing will be applied. Some requests have replies to give you some information about how they are applied. The replies will mirror the requests. For example, if you applied 4 updates and the 3rd one had a reply, then the response will have 2 empty replies, the actual reply, and another empty reply, in that order. Due to the collaborative nature of spreadsheets, it is not guaranteed that the spreadsheet will reflect exactly your changes after this completes, however it is guaranteed that the updates in the request will be applied together atomically. Your changes may be altered with respect to collaborator changes. If there are no collaborators, the spreadsheet should reflect your changes.", + "scopes": [ + "https://www.googleapis.com/auth/drive", + "https://www.googleapis.com/auth/drive.file", + "https://www.googleapis.com/auth/spreadsheets" + ], + "request": { + "$ref": "BatchUpdateSpreadsheetRequest" + }, + "parameters": { + "spreadsheetId": { + "description": "The spreadsheet to apply the updates to.", + "required": true, + "type": "string", + "location": "path" + } + }, + "httpMethod": "POST", + "response": { + "$ref": "BatchUpdateSpreadsheetResponse" + }, + "id": "sheets.spreadsheets.batchUpdate", + "path": "v4/spreadsheets/{spreadsheetId}:batchUpdate", + "flatPath": "v4/spreadsheets/{spreadsheetId}:batchUpdate" + }, + "getByDataFilter": { + "scopes": [ + "https://www.googleapis.com/auth/drive", + "https://www.googleapis.com/auth/drive.file", + "https://www.googleapis.com/auth/spreadsheets" + ], + "request": { + "$ref": "GetSpreadsheetByDataFilterRequest" + }, + "parameterOrder": [ + "spreadsheetId" + ], + "httpMethod": "POST", + "flatPath": "v4/spreadsheets/{spreadsheetId}:getByDataFilter", + "path": "v4/spreadsheets/{spreadsheetId}:getByDataFilter", + "description": "Returns the spreadsheet at the given ID. The caller must specify the spreadsheet ID. This method differs from GetSpreadsheet in that it allows selecting which subsets of spreadsheet data to return by specifying a dataFilters parameter. Multiple DataFilters can be specified. Specifying one or more data filters will return the portions of the spreadsheet that intersect ranges matched by any of the filters. By default, data within grids will not be returned. You can include grid data one of two ways: * Specify a field mask listing your desired fields using the `fields` URL parameter in HTTP * Set the includeGridData parameter to true. If a field mask is set, the `includeGridData` parameter is ignored For large spreadsheets, it is recommended to retrieve only the specific fields of the spreadsheet that you want.", + "id": "sheets.spreadsheets.getByDataFilter", + "response": { + "$ref": "Spreadsheet" + }, + "parameters": { + "spreadsheetId": { + "type": "string", + "required": true, + "description": "The spreadsheet to request.", + "location": "path" + } + } + }, + "create": { + "flatPath": "v4/spreadsheets", + "response": { + "$ref": "Spreadsheet" + }, + "request": { + "$ref": "Spreadsheet" + }, + "description": "Creates a spreadsheet, returning the newly created spreadsheet.", + "httpMethod": "POST", + "parameterOrder": [], + "id": "sheets.spreadsheets.create", + "scopes": [ + "https://www.googleapis.com/auth/drive", + "https://www.googleapis.com/auth/drive.file", + "https://www.googleapis.com/auth/spreadsheets" + ], + "parameters": {}, + "path": "v4/spreadsheets" + }, + "get": { + "parameters": { + "spreadsheetId": { + "required": true, + "description": "The spreadsheet to request.", + "type": "string", + "location": "path" + }, + "includeGridData": { + "location": "query", + "description": "True if grid data should be returned. This parameter is ignored if a field mask was set in the request.", + "type": "boolean" + }, + "ranges": { + "description": "The ranges to retrieve from the spreadsheet.", + "repeated": true, + "location": "query", + "type": "string" + } + }, + "id": "sheets.spreadsheets.get", + "path": "v4/spreadsheets/{spreadsheetId}", + "flatPath": "v4/spreadsheets/{spreadsheetId}", + "httpMethod": "GET", + "description": "Returns the spreadsheet at the given ID. The caller must specify the spreadsheet ID. By default, data within grids will not be returned. You can include grid data one of two ways: * Specify a field mask listing your desired fields using the `fields` URL parameter in HTTP * Set the includeGridData URL parameter to true. If a field mask is set, the `includeGridData` parameter is ignored For large spreadsheets, it is recommended to retrieve only the specific fields of the spreadsheet that you want. To retrieve only subsets of the spreadsheet, use the ranges URL parameter. Multiple ranges can be specified. Limiting the range will return only the portions of the spreadsheet that intersect the requested ranges. Ranges are specified using A1 notation.", + "response": { + "$ref": "Spreadsheet" + }, + "scopes": [ + "https://www.googleapis.com/auth/drive", + "https://www.googleapis.com/auth/drive.file", + "https://www.googleapis.com/auth/drive.readonly", + "https://www.googleapis.com/auth/spreadsheets", + "https://www.googleapis.com/auth/spreadsheets.readonly" + ], + "parameterOrder": [ + "spreadsheetId" + ] + } + } + } + } +} diff --git a/venv/lib/python3.10/site-packages/pygsheets/datarange.py b/venv/lib/python3.10/site-packages/pygsheets/datarange.py new file mode 100644 index 0000000000000000000000000000000000000000..1310f70161ebf575ede598f3427d21249a240c4c --- /dev/null +++ b/venv/lib/python3.10/site-packages/pygsheets/datarange.py @@ -0,0 +1,462 @@ +# -*- coding: utf-8 -*-. + +""" +pygsheets.datarange +~~~~~~~~~~~~~~~~~~~ + +This module contains DataRange class. + +""" + +import logging + +from pygsheets.address import GridRange +from pygsheets.exceptions import InvalidArgumentValue, CellNotFound + + +class DataRange(object): + """ + DataRange specifies a range of cells in the sheet. It can be unbounded on one or more axes. + DataRange is for storing/manipulating a range of data in worksheet. This class can be used for + group operations, e.g. changing format of all cells in a given range. This can also + represent named ranges protected ranges, banned ranges etc. + + All the proteted range properties are stored in protected_properties. + + + :param start: top left cell address. can be unbounded. + :param end: bottom right cell address + :param worksheet: worksheet where this range belongs + :param name: name of the named range + :param data: data of the range in as row major matrix + :param name_id: id of named range + :param namedjson: json representing the NamedRange from api + + >>> drange = Datarange(start='A1', end='B2', worksheet=wks) + + >>> drange.name = "my_named_range" # make this datarange a named range + + >>> drange.protected = True # make the range protected + + >>> drange.start_addr = 'B' # make the range unbounded on rows + + >>> drange.end_addr = None # make the range unbounded on both axes + + + """ + + def __init__(self, start=None, end=None, worksheet=None, name='', data=None, name_id=None, namedjson=None, + protectedjson=None, grange=None): + self._worksheet = worksheet + self.logger = logging.getLogger(__name__) + self.protected_properties = ProtectedRangeProperties() + if grange: + self.grid_range = grange + else: + self.grid_range = GridRange(worksheet=worksheet, start=start, end=end) + + if namedjson: + self.grid_range.set_json(namedjson['range']) + name_id = namedjson['namedRangeId'] + name = namedjson['name'] + if protectedjson: + self.grid_range.set_json(protectedjson['range']) + name_id = protectedjson.get('namedRangeId', '') # @TODO get the name also + self.protected_properties = ProtectedRangeProperties(protectedjson) + + if data: + if len(data) == self.grid_range.height and len(data[0]) == self.grid_range.width: + self._data = data + else: + self.fetch() + else: + self._data = [[]] + + self._linked = True + self._name_id = name_id + self._name = name + + @property + def name(self): + """name of the named range. setting a name will make this a range a named range + setting this to empty string will delete the named range + """ + return self._name + + @name.setter + def name(self, name): + if type(name) is not str: + raise InvalidArgumentValue('name should be a string') + if not name: + self._worksheet.delete_named_range(range_id=self._name_id) + self._name = '' + self._name_id = '' + else: + if not self._name_id: + # @TODO handle when not linked (create an range on link) + if not self._linked: + self.logger.warn("unimplimented bahaviour") + api_obj = self._worksheet.create_named_range(name, grange=self.grid_range, returnas='json') + self._name = name + self._name_id = api_obj['namedRangeId'] + else: + self._name = name + self.update_named_range() + + @property + def name_id(self): + """ if of the named range """ + return self._name_id + + # Protected properties TODO move to protected properties @next_version + + @property + def protect_id(self): + """ id of the protected range """ + return self.protected_properties.protected_id + + @property + def protected(self): + """get/set the range as protected + setting this to False will make this range unprotected + """ + return self.protected_properties.is_protected() + + @protected.setter + def protected(self, value): + if value: + if not self.protected: + resp = self._worksheet.create_protected_range(grange=self.grid_range, named_range_id=self._name_id, + returnas='json') + self.protected_properties.set_json(resp) + else: + if self.protected: + self._worksheet.remove_protected_range(self.protect_id) + self.protected_properties.clear() + + @property + def editors(self): + """ + Lists the editors of the protected range + can also set a list of editors, take a tuple ('users' or 'groups', []) + can also set ('domainUsersCanEdit', Boolean) + """ + return self.protected_properties.editors + + @editors.setter + def editors(self, value): + if type(value) is not tuple or value[0] not in ['users', 'groups', 'domainUsersCanEdit']: + raise InvalidArgumentValue + self.protected_properties.editors[value[0]] = value[1] + self.update_protected_range(fields='editors') + + @property + def requesting_user_can_edit(self): + """ if the requesting user can edit protected range """ + return self.protected_properties.requestingUserCanEdit + + @requesting_user_can_edit.setter + def requesting_user_can_edit(self, value): + self.protected_properties.requestingUserCanEdit = value + self.update_protected_range(fields='requestingUserCanEdit') + + @property + def description(self): + """ if the requesting user can edit protected range """ + return self.protected_properties.description + + @description.setter + def description(self, value): + self.protected_properties.description = value + self.update_protected_range(fields='description') + + # End protected properties + + @property + def start_addr(self): + """top-left address of the range""" + return self.grid_range.start.index + + @start_addr.setter + def start_addr(self, addr): + self.grid_range.start = addr + self.update_named_range() + self.update_protected_range() + + @property + def end_addr(self): + """bottom-right address of the range""" + return self.grid_range.end.index + + @end_addr.setter + def end_addr(self, addr): + self.grid_range.end = addr + self.update_named_range() + self.update_protected_range() + + @property + def range(self): + """Range in format A1:C5""" + return self.grid_range.start.label + ':' + self.grid_range.end.label + + @property + def worksheet(self): + """ linked worksheet """ + return self._worksheet + + @property + def cells(self): + """Get cells of this range""" + if len(self._data[0]) == 0: + self.fetch() + return self._data + + def link(self, update=True): + """link the datarange so that all properties are synced right after setting them + + :param update: if the range should be synced to cloud on link + """ + if not self._worksheet: + raise InvalidArgumentValue("No worksheet defined to link this range to.") + self._linked = True + + [[y.link(worksheet=self._worksheet, update=update) for y in x] for x in self._data] + if update: + self.update_protected_range() + self.update_named_range() + + def unlink(self): + """unlink the sheet so that all properties are not synced as it is changed""" + self._linked = False + [[y.unlink() for y in x] for x in self._data] + + def fetch(self, only_data=True): + """ + update the range data/properties from cloud + + .. warning:: + Currently only data is fetched not properties, so `only_data` wont work + + :param only_data: fetch only data + + """ + self._data = self._worksheet.get_values(grange=self.grid_range, returnas='cells', + include_tailing_empty_rows=True, include_tailing_empty=True) + if not only_data: + logging.error("functionality not implimented") + + def apply_format(self, cell=None, fields=None, cell_json=None): + """ + Change format of all cells in the range + + :param cell: a model :class: Cell whose format will be applied to all cells + :param fields: comma seprated string of fields of cell to apply, refer to `google api docs `__ + :param cell_json: if not providing a cell object, provide a cell json. refer to `google api docs `__ + """ + if not cell_json: + cell_json = cell.get_json() + request = {"repeatCell": { + "range": self._get_gridrange(), + "cell": cell_json, + "fields": fields or "userEnteredFormat,hyperlink,note,textFormatRuns,dataValidation,pivotTable" + } + } + self._worksheet.client.sheet.batch_update(self._worksheet.spreadsheet.id, request) + + def update_values(self, values=None): + """ + Update the worksheet with values of the cells in this range + + :param values: values as matrix, which has same size as the range + + """ + if self._linked and values: + self._worksheet.update_values(crange=self.range, values=values) + self.fetch() + if self._linked and not values: + self._worksheet.update_values(cell_list=self._data) + + def sort(self, basecolumnindex=0, sortorder="ASCENDING"): + """sort the values in the datarange + + :param basecolumnindex: Index of the base column in which sorting is to be done (Integer). + The index here is the index of the column in range (first columen is 0). + :param sortorder: either "ASCENDING" or "DESCENDING" (String) + """ + self._worksheet.sort_range(grange=self.grid_range, + basecolumnindex=basecolumnindex + self.grid_range.start[1]-1, + sortorder=sortorder) + + def clear(self, fields="userEnteredValue"): + """ + Clear values in this datarange. + + Reference: + + - `FieldMask Api object `_ + + :param fields: Comma separated list of field masks. + + """ + self._worksheet.clear(grange=self.grid_range, fields=fields) + + def update_named_range(self): + """update the named range properties""" + if not self._name_id or not self._linked: + return False + if self.protected: + self.update_protected_range() + request = {'updateNamedRange': { + "namedRange": { + "namedRangeId": self._name_id, + "name": self._name, + "range": self._get_gridrange(), + }, + "fields": '*', + }} + self._worksheet.client.sheet.batch_update(self._worksheet.spreadsheet.id, request) + + def update_protected_range(self, fields='*'): + """ update the protected range properties """ + if not self.protected or not self._linked: + return False + + request = {'updateProtectedRange': { + "protectedRange": self.protected_properties.to_json(), + "fields": fields, + }} + if self._name_id: + request['updateProtectedRange']['protectedRange']['namedRangeId'] = self._name_id + else: + request['updateProtectedRange']['protectedRange']['range'] = self._get_gridrange() + self._worksheet.client.sheet.batch_update(self._worksheet.spreadsheet.id, request) + + def update_borders(self, top=False, right=False, bottom=False, left=False, inner_horizontal=False, inner_vertical=False, + style='NONE', width=1, red=0, green=0, blue=0): + """ + update borders for range + + NB use style='NONE' to erase borders + default color is black + + :param top: make a top border + :param right: make a right border + :param bottom: make a bottom border + :param left: make a left border + :param style: either 'SOLID', 'DOTTED', 'DASHED', 'SOLID', 'SOLID_MEDIUM', 'SOLID_THICK', 'DOUBLE' or 'NONE' (String). + :param width: border width (depreciated) (Integer). + :param red: 0-255 (Integer). + :param green: 0-255 (Integer). + :param blue: 0-255 (Integer). + """ + if not (top or right or bottom or left): + return + + if style not in ['SOLID', 'DOTTED', 'DASHED', 'SOLID', 'SOLID_MEDIUM', 'SOLID_THICK', 'DOUBLE', 'NONE']: + raise ValueError('specified value is not a valid border style') + + request = {"updateBorders": {"range": self._get_gridrange()}} + + border = { + "style": style, + "width": width, + "color": { + "red": red, + "green": green, + "blue": blue + }} + + if top: + request["updateBorders"]["top"] = border + if bottom: + request["updateBorders"]["bottom"] = border + if left: + request["updateBorders"]["left"] = border + if right: + request["updateBorders"]["right"] = border + if inner_horizontal: + request["updateBorders"]["innerHorizontal"] = border + if inner_vertical: + request["updateBorders"]["innerVertical"] = border + + self._worksheet.client.sheet.batch_update(self._worksheet.spreadsheet.id, request) + + def merge_cells(self, merge_type='MERGE_ALL'): + """ + Merge cells in range + + ! You can't vertically merge cells that intersect an existing filter + + :param merge_type: either 'MERGE_ALL' + ,'MERGE_COLUMNS' ( = merge multiple rows (!) together to make column(s)) + ,'MERGE_ROWS' ( = merge multiple columns (!) together to make a row(s)) + ,'NONE' (unmerge) + """ + self._worksheet.merge_cells(merge_type=merge_type, grange=self.grid_range) + + def _get_gridrange(self): + return self.grid_range.to_json() + + def __getitem__(self, item): + if len(self._data[0]) == 0 and self.grid_range.width > 0: + self.fetch() + if type(item) is int: + try: + return self._data[item] + except IndexError: + raise CellNotFound + + def __eq__(self, other): + return self.start_addr == other.start_addr and self.end_addr == other.end_addr\ + and self.name == other.name and self.protect_id == other.protect_id + + def __repr__(self): + range_str = self.range + if self.worksheet: + range_str = str(self.grid_range.label) + protected_str = " protected" if self.protected else "" + + return '<%s %s %s%s>' % (self.__class__.__name__, str(self._name), range_str, protected_str) + + +class ProtectedRangeProperties(object): + + def __init__(self, api_obj=None): + self.protected_id = None + self.description = None + self.warningOnly = None + self.requestingUserCanEdit = None + self.editors = None + if api_obj: + self.set_json(api_obj) + + def set_json(self, api_obj): + if type(api_obj) is not dict: + raise InvalidArgumentValue + self.protected_id = api_obj['protectedRangeId'] + self.description = api_obj.get('description', '') + self.editors = api_obj.get('editors', {}) + self.warningOnly = api_obj.get('warningOnly', False) + self.requestingUserCanEdit = api_obj.get('requestingUserCanEdit', None) + + def to_json(self): + api_obj = { + "protectedRangeId": self.protected_id, + "description": self.description, + "warningOnly": self.warningOnly, + "requestingUserCanEdit": self.requestingUserCanEdit, + "editors": self.editors + } + return api_obj + + def is_protected(self): + return self.protected_id is not None + + def clear(self): + self.protected_id = None + self.description = None + self.warningOnly = None + self.requestingUserCanEdit = None + self.editors = None + + diff --git a/venv/lib/python3.10/site-packages/pygsheets/developer_metadata.py b/venv/lib/python3.10/site-packages/pygsheets/developer_metadata.py new file mode 100644 index 0000000000000000000000000000000000000000..aa71f4f04330381ba450075b83c0aa3f9b585a50 --- /dev/null +++ b/venv/lib/python3.10/site-packages/pygsheets/developer_metadata.py @@ -0,0 +1,106 @@ +# -*- coding: utf-8 -*-. + + +class DeveloperMetadataLookupDataFilter: + """Class for filtering developer metadata queries + + This class only supports filtering for metadata on a whole spreadsheet or + worksheet. + + :param spreadsheet_id: Spreadsheet id to filter on (leave at None to search all metadata) + :param sheet_id: Worksheet id to filter on (leave at None for whole-spreadsheet metadata) + :param meta_id: Developer metadata id to filter on (optional) + :param meta_key: Developer metadata key to filter on (optional) + :param meta_value: Developer metadata value to filter on (optional) + """ + + def __init__(self, spreadsheet_id=None, sheet_id=None, meta_id=None, meta_key=None, meta_value=None): + self.spreadsheet_id = spreadsheet_id + self.sheet_id = sheet_id + self.meta_filters = { + "metadataId": meta_id, + "metadataKey": meta_key, + "metadataValue": meta_value, + "metadataLocation": self.location + } + + def to_json(self): + lookup = dict((k, v) for k, v in self.meta_filters.items() if v is not None) + return {"developerMetadataLookup": lookup} + + @property + def location(self): + if self.spreadsheet_id is not None: + if self.sheet_id is None: + return {"spreadsheet": True} + elif self.sheet_id is not None: + return {"sheetId": self.sheet_id} + return None + + +class DeveloperMetadata(object): + @classmethod + def new(cls, key, value, client, spreadsheet_id, sheet_id=None): + """Create a new developer metadata entry + + Will return None when in batch mode, otherwise will return a DeveloperMetadata object + + :param key: They key of the new developer metadata entry to create + :param value: They value of the new developer metadata entry to create + :param client: The client which is responsible to connect the sheet with the remote. + :param spreadsheet_id: The id of the spreadsheet where metadata will be created. + :param sheet_id: The id of the worksheet where the metadata will be created (optional) + """ + filter = DeveloperMetadataLookupDataFilter(spreadsheet_id, sheet_id) + meta_id = client.sheet.developer_metadata_create(spreadsheet_id, key, value, filter.location) + if meta_id is None: + # we're in batch mode + return + return cls(meta_id, key, value, client, spreadsheet_id, sheet_id) + + def __init__(self, meta_id, key, value, client, spreadsheet_id, sheet_id=None): + """Create a new developer metadata entry + + Will return None when in batch mode, otherwise will return a DeveloperMetadata object + + :param meta_id: The id of the developer metadata entry this represents + :param key: They key of the new developer metadata entry this represents + :param value: They value of the new developer metadata entry this represents + :param client: The client which is responsible to connect the sheet with the remote. + :param spreadsheet_id: The id of the spreadsheet where metadata is stored + :param sheet_id: The id of the worksheet where the metadata is stored (optional) + """ + self._id = meta_id + self.key = key + self.value = value + self.client = client + self.spreadsheet_id = spreadsheet_id + self.sheet_id = sheet_id + self._filter = DeveloperMetadataLookupDataFilter(self.spreadsheet_id, + self.sheet_id, self.id) + + def __repr__(self): + return "".format(repr(self.id), + repr(self.key), + repr(self.value)) + + @property + def id(self): + return self._id + + def fetch(self): + """Refresh this developer metadata entry from the spreadsheet""" + response = self.client.sheet.developer_metadata_get(self.spreadsheet_id, self.id) + self.key = response["metadataKey"] + self.value = response["metadataValue"] + + def update(self): + """Push the current local values to the spreadsheet""" + self.client.sheet.developer_metadata_update(self.spreadsheet_id, self.key, + self.value, self._filter.location, + self._filter.to_json()) + + def delete(self): + """Delete this developer metadata entry""" + self.client.sheet.developer_metadata_delete(self.spreadsheet_id, + self._filter.to_json()) diff --git a/venv/lib/python3.10/site-packages/pygsheets/drive.py b/venv/lib/python3.10/site-packages/pygsheets/drive.py new file mode 100644 index 0000000000000000000000000000000000000000..4f6ea2c31bce56cee419471e7574227e18fc3b61 --- /dev/null +++ b/venv/lib/python3.10/site-packages/pygsheets/drive.py @@ -0,0 +1,428 @@ +from pygsheets.spreadsheet import Spreadsheet +from pygsheets.worksheet import Worksheet +from pygsheets.custom_types import ExportType +from pygsheets.exceptions import InvalidArgumentValue, CannotRemoveOwnerError, FolderNotFound + +from googleapiclient import discovery +from googleapiclient.http import MediaIoBaseDownload +from googleapiclient.errors import HttpError + +import logging +import json +import os +import re + +""" +pygsheets.drive +~~~~~~~~~~~~~~ + +This module provides wrappers for the Google Drive API v3. + +""" + +PERMISSION_ROLES = ['organizer', 'owner', 'writer', 'commenter', 'reader'] +PERMISSION_TYPES = ['user', 'group', 'domain', 'anyone'] + +FIELDS_TO_INCLUDE = 'files(id, name, parents), nextPageToken, incompleteSearch' + +_EMAIL_PATTERN = re.compile(r"\"?([-a-zA-Z0-9.`?{}]+@[-a-zA-Z0-9.]+\.\w+)\"?") +DISCOVERY_SERVICE_URL = 'https://www.googleapis.com/discovery/v1/apis/drive/v3/rest' + + +class DriveAPIWrapper(object): + """A simple wrapper for the Google Drive API. + + Various utility and convenience functions to support access to Google Drive files. By default the + requests will access the users personal drive. Use enable_team_drive(team_drive_id) to connect to a + TeamDrive instead. + + Only functions used by pygsheet are wrapped. All other functionality can be accessed through the service + attribute. + + See `reference `__ for details. + + :param http: HTTP object to make requests with. + :param data_path: Path to the drive discovery file. + """ + + _spreadsheet_mime_type = "application/vnd.google-apps.spreadsheet" + _folder_mime_type = "application/vnd.google-apps.folder" + + def __init__(self, http, data_path, retries=3, logger=logging.getLogger(__name__)): + + try: + with open(os.path.join(data_path, "drive_discovery.json")) as jd: + self.service = discovery.build_from_document(json.load(jd), http=http) + except: + self.service = discovery.build('drive', 'v3', http=http, discoveryServiceUrl=DISCOVERY_SERVICE_URL) + self.team_drive_id = None + self.include_team_drive_items = True # TODO Deprecated remove + self.include_items_from_all_drive = True + """Include files from TeamDrive and My Drive when executing requests.""" + self.logger = logger + self.retries = retries + + def enable_team_drive(self, team_drive_id): + """Access TeamDrive instead of the users personal drive.""" + self.team_drive_id = team_drive_id + + def disable_team_drive(self): + """Do not access TeamDrive (default behaviour).""" + self.team_drive_id = None + + def is_team_drive(self): + return self.team_drive_id is not None + + def get_update_time(self, file_id): + """Returns the time this file was last modified in RFC 3339 format.""" + return self._execute_request(self.service.files().get(fileId=file_id, fields='modifiedTime', + supportsAllDrives=self.is_team_drive()))['modifiedTime'] + + def list(self, **kwargs): + """ + Fetch metadata of spreadsheets. Fetches a list of all files present in the users drive + or TeamDrive. See Google Drive API Reference for details. + + Reference: `Files list request `__ + + :param kwargs: Standard parameters (see documentation for details). + :return: List of metadata. + """ + result = list() + if self.is_team_drive(): + kwargs["driveId"] = self.team_drive_id + kwargs["includeItemsFromAllDrives"] = self.include_items_from_all_drive + kwargs["supportsAllDrives"] = True + kwargs["corpora"] = kwargs.get("corpora") or "drive" + + response = self._execute_request(self.service.files().list(**kwargs)) + result.extend(response['files']) + while 'nextPageToken' in response: + kwargs['pageToken'] = response['nextPageToken'] + response = self._execute_request(self.service.files().list(**kwargs)) + result.extend(response['files']) + + if 'incompleteSearch' in response and response['incompleteSearch']: + self.logger.warning('Not all files in the corpora %s were searched. As a result ' + 'the response might be incomplete.', kwargs['corpora']) + return result + + def create_folder(self, name, folder=None, **kwargs): + """Create a new folder + + :param name: The name to give the new folder + :param folder: The id of the folder this one will be stored in + :param kwargs: Standard parameters (see documentation for details). + :return: The new folder id + """ + body = { + 'name': name, + 'mimeType': self._folder_mime_type + } + if folder: + body['parents'] = [folder] + return self._execute_request(self.service.files().create(body=body, supportsAllDrives=self.is_team_drive(), + **kwargs))["id"] + + def get_folder_id(self, name): + """Fetch the first folder id with a given name + + :param name: The name of the folder to find + """ + try: + return list(filter(lambda x: x['name'] == name, self.folder_metadata()))[0]["id"] + except (KeyError, IndexError): + raise FolderNotFound('Could not find a folder with name %s.' % name) + + def folder_metadata(self, query='', only_team_drive=False): + """Fetch folder names, ids & and parent folder ids. + + The query string can be used to filter the returned metadata. + + Reference: `search parameters docs. `__ + + :param query: Can be used to filter the returned metadata. + """ + return self._metadata_for_mime_type(self._folder_mime_type, query, only_team_drive) + + def spreadsheet_metadata(self, query='', only_team_drive=False, fid=None): + """Fetch spreadsheet titles, ids & and parent folder ids. + + The query string can be used to filter the returned metadata. + + Reference: `search parameters docs. `__ + + :param fid: id of file [optional] + :param query: Can be used to filter the returned metadata. + """ + if fid: + return self._execute_request(self.service.files().get(fileId=fid, supportsAllDrives=self.is_team_drive())) + return self._metadata_for_mime_type(self._spreadsheet_mime_type, query, only_team_drive) + + def _metadata_for_mime_type(self, mime_type, query, only_team_drive): + """ + Implementation for fetching drive object metadata by mime type + """ + mime_type_query = "mimeType='{}'".format(mime_type) + if query: + query = query + ' and ' + str(mime_type_query) + else: + query = mime_type_query + result = self.list(fields=FIELDS_TO_INCLUDE, + q=query, pageSize=500, orderBy='recency') + + if self.is_team_drive() and not result and not only_team_drive: + return self.list(fields=FIELDS_TO_INCLUDE, corpora="allDrives", + q=query, pageSize=500, orderBy='recency') + return result + + def delete(self, file_id, **kwargs): + """Delete a file by ID. + + Permanently deletes a file owned by the user without moving it to the trash. If the file belongs to a + Team Drive the user must be an organizer on the parent. If the input id is a folder, all descendants + owned by the user are also deleted. + + Reference: `delete request `__ + + :param file_id: The Id of the file to be deleted. + :param kwargs: Standard parameters (see documentation for details). + """ + kwargs['supportsAllDrives'] = self.is_team_drive() + + self._execute_request(self.service.files().delete(fileId=file_id, **kwargs)) + + def move_file(self, file_id, old_folder, new_folder, body=None, **kwargs): + """Move a file from one folder to another. + + Requires the current folder to delete it. + + Reference: `update request `_ + + :param file_id: ID of the file which should be moved. + :param old_folder: Current location. + :param new_folder: Destination. + :param body: Other fields of the file to change. See reference for details. + :param kwargs: Optional arguments. See reference for details. + """ + return self.update_file(file_id, body, removeParents=old_folder, addParents=new_folder, **kwargs) + + def copy_file(self, file_id, title, folder, body=None, **kwargs): + """ + Copy a file from one location to another + + Reference: `update request`_ + + :param file_id: Id of file to copy. + :param title: New title of the file. + :param folder: New folder where file should be copied. + :param body: Other fields of the file to change. See reference for details. + :param kwargs: Optional arguments. See reference for details. + """ + kwargs['supportsAllDrives'] = self.is_team_drive() + + body = body or {} + body['name'] = title + if folder: + body['parents'] = [folder] + return self._execute_request(self.service.files().copy(fileId=file_id, body=body, **kwargs)) + + def update_file(self, file_id, body=None, **kwargs): + """Update file body. + + Reference: `update request `_ + + :param file_id: ID of the file which should be updated. + :param body: The properties of the file to update. See reference for details. + :param kwargs: Optional arguments. See reference for details. + """ + kwargs['supportsAllDrives'] = self.is_team_drive() + + if body is not None: + kwargs["body"] = body + + return self._execute_request(self.service.files().update(fileId=file_id, **kwargs)) + + def _export_request(self, file_id, mime_type, **kwargs): + """The export request.""" + return self.service.files().export(fileId=file_id, mimeType=mime_type, **kwargs) + + def export(self, sheet, file_format, path='', filename=''): + """Download a spreadsheet and store it. + + Exports a Google Doc to the requested MIME type and returns the exported content. + + .. warning:: + This can at most export files with 10 MB in size! + + Uses one or several export request to download the files. When exporting to CSV or TSV each worksheet is + exported into a separate file. The API cannot put them into the same file. In this case the worksheet index + is appended to the file-name. + + Reference: `request `__ + + :param sheet: The spreadsheet or worksheet to be exported. + :param file_format: File format (:class:`ExportType`) + :param path: Path to where the file should be stored. (default: current working directory) + :param filename: Name of the file. (default: Spreadsheet Id) + """ + request = None + tmp = None + mime_type, file_extension = getattr(file_format, 'value', file_format).split(':') + + if isinstance(sheet, Spreadsheet): + if (file_format == ExportType.CSV or file_format == ExportType.TSV) and len(sheet.worksheets()) > 1: + for worksheet in sheet: + self.export(worksheet, file_format, path=path, filename=filename + str(worksheet.index)) + return + else: + request = self._export_request(sheet.id, mime_type) + elif isinstance(sheet, Worksheet): + if sheet.index != 0: + tmp = sheet.index + try: + sheet.index = 0 + except HttpError: + raise Exception("Can only export first sheet in readonly mode") + request = self._export_request(sheet.spreadsheet.id, mime_type) + + import io + file_name = str(sheet.id or tmp) + file_extension if filename is None else filename + file_extension + file_path = os.path.join(path, file_name) + fh = io.FileIO(file_path, 'wb') + downloader = MediaIoBaseDownload(fh, request) + done = False + while done is False: + status, done = downloader.next_chunk() + # logging.info('Download progress: %d%%.', int(status.progress() * 100)) TODO fix this + logging.info('Download finished. File saved in %s.', file_path) + + if tmp is not None: + sheet.index = tmp + 1 + if isinstance(sheet, Worksheet): + sheet.refresh(False) + + def create_permission(self, file_id, role, type, **kwargs): + """Creates a permission for a file or a TeamDrive. + + See `reference `__ for more details. + + :param file_id: The ID of the file or Team Drive. + :param role: The role granted by this permission. + :param type: The type of the grantee. + :keyword emailAddress: The email address of the user or group to which this permission refers. + :keyword domain: The domain to which this permission refers. + :parameter allowFileDiscovery: Whether the permission allows the file to be discovered through search. This is + only applicable for permissions of type domain or anyone. + :keyword expirationTime: The time at which this permission will expire (RFC 3339 date-time). Expiration + times have the following restrictions: + + * They can only be set on user and group permissions + * The time must be in the future + * The time cannot be more than a year in the future + + :keyword emailMessage: A plain text custom message to include in the notification email. + :keyword sendNotificationEmail: Whether to send a notification email when sharing to users or groups. + This defaults to true for users and groups, and is not allowed for other + requests. It must not be disabled for ownership transfers. + :keyword supportsTeamDrives: Whether the requesting application supports Team Drives. (Default: False) + :keyword transferOwnership: Whether to transfer ownership to the specified user and downgrade + the current owner to a writer. This parameter is required as an acknowledgement + of the side effect. (Default: False) + :keyword useDomainAdminAccess: Whether the request should be treated as if it was issued by a + domain administrator; if set to true, then the requester will be granted + access if they are an administrator of the domain to which the item belongs. + (Default: False) + :return: `Permission Resource `_ + """ + kwargs['supportsAllDrives'] = self.is_team_drive() + + if 'emailAddress' in kwargs and 'domain' in kwargs: + raise InvalidArgumentValue('A permission can only use emailAddress or domain. Do not specify both.') + if role not in PERMISSION_ROLES: + raise InvalidArgumentValue('A permission role can only be one of ' + str(PERMISSION_ROLES) + '.') + if type not in PERMISSION_TYPES: + raise InvalidArgumentValue('A permission role can only be one of ' + str(PERMISSION_TYPES) + '.') + + body = { + 'kind': 'drive#permission', + 'type': type, + 'role': role + } + + if 'emailAddress' in kwargs: + body['emailAddress'] = kwargs['emailAddress'] + del kwargs['emailAddress'] + elif 'domain' in kwargs: + body['domain'] = kwargs['domain'] + del kwargs['domain'] + + if 'allowFileDiscovery' in kwargs: + body['allowFileDiscovery'] = kwargs['allowFileDiscovery'] + del kwargs['allowFileDiscovery'] + + if 'expirationTime' in kwargs: + body['expirationTime'] = kwargs['expirationTime'] + del kwargs['expirationTime'] + + return self._execute_request(self.service.permissions().create(fileId=file_id, body=body, **kwargs)) + + def list_permissions(self, file_id, **kwargs): + """List all permissions for the specified file. + + See `reference `__ for more details. + + :param file_id: The file to get the permissions for. + :keyword pageSize: Number of permissions returned per request. (Default: all) + :keyword supportsTeamDrives: Whether the application supports TeamDrives. (Default: False) + :keyword useDomainAdminAccess: Request permissions as domain admin. (Default: False) + :return: List of `Permission Resources `_ + """ + kwargs['supportsAllDrives'] = self.is_team_drive() + + # Ensure that all fields are returned. Default is only id, type & role. + if 'fields' not in kwargs: + kwargs['fields'] = '*' + + permissions = list() + response = self._execute_request(self.service.permissions().list(fileId=file_id, **kwargs)) + permissions.extend(response['permissions']) + while 'nextPageToken' in response: + response = self._execute_request(self.service.permissions().list(fileId=file_id, + pageToken=response['nextPageToken'], + **kwargs)) + permissions.extend(response['permissions']) + return permissions + + def delete_permission(self, file_id, permission_id, **kwargs): + """Deletes a permission. + + See `reference `__ for more details. + + :param file_id: The ID of the file or Team Drive. + :param permission_id: The ID of the permission. + :keyword supportsTeamDrives: Whether the requesting application supports Team Drives. (Default: false) + :keyword useDomainAdminAccess: Whether the request should be treated as if it was issued by a + domain administrator; if set to true, then the requester will be + granted access if they are an administrator of the domain to which + the item belongs. (Default: false) + """ + kwargs['supportsAllDrives'] = self.is_team_drive() + + try: + self._execute_request( + self.service.permissions().delete(fileId=file_id, permissionId=permission_id, **kwargs)) + except HttpError as error: + self.logger.exception(str(error)) + if re.search(r'The owner of a file cannot be removed\.', str(error)): + raise CannotRemoveOwnerError('The owner of a file cannot be removed!') + else: + raise + + def _execute_request(self, request): + """Executes a request. + + :param request: The request to be executed. + :return: Returns the response of the request. + """ + return request.execute(num_retries=self.retries) diff --git a/venv/lib/python3.10/site-packages/pygsheets/exceptions.py b/venv/lib/python3.10/site-packages/pygsheets/exceptions.py new file mode 100644 index 0000000000000000000000000000000000000000..b83a1c70bcee3aab3ace3e62301c849b86a88a4e --- /dev/null +++ b/venv/lib/python3.10/site-packages/pygsheets/exceptions.py @@ -0,0 +1,65 @@ +# -*- coding: utf-8 -*- + +""" +pygsheets.exceptions +~~~~~~~~~~~~~~~~~~~~ + +Exceptions used in pygsheets. + +""" + + +class PyGsheetsException(Exception): + """A base class for pygsheets's exceptions.""" + + +class AuthenticationError(PyGsheetsException): + """An error during authentication process.""" + + +class SpreadsheetNotFound(PyGsheetsException): + """Trying to open non-existent or inaccessible spreadsheet.""" + + +class WorksheetNotFound(PyGsheetsException): + """Trying to open non-existent or inaccessible worksheet.""" + + +class CellNotFound(PyGsheetsException): + """Cell lookup exception.""" + + +class RangeNotFound(PyGsheetsException): + """Range lookup exception.""" + + +class TeamDriveNotFound(PyGsheetsException): + """TeamDrive Lookup Exception""" + + +class FolderNotFound(PyGsheetsException): + """Folder lookup exception.""" + + +class NoValidUrlKeyFound(PyGsheetsException): + """No valid key found in URL.""" + + +class IncorrectCellLabel(PyGsheetsException): + """The cell label is incorrect.""" + + +class RequestError(PyGsheetsException): + """Error while sending API request.""" + + +class InvalidArgumentValue(PyGsheetsException): + """Invalid value for argument""" + + +class InvalidUser(PyGsheetsException): + """Invalid user/domain""" + + +class CannotRemoveOwnerError(PyGsheetsException): + """A owner permission cannot be removed if is the last one.""" diff --git a/venv/lib/python3.10/site-packages/pygsheets/sheet.py b/venv/lib/python3.10/site-packages/pygsheets/sheet.py new file mode 100644 index 0000000000000000000000000000000000000000..7c705131fb3a35587cbfc9e61bd2c6424887c1c2 --- /dev/null +++ b/venv/lib/python3.10/site-packages/pygsheets/sheet.py @@ -0,0 +1,503 @@ +from pygsheets.spreadsheet import Spreadsheet +from pygsheets.utils import format_addr +from pygsheets.exceptions import InvalidArgumentValue +from pygsheets.custom_types import ValueRenderOption, DateTimeRenderOption + +from googleapiclient import discovery +from googleapiclient.errors import HttpError + +import logging +import json +import os +import time + +GOOGLE_SHEET_CELL_UPDATES_LIMIT = 50000 +DISCOVERY_SERVICE_URL = 'https://sheets.googleapis.com/$discovery/rest?version=v4' + + +class SheetAPIWrapper(object): + + def __init__(self, http, data_path, seconds_per_quota=100, retries=1, logger=logging.getLogger(__name__), + check=True): + """A wrapper class for the Google Sheets API v4. + + All calls to the the API are made in this class. This ensures that the quota is never hit. + + The default quota for the API is 100 requests per 100 seconds. Each request is made immediately and counted. + When 100 seconds have passed the counter is reset. Should the counter reach 101 the request is delayed until seconds_per_quota + seconds since the first request pass. + + :param http: The http object used to execute the requests. + :param data_path: Where the discovery json file is stored. + :param seconds_per_quota: Default value is 100 seconds + :param retries: How often the requests will be repeated if the connection times out. (Default 1) + :param check: Check for quota error and apply rate limiting. + :param logger: + """ + + self.logger = logger + try: + with open(os.path.join(data_path, "sheets_discovery.json")) as jd: + self.service = discovery.build_from_document(json.load(jd), http=http) + except: + self.service = discovery.build('sheets', 'v4', http=http, discoveryServiceUrl=DISCOVERY_SERVICE_URL) + self.retries = retries + self.seconds_per_quota = seconds_per_quota + self.check = check + self.batch_mode = False + self.batched_requests = dict() + + def set_batch_mode(self, mode): + self.batch_mode = mode + self.batched_requests = dict() + + def run_batch(self): + for ss, req in self.batched_requests.items(): + body = {'requests': req} + request = self.service.spreadsheets().batchUpdate(spreadsheetId=ss, body=body) + return self._execute_requests(request) + self.batched_requests = dict() + + def batch_update(self, spreadsheet_id, requests, **kwargs): + """ + Applies one or more updates to the spreadsheet. + + Each request is validated before being applied. If any request is not valid then the entire request will + fail and nothing will be applied. + + Some requests have replies to give you some information about how they are applied. The replies will mirror + the requests. For example, if you applied 4 updates and the 3rd one had a reply, then the response will have + 2 empty replies, the actual reply, and another empty reply, in that order. + + Due to the collaborative nature of spreadsheets, it is not guaranteed that the spreadsheet will reflect exactly + your changes after this completes, however it is guaranteed that the updates in the request will be applied + together atomically. Your changes may be altered with respect to collaborator changes. If there are no + collaborators, the spreadsheet should reflect your changes. + + +-----------------------------------+-----------------------------------------------------+ + | Request body params | Description | + +===================================+=====================================================+ + | includeSpreadsheetInResponse | | Determines if the update response should include | + | | | the spreadsheet resource. (default: False) | + +-----------------------------------+-----------------------------------------------------+ + | responseRanges[] | | Limits the ranges included in the response | + | | | spreadsheet. Only applied if the first param is | + | | | True. | + +-----------------------------------+-----------------------------------------------------+ + | responseIncludeGridData | | True if grid data should be returned. Meaningful | + | | | only if if includeSpreadsheetInResponse is 'true'.| + | | | This parameter is ignored if a field mask was set | + | | | in the request. | + +-----------------------------------+-----------------------------------------------------+ + + :param spreadsheet_id: The spreadsheet to apply the updates to. + :param requests: A list of updates to apply to the spreadsheet. Requests will be applied in the order + they are specified. If any request is not valid, no requests will be applied. + :param kwargs: Request body params & standard parameters (see reference for details). + :return: + """ + + if not isinstance(requests, list): + requests = [requests] + + if self.batch_mode: + if spreadsheet_id in self.batched_requests: + self.batched_requests[spreadsheet_id].extend(requests) + else: + self.batched_requests[spreadsheet_id] = requests + return + + body = {'requests': requests} + for param in ['includeSpreadsheetInResponse', 'responseRanges', 'responseIncludeGridData']: + if param in kwargs: + body[param] = kwargs[param] + del kwargs[param] + if 'fields' not in kwargs: + kwargs['fields'] = '*' + + request = self.service.spreadsheets().batchUpdate(spreadsheetId=spreadsheet_id, + body=body, **kwargs) + return self._execute_requests(request) + + def create(self, title, template=None, **kwargs): + """Create a spreadsheet. + + Can be created with just a title. All other values will be set to default. + + A template can be either a JSON representation of a Spreadsheet Resource as defined by the + Google Sheets API or an instance of the Spreadsheet class. Missing fields will be set to default. + + :param title: Title of the new spreadsheet. + :param template: Template used to create the new spreadsheet. + :param kwargs: Standard parameters (see reference for details). + :return: A Spreadsheet Resource. + """ + if template is None: + body = {'properties': {'title': title}} + else: + if isinstance(template, dict): + if 'properties' in template: + template['properties']['title'] = title + else: + template['properties'] = {'title': title} + body = template + elif isinstance(template, Spreadsheet): + body = template.to_json() + body['properties']['title'] = title + else: + raise InvalidArgumentValue('Need a dictionary or spreadsheet for a template.') + body.pop('spreadsheetId', None) + return self._execute_requests(self.service.spreadsheets().create(body=body, **kwargs)) + + def get(self, spreadsheet_id, **kwargs): + """Returns a full spreadsheet with the entire data. + + The data returned can be limited with parameters. See `reference `__ for details . + + :param spreadsheet_id: The Id of the spreadsheet to return. + :param kwargs: Standard parameters (see reference for details). + :return: Return a SheetResource. + """ + if 'fields' not in kwargs: + kwargs['fields'] = '*' + if 'includeGridData' not in kwargs: + kwargs['includeGridData'] = True + return self._execute_requests(self.service.spreadsheets().get(spreadsheetId=spreadsheet_id, **kwargs)) + + ################################# + # BATCH UPDATE REQUESTS # + ################################# + + def update_sheet_properties_request(self, spreadsheet_id, properties, fields): + """Updates the properties of the specified sheet. + + Properties must be an instance of `SheetProperties `__. + + :param spreadsheet_id: The id of the spreadsheet to be updated. + :param properties: The properties to be updated. + :param fields: Specifies the fields which should be updated. + :return: SheetProperties + """ + request = { + 'updateSheetProperties': + { + 'properties': properties, + 'fields': fields + } + } + return self.batch_update(spreadsheet_id, request) + + # def get_by_data_filter(self): + # pass + + def developer_metadata_get(self, spreadsheet_id, metadata_id): + """Returns a dictionary of developer metadata matching the supplied filter + + Reference: `request `__ + + :param spreadsheet_id: The id of the spreadsheet to search. + :param data_filter: The id of the developer metadata item to get + """ + request = self.service.spreadsheets().developerMetadata().get(spreadsheetId=spreadsheet_id, + metadataId=metadata_id) + return self._execute_requests(request) + + def developer_metadata_search(self, spreadsheet_id, data_filter): + """Returns a dictionary of developer metadata matching the supplied filter + + Reference: `request `__ + + :param spreadsheet_id: The id of the spreadsheet to search. + :param data_filter: A dictionary represeting a DeveloperMetadataLookup filter (see reference) + """ + body = {"dataFilters": [data_filter]} + request = self.service.spreadsheets().developerMetadata().search(spreadsheetId=spreadsheet_id, + body=body) + return self._execute_requests(request) + + def sheets_copy_to(self, source_spreadsheet_id, worksheet_id, destination_spreadsheet_id, **kwargs): + """Copies a worksheet from one spreadsheet to another. + + Reference: `request `_ + + :param source_spreadsheet_id: The ID of the spreadsheet containing the sheet to copy. + :param worksheet_id: The ID of the sheet to copy. + :param destination_spreadsheet_id: The ID of the spreadsheet to copy the sheet to. + :param kwargs: Standard parameters (see reference for details). + :return: SheetProperties + """ + if 'fields' not in kwargs: + kwargs['fields'] = '*' + + body = {"destinationSpreadsheetId": destination_spreadsheet_id} + request = self.service.spreadsheets().sheets().copyTo(spreadsheetId=source_spreadsheet_id, + sheetId=worksheet_id, + body=body, + **kwargs) + return self._execute_requests(request) + + def values_append(self, spreadsheet_id, values, major_dimension, range, **kwargs): + """Appends values to a spreadsheet. + + The input range is used to search for existing data and find a "table" within that range. Values will be + appended to the next row of the table, starting with the first column of the table. See the guide and + sample code for specific details of how tables are detected and data is appended. + + The caller must specify the spreadsheet ID, range, and a valueInputOption. The valueInputOption only + controls how the input data will be added to the sheet (column-wise or row-wise), + it does not influence what cell the data starts being written to. + + Reference: `request `__ + + :param spreadsheet_id: The ID of the spreadsheet to update. + :param values: The values to be appended in the body. + :param major_dimension: The major dimension of the values provided (e.g. row or column first?) + :param range: The A1 notation of a range to search for a logical table of data. + Values will be appended after the last row of the table. + :param kwargs: Query & standard parameters (see reference for details). + """ + body = { + 'values': values, + 'majorDimension': major_dimension + } + request = self.service.spreadsheets().values().append(spreadsheetId=spreadsheet_id, + range=range, + body=body, + valueInputOption=kwargs.get('valueInputOption', 'USER_ENTERED'), + **kwargs) + return self._execute_requests(request) + + def values_batch_clear(self, spreadsheet_id, ranges): + """Clear values from sheet. + + Clears one or more ranges of values from a spreadsheet. The caller must specify the spreadsheet ID and one or + more ranges. Only values are cleared -- all other properties of the cell (such as formatting, data validation, + etc..) are kept. + + Reference: `request `__ + + :param spreadsheet_id: The ID of the spreadsheet to update. + :param ranges: A list of ranges to clear in A1 notation. + """ + body = {'ranges': ranges} + request = self.service.spreadsheets().values().batchClear(spreadsheetId=spreadsheet_id, body=body) + self._execute_requests(request) + + # def values_batch_clear_by_data_filter(self): + # pass + + def values_batch_get(self, spreadsheet_id, value_ranges, major_dimension='ROWS', + value_render_option=ValueRenderOption.FORMATTED_VALUE, + date_time_render_option=DateTimeRenderOption.SERIAL_NUMBER): + """Returns multiple range of values from a spreadsheet. The caller must specify the spreadsheet ID and list of range. + + Reference: `request `__ + + :param spreadsheet_id: The ID of the spreadsheet to retrieve data from. + :param value_ranges: The list of A1 notation of the values to retrieve. + :param major_dimension: The major dimension that results should use. + For example, if the spreadsheet data is: A1=1,B1=2,A2=3,B2=4, then + requesting range=A1:B2,majorDimension=ROWS will return [[1,2],[3,4]], + whereas requesting range=A1:B2,majorDimension=COLUMNS will return + [[1,3],[2,4]]. + :param value_render_option: How values should be represented in the output. The default + render option is ValueRenderOption.FORMATTED_VALUE. + :param date_time_render_option: How dates, times, and durations should be represented in the output. + This is ignored if valueRenderOption is FORMATTED_VALUE. The default + dateTime render option is [DateTimeRenderOption.SERIAL_NUMBER]. + :return: `ValueRange `_ + """ + if isinstance(value_render_option, ValueRenderOption): + value_render_option = value_render_option.value + + if isinstance(date_time_render_option, DateTimeRenderOption): + date_time_render_option = date_time_render_option.value + + request = self.service.spreadsheets().values().batchGet(spreadsheetId=spreadsheet_id, + ranges=value_ranges, + majorDimension=major_dimension, + valueRenderOption=value_render_option, + dateTimeRenderOption=date_time_render_option) + response = self._execute_requests(request) + return response.get('valueRanges', []) + + # def values_batch_get_by_data_filter(self): + # pass + + # TODO: actually implement batch update. Only uses one or several update requests. + def values_batch_update(self, spreadsheet_id, body, parse=True): + """ + Impliments batch update + + :param spreadsheet_id: id of spreadsheet + :param body: body of request + :param parse: + """ + cformat = 'USER_ENTERED' if parse else 'RAW' + batch_limit = GOOGLE_SHEET_CELL_UPDATES_LIMIT + lengths = [len(x) for x in body['values']] + avg_row_length = (min(lengths) + max(lengths))/2 + avg_row_length = 1 if avg_row_length == 0 else avg_row_length + if body['majorDimension'] == 'ROWS': + batch_length = int(batch_limit / avg_row_length) # num of rows to include in a batch + num_rows = len(body['values']) + else: + batch_length = int(batch_limit / len(body['values'])) # num of rows to include in a batch + num_rows = len(body['values'][0]) + if len(body['values']) * len(body['values'][0]) <= batch_limit: + request = self.service.spreadsheets().values().update(spreadsheetId=spreadsheet_id, + range=body['range'], + valueInputOption=cformat, body=body) + self._execute_requests(request) + else: + if batch_length == 0: + raise AssertionError("num_columns < " + str(GOOGLE_SHEET_CELL_UPDATES_LIMIT)) + values = body['values'] + title, value_range = body['range'].split('!') + value_range_start, value_range_end = value_range.split(':') + value_range_end = list(format_addr(str(value_range_end), output='tuple')) + value_range_start = list(format_addr(str(value_range_start), output='tuple')) + max_rows = value_range_end[0] + start_row = value_range_start[0] + for batch_start in range(0, num_rows, batch_length): + if body['majorDimension'] == 'ROWS': + body['values'] = values[batch_start:batch_start + batch_length] + else: + body['values'] = [col[batch_start:batch_start + batch_length] for col in values] + value_range_start[0] = batch_start + start_row + value_range_end[0] = min(batch_start + batch_length, max_rows) + start_row + body['range'] = title + '!' + format_addr(tuple(value_range_start), output='label') + ':' + \ + format_addr(tuple(value_range_end), output='label') + request = self.service.spreadsheets().values().update(spreadsheetId=spreadsheet_id, body=body, + range=body['range'], + valueInputOption=cformat) + self._execute_requests(request) + + def values_batch_update_by_data_filter(self, spreadsheet_id, data, parse=True): + body = { + "data": data, + "valueInputOption": 'USER_ENTERED' if parse else 'RAW', + "includeValuesInResponse": False + } + request = self.service.spreadsheets().values().batchUpdateByDataFilter(spreadsheetId=spreadsheet_id, body=body) + self._execute_requests(request) + + # def values_clear(self): + # pass + + def values_get(self, spreadsheet_id, value_range, major_dimension='ROWS', + value_render_option=ValueRenderOption.FORMATTED_VALUE, + date_time_render_option=DateTimeRenderOption.SERIAL_NUMBER): + """Returns a range of values from a spreadsheet. The caller must specify the spreadsheet ID and a range. + + Reference: `request `__ + + :param spreadsheet_id: The ID of the spreadsheet to retrieve data from. + :param value_range: The A1 notation of the values to retrieve. + :param major_dimension: The major dimension that results should use. + For example, if the spreadsheet data is: A1=1,B1=2,A2=3,B2=4, then + requesting range=A1:B2,majorDimension=ROWS will return [[1,2],[3,4]], + whereas requesting range=A1:B2,majorDimension=COLUMNS will return + [[1,3],[2,4]]. + :param value_render_option: How values should be represented in the output. The default + render option is ValueRenderOption.FORMATTED_VALUE. + :param date_time_render_option: How dates, times, and durations should be represented in the output. + This is ignored if valueRenderOption is FORMATTED_VALUE. The default + dateTime render option is [DateTimeRenderOption.SERIAL_NUMBER]. + :return: `ValueRange `_ + """ + if isinstance(value_render_option, ValueRenderOption): + value_render_option = value_render_option.value + + if isinstance(date_time_render_option, DateTimeRenderOption): + date_time_render_option = date_time_render_option.value + + request = self.service.spreadsheets().values().get(spreadsheetId=spreadsheet_id, + range=value_range, + majorDimension=major_dimension, + valueRenderOption=value_render_option, + dateTimeRenderOption=date_time_render_option) + return self._execute_requests(request) + + def developer_metadata_delete(self, spreadsheet_id, data_filter): + """Deletes all developer metadata matching the supplied filter + + Reference: `request `__ + + :param spreadsheet_id: The id of the spreadsheet to search. + :param data_filter: A dictionary represeting a DeveloperMetadataLookup filter (see reference) + """ + request = {"deleteDeveloperMetadata": {"dataFilter": data_filter}} + self.batch_update(spreadsheet_id, [request]) + + def developer_metadata_create(self, spreadsheet_id, key, value, location): + """Creates a new developer metadata entry at the specified location + + Reference: `request `__ + + :param spreadsheet_id: The id of the spreadsheet where metadata will be created. + :param key: They key of the new developer metadata entry to create + :param value: They value of the new developer metadata entry to create + :param location: A dictionary represeting the location where metadata will be created + """ + request = { + "createDeveloperMetadata": { + "developerMetadata": { + "metadataKey": key, + "metadataValue": value, + "location": location, + "visibility": "DOCUMENT" + } + } + } + response = self.batch_update(spreadsheet_id, [request]) + if response is None: + # we're in batch mode + return + else: + return response["replies"][0]["createDeveloperMetadata"]["developerMetadata"]["metadataId"] + + def developer_metadata_update(self, spreadsheet_id, key, value, location, data_filter): + """Updates all developer metadata matching the supplied filter + + Reference: `request `__ + + :param spreadsheet_id: The id of the spreadsheet to search. + :param location: A dictionary represeting the location where metadata will be created + :param data_filter: A dictionary represeting a DeveloperMetadataLookup filter (see reference) + """ + request = { + "updateDeveloperMetadata": { + "dataFilters": [data_filter], + "developerMetadata": { + "metadataKey": key, + "metadataValue": value, + "location": location, + "visibility": "DOCUMENT" + }, + "fields": "*" + } + } + self.batch_update(spreadsheet_id, [request]) + + # TODO: implement as base for batch update. + # def values_update(self): + # pass + + def _execute_requests(self, request): + """Execute a request to the Google Sheets API v4. + + When the API returns a 429 Error will sleep for the specified time and try again. + + :param request: The request to be made. + :return: Response + """ + try: + response = request.execute(num_retries=self.retries) + except HttpError as error: + if error.resp['status'] == '429' and self.check: + time.sleep(self.seconds_per_quota) # TODO use asyncio + response = request.execute(num_retries=self.retries) + else: + raise + return response diff --git a/venv/lib/python3.10/site-packages/pygsheets/spreadsheet.py b/venv/lib/python3.10/site-packages/pygsheets/spreadsheet.py new file mode 100644 index 0000000000000000000000000000000000000000..5372a52fedbc0e0d7fe453a56c5829a15be95583 --- /dev/null +++ b/venv/lib/python3.10/site-packages/pygsheets/spreadsheet.py @@ -0,0 +1,422 @@ +# -*- coding: utf-8 -*-. + +""" +pygsheets.spreadsheet +~~~~~~~~~~~~~~~~~~~~~ + +This module represents an entire spreadsheet. Which can have several worksheets. + +""" + +import logging +import warnings + +from pygsheets.worksheet import Worksheet +from pygsheets.datarange import DataRange +from pygsheets.exceptions import (WorksheetNotFound, RequestError, + InvalidArgumentValue, InvalidUser) +from pygsheets.custom_types import * +from pygsheets.developer_metadata import DeveloperMetadataLookupDataFilter, DeveloperMetadata + + +class Spreadsheet(object): + """ A class for a spreadsheet object.""" + + worksheet_cls = Worksheet + + def __init__(self, client, jsonsheet=None, id=None): + """The spreadsheet is used to store and manipulate metadata and load specific sheets. + + :param client: The client which is responsible to connect the sheet with the remote. + :param jsonsheet: The json-dict representation of the spreadsheet as returned by Google Sheets API v4. + :param id: Id of this spreadsheet + """ + if type(jsonsheet) != dict and jsonsheet is not None: + raise InvalidArgumentValue("jsonsheet") + self.logger = logging.getLogger(__name__) + self.client = client + self._sheet_list = [] + self._jsonsheet = jsonsheet + self._id = id + self._title = '' + self._named_ranges = [] + self.fetch_properties(jsonsheet) + self.default_parse = True + + @property + def id(self): + """Id of the spreadsheet.""" + return self._id + + @property + def title(self): + """Title of the spreadsheet.""" + return self._title + + @title.setter + def title(self, value): + self._title = value + self._jsonsheet['properties']['title'] = value + self.update_properties() + + @property + def locale(self): + """Locale of the spreadsheet.""" + return self._jsonsheet['properties']['locale'] + + @locale.setter + def locale(self, value): + self._locale = value + self._jsonsheet['properties']['locale'] = value + self.update_properties() + + @property + def sheet1(self): + """Direct access to the first worksheet.""" + return self.worksheet() + + @property + def url(self): + """Url of the spreadsheet.""" + return "https://docs.google.com/spreadsheets/d/"+self.id + + @property + def named_ranges(self): + """All named ranges in this spreadsheet.""" + return [DataRange(namedjson=x, name=x['name'], worksheet=self.worksheet('id', x['range'].get('sheetId', 0))) + for x in self._named_ranges] + + @property + def protected_ranges(self): + """All protected ranges in this spreadsheet.""" + response = self.client.sheet.get(spreadsheet_id=self.id, fields='sheets(properties.sheetId,protectedRanges)') + return [DataRange(protectedjson=x, worksheet=self.worksheet('id', sheet['properties']['sheetId'])) + for sheet in response['sheets'] + for x in sheet.get('protectedRanges', [])] + + @property + def defaultformat(self): + """Default cell format used.""" + return self._defaultFormat + + @property + def updated(self): + """Last time the spreadsheet was modified using RFC 3339 format.""" + return self.client.drive.get_update_time(self.id) + + def update_properties(self): + """ + Update the sheet properties in cloud + """ + request = { + "updateSpreadsheetProperties": {"properties": self._jsonsheet['properties'], "fields": "*"}} + self.client.sheet.batch_update(self.id, request, fields='*') + + def fetch_properties(self, jsonsheet=None, fetch_sheets=True): + """Update all properties of this spreadsheet with the remote. + + The provided json representation must be the same as the Google Sheets v4 Response. If no sheet is given this + will simply fetch all data from remote and update the local representation. + + Reference: https://developers.google.com/sheets/api/reference/rest/v4/spreadsheets + + :param jsonsheet: Used to update the spreadsheet. + :param fetch_sheets: Fetch sheets from remote. + + """ + if not jsonsheet and len(self.id) > 1: + self._jsonsheet = self.client.open_as_json(self.id) + elif not jsonsheet and len(self.id) == 0: + raise InvalidArgumentValue('jsonsheet') + self._id = self._jsonsheet['spreadsheetId'] + if fetch_sheets: + self._fetch_sheets(self._jsonsheet) + self._title = self._jsonsheet['properties']['title'] + self._defaultFormat = self._jsonsheet['properties']['defaultFormat'] + self.client.spreadsheetId = self._id + self._named_ranges = self._jsonsheet.get('namedRanges', []) + + def _fetch_sheets(self, jsonsheet=None): + """Update the sheets stored in this spreadsheet.""" + self._sheet_list = [] + if not jsonsheet: + jsonsheet = self.client.open_as_json(self.id) + for sheet in jsonsheet.get('sheets'): + self._sheet_list.append(self.worksheet_cls(self, sheet)) + + def worksheets(self, sheet_property=None, value=None, force_fetch=False): + """Get worksheets matching the specified property. + + :param sheet_property: Property used to filter ('title', 'index', 'id'). + :param value: Value of the property. + :param force_fetch: Fetch data from remote. + + :returns: List of :class:`Worksheets `. + """ + if not sheet_property and not value: + return self._sheet_list + + if sheet_property not in ['title', 'index', 'id']: + raise InvalidArgumentValue('sheet_property') + elif sheet_property in ['index', 'id']: + value = int(value) + + sheets = [x for x in self._sheet_list if getattr(x, sheet_property) == value] + if not len(sheets) > 0 or force_fetch: + self._fetch_sheets() + sheets = [x for x in self._sheet_list if getattr(x, sheet_property) == value] + if not len(sheets) > 0: + raise WorksheetNotFound() + return sheets + + def worksheet(self, property='index', value=0): + """Returns the worksheet with the specified index, title or id. + + If several worksheets with the same property are found the first is returned. This may not be the same + worksheet every time. + + Example: Getting a worksheet named 'Annual bonuses' + + >>> sht = client.open('Sample one') + >>> worksheet = sht.worksheet('title','Annual bonuses') + + :param property: The searched property. + :param value: Value of the property. + + :returns: :class:`Worksheets `. + """ + return self.worksheets(property, value)[0] + + def worksheet_by_title(self, title): + """Returns worksheet by title. + + :param title: Title of the sheet + + :returns: :class:`Worksheets `. + """ + return self.worksheet('title', title) + + def add_worksheet(self, title, rows=100, cols=26, src_tuple=None, src_worksheet=None, index=None): + """Creates or copies a worksheet and adds it to this spreadsheet. + + When creating only a title is needed. Rows & columns can be adjusted to match your needs. + Index can be specified to set position of the sheet. + + When copying another worksheet supply the spreadsheet id & worksheet id and the worksheet wrapped in a Worksheet + class. + + :param title: Title of the worksheet. + :param rows: Number of rows which should be initialized (default 100) + :param cols: Number of columns which should be initialized (default 26) + :param src_tuple: Tuple of (spreadsheet id, worksheet id) specifying the worksheet to copy. + :param src_worksheet: The source worksheet. + :param index: Tab index of the worksheet. + + :returns: :class:`Worksheets `. + """ + + jsheet = dict() + if src_tuple: + jsheet['properties'] = self.client.sheet.sheets_copy_to(src_tuple[0], src_tuple[1], self.id) + wks = self.worksheet_cls(self, jsheet) + wks.title = title + wks.index = index + elif src_worksheet: + if type(src_worksheet) != Worksheet: + raise InvalidArgumentValue("src_worksheet") + jsheet['properties'] = self.client.sheet.sheets_copy_to(src_worksheet.spreadsheet.id, src_worksheet.id, self.id) + wks = self.worksheet_cls(self, jsheet) + wks.title = title + wks.index = index + else: + request = {"addSheet": {"properties": {'title': title, "gridProperties": {"rowCount": rows, "columnCount": cols}}}} + if index is not None: + request["addSheet"]["properties"]["index"] = index + result = self.client.sheet.batch_update(self.id, request, fields='replies/addSheet') + jsheet['properties'] = result['replies'][0]['addSheet']['properties'] + wks = self.worksheet_cls(self, jsheet) + self._sheet_list.append(wks) + return wks + + def del_worksheet(self, worksheet): + """Deletes the worksheet from this spreadsheet. + + :param worksheet: The :class:`worksheets ` to be deleted. + """ + if worksheet not in self.worksheets(): + raise WorksheetNotFound + request = {"deleteSheet": {'sheetId': worksheet.id}} + self.client.sheet.batch_update(self.id, request) + self._sheet_list.remove(worksheet) + + def replace(self, pattern, replacement=None, **kwargs): + """Replace values in any cells matched by pattern in all worksheets. + + Keyword arguments not specified will use the default value. If the spreadsheet is - + + Unlinked: + Uses `self.find(pattern, **kwargs)` to find the cells and then replace the values in each cell. + + Linked: + The replacement will be done by a `findReplaceRequest `_ + as defined by the Google Sheets API. After the request the local copy is updated. + + :param pattern: Match cell values. + :param replacement: Value used as replacement. + :arg searchByRegex: Consider pattern a regex pattern. (default False) + :arg matchCase: Match case sensitive. (default False) + :arg matchEntireCell: Only match on full match. (default False) + :arg includeFormulas: Match fields with formulas too. (default False) + """ + for wks in self.worksheets(): + wks.replace(pattern, replacement=replacement, **kwargs) + + def find(self, pattern, **kwargs): + """Searches through all worksheets. + + Search all worksheets with the options given. If an option is not given, the default will be used. + Will return a list of cells for each worksheet packed into a list. If a worksheet has no cell which + matches pattern an empty list is added. + + :param pattern: The value to search. + :arg searchByRegex: Consider pattern a regex pattern. (default False) + :arg matchCase: Match case sensitive. (default False) + :arg matchEntireCell: Only match on full match. (default False) + :arg includeFormulas: Match fields with formulas too. (default False) + + :returns: A list of lists of :class:`Cells ` + """ + found_cells = [] + for sheet in self.worksheets(): + found_cells.append(sheet.find(pattern, **kwargs)) + return found_cells + + def share(self, email_or_domain, role='reader', type='user', **kwargs): + """Share this file with a user, group or domain. + + User and groups need an e-mail address and domain needs a domain for a permission. + Share sheet with a person and send an email message. + + >>> spreadsheet.share('example@gmail.com', role='commenter', type='user', emailMessage='Here is the spreadsheet we talked about!') + + Make sheet public with read only access: + + >>> spreadsheet.share('', role='reader', type='anyone') + + :param email_or_domain: The email address or domain this file should be shared to. + :param role: The role of the new permission. + :param type: The type of the new permission. + :param kwargs: Optional arguments. See DriveAPIWrapper.create_permission documentation for details. + """ + if type in ['user', 'group']: + kwargs['emailAddress'] = email_or_domain + elif type == 'domain': + kwargs['domain'] = email_or_domain + self.client.drive.create_permission(self.id, role=role, type=type, **kwargs) + + @property + def permissions(self): + """Permissions for this file.""" + return self.client.drive.list_permissions(self.id) + + def remove_permission(self, email_or_domain, permission_id=None): + """Remove a permission from this sheet. + + All permissions associated with this email or domain are deleted. + + :param email_or_domain: Email or domain of the permission. + :param permission_id: (optional) permission id if a specific permission should be deleted. + """ + if permission_id is not None: + self.client.drive.delete_permission(self.id, permission_id=permission_id) + else: + for permission in self.permissions: + if email_or_domain in [permission.get('domain', ''), permission.get('emailAddress', '')]: + self.client.drive.delete_permission(self.id, permission_id=permission['id']) + + def export(self, file_format=ExportType.CSV, path='', filename=''): + """Export all worksheets. + + The filename must have an appropriate file extension. Each sheet will be exported into a separate file. + The filename is extended (before the extension) with the index number of the worksheet to not overwrite + each file. + + :param file_format: ExportType. + :param path: Path to the directory where the file will be stored. (default: current working directory) + :param filename: Filename (default: spreadsheet id) + """ + self.client.drive.export(self, file_format=file_format, filename=filename, path=path) + + def delete(self): + """Deletes this spreadsheet. + + Leaves the local copy intact. The deleted spreadsheet is permanently removed from your drive + and not moved to the trash. + """ + self.client.drive.delete(self.id) + + def get_developer_metadata(self, key=None, search_sheets=False): + """ + Fetch developer metadata associated with this spreadsheet + + :param key: The key of the metadata to fetch. If unspecified, all metadata will be returned + :param search_sheets: Set to True to also include worksheets in the metadata search + """ + spreadsheet_id = None if search_sheets else self.id + data_filter = DeveloperMetadataLookupDataFilter(spreadsheet_id, meta_key=key) + results = self.client.sheet.developer_metadata_search(self.id, data_filter.to_json()) + metadata = [] + if results: + for result in results["matchedDeveloperMetadata"]: + meta_id = result["developerMetadata"]["metadataId"] + key = result["developerMetadata"]["metadataKey"] + value = result["developerMetadata"]["metadataValue"] + sheet_id = result["developerMetadata"]["location"].get("sheetId", None) + metadata.append(DeveloperMetadata(meta_id, key, value, self.client, self.id, sheet_id)) + return metadata + + def create_developer_metadata(self, key, value=None): + """ + Create a new developer metadata associated with this spreadsheet + + Will return None when in batch mode, otherwise will return a DeveloperMetadata object + + :param key: the key of the metadata to be created + :param value: the value of the metadata to be created (optional) + """ + return DeveloperMetadata.new(key, value, self.client, self.id) + + def custom_request(self, request, fields, **kwargs): + """ + Send a custom batch update request to this spreadsheet. + + These requests have to be properly constructed. All possible requests are documented in the reference. + + Reference: api docs `__ + + :param request: One or several requests as dictionaries. + :param fields: Fields which should be included in the response. + :param kwargs: Any other params according to refrence. + + :return: json response __ + """ + return self.client.sheet.batch_update(self.id, request, fields=fields, **kwargs) + + def to_json(self): + """Return this spreadsheet as json resource.""" + return self.client.open_as_json(self.id) + + def __repr__(self): + return '<%s %s Sheets:%s>' % (self.__class__.__name__, + repr(self.title), len(self._sheet_list)) + + def __eq__(self, other): + return self.id == other.id + + def __iter__(self): + for sheet in self.worksheets(): + yield(sheet) + + def __getitem__(self, item): + if type(item) == int: + return self.worksheet('index', item) diff --git a/venv/lib/python3.10/site-packages/pygsheets/utils.py b/venv/lib/python3.10/site-packages/pygsheets/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..faf8764bb8ce4594206db2f91db324f63b6a0fec --- /dev/null +++ b/venv/lib/python3.10/site-packages/pygsheets/utils.py @@ -0,0 +1,232 @@ +# -*- coding: utf-8 -*- + +""" +pygsheets.utils +~~~~~~~~~~~~~~~ + +This module contains utility functions. + +""" + +from pygsheets.exceptions import (IncorrectCellLabel, InvalidArgumentValue) +from functools import wraps +import re + + +def finditem(func, seq): + """Finds and returns first item in iterable for which func(item) is True. + """ + return next((item for item in seq if func(item))) + + +def numericise(value, empty_value=''): + """Returns a value that depends on the input string: + - Float if input can be converted to Float + - Integer if input can be converted to integer + - Zero if the input string is empty and empty2zero flag is set + - The same input string, empty or not, otherwise. + + Executable examples: + + >>> numericise("faa") + 'faa' + >>> numericise("3") + 3 + >>> numericise("3.1") + 3.1 + >>> numericise("", empty2zero=True) + 0 + >>> numericise("", empty2zero=False) + '' + >>> numericise("") + '' + >>> numericise(None) + >>> + """ + if value == '': + return empty_value + if isinstance(value, str): + try: + value = int(value) + except ValueError: + try: + value = float(value) + except ValueError: + pass + return value + + +def numericise_all(input, empty_value=''): + """Returns a list of numericised values from strings""" + return [numericise(s, empty_value) for s in input] + + +def is_number(n): + if '_' in str(n): + return False + try: + float(n) + except ValueError: + return False + return True + + +def format_addr(addr, output='flip'): + """ + function to convert address format of cells from one to another + + :param addr: address as tuple or label + :param output: -'label' will output label + - 'tuple' will output tuple + - 'flip' will convert to other type + :returns: tuple or label + """ + _MAGIC_NUMBER = 64 + if type(addr) == tuple: + if output == 'label' or output == 'flip': + # return self.get_addr_int(*addr) + if addr[0] is None: + row_label = '' + else: + row = int(addr[0]) + if row < 1: + raise IncorrectCellLabel(repr(addr)) + row_label = str(row) + + if addr[1] is None: + column_label = '' + else: + col = int(addr[1]) + if col < 1: + raise IncorrectCellLabel(repr(addr)) + div = col + column_label = '' + while div: + (div, mod) = divmod(div, 26) + if mod == 0: + mod = 26 + div -= 1 + column_label = chr(mod + _MAGIC_NUMBER) + column_label + label = '%s%s' % (column_label, row_label) + return label + + elif output == 'tuple': + return addr + + elif type(addr) == str: + if output == 'tuple' or output == 'flip': + _cell_addr_re = re.compile(r'([A-Za-z]+)(\d+)') + m = _cell_addr_re.match(addr) + if m: + column_label = m.group(1).upper() + row, col = int(m.group(2)), 0 + for i, c in enumerate(reversed(column_label)): + col += (ord(c) - _MAGIC_NUMBER) * (26 ** i) + else: + raise IncorrectCellLabel(addr) + return int(row), int(col) + elif output == 'label': + return addr + else: + raise InvalidArgumentValue("addr of type " + str(type(addr))) + + +def fullmatch(regex, string, flags=0): + """Emulate python-3.4 re.fullmatch().""" + return re.match("(?:" + regex + r")\Z", string, flags=flags) + + +def format_color(data, to='dict'): + """ + change color format + :param data: coloe data as dict or tuple + :param to: 'dict' or 'tuple' + """ + if not (type(data) is dict or type(data) is tuple): + InvalidArgumentValue('data should be tuple or dict') + + if type(data) is tuple and to == 'dict': + return {"red": data[0], "green": data[1], "blue": data[2], "alpha": data[3]} + elif type(data) is dict and to == 'tuple': + return data.get('red', 1), data.get('green', 1), data.get('blue', 1), data.get('alpha', 1) + else: + return data + +def get_color_style(color_obj): + """ + get color style object. + + refer to `api docs `__ for possible inputs. + + :param color_obj: color data as tuple string. please refer to `api docs `__ for possible inputs. + + """ + if type(color_obj) is tuple: + color_style = {'rgbColor': { + 'red': color_obj[0], + 'green': color_obj[1], + 'blue': color_obj[2], + 'alpha': color_obj[3] + } + } + return color_style + elif type(color_obj) is str: + color_style = { + 'themeColor': color_obj + } + return color_style + else: + InvalidArgumentValue('data should be tuple or str') + +def get_boolean_condition(type, values): + """ + get boolean_condition. + + refer to `api docs `__ for possible inputs. + + :param type: the type of condition (String). please refer to `api docs `__ for possible inputs. + :param values: The values of the condition (List). please refer to `api docs `__ for possible inputs. + """ + if type: + condition_json = [] + for value in values: + if value in ['RELATIVE_DATE_UNSPECIFIED', 'PAST_YEAR', 'PAST_MONTH', 'PAST_WEEK', + 'YESTERDAY', 'TODAY', 'TOMORROW']: + condition_json.append({'relativeDate': value}) + else: + condition_json.append({'userEnteredValue': value}) + boolean_condition = { + 'type': type, + 'values': condition_json + } + else: + boolean_condition = None + return boolean_condition + + +def batchable(func): + """ Function generator to make a model member function batachable. + Model needs to have an attribute named _func_calls """ + @wraps(func) + def wrapper(*args, **kwargs): + obj = args[0] + if obj.linked: + return func(*args, **kwargs) + else: + obj._func_calls.append((func, (args, kwargs))) + return False + return wrapper + + +def allow_gridrange(method): + """ + Decorator function casts gridrange in argument to start and end + in range method calls. + """ + @wraps(method) + def wrapper(self, *args, **kwargs): + if 'grange' in kwargs: + grid_range = kwargs.pop('grange') + kwargs['start'], kwargs['end'] = [x.index for x in grid_range.get_bounded_indexes()] + return method(self, *args, **kwargs) + return wrapper diff --git a/venv/lib/python3.10/site-packages/pygsheets/worksheet.py b/venv/lib/python3.10/site-packages/pygsheets/worksheet.py new file mode 100644 index 0000000000000000000000000000000000000000..0ddba8efe668da3ee9807d2ede34cd15b725bea4 --- /dev/null +++ b/venv/lib/python3.10/site-packages/pygsheets/worksheet.py @@ -0,0 +1,1939 @@ +# -*- coding: utf-8 -*-. + +""" +pygsheets.worksheet +~~~~~~~~~~~~~~~~~~~ + +This module represents a worksheet within a spreadsheet. + +""" + +import datetime +import re +import warnings +import logging + +from pygsheets.cell import Cell +from pygsheets.datarange import DataRange +from pygsheets.address import GridRange, Address +from pygsheets.exceptions import (CellNotFound, InvalidArgumentValue, RangeNotFound) +from pygsheets.utils import numericise_all, format_addr, fullmatch, batchable, allow_gridrange, get_color_style, get_boolean_condition +from pygsheets.custom_types import * +from pygsheets.chart import Chart +from pygsheets.developer_metadata import DeveloperMetadataLookupDataFilter, DeveloperMetadata +try: + import pandas as pd +except ImportError: + pd = None + + +_warning_message = "this {} is deprecated. Use {} instead" +_deprecated_keyword_mapping = { + 'include_empty': 'include_tailing_empty', + 'include_all': 'include_tailing_empty_rows', +} + + +class Worksheet(object): + """ + A worksheet. + + :param spreadsheet: Spreadsheet object to which this worksheet belongs to + :param jsonSheet: Contains properties to initialize this worksheet. + + Ref to api details for more info + """ + + def __init__(self, spreadsheet, jsonSheet): + self.logger = logging.getLogger(__name__) + self.spreadsheet = spreadsheet + self.client = spreadsheet.client + self._linked = True + self.jsonSheet = jsonSheet + self.data_grid = None # for storing sheet data while unlinked + self._func_calls = [] + self.grid_update_time = None + + def __repr__(self): + return '<%s %s index:%s>' % (self.__class__.__name__, + repr(self.title), self.index) + + @property + def id(self): + """The ID of this worksheet.""" + return self.jsonSheet['properties']['sheetId'] + + @property + def index(self): + """The index of this worksheet""" + return self.jsonSheet['properties']['index'] + + @index.setter + def index(self, index): + self.jsonSheet['properties']['index'] = index + if self._linked: + self.client.sheet.update_sheet_properties_request(self.spreadsheet.id, self.jsonSheet['properties'], 'index') + + @property + def title(self): + """The title of this worksheet.""" + return self.jsonSheet['properties']['title'] + + @title.setter + def title(self, title): + self.jsonSheet['properties']['title'] = title + if self._linked: + self.client.sheet.update_sheet_properties_request(self.spreadsheet.id, self.jsonSheet['properties'], 'title') + + @property + def hidden(self): + """Mark the worksheet as hidden.""" + return self.jsonSheet['properties'].get('hidden', False) + + @hidden.setter + def hidden(self, hidden): + self.jsonSheet['properties']['hidden'] = hidden + if self._linked: + self.client.sheet.update_sheet_properties_request(self.spreadsheet.id, self.jsonSheet['properties'], 'hidden') + + @property + def url(self): + """The url of this worksheet.""" + return self.spreadsheet.url+"/edit#gid="+str(self.id) + + @property + def rows(self): + """Number of rows active within the sheet. A new sheet contains 1000 rows.""" + return int(self.jsonSheet['properties']['gridProperties']['rowCount']) + + @rows.setter + def rows(self, row_count): + if row_count == self.rows: + return + self.jsonSheet['properties']['gridProperties']['rowCount'] = int(row_count) + if self._linked: + self.client.sheet.update_sheet_properties_request(self.spreadsheet.id, self.jsonSheet['properties'], + 'gridProperties/rowCount') + + @property + def cols(self): + """Number of columns active within the sheet.""" + return int(self.jsonSheet['properties']['gridProperties']['columnCount']) + + @cols.setter + def cols(self, col_count): + if col_count == self.cols: + return + self.jsonSheet['properties']['gridProperties']['columnCount'] = int(col_count) + if self._linked: + self.client.sheet.update_sheet_properties_request(self.spreadsheet.id, self.jsonSheet['properties'], + 'gridProperties/columnCount') + + @property + def frozen_rows(self): + """Number of frozen rows.""" + return self.jsonSheet['properties']['gridProperties'].get('frozenRowCount', 0) + + @frozen_rows.setter + def frozen_rows(self, row_count): + self.jsonSheet['properties']['gridProperties']['frozenRowCount'] = int(row_count) + if self._linked: + self.client.sheet.update_sheet_properties_request(self.spreadsheet.id, self.jsonSheet['properties'], + 'gridProperties/frozenRowCount') + + @property + def frozen_cols(self): + """Number of frozen columns.""" + return self.jsonSheet['properties']['gridProperties'].get('frozenColumnCount', 0) + + @frozen_cols.setter + def frozen_cols(self, col_count): + self.jsonSheet['properties']['gridProperties']['frozenColumnCount'] = int(col_count) + if self._linked: + self.client.sheet.update_sheet_properties_request(self.spreadsheet.id, self.jsonSheet['properties'], + 'gridProperties/frozenColumnCount') + + @property + def merged_ranges(self): + """Ranges of merged cells in this sheet.""" + return [GridRange(propertiesjson=x, worksheet=self) for x in self.jsonSheet.get('merges', list())] + + @property + def linked(self): + """If the sheet is linked.""" + return self._linked + + def refresh(self, update_grid=False): + """refresh worksheet data""" + jsonsheet = self.client.open_as_json(self.spreadsheet.id) + for sheet in jsonsheet.get('sheets'): + if sheet['properties']['sheetId'] == self.id: + self.jsonSheet = sheet + if update_grid: + self._update_grid() + + # @TODO the update is not instantaneous + def _update_grid(self, force=False): + """ + update the data grid (offline) with values from sheet + :param force: force update data grid + + """ + if not self.data_grid or force: + self.data_grid = self.get_all_values(returnas='cells-unlinked', include_tailing_empty=True, include_tailing_empty_rows=True) + elif not force: + updated = datetime.datetime.strptime(self.spreadsheet.updated, '%Y-%m-%dT%H:%M:%S.%fZ') + if updated > self.grid_update_time: + self.data_grid = self.get_all_values(returnas='cells-unlinked', include_tailing_empty=True, include_tailing_empty_rows=True) + self.grid_update_time = datetime.datetime.utcnow() + + def link(self, syncToCloud=True): + """ Link the spreadsheet with cloud, so all local changes + will be updated instantly. Data fetches will work only in linked sheet. + All the data update calls made when sheet is unlinked will be replayed on linking. + + :param syncToCloud: update the cloud with local changes (data_grid), cached update calls if set to true + update the local copy with cloud if set to false + """ + warnings.warn('link and unlink is deprecated, use batch_mode instead.', category=DeprecationWarning) + self._linked = True + if syncToCloud: + self.client.sheet.update_sheet_properties_request(self.spreadsheet.id, self.jsonSheet['properties'], '*') + if self.data_grid: + tmp_data_grid = [item for sublist in self.data_grid for item in sublist] # flatten the list + self.update_cells(tmp_data_grid) + + # call all saved function calls + for func, fargs in self._func_calls: + func(*fargs[0], **fargs[1]) + self._func_calls = [] + else: + wks = self.spreadsheet.worksheet(property='id', value=self.id) + self.jsonSheet = wks.jsonSheet + + # TODO change to False @nextRelease + def unlink(self, save_grid=True): + """ Unlink the spreadsheet with cloud, so that any changes made wont be updated instantaneously. + All the data update calls are cached and will be called once the sheet is linked again. + + .. warning:: + After unlinking, functions which return data won't work. + + """ + warnings.warn('link and unlink is deprecated, use batch_mode instead.', category=DeprecationWarning) + if save_grid: + self._update_grid() + self._linked = False + self._func_calls = [] + + def sync(self): + """ + sync the worksheet (datagrid, and worksheet properties) to cloud + + """ + self.link(True) + self.logger.warn("sync not implemented") + + def _get_range(self, start_label, end_label=None, rformat='A1'): + """get range in A1 notation, given start and end labels + + :param start_label: range start label + :param end_label: range end label + :param rformat: can be A1 or GridRange + + """ + grange = GridRange(worksheet=self, start=start_label, end=end_label) + if rformat == "A1": + return grange.label + else: + return grange.to_json() + + def cell(self, addr): + """ + Returns cell object at given address. + + :param addr: cell address as either tuple (row, col) or cell label 'A1' or Address + + :returns: an instance of a :class:`Cell` + + Example: + + >>> wks.cell((1,1)) + + >>> wks.cell('A1') + + + """ + if not self._linked: return False + addr = Address(addr) + try: + val = self.client.get_range(self.spreadsheet.id, self._get_range(addr, addr), 'ROWS')[0][0] + except Exception as e: + if str(e).find('exceeds grid limits') != -1: + raise CellNotFound + else: + raise + + return Cell(addr, val, self) + + def range(self, crange, returnas='cells'): + """Returns a list of :class:`Cell` objects from specified range. + + :param crange: A string with range value in common format, + e.g. 'A1:A5'. + :param returnas: can be 'matrix', 'cell', 'range' the corresponding type will be returned + """ + startcell = crange.split(':')[0] + endcell = crange.split(':')[1] + return self.get_values(startcell, endcell, returnas=returnas, include_tailing_empty_rows=True) + + def get_value(self, addr, value_render=ValueRenderOption.FORMATTED_VALUE): + """ + value of a cell at given address + + :param addr: cell address as either tuple or label + :param value_render: how the output values should rendered. `api docs `__ + + """ + addr = format_addr(addr, 'tuple') + try: + return self.get_values(addr, addr, returnas='matrix', include_tailing_empty=True, + include_tailing_empty_rows=True, value_render=value_render)[0][0] + except KeyError: + raise CellNotFound + + @allow_gridrange + def get_values(self, start, end, returnas='matrix', majdim='ROWS', include_tailing_empty=True, + include_tailing_empty_rows=False, value_render=ValueRenderOption.FORMATTED_VALUE, + date_time_render_option=DateTimeRenderOption.SERIAL_NUMBER, grange=None, **kwargs): + """ + Returns a range of values from start cell to end cell. It will fetch these values from remote and then + processes them. Will return either a simple list of lists, a list of Cell objects or a DataRange object with + all the cells inside. + + :param start: Top left position as tuple or label + :param end: Bottom right position as tuple or label + :param grange: give range as grid range object, object of :class:`GridRange` + :param majdim: The major dimension of the matrix. ('ROWS') ( 'COLUMNS' not implemented ) + :param returnas: The type to return the fetched values as. ('matrix', 'cell', 'range') + :param include_tailing_empty: whether to include empty trailing cells/values after last non-zero value in a row + :param include_tailing_empty_rows: whether to include tailing rows with no values; if include_tailing_empty is false, + will return unfilled list for each empty row, else will return rows filled with empty cells + :param value_render: how the output values should rendered. `api docs `__ + :param date_time_render_option: How dates, times, and durations should be represented in the output. + This is ignored if `valueRenderOption` is `FORMATTED_VALUE`. The default + dateTime render option is [`DateTimeRenderOption.SERIAL_NUMBER`]. + + :returns: 'range': :class:`DataRange ` + 'cell': [:class:`Cell `] + 'matrix': [[ ... ], [ ... ], ...] + append '-unlinked' to get unlinked objects + """ + include_tailing_empty = kwargs.get('include_empty', include_tailing_empty) + include_tailing_empty_rows = kwargs.get('include_all', include_tailing_empty_rows) + + return_unlinked, return_worksheet = returnas.endswith('-unlinked'), self + returnas = returnas.split('-')[0] + if return_unlinked: + return_worksheet = None + + _deprecated_keywords = ['include_empty', 'include_all'] + for key in list(kwargs): + if key in _deprecated_keywords: + warnings.warn( + 'The argument {} is deprecated. Use {} instead.'.format(key, _deprecated_keyword_mapping[key]) + , category=DeprecationWarning) + kwargs.pop(key, None) + + if not self._linked: return False + + majdim = majdim.upper() + if majdim.startswith('COL'): + majdim = "COLUMNS" + prev_include_tailing_empty_rows, prev_include_tailing_empty = True, True + + if not grange: + grange = GridRange(worksheet=self, start=start, end=end) + grange.set_worksheet(self) + + # fetch the values + if returnas == 'matrix': + values = self.client.get_range(self.spreadsheet.id, grange.label, majdim, + value_render_option=value_render, + date_time_render_option=date_time_render_option, **kwargs) + empty_value = '' + else: + values = self.client.sheet.get(self.spreadsheet.id, fields='sheets/data/rowData', + includeGridData=True, + ranges=grange.label) + values = values['sheets'][0]['data'][0].get('rowData', []) + values = [x.get('values', []) for x in values] + empty_value = dict({"effectiveValue": {"stringValue": ""}}) + + # Cells are always returned in row major form from api. lets keep them such that for now + # So lets first make a complete rectangle and cleanup later + if majdim == "COLUMNS": + prev_include_tailing_empty = include_tailing_empty + prev_include_tailing_empty_rows = include_tailing_empty_rows + include_tailing_empty = True + include_tailing_empty_rows = True + + if returnas == 'range': # need perfect rectangle + include_tailing_empty = True + include_tailing_empty_rows = True + + if values == [['']] or values == []: values = [[]] + + # cleanup and re-structure the values + start, end = [x.index for x in grange.get_bounded_indexes()] + + max_rows = end[0] - start[0] + 1 + max_cols = end[1] - start[1] + 1 + if majdim == "COLUMNS" and returnas == "matrix": + max_cols = end[0] - start[0] + 1 + max_rows = end[1] - start[1] + 1 + + # restructure values according to params + if include_tailing_empty_rows and (max_rows-len(values)) > 0: # append empty rows in end + values.extend([[]]*(max_rows-len(values))) + if include_tailing_empty: # append tailing cells in rows + values = [list(x + [empty_value] * (max_cols - len(x))) for x in values] + elif returnas != 'matrix': + for i, row in enumerate(values): + for j, cell in reversed(list(enumerate(row))): + if 'effectiveValue' not in cell: + del values[i][j] + else: + break + + if values == [[]] or values == [['']]: return values + + if returnas == 'matrix': + return values + else: + + # Now the cells are complete rectangle, convert to column major form and remove + # the excess cells based on the params saved + if majdim == "COLUMNS": + values = list(map(list, zip(*values))) + for i in range(len(values) - 1, -1, -1): + if not prev_include_tailing_empty_rows: + if not any((item.get("effectiveValue", {}).get("stringValue", "-1") != "" and "effectiveValue" in item) for item in values[i]): + del values[i] + continue + if not prev_include_tailing_empty: + for k in range(len(values[i])-1, -1, -1): + if values[i][k].get("effectiveValue", {}).get("stringValue", "-1") != "" and "effectiveValue" in values[i][k]: + break + else: + del values[i][k] + max_cols = end[0] - start[0] + 1 + max_rows = end[1] - start[1] + 1 + + cells = [] + for k in range(len(values)): + cells.extend([[]]) + for i in range(len(values[k])): + if majdim == "ROWS": + cells[-1].append(Cell(pos=(start[0]+k, start[1]+i), worksheet=return_worksheet, cell_data=values[k][i])) + else: + cells[-1].append(Cell(pos=(start[0]+i, start[1]+k), worksheet=return_worksheet, cell_data=values[k][i])) + + if cells == []: cells = [[]] + + if returnas.startswith('cell'): + return cells + elif returnas == 'range': + dd = DataRange(start, format_addr(end, 'label'), worksheet=return_worksheet, data=cells) + return dd + + def get_values_batch(self, ranges, majdim='ROWS', value_render=ValueRenderOption.FORMATTED_VALUE, + date_time_render_option=DateTimeRenderOption.SERIAL_NUMBER, **kwargs): + """ + Returns a range of values from start cell to end cell. It will fetch these values from remote and then + processes them. Will return either a simple list of lists, a list of Cell objects or a DataRange object with + all the cells inside. + + :param ranges: list of ranges to get data as - objects of :class:`GridRange`, or tuple (with start and end) + or A1 notation string or dict in GridRange format + :param majdim: The major dimension of the matrix. ('ROWS') ( 'COLMUNS' not implemented ) + :param value_render: refer get_values + :param date_time_render_option: refer get_values + + Example: + + >>> wks.get_values_batch( ['A1:A2', 'C1:C2'] ) + [ [['3'], ['4']], [['c']]] + >>> wks.get_values_batch( [('1', None), ('5', None)] ) + [ , ] + >>> wks.get_values_batch( [('A1', 'B2'), ('5', None), 'Sheet1!D1:F10', 'A']) + [ ] + """ + labels = [GridRange.create(x, self).label for x in ranges] + values = self.client.get_range(self.spreadsheet.id, value_ranges=labels, major_dimension=majdim, + value_render_option=value_render, + date_time_render_option=date_time_render_option, **kwargs) + + return values + + def get_all_values(self, returnas='matrix', majdim='ROWS', include_tailing_empty=True, + include_tailing_empty_rows=True, **kwargs): + """Returns a list of lists containing all cells' values as strings. + + :param majdim: output as row wise or column-wise + :param returnas: return as list of strings of cell objects + :param include_tailing_empty: whether to include empty trailing cells/values after last non-zero value + :param include_tailing_empty_rows: whether to include rows with no values; if include_tailing_empty is false, + will return unfilled list for each empty row, else will return rows filled with empty string + :param kwargs: all parameters of :meth:`pygsheets.Worksheet.get_values` + + :type returnas: 'matrix','cell', 'range + + Example: + + >>> wks.get_all_values() + [[u'another look.', u'', u'est'], + [u'EE 4212', u"it's down there "], + [u'ee 4210', u'somewhere, let me take ']] + """ + return self.get_values(None, None, returnas=returnas, majdim=majdim, + include_tailing_empty=include_tailing_empty, + include_tailing_empty_rows=include_tailing_empty_rows, **kwargs) + + def get_all_records(self, empty_value='', head=1, majdim='ROWS', numericise_data=True, **kwargs): + """ + Returns a list of dictionaries, all of them having + + - the contents of the spreadsheet's with the head row as keys, \ + And each of these dictionaries holding + - the contents of subsequent rows of cells as values. + + Cell values are numericised (strings that can be read as ints + or floats are converted). + + :param empty_value: determines empty cell's value + :param head: determines which row to use as keys, starting from 1 + following the numeration of the spreadsheet. + :param majdim: ROW or COLUMN major form + :param numericise_data: determines if data is converted to numbers or left as string + :param kwargs: all parameters of :meth:`pygsheets.Worksheet.get_values` + + :returns: a list of dict with header column values as head and rows as list + + .. warning:: + Will work nicely only if there is a single table in the sheet + + """ + if not self._linked: return False + + idx = head - 1 + data = self.get_all_values(returnas='matrix', include_tailing_empty=False, include_tailing_empty_rows=False, + majdim=majdim, **kwargs) + keys = data[idx] + num_keys = len(keys) + values = [] + for row in data[idx+1:]: + if len(row) < num_keys: + row.extend([""]*(num_keys-len(row))) + elif len(row) > num_keys: + row = row[:num_keys] + if numericise_data: + values.append(numericise_all(row, empty_value)) + else: + values.append(row) + + return [dict(zip(keys, row)) for row in values] + + def get_row(self, row, returnas='matrix', include_tailing_empty=True, **kwargs): + """Returns a list of all values in a `row`. + + Empty cells in this list will be rendered as empty strings . + + :param include_tailing_empty: whether to include empty trailing cells/values after last non-zero value + :param row: index of row + :param kwargs: all parameters of :meth:`pygsheets.Worksheet.get_values` + + :param returnas: ('matrix', 'cell', 'range') return as cell objects or just 2d array or range object + + """ + row = self.get_values((row, 1), (row, None), returnas=returnas, + include_tailing_empty=include_tailing_empty, include_tailing_empty_rows=True, **kwargs) + if returnas == 'range': + return row + else: + return row[0] + + def get_col(self, col, returnas='matrix', include_tailing_empty=True, **kwargs): + """Returns a list of all values in column `col`. + + Empty cells in this list will be rendered as :const:` ` . + + :param include_tailing_empty: whether to include empty trailing cells/values after last non-zero value + :param col: index of col + :param kwargs: all parameters of :meth:`pygsheets.Worksheet.get_values` + + :param returnas: ('matrix' or 'cell' or 'range') return as cell objects or just values + + """ + col = self.get_values((1, col), (None, col), returnas=returnas, majdim='COLUMNS', + include_tailing_empty=include_tailing_empty, include_tailing_empty_rows=True, **kwargs) + if returnas == 'range': + return col + else: + return col[0] + + def get_gridrange(self, start, end): + """ + get a range in gridrange format + + :param start: start address + :param end: end address + """ + return self._get_range(start, end, "gridrange") + + @batchable + def update_cell(self, **kwargs): + warnings.warn(_warning_message.format("method", "update_value"), category=DeprecationWarning) + self.update_value(**kwargs) + + @batchable + def update_value(self, addr, val, parse=None): + """Sets the new value to a cell. + + :param addr: cell address as tuple (row,column) or label 'A1'. + :param val: New value + :param parse: if False, values will be stored \ + as is else as if the user typed them into the UI default is spreadsheet.default_parse + + Example: + + >>> wks.update_value('A1', '42') # this could be 'a1' as well + + >>> wks.update_value('A3', '=A1+A2', True) + + """ + if not self._linked: + self._func_calls.append(()) + return False + + label = format_addr(addr, 'label') + body = dict() + body['range'] = self._get_range(label, label) + body['majorDimension'] = 'ROWS' + body['values'] = [[val]] + parse = parse if parse is not None else self.spreadsheet.default_parse + self.client.sheet.values_batch_update(self.spreadsheet.id, body, parse) + + @batchable + def update_values(self, crange=None, values=None, cell_list=None, extend=False, majordim='ROWS', parse=None): + """Updates a range cell values, it can take either a cell list or a range and its values. cell list is only efficient + for small lists. This will only update the cell values not other properties. + + :param cell_list: List of a :class:`Cell` objects to update with their values. If you pass a matrix to this,\ + then it is assumed that the matrix is continuous (range), and will just update values based on label of top \ + left and bottom right cells. + + :param crange: range in format A1:A2 or just 'A1' or even (1,2) end cell will be inferred from values + :param values: matrix of values if range given, if a value is None its unchanged + :param extend: add columns and rows to the workspace if needed (not for cell list) + :param majordim: major dimension of given data + :param parse: if the values should be as if the user typed them into the UI else its stored as is. Default is + spreadsheet.default_parse + """ + if not self._linked: return False + + if cell_list: + if type(cell_list[0]) is list: + values = [] + for row in cell_list: + tmp_row = [] + for col in cell_list: + tmp_row.append(cell_list[row][col].value) + values.append(tmp_row) + crange = cell_list[0][0].label + ':' + cell_list[-1][-1].label + else: + values = [[None for x in range(self.cols)] for y in range(self.rows)] + min_tuple = [cell_list[0].row, cell_list[0].col] + max_tuple = [0, 0] + for cell in cell_list: + min_tuple[0] = min(min_tuple[0], cell.row) + min_tuple[1] = min(min_tuple[1], cell.col) + max_tuple[0] = max(max_tuple[0], cell.row) + max_tuple[1] = max(max_tuple[1], cell.col) + try: + values[cell.row-1][cell.col-1] = cell.value + except IndexError: + raise CellNotFound(cell) + values = [row[min_tuple[1]-1:max_tuple[1]] for row in values[min_tuple[0]-1:max_tuple[0]]] + crange = str(format_addr(tuple(min_tuple))) + ':' + str(format_addr(tuple(max_tuple))) + elif crange and values: + if not isinstance(values, list) or not isinstance(values[0], list): + raise InvalidArgumentValue("values should be a matrix") + else: + raise InvalidArgumentValue("provide either cells or values, not both") + + body = dict() + estimate_size = False + if type(crange) == str: + if crange.find(':') == -1: + estimate_size = True + elif type(crange) == tuple: + estimate_size = True + else: + raise InvalidArgumentValue('crange') + + if estimate_size: + start_r_tuple = format_addr(crange, output='tuple') + max_2nd_dim = max(map(len, values)) + if majordim == 'ROWS': + end_r_tuple = (start_r_tuple[0]+len(values), start_r_tuple[1]+max_2nd_dim) + else: + end_r_tuple = (start_r_tuple[0] + max_2nd_dim, start_r_tuple[1] + len(values)) + body['range'] = self._get_range(crange, format_addr(end_r_tuple)) + else: + body['range'] = self._get_range(*crange.split(':')) + + if extend: + self.refresh() + end_r_tuple = format_addr(str(body['range']).split(':')[-1]) + if self.rows < end_r_tuple[0]: + self.rows = end_r_tuple[0]-1 + if self.cols < end_r_tuple[1]: + self.cols = end_r_tuple[1]-1 + body['majorDimension'] = majordim + body['values'] = values + parse = parse if parse is not None else self.spreadsheet.default_parse + self.client.sheet.values_batch_update(self.spreadsheet.id, body, parse) + + @batchable + def update_values_batch(self, ranges, values, majordim='ROWS', parse=None): + """ + update multiple ranges of values in a single call. + + :param ranges: list of addresses of the range. can be GridRange, label, tuple, etc + :param values: list of values corresponding to ranges, should be list of matrices + :param majordim: major dimension of values provided. 'ROWS' or 'COLUMNS' + :param parse: if the values should be as if the user typed them into the UI else its stored as is. Default is + spreadsheet.default_parse + + Example: + >>> wks.update_values_batch(['A1:A2', 'B1:B2'], [[[1],[2]], [[3],[4]]]) + >>> wks.get_values_batch(['A1:A2', 'B1:B2']) + [[['1'], ['2']], [['3'], ['4']]] + + >>> wks.update_values_batch([((1,1), (2,1)), 'B1:B2'], [[[1,2]], [[3,4]]], 'COLUMNS') + >>> wks.get_values_batch(['A1:A2', 'B1:B2']) + [[['1'], ['2']], [['3'], ['4']]] + + """ + ranges = [GridRange.create(x, self).label for x in ranges] + if not isinstance(values, list): + raise InvalidArgumentValue('values is not a list') + if len(ranges) != len(values): + raise InvalidArgumentValue('number of ranges and values should match') + # TODO update to enable filters + data = [ + {'dataFilter': {'a1Range': x[0]}, 'values': x[1], 'majorDimension': majordim} for x in zip(ranges, values) + ] + self.client.sheet.values_batch_update_by_data_filter(self.spreadsheet.id, data, parse) + + @batchable + def update_cells_prop(self, **kwargs): + warnings.warn(_warning_message.format('method', 'update_cells'), category=DeprecationWarning) + self.update_cells(**kwargs) + + @batchable + def update_cells(self, cell_list, fields='*'): + """ + update cell properties and data from a list of cell objects + + :param cell_list: list of cell objects + :param fields: cell fields to update, in google `FieldMask format `_ + + """ + if not self._linked: return False + + if fields == 'userEnteredValue': + pass # TODO Create a grid and put values there and update + + requests = [] + for cell in cell_list: + request = cell.update(get_request=True, worksheet_id=self.id) + request['repeatCell']['fields'] = fields + requests.append(request) + + self.client.sheet.batch_update(self.spreadsheet.id, requests) + + @batchable + def update_col(self, index, values, row_offset=0): + """ + update an existing colum with values + + :param index: index of the starting column form where value should be inserted + :param values: values to be inserted as matrix, column major + :param row_offset: rows to skip before inserting values + + """ + if not self._linked: return False + + if type(values[0]) is not list: + values = [values] + colrange = format_addr((row_offset+1, index), 'label') + ":" + format_addr((row_offset+len(values[0]), + index+len(values)-1), "label") + self.update_values(crange=colrange, values=values, majordim='COLUMNS') + + @batchable + def update_row(self, index, values, col_offset=0): + """Update an existing row with values + + :param index: Index of the starting row form where value should be inserted + :param values: Values to be inserted as matrix + :param col_offset: Columns to skip before inserting values + + """ + if not self._linked: return False + + if type(values[0]) is not list: + values = [values] + colrange = format_addr((index, col_offset+1), 'label') + ':' + format_addr((index+len(values)-1, + col_offset+len(values[0])), 'label') + self.update_values(crange=colrange, values=values, majordim='ROWS') + + @batchable + def resize(self, rows=None, cols=None): + """Resizes the worksheet. + + :param rows: New number of rows. + :param cols: New number of columns. + """ + trows, tcols = self.rows, self.cols + try: + self.rows, self.cols = rows or trows, cols or tcols + except: + self.logger.error("couldn't resize the sheet to " + str(rows) + ',' + str(cols)) + self.rows, self.cols = trows, tcols + raise + + @batchable + def add_rows(self, rows): + """Adds new rows to this worksheet. + + :param rows: How many rows to add (integer) + """ + self.resize(rows=self.rows + rows, cols=self.cols) + + @batchable + def add_cols(self, cols): + """Add new columns to this worksheet. + + :param cols: How many columns to add (integer) + """ + self.resize(cols=self.cols + cols, rows=self.rows) + + @batchable + def delete_cols(self, index, number=1): + """Delete 'number' of columns from index. + + :param index: Index of first column to delete + :param number: Number of columns to delete + + """ + if not self._linked: return False + + index -= 1 + if number < 1: + raise InvalidArgumentValue('number') + request = {'deleteDimension': {'range': {'sheetId': self.id, 'dimension': 'COLUMNS', + 'endIndex': (index+number), 'startIndex': index}}} + self.client.sheet.batch_update(self.spreadsheet.id, request) + self.jsonSheet['properties']['gridProperties']['columnCount'] = self.cols-number + + @batchable + def delete_rows(self, index, number=1): + """Delete 'number' of rows from index. + + :param index: Index of first row to delete + :param number: Number of rows to delete + """ + if not self._linked: return False + + index -= 1 + if number < 1: + raise InvalidArgumentValue + request = {'deleteDimension': {'range': {'sheetId': self.id, 'dimension': 'ROWS', + 'endIndex': (index+number), 'startIndex': index}}} + self.client.sheet.batch_update(self.spreadsheet.id, request) + self.jsonSheet['properties']['gridProperties']['rowCount'] = self.rows-number + + @batchable + def insert_cols(self, col, number=1, values=None, inherit=False): + """Insert new columns after 'col' and initialize all cells with values. Increases the + number of rows if there are more values in values than rows. + + Reference: `insert request `_ + + :param col: Index of the col at which the values will be inserted. + :param number: Number of columns to be inserted. + :param values: Content to be inserted into new columns. + :param inherit: New cells will inherit properties from the column to the left (True) or to the right (False). + """ + if not self._linked: return False + + request = {'insertDimension': {'inheritFromBefore': inherit, + 'range': {'sheetId': self.id, 'dimension': 'COLUMNS', + 'endIndex': (col+number), 'startIndex': col} + }} + self.client.sheet.batch_update(self.spreadsheet.id, request) + self.jsonSheet['properties']['gridProperties']['columnCount'] = self.cols+number + if values: + self.update_col(col+1, values) + + @batchable + def insert_rows(self, row, number=1, values=None, inherit=False): + """Insert a new row after 'row' and initialize all cells with values. + + Widens the worksheet if there are more values than columns. + + Reference: `insert request`_ + + :param row: Index of the row at which the values will be inserted. + :param number: Number of rows to be inserted. + :param values: Content to be inserted into new rows. + :param inherit: New cells will inherit properties from the row above (True) or below (False). + """ + if not self._linked: return False + + request = {'insertDimension': {'inheritFromBefore': inherit, + 'range': {'sheetId': self.id, 'dimension': 'ROWS', + 'endIndex': (row+number), 'startIndex': row}}} + self.client.sheet.batch_update(self.spreadsheet.id, request) + self.jsonSheet['properties']['gridProperties']['rowCount'] = self.rows + number + if values: + self.update_row(row+1, values) + + @batchable + @allow_gridrange + def clear(self, start='A1', end=None, fields="userEnteredValue"): + """Clear all values in worksheet. Can be limited to a specific range with start & end. + + Fields specifies which cell properties should be cleared. Use "*" to clear all fields. + + Reference: + + - `CellData Api object `_ + - `FieldMask Api object `_ + + :param start: Top left cell label. + :param end: Bottom right cell label. + :param fields: Comma separated list of field masks. + + """ + if not self._linked: return False + + if not end: + end = (self.rows, self.cols) + grange = GridRange(worksheet=self, start=start, end=end) + request = {"updateCells": {"range": grange.to_json(), "fields": fields}} + self.client.sheet.batch_update(self.spreadsheet.id, request) + + @batchable + def adjust_column_width(self, start, end=None, pixel_size=None): + """Set the width of one or more columns. + + :param start: Index of the first column to be widened. + :param end: Index of the last column to be widened. + :param pixel_size: New width in pixels or None to set width automatically based on the size of the column content. + + """ + if not self._linked: return False + + if end is None or end <= start: + end = start + + start -= 1 + + if pixel_size: + request = { + "updateDimensionProperties": { + "range": { + "sheetId": self.id, + "dimension": "COLUMNS", + "startIndex": start, + "endIndex": end + }, + "properties": { + "pixelSize": pixel_size + }, + "fields": "pixelSize" + } + }, + else: + request = { + "autoResizeDimensions": { + "dimensions": { + "sheetId": self.id, + "dimension": "COLUMNS", + "startIndex": start, + "endIndex": end + } + } + }, + + self.client.sheet.batch_update(self.spreadsheet.id, request) + + def apply_format(self, ranges, format_info, fields='userEnteredFormat'): + """ + apply formatting for for multiple ranges + + :param ranges: list of ranges (any type) to apply the formats to + :param format_info: list or single pygsheets cell or dict of properties specifying the formats to be updated, + see `this `__ + for available options. if a list is given it should match size of ranges. + :param fields: fields to be updated in the cell + + Example: + >>> wks.apply_format('A1:A10', {"numberFormat": {"type": "NUMBER"}}) + >>> wks.apply_format('A1:A10', "TEXT") # by default number format is assumed + >>> wks.apply_format(ranges=['A1:B1', 'D:E'], format_info={'numberFormat': {"type": "NUMBER"}}) + >>> mcell = Cell('A1') # dummy cell + >>> mcell.format = (pygsheets.FormatType.PERCENT, '') + >>> wks.apply_format(ranges=['A1:B1', 'D:E'], format_info=mcell) + + """ + requests = [] + format_info = [format_info] if not isinstance(format_info, list) else format_info + model_cells = [{"numberFormat": {"type": x.upper()}} if isinstance(x, str) else x for x in format_info] + ranges = [ranges] if not isinstance(ranges, list) else ranges + if len(model_cells) == 1: + model_cells = model_cells * len(ranges) + for crange, cell in zip(ranges, model_cells): + range_json = GridRange.create(crange, self).to_json() + if isinstance(cell, Cell): + cell = cell.get_json() + else: + cell = {"userEnteredFormat": cell} + requests.append({"repeatCell": { + "range": range_json, + "cell": cell, + "fields": fields or "userEnteredFormat,hyperlink,note,textFormatRuns,dataValidation,pivotTable" + }}) + self.client.sheet.batch_update(self.spreadsheet.id, requests) + + @batchable + def update_dimensions_visibility(self, start, end=None, dimension="ROWS", hidden=True): + """Hide or show one or more rows or columns. + + :param start: Index of the first row or column. + :param end: Index of the last row or column. + :param dimension: 'ROWS' or 'COLUMNS' + :param hidden: Hide rows or columns + """ + if not self._linked: return False + + if end is None or end <= start: + end = start + start -= 1 + + request = { + "updateDimensionProperties": { + "range": { + "sheetId": self.id, + "dimension": dimension, + "startIndex": start, + "endIndex": end + }, + "properties": { + "hiddenByUser": hidden + }, + "fields": "hiddenByUser" + } + }, + + self.client.sheet.batch_update(self.spreadsheet.id, request) + + @batchable + def hide_dimensions(self, start, end=None, dimension="ROWS"): + """Hide one ore more rows or columns. + + :param start: Index of the first row or column. + :param end: Index of the last row or column. + :param dimension: 'ROWS' or 'COLUMNS' + """ + self.update_dimensions_visibility(start, end, dimension, hidden=True) + + @batchable + def show_dimensions(self, start, end=None, dimension="ROWS"): + """Show one ore more rows or columns. + + :param start: Index of the first row or column. + :param end: Index of the last row or column. + :param dimension: 'ROWS' or 'COLUMNS' + """ + self.update_dimensions_visibility(start, end, dimension, hidden=False) + + @batchable + def adjust_row_height(self, start, end=None, pixel_size=None): + """Adjust the height of one or more rows. + + :param start: Index of first row to be heightened. + :param end: Index of last row to be heightened. + :param pixel_size: New height in pixels or None to set height automatically based on the size of the row content. + """ + if not self._linked: return False + + if end is None or end <= start: + end = start + start -= 1 + + if pixel_size: + request = { + "updateDimensionProperties": { + "range": { + "sheetId": self.id, + "dimension": "ROWS", + "startIndex": start, + "endIndex": end + }, + "properties": { + "pixelSize": pixel_size + }, + "fields": "pixelSize" + } + } + else: + request = { + "autoResizeDimensions": { + "dimensions": { + "sheetId": self.id, + "dimension": "ROWS", + "startIndex": start, + "endIndex": end + } + } + }, + + self.client.sheet.batch_update(self.spreadsheet.id, request) + + @batchable + def append_table(self, values, start='A1', end=None, dimension='ROWS', overwrite=False, **kwargs): + """Append a row or column of values to an existing table in the sheet. + The input range is used to search for existing data and find a "table" within that range. + Values will be appended to the next row of the table, starting with the first column of the table. + The return value contains the index of the appended table. It is useful to get the index of last row or last column. + + Reference: `request `_ + + :param values: List of values for the new row or column. + :param start: Top left cell of the range (requires a label). + :param end: Bottom right cell of the range (requires a label). + :param dimension: Dimension to which the values will be added ('ROWS' or 'COLUMNS') + :param overwrite: If true will overwrite data present in the spreadsheet. Otherwise will create new + rows to insert the data into. + + :returns: A :class:dict containing the result of `request `_ + """ + if not self._linked: + return False + + if type(values[0]) != list: + values = [values] + if not end: + end = (self.rows, self.cols) + response_json = self.client.sheet.values_append(self.spreadsheet.id, values, dimension, range=self._get_range(start, end), + insertDataOption='OVERWRITE' if overwrite else 'INSERT_ROWS', **kwargs) + self.refresh(False) + + # Prepare the returned data as discussed in issue 546 (https://github.com/nithinmurali/pygsheets/issues/546) + ret = { + 'tableRange': GridRange.create(response_json['tableRange'], self), + 'updates': { + 'updatedRange': GridRange.create(response_json['updates']['updatedRange'], self), + 'updatedCells': response_json['updates']['updatedCells'], + 'updatedColumns': response_json['updates']['updatedColumns'], + 'updatedRows': response_json['updates']['updatedRows'], + }, + } + return ret + + def replace(self, pattern, replacement=None, **kwargs): + """Replace values in any cells matched by pattern in this worksheet. Keyword arguments + not specified will use the default value. + + If the worksheet is + + - **Unlinked** : Uses `self.find(pattern, **kwargs)` to find the cells and then replace the values in each cell. + - **Linked** : The replacement will be done by a findReplaceRequest as defined by the Google Sheets API.\ + After the request the local copy is updated. + + Reference: `request `__ + + :param pattern: Match cell values. + :param replacement: Value used as replacement. + :arg searchByRegex: Consider pattern a regex pattern. (default False) + :arg matchCase: Match case sensitive. (default False) + :arg matchEntireCell: Only match on full match. (default False) + :arg includeFormulas: Match fields with formulas too. (default False) + """ + if self._linked: + find_replace = dict() + find_replace['find'] = pattern + find_replace['replacement'] = replacement + for key in kwargs: + find_replace[key] = kwargs[key] + find_replace['sheetId'] = self.id + body = {'findReplace': find_replace} + self.client.sheet.batch_update(self.spreadsheet.id, body) + # self._update_grid(True) + else: + found_cells = self.find(pattern, **kwargs) + if replacement is None: + replacement = '' + + for cell in found_cells: + if 'matchEntireCell' in kwargs and kwargs['matchEntireCell']: + cell.value = replacement + else: + cell.value = re.sub(pattern, replacement, cell.value) + + def find(self, pattern, searchByRegex=False, matchCase=False, matchEntireCell=False, includeFormulas=False, + cols=None, rows=None, forceFetch=True): + """Finds all cells matched by the pattern. + + Compare each cell within this sheet with pattern and return all matched cells. All cells are compared + as strings. If replacement is set, the value in each cell is set to this value. Unless full_match is False in + in which case only the matched part is replaced. + + .. note:: + - Formulas are searched as their calculated values and not the actual formula. + - Find fetches all data and then run a linear search on then, so this will be slow if you have a large sheet + + :param pattern: A string pattern. + :param searchByRegex: Compile pattern as regex. (default False) + :param matchCase: Comparison is case sensitive. (default False) + :param matchEntireCell: Only match a cell if the pattern matches the entire value. (default False) + :param includeFormulas: Match cells with formulas. (default False) + :param rows: Range of rows to search in as tuple, example (2, 10) + :param cols: Range of columns to search in as tuple, example (3, 10) + :param forceFetch: If the offline data should be updated before search. (default False) + + :returns: A list of :class:`Cells `. + """ + if self._linked and forceFetch: + self._update_grid(True) + + # flatten and filter data grid. + cells = self.data_grid + if rows: cells = self.data_grid[rows[0]-1: rows[1]] + found_cells = [] + for cells_row in cells: + if cols: cells_row = cells_row[cols[0]-1: cols[1]] + found_cells.extend(cells_row) + + if not includeFormulas: + found_cells = filter(lambda x: x.formula == '', found_cells) + + if not matchCase: + pattern = pattern.lower() + + if searchByRegex and matchEntireCell and matchCase: + return list(filter(lambda x: fullmatch(pattern, x.value), found_cells)) + elif searchByRegex and matchEntireCell and not matchCase: + return list(filter(lambda x: fullmatch(pattern.lower(), x.value.lower()), found_cells)) + elif searchByRegex and not matchEntireCell and matchCase: + return list(filter(lambda x: re.search(pattern, x.value), found_cells)) + elif searchByRegex and not matchEntireCell and not matchCase: + return list(filter(lambda x: re.search(pattern, x.value.lower()), found_cells)) + + elif not searchByRegex and matchEntireCell and matchCase: + return list(filter(lambda x: x.value == pattern, found_cells)) + elif not searchByRegex and matchEntireCell and not matchCase: + return list(filter(lambda x: x.value.lower() == pattern, found_cells)) + elif not searchByRegex and not matchEntireCell and matchCase: + return list(filter(lambda x: False if x.value.find(pattern) == -1 else True, found_cells)) + else: # if not searchByRegex and not matchEntireCell and not matchCase + return list(filter(lambda x: False if x.value.lower().find(pattern) == -1 else True, found_cells)) + + @batchable + def create_named_range(self, name, start=None, end=None, grange=None, returnas='range'): + """Create a new named range in this worksheet. Provide either start and end or grange. + + Reference: `Named range Api object `_ + + :param name: Name of the range. + :param start: Top left cell address (label or coordinates) + :param end: Bottom right cell address (label or coordinates) + :param grange: grid range, object of :class:`GridRange` + :returns: :class:`DataRange` + """ + if not self._linked: return False + + if not grange: + grange = GridRange(worksheet=self, start=start, end=end) + + request = {"addNamedRange": { + "namedRange": { + "name": name, + "range": grange.to_json() + }}} + res = self.client.sheet.batch_update(self.spreadsheet.id, request) + + batch_mode = self.client.sheet.batch_mode + if not batch_mode: + if returnas == 'json': + return res['replies'][0]['addNamedRange']['namedRange'] + else: + return DataRange(worksheet=self, namedjson=res) + + def get_named_range(self, name): + """Get a named range by name. + + Reference: `Named range Api object `_ + + :param name: Name of the named range to be retrieved. + :returns: :class:`DataRange` + + :raises RangeNotFound: if no range matched the name given. + """ + if not self._linked: return False + + nrange = [x for x in self.spreadsheet.named_ranges if x.name == name and x.worksheet.id == self.id] + if len(nrange) == 0: + self.spreadsheet.fetch_properties() + nrange = [x for x in self.spreadsheet.named_ranges if x.name == name and x.worksheet.id == self.id] + if len(nrange) == 0: + raise RangeNotFound(name) + return nrange[0] + + def get_named_ranges(self, name=''): + """Get named ranges from this worksheet. + + Reference: `Named range Api object `_ + + :param name: Name of the named range to be retrieved, if omitted all ranges are retrieved. + :return: :class:`DataRange` + """ + if not self._linked: return False + + if name == '': + self.spreadsheet.fetch_properties() + nrange = [x for x in self.spreadsheet.named_ranges if x.worksheet.id == self.id] + return nrange + else: + return self.get_named_range(name) + + @batchable + def delete_named_range(self, name, range_id=''): + """Delete a named range. + + Reference: `Named range Api object`_ + + :param name: Name of the range. + :param range_id: Id of the range (optional) + + """ + if not self._linked: return False + + if not range_id: + range_id = self.get_named_ranges(name=name).name_id + request = {'deleteNamedRange': { + "namedRangeId": range_id, + }} + self.client.sheet.batch_update(self.spreadsheet.id, request) + self.spreadsheet._named_ranges = [x for x in self.spreadsheet._named_ranges if x["namedRangeId"] != range_id] + + @batchable + def create_protected_range(self, start=None, end=None, grange=None, named_range_id=None, returnas='range'): + """Create protected range. Provide either start and end or grange. + + Reference: `Protected range Api object `_ + + :param start: address of the topleft cell + :param end: address of the bottomright cell + :param grange: grid range to protect, object of :class:`GridRange` + :param named_range_id: id of named range to protect + :param returnas: 'json' or 'range' + + """ + if not self._linked: return False + + if not grange: + grange = GridRange(worksheet=self, start=start, end=end) + + request = {"addProtectedRange": { + "protectedRange": {}, + }} + if named_range_id: + request['addProtectedRange']['protectedRange']['namedRangeId'] = named_range_id + else: + request['addProtectedRange']['protectedRange']['range'] = grange.to_json() + drange = self.client.sheet.batch_update(self.spreadsheet.id, + request)['replies'][0]['addProtectedRange']['protectedRange'] + if returnas == 'json': + return drange + else: + return DataRange(protectedjson=drange, worksheet=self) + + @batchable + def remove_protected_range(self, range_id): + """Remove protected range. + + Reference: `Protected range Api object`_ + + :param range_id: ID of the protected range. + """ + if not self._linked: return False + + request = {"deleteProtectedRange": { + "protectedRangeId": range_id + }} + return self.client.sheet.batch_update(self.spreadsheet.id, request) + + def get_protected_ranges(self): + """ + returns protected ranges in this sheet + + :return: Protected range objects + :rtype: :class:`Datarange` + """ + if not self._linked: return False + + self.refresh(False) + return [DataRange(protectedjson=x, worksheet=self) for x in self.jsonSheet.get('protectedRanges', {})] + + @batchable + def set_dataframe(self, df, start, copy_index=False, copy_head=True, extend=False, fit=False, escape_formulae=False, **kwargs): + """Load sheet from Pandas Dataframe. + + Will load all data contained within the Pandas data frame into this worksheet. + It will begin filling the worksheet at cell start. Supports multi index and multi header + datarames. + + :param df: Pandas data frame. + :param start: Address of the top left corner where the data should be added. + :param copy_index: Copy data frame index (multi index supported). + :param copy_head: Copy header data into first row. + :param extend: Add columns and rows to the worksheet if necessary, but won't delete any rows or columns. + :param fit: Resize the worksheet to fit all data inside if necessary. + :param escape_formulae: Any value starting with an equal or plus sign (=/+), will be prefixed with an apostrophe (') to + avoid value being interpreted as a formula. + :param nan: Value with which NaN values are replaced. by default it will be replaced with string 'nan'. for converting nan values to + empty cells set nan="". + + """ + + if not self._linked: + return False + nan = kwargs.get('nan', "NaN") + + start = Address(start) + for col in df.select_dtypes('Int64'): + df[col] = df[col].astype('unicode').replace('', nan) + df = df.fillna(nan) + values = df.astype('unicode').values.tolist() + (df_rows, df_cols) = df.shape + num_indexes = 1 + index_column_names = None + + if copy_index: + if isinstance(df.index, pd.MultiIndex): + num_indexes = len(df.index[0]) + for i, indexes in enumerate(df.index): + indexes = map(str, indexes) + for index_item in reversed(list(indexes)): + values[i].insert(0, index_item) + df_cols += num_indexes + index_column_names = list(df.index.names) # creates the column names + else: + for i, val in enumerate(df.index.astype(str)): + values[i].insert(0, val) + df_cols += num_indexes + index_column_names = [df.index.name] # creates the column name + + if copy_head: + # If multi index, copy indexes in each level to new row + if isinstance(df.columns, pd.MultiIndex): + head = [""]*num_indexes if copy_index else [] # skip index columns + heads = [head[:] for x in df.columns[0]] + for col_head in df.columns: + for i, col_item in enumerate(col_head): + heads[i].append(str(col_item)) + # adds in the index names to bottom header row if copy_index is also True + if copy_index: + # to account for multi-index names we will replace all '' in our head list + # with the index_column_names + heads[-1][:num_indexes] = index_column_names + values = heads + values + df_rows += len(df.columns[0]) + else: + head = [""]*num_indexes if copy_index else [] # skip index columns + map(str, head) + head.extend(df.columns.tolist()) + # if copy_index & copy_head, include the index names + if copy_index: + # to account for multi-index names we will replace all '' in our head list + # with the index_column_names + head[:num_indexes] = index_column_names + values.insert(0, head) + df_rows += 1 + + end = start + (df_rows, df_cols) + + if fit == extend is not False: + raise InvalidArgumentValue("fit should not be same with extend") + + if fit: + self.cols = start[1] - 1 + df_cols + self.rows = start[0] - 1 + df_rows + elif extend: + self.cols = max(self.cols, start[1] - 1 + df_cols) + self.rows = max(self.rows, start[0] - 1 + df_rows) + else: + if fit == "column": + self.cols = start[1] - 1 + df_cols + if fit == "row": + self.rows = start[0] - 1 + df_rows + if extend == "column": + self.cols = max(self.cols, start[1] - 1 + df_cols) + if extend == "row": + self.rows = max(self.rows, start[0] - 1 + df_rows) + + if escape_formulae: + values = list(map(lambda row: list(map(lambda cell: "'" + cell if type(cell) == str + and (cell.startswith('=') or cell.startswith('+')) else cell, row)), values)) + + crange = start.label + ':' + end.label + self.update_values(crange=crange, values=values) + + def get_as_df(self, has_header=True, index_column=None, start=None, end=None, numerize=True, + empty_value='', value_render=ValueRenderOption.FORMATTED_VALUE, **kwargs): + """ + Get the content of this worksheet as a pandas data frame. + + :param has_header: Interpret first row as data frame header. + :param index_column: Column to use as data frame index (integer). + :param numerize: Numerize cell values. + :param empty_value: Placeholder value to represent empty cells when numerizing. + :param start: Top left cell to load into data frame. (default: A1) + :param end: Bottom right cell to load into data frame. (default: (rows, cols)) + :param value_render: How the output values should returned, `api docs `__ + By default, will convert everything to strings. Setting as UNFORMATTED_VALUE will do + numerizing, but values will be unformatted. + :param include_tailing_empty: whether to include empty trailing cells/values after last non-zero value in a row + :param include_tailing_empty_rows: whether to include tailing rows with no values; if include_tailing_empty is false, + will return unfilled list for each empty row, else will return rows filled with empty cells + :returns: pandas.Dataframe + """ + if not self._linked: return False + + include_tailing_empty = kwargs.get('include_tailing_empty', False) + include_tailing_empty_rows = kwargs.get('include_tailing_empty_rows', False) + index_column = index_column or kwargs.get('index_colum', None) + + if not pd: + raise ImportError("pandas") + if start is not None or end is not None: + if end is None: + end = (self.rows, self.cols) + values = self.get_values(start, end, value_render=value_render, + include_tailing_empty=include_tailing_empty, + include_tailing_empty_rows=include_tailing_empty_rows) + else: + values = self.get_all_values(returnas='matrix', include_tailing_empty=include_tailing_empty, + value_render=value_render, include_tailing_empty_rows=include_tailing_empty_rows) + + max_row = max(len(row) for row in values) + values = [row + [empty_value] * (max_row - len(row)) for row in values] + + if numerize: + values = [numericise_all(row, empty_value) for row in values] + + if has_header: + keys = values[0] + values = values[1:] + if any(key == '' for key in keys): + warnings.warn('At least one column name in the data frame is an empty string. If this is a concern, please specify include_tailing_empty=False and/or ensure that each column containing data has a name.') + df = pd.DataFrame(values, columns=keys) + else: + df = pd.DataFrame(values) + + if index_column: + if index_column < 1 or index_column > len(df.columns): + raise ValueError("index_column %s not found" % index_column) + else: + df.index = df[df.columns[index_column - 1]] + del df[df.columns[index_column - 1]] + return df + + def export(self, file_format=ExportType.CSV, filename=None, path=''): + """Export this worksheet to a file. + + .. note:: + - Only CSV & TSV exports support single sheet export. In all other cases the entire \ + spreadsheet will be exported. + - This can at most export files with 10 MB in size! + + :param file_format: Target file format (default: CSV), enum :class: + :param filename: Filename (default: spreadsheet id + worksheet index). + :param path: Directory the export will be stored in. (default: current working directory) + + """ + if not self._linked: + return + self.client.drive.export(self, file_format=file_format, filename=filename, path=path) + + @batchable + def copy_to(self, spreadsheet_id): + """Copy this worksheet to another spreadsheet. + + This will copy the entire sheet into another spreadsheet and then return the new worksheet. + Can be slow for huge spreadsheets. + + Reference: `request `__ + + :param spreadsheet_id: The id this should be copied to. + :returns: Copy of the worksheet in the new spreadsheet. + """ + # TODO: Implement a way to limit returned data. For large spreadsheets. + + if not self._linked: return False + + response = self.client.sheet.sheets_copy_to(self.spreadsheet.id, self.id, spreadsheet_id) + new_spreadsheet = self.client.open_by_key(spreadsheet_id) + return new_spreadsheet[response['index']] + + @allow_gridrange + def sort_range(self, start, end, basecolumnindex=0, sortorder="ASCENDING"): + """Sorts the data in rows based on the given column index. + + :param start: Address of the starting cell of the grid. + :param end: Address of the last cell of the grid to be considered. + :param basecolumnindex: Index of the base column in which sorting is to be done (Integer), + default value is 0. The index here is the index of the column in worksheet. + :param sortorder: either "ASCENDING" or "DESCENDING" (String) + + Example: + If the data contain 5 rows and 6 columns and sorting is to be done in 4th column. + In this case the values in other columns also change to maintain the same relative values. + """ + + if not self._linked: return False + start = format_addr(start, 'tuple') + end = format_addr(end, 'tuple') + + request = {"sortRange": { + "range": { + + "sheetId": self.id, + "startRowIndex": start[0]-1, + "endRowIndex": end[0], + "startColumnIndex": start[1]-1, + "endColumnIndex": end[1], + }, + "sortSpecs": [ + { + "dimensionIndex": basecolumnindex, + "sortOrder": sortorder + } + ], + }} + self.client.sheet.batch_update(self.spreadsheet.id, request) + + def add_chart(self, domain, ranges, title=None, chart_type=ChartType.COLUMN, anchor_cell=None): + """ + Creates a chart in the sheet and returns a chart object. The X-axis is called the domain and the Y-axis is + called range. There can only be a single domain as it is the values against which the ranges are plotted. + You can have multiple ranges, and all of them will be plotted against the values on the domain + (depending on chart_type). + + For example, suppose you want to plot temperature against the years. Here Year will be the domain and Temperature + will be a range. Now suppose you want to add a plot of rainfall also to this chart (given you have the same year range). + You can just add the rainfall data as a range. + + + :param domain: Cell range of the desired chart domain (x-axis) in the form of tuple of adresses + (start_address, end_address) + :param ranges: Cell ranges of the desired ranges (y-axis) in the form of list of tuples of adresses + :param title: Title of the chart + :param chart_type: Basic chart type (default: COLUMN) + :param anchor_cell: position of the left corner of the chart in the form of cell address or cell object + + :return: :class:`Chart` + + Example: + + To plot a chart with x values from 'A1' to 'A6' and y values from 'B1' to 'B6' + + >>> wks.add_chart(('A1', 'A6'), [('B1', 'B6')], 'TestChart') + + + """ + return Chart(self, domain, ranges, chart_type, title, anchor_cell) + + def get_charts(self, title=None): + """Returns a list of chart objects, can be filtered by title. + + :param title: title to be matched. + + :return: list of :class:`Chart` + """ + matched_charts = [] + chart_data = self.client.sheet.get(self.spreadsheet.id, fields='sheets(charts,properties/sheetId)') + sheet_list = chart_data.get('sheets') + sheet = [x for x in sheet_list if x.get('properties', {}).get('sheetId') == self.id][0] + chart_list = sheet.get('charts', []) + for chart in chart_list: + if not title or chart.get('spec', {}).get('title', '') == title: + matched_charts.append(Chart(worksheet=self, json_obj=chart)) + return matched_charts + + @batchable + def set_data_validation(self, start=None, end=None, condition_type=None, condition_values=None, + grange=None, **kwargs): + """ + Sets a data validation rule to every cell in the range. To clear validation in a range, + call this with no condition_type specified. + + refer to `api docs `__ for possible inputs. + + :param start: start address + :param end: end address + :param grange: address as grid range + :param condition_type: validation condition type: `possible values `__ + :param condition_values: list of values for supporting condition type. For example , + when condition_type is NUMBER_BETWEEN, value should be two numbers indicationg lower + and upper bound. See api docs for more info. + :param kwargs: other options of rule. + possible values: inputMessage, strict, showCustomUi + `ref `__ + """ + if not grange: + grange = GridRange(worksheet=self, start=start, end=end) + grange.set_worksheet(self) + + condition_values = list() if not condition_values else condition_values + json_values = [] + for value in condition_values: + if condition_type in \ + ['DATE_BEFORE', 'DATE_AFTER', 'DATE_ON_OR_BEFORE', 'DATE_ON_OR_AFTER']: + json_values.append({'relativeDate': str(value)}) + else: + json_values.append({'userEnteredValue': str(value)}) + + request = {"setDataValidation": { + "range": grange.to_json() + } + } + if condition_type: + rule = {'condition': { + 'type': condition_type, + 'values': json_values + } + } + for kwarg in kwargs: + rule[kwarg] = kwargs[kwarg] + request['setDataValidation']['rule'] = rule + self.client.sheet.batch_update(self.spreadsheet.id, request) + + @batchable + def set_basic_filter( + self, + start=None, + end=None, + grange=None, + sort_order=None, + sort_foreground_color=None, + sort_background_color=None, + sort_column_index=None, + filter_column_index=None, + hidden_values=None, + condition_type=None, + condition_values=None, + filter_foreground_color=None, + filter_background_color=None + ): + """ + Sets a basic filter to a row in worksheet. + + refer to `api docs `__ for possible inputs. + + :param start: start address + :param end: end address + :param grange: address as grid range + :param sort_order: either "ASCENDING" or "DESCENDING" (String) + :param sort_foreground_color: either Color obj (Tuple) or ThemeColorType (String). please refer to `api docs `__ for possible inputs. + :param sort_background_color: either Color obj (Tuple) or ThemeColorType (String). please refer to `api docs `__ for possible inputs. + :param sort_column_index: the position of column for sort. + :param filter_column_index: the position of column for filter. + :param hidden_values: values which are hidden by filter. + :param condition_type: validation condition type: `possible values `__ + :param condition_values: list of values for supporting condition type. For example , + when condition_type is NUMBER_BETWEEN, value should be two numbers indicationg lower + and upper bound. It also can be `this enum. `__ See api docs for more info. + :param filter_foreground_color: either Color obj (Tuple) or ThemeColorType (String). please refer to `api docs `__ for possible inputs. + :param filter_background_color: either Color obj (Tuple) or ThemeColorType (String). please refer to `api docs `__ for possible inputs. + """ + if not grange: + grange = GridRange(worksheet=self, start=start, end=end) + grange.set_worksheet(self) + + if sort_order: + sort_specs = [{ + 'sortOrder': sort_order, + 'foregroundColorStyle': get_color_style(sort_foreground_color), + 'backgroundColorStyle': get_color_style(sort_background_color), + 'dimensionIndex': sort_column_index + }] + else: + sort_specs = [] + + if filter_column_index is not None: + filter_specs = [{ + 'filterCriteria': { + 'hiddenValues': hidden_values, + 'condition': get_boolean_condition(condition_type, condition_values), + 'visibleBackgroundColorStyle': get_color_style(filter_foreground_color), + 'visibleForegroundColorStyle': get_color_style(filter_background_color) + }, + 'columnIndex': filter_column_index + }] + else: + filter_specs = [] + + request = { + 'setBasicFilter': { + 'filter': { + 'range': grange.to_json(), + 'sortSpecs': sort_specs, + 'filterSpecs': filter_specs + } + } + } + self.client.sheet.batch_update(self.spreadsheet.id, request) + + @batchable + def clear_basic_filter(self): + """ + Clear a basic filter in worksheet + + refer to `api docs `__ for possible inputs. + """ + request = { + 'clearBasicFilter': { + 'sheetId': self.id + } + } + self.client.sheet.batch_update(self.spreadsheet.id, request) + + def add_conditional_formatting(self, start, end, condition_type, format, condition_values=None, grange=None): + """ + Adds a new conditional format rule. + + :param start: start address + :param end: end address + :param grange: address as grid range + :param condition_type: validation condition type: `possible values `__ + :param condition_values: list of values for supporting condition type. For example , + when condition_type is NUMBER_BETWEEN, value should be two numbers indicationg lower + and upper bound. It also can be `this enum. `__ See api docs for more info. + :param format: cell format json to apply if condition succeedes. `refer. ` + """ + if not grange: + grange = GridRange(worksheet=self, start=start, end=end) + grange.set_worksheet(self) + condition_values = list() if not condition_values else condition_values + + condition_json = [] + for value in condition_values: + if value in ['RELATIVE_DATE_UNSPECIFIED', 'PAST_YEAR', 'PAST_MONTH', 'PAST_WEEK', + 'YESTERDAY', 'TODAY', 'TOMORROW']: + condition_json.append({'relativeDate': value}) + else: + condition_json.append({'userEnteredValue': value}) + request = { + "addConditionalFormatRule": { + "rule": { + "ranges": [grange.to_json()], + "booleanRule": {"condition": {"type": condition_type, "values": condition_json}, "format": format}, + }, + "index": 0 + } + } + self.client.sheet.batch_update(self.spreadsheet.id, request) + + @batchable + def merge_cells(self, start=None, end=None, merge_type='MERGE_ALL', grange=None): + """ + Merge cells in range + + ! You can't vertically merge cells that intersect an existing filter + + :param merge_type: either 'MERGE_ALL' + ,'MERGE_COLUMNS' ( = merge multiple rows (!) together to make column(s)) + ,'MERGE_ROWS' ( = merge multiple columns (!) together to make a row(s)) + ,'NONE' (unmerge) + + :param start: start Address + :param end: end Address + """ + if merge_type not in ['MERGE_ALL', 'MERGE_COLUMNS', 'MERGE_ROWS', 'NONE']: + raise ValueError("merge_type should be one of the following : " + "'MERGE_ALL' 'MERGE_COLUMNS' 'MERGE_ROWS' 'NONE'") + if not grange: + grange = GridRange(worksheet=self, start=start, end=end) + grange.set_worksheet(self) + + if merge_type == 'NONE': + request = {'unmergeCells': {'range': grange.to_json()}} + else: + request = {'mergeCells': {'range': grange.to_json(), 'mergeType': merge_type}} + self.client.sheet.batch_update(self.spreadsheet.id, request) + + def get_developer_metadata(self, key=None): + """ + Fetch developer metadata associated with this worksheet + + :param key: the key of the metadata to fetch. If unspecified, all metadata will be returned + """ + data_filter = DeveloperMetadataLookupDataFilter(self.spreadsheet.id, self.id, meta_key=key) + results = self.client.sheet.developer_metadata_search(self.spreadsheet.id, data_filter.to_json()) + metadata = [] + if results: + for result in results["matchedDeveloperMetadata"]: + meta_id = result["developerMetadata"]["metadataId"] + key = result["developerMetadata"]["metadataKey"] + value = result["developerMetadata"]["metadataValue"] + metadata.append(DeveloperMetadata(meta_id, key, value, self.client, self.spreadsheet.id, self.id)) + return metadata + + def create_developer_metadata(self, key, value=None): + """ + Create a new developer metadata associated with this worksheet + + Will return None when in batch mode, otherwise will return a DeveloperMetadata object + + :param key: the key of the metadata to be created + :param value: the value of the metadata to be created (optional) + """ + return DeveloperMetadata.new(key, value, self.client, self.spreadsheet.id, self.id) + + def __eq__(self, other): + return self.id == other.id and self.spreadsheet == other.spreadsheet + + # @TODO optimize (use datagrid) + def __iter__(self): + rows = self.get_all_values(majdim='ROWS', include_tailing_empty=False, include_tailing_empty_rows=False) + for row in rows: + yield row + (self.cols - len(row))*[''] + + # @TODO optimize (use datagrid) + def __getitem__(self, item): + if type(item) == int: + if item < 1: + raise CellNotFound("index start at 1") + if item >= self.rows: + raise CellNotFound + try: + row = self.get_row(item, include_tailing_empty=True) + except IndexError: + raise CellNotFound + return row diff --git a/venv/lib/python3.10/site-packages/pytablewriter-1.2.1.dist-info/INSTALLER b/venv/lib/python3.10/site-packages/pytablewriter-1.2.1.dist-info/INSTALLER new file mode 100644 index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68 --- /dev/null +++ b/venv/lib/python3.10/site-packages/pytablewriter-1.2.1.dist-info/INSTALLER @@ -0,0 +1 @@ +pip diff --git a/venv/lib/python3.10/site-packages/pytablewriter-1.2.1.dist-info/LICENSE b/venv/lib/python3.10/site-packages/pytablewriter-1.2.1.dist-info/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..3e3c2f9d5e2bc9c160cda612c58f5fb61df672d0 --- /dev/null +++ b/venv/lib/python3.10/site-packages/pytablewriter-1.2.1.dist-info/LICENSE @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) 2016-2025 Tsuyoshi Hombashi + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/venv/lib/python3.10/site-packages/pytablewriter-1.2.1.dist-info/METADATA b/venv/lib/python3.10/site-packages/pytablewriter-1.2.1.dist-info/METADATA new file mode 100644 index 0000000000000000000000000000000000000000..013bef3e8bd46cf7b5c6c3b40ec30a4553b338ce --- /dev/null +++ b/venv/lib/python3.10/site-packages/pytablewriter-1.2.1.dist-info/METADATA @@ -0,0 +1,932 @@ +Metadata-Version: 2.1 +Name: pytablewriter +Version: 1.2.1 +Summary: pytablewriter is a Python library to write a table in various formats: AsciiDoc / CSV / Elasticsearch / HTML / JavaScript / JSON / LaTeX / LDJSON / LTSV / Markdown / MediaWiki / NumPy / Excel / Pandas / Python / reStructuredText / SQLite / TOML / TSV / YAML. +Home-page: https://github.com/thombashi/pytablewriter +Author: Tsuyoshi Hombashi +Author-email: tsuyoshi.hombashi@gmail.com +License: MIT License +Project-URL: Changelog, https://github.com/thombashi/pytablewriter/blob/master/CHANGELOG.md +Project-URL: Documentation, https://pytablewriter.rtfd.io/ +Project-URL: Funding, https://github.com/sponsors/thombashi +Project-URL: Source, https://github.com/thombashi/pytablewriter +Project-URL: Tracker, https://github.com/thombashi/pytablewriter/issues +Keywords: AsciiDoc,table,CSV,Excel,JavaScript,JSON,LaTeX,LTSV,Markdown,MediaWiki,HTML,pandas,reStructuredText,SQLite,TSV,TOML +Classifier: Development Status :: 5 - Production/Stable +Classifier: Intended Audience :: Developers +Classifier: Intended Audience :: Information Technology +Classifier: License :: OSI Approved :: MIT License +Classifier: Operating System :: OS Independent +Classifier: Programming Language :: Python :: 3 +Classifier: Programming Language :: Python :: 3.9 +Classifier: Programming Language :: Python :: 3.10 +Classifier: Programming Language :: Python :: 3.11 +Classifier: Programming Language :: Python :: 3.12 +Classifier: Programming Language :: Python :: 3.13 +Classifier: Programming Language :: Python :: 3 :: Only +Classifier: Programming Language :: Python :: Implementation :: CPython +Classifier: Programming Language :: Python :: Implementation :: PyPy +Classifier: Topic :: Software Development :: Code Generators +Classifier: Topic :: Software Development :: Libraries +Classifier: Topic :: Software Development :: Libraries :: Python Modules +Classifier: Topic :: Text Processing +Classifier: Topic :: Text Processing :: Markup :: HTML +Classifier: Topic :: Text Processing :: Markup :: LaTeX +Classifier: Topic :: Text Processing :: Markup :: Markdown +Classifier: Topic :: Text Processing :: Markup :: reStructuredText +Classifier: Typing :: Typed +Requires-Python: >=3.9 +Description-Content-Type: text/x-rst +License-File: LICENSE +Requires-Dist: setuptools>=38.3.0 +Requires-Dist: DataProperty<2,>=1.1.0 +Requires-Dist: mbstrdecoder<2,>=1.0.0 +Requires-Dist: pathvalidate<4,>=2.3.0 +Requires-Dist: tabledata<2,>=1.3.1 +Requires-Dist: tcolorpy<1,>=0.0.5 +Requires-Dist: typepy[datetime]<2,>=1.3.2 +Provides-Extra: all +Requires-Dist: xlwt; extra == "all" +Requires-Dist: XlsxWriter<4,>=0.9.6; extra == "all" +Requires-Dist: elasticsearch<9,>=8.0.1; extra == "all" +Requires-Dist: pytablereader<2,>=0.31.3; extra == "all" +Requires-Dist: dominate<3,>=2.1.5; extra == "all" +Requires-Dist: loguru<1,>=0.4.1; extra == "all" +Requires-Dist: SimpleSQLite<2,>=1.3.2; extra == "all" +Requires-Dist: pytablewriter-altrow-theme<1,>=0.2.0; extra == "all" +Requires-Dist: pytablewriter-altcol-theme<1,>=0.1.0; extra == "all" +Requires-Dist: toml<1,>=0.9.3; extra == "all" +Requires-Dist: PyYAML<7,>=3.11; extra == "all" +Requires-Dist: simplejson<4,>=3.8.1; extra == "all" +Requires-Dist: pandas<3,>=0.25.3; extra == "all" +Provides-Extra: docs +Requires-Dist: sphinx_rtd_theme>=1.2.2; extra == "docs" +Requires-Dist: Sphinx>=2.4; extra == "docs" +Requires-Dist: xlwt; extra == "docs" +Requires-Dist: XlsxWriter<4,>=0.9.6; extra == "docs" +Requires-Dist: elasticsearch<9,>=8.0.1; extra == "docs" +Requires-Dist: pytablereader<2,>=0.31.3; extra == "docs" +Requires-Dist: dominate<3,>=2.1.5; extra == "docs" +Requires-Dist: loguru<1,>=0.4.1; extra == "docs" +Requires-Dist: SimpleSQLite<2,>=1.3.2; extra == "docs" +Requires-Dist: pytablewriter-altrow-theme<1,>=0.2.0; extra == "docs" +Requires-Dist: pytablewriter-altcol-theme<1,>=0.1.0; extra == "docs" +Requires-Dist: toml<1,>=0.9.3; extra == "docs" +Requires-Dist: PyYAML<7,>=3.11; extra == "docs" +Requires-Dist: simplejson<4,>=3.8.1; extra == "docs" +Requires-Dist: pandas<3,>=0.25.3; extra == "docs" +Provides-Extra: es +Requires-Dist: elasticsearch<9,>=8.0.1; extra == "es" +Provides-Extra: es8 +Requires-Dist: elasticsearch<9,>=8.0.1; extra == "es8" +Provides-Extra: excel +Requires-Dist: xlwt; extra == "excel" +Requires-Dist: XlsxWriter<4,>=0.9.6; extra == "excel" +Provides-Extra: from +Requires-Dist: pytablereader<2,>=0.31.3; extra == "from" +Provides-Extra: html +Requires-Dist: dominate<3,>=2.1.5; extra == "html" +Provides-Extra: logging +Requires-Dist: loguru<1,>=0.4.1; extra == "logging" +Provides-Extra: pandas +Requires-Dist: pandas<3,>=0.25.3; extra == "pandas" +Provides-Extra: sqlite +Requires-Dist: SimpleSQLite<2,>=1.3.2; extra == "sqlite" +Provides-Extra: test +Requires-Dist: pytest-md-report>=0.6.2; extra == "test" +Requires-Dist: pytablewriter-altcol-theme<1,>=0.1.0; extra == "test" +Requires-Dist: PyYAML<7,>=3.11; extra == "test" +Requires-Dist: pytablereader[excel,sqlite]>=0.31.3; extra == "test" +Requires-Dist: dominate<3,>=2.1.5; extra == "test" +Requires-Dist: pytablewriter-altrow-theme<1,>=0.2.0; extra == "test" +Requires-Dist: toml<1,>=0.9.3; extra == "test" +Requires-Dist: simplejson<4,>=3.8.1; extra == "test" +Requires-Dist: pytest>=6.0.1; extra == "test" +Requires-Dist: beautifulsoup4>=4.10; extra == "test" +Requires-Dist: SimpleSQLite<2,>=1.3.2; extra == "test" +Requires-Dist: pytablereader<2,>=0.31.3; extra == "test" +Requires-Dist: elasticsearch<9,>=8.0.1; extra == "test" +Requires-Dist: xlwt; extra == "test" +Requires-Dist: tablib>=3.2.0; extra == "test" +Requires-Dist: sqliteschema>=2; extra == "test" +Requires-Dist: loguru<1,>=0.4.1; extra == "test" +Requires-Dist: XlsxWriter<4,>=0.9.6; extra == "test" +Requires-Dist: pandas<3,>=0.25.3; extra == "test" +Provides-Extra: theme +Requires-Dist: pytablewriter-altrow-theme<1,>=0.2.0; extra == "theme" +Requires-Dist: pytablewriter-altcol-theme<1,>=0.1.0; extra == "theme" +Provides-Extra: toml +Requires-Dist: toml<1,>=0.9.3; extra == "toml" +Provides-Extra: yaml +Requires-Dist: PyYAML<7,>=3.11; extra == "yaml" + +.. contents:: **pytablewriter** + :backlinks: top + :depth: 2 + +Summary +========= +`pytablewriter `__ is a Python library to write a table in various formats: AsciiDoc / CSV / Elasticsearch / HTML / JavaScript / JSON / LaTeX / LDJSON / LTSV / Markdown / MediaWiki / NumPy / Excel / Pandas / Python / reStructuredText / SQLite / TOML / TSV / YAML. + +.. image:: https://badge.fury.io/py/pytablewriter.svg + :target: https://badge.fury.io/py/pytablewriter + :alt: PyPI package version + +.. image:: https://anaconda.org/conda-forge/pytablewriter/badges/version.svg + :target: https://anaconda.org/conda-forge/pytablewriter + :alt: conda-forge package version + +.. image:: https://img.shields.io/pypi/pyversions/pytablewriter.svg + :target: https://pypi.org/project/pytablewriter/ + :alt: Supported Python versions + +.. image:: https://img.shields.io/pypi/implementation/pytablewriter.svg + :target: https://pypi.org/project/pytablewriter + :alt: Supported Python implementations + +.. image:: https://github.com/thombashi/pytablewriter/actions/workflows/ci.yml/badge.svg + :target: https://github.com/thombashi/pytablewriter/actions/workflows/ci.yml + :alt: CI status of Linux/macOS/Windows + +.. image:: https://coveralls.io/repos/github/thombashi/pytablewriter/badge.svg?branch=master + :target: https://coveralls.io/github/thombashi/pytablewriter?branch=master + :alt: Test coverage + +.. image:: https://github.com/thombashi/pytablewriter/actions/workflows/github-code-scanning/codeql/badge.svg + :target: https://github.com/thombashi/pytablewriter/actions/workflows/github-code-scanning/codeql + :alt: CodeQL + +Features +-------- +- Write a table in various formats: + - Text formats: + - `AsciiDoc `__ + - CSV / Tab-separated values (TSV) / Space-separated values (SSV) + - HTML / CSS + - JSON / `Line-delimited JSON(LDJSON) `__ + - `Labeled Tab-separated Values (LTSV) `__ + - LaTeX: ``tabular``/``array`` environment + - Markdown: CommonMark / `GitHub Flavored Markdown (GFM) `__ / `kramdown `__ + - `MediaWiki `__ + - reStructuredText: `Grid Tables `__/`Simple Tables `__/`CSV Table `__ + - Source code (definition of a variable that represents tabular data) + - JavaScript / `NumPy `__ (`numpy.array `__) / `Pandas `__ (`pandas.DataFrame `__) / Python + - `TOML `__ + - `YAML `__ + - Unicode + - Binary file formats: + - Microsoft Excel :superscript:`TM` (``.xlsx``/``.xls`` file format) + - `pandas.DataFrame `__ pickle file + - `SQLite `__ database + - Application-specific formats: + - `Elasticsearch `__ +- Automatic table cell formatting: + - Alignment + - Padding + - Decimal places of numbers +- Customize table cell styles: + - Text/Background color + - Text alignment + - Font size/weight + - Thousand separator for numbers: e.g. ``1,000``/``1 000`` +- Configure output: + - Write a table to a stream such as a file/standard-output/string-buffer/Jupyter-Notebook + - Get rendered tabular text +- Data sources: + - nested list + - CSV + - `pandas.DataFrame `__ / `pandas.Series `__ + - etc. +- Multibyte character support +- ANSI color support + +Installation +============ + +Installation: pip +------------------------------ +:: + + pip install pytablewriter + +Some of the formats require additional dependency packages, you can install these packages as follows: + +.. csv-table:: Installation of optional dependencies + :header: Installation example, Remark + + ``pip install pytablewriter[es]``, Elasticsearch + ``pip install pytablewriter[excel]``, Excel + ``pip install pytablewriter[html]``, HTML + ``pip install pytablewriter[sqlite]``, SQLite database + ``pip install pytablewriter[toml]``, TOML + ``pip install pytablewriter[theme]``, pytablewriter theme plugins + ``pip install pytablewriter[all]``, Install all of the optional dependencies + +Installation: conda +------------------------------ +:: + + conda install -c conda-forge pytablewriter + +Installation: apt +------------------------------ +:: + + sudo add-apt-repository ppa:thombashi/ppa + sudo apt update + sudo apt install python3-pytablewriter + +Examples +========== +Write tables +-------------- +Write a Markdown table +~~~~~~~~~~~~~~~~~~~~~~~~ +:Sample Code: + .. code-block:: python + + from pytablewriter import MarkdownTableWriter + + def main(): + writer = MarkdownTableWriter( + table_name="example_table", + headers=["int", "float", "str", "bool", "mix", "time"], + value_matrix=[ + [0, 0.1, "hoge", True, 0, "2017-01-01 03:04:05+0900"], + [2, "-2.23", "foo", False, None, "2017-12-23 45:01:23+0900"], + [3, 0, "bar", "true", "inf", "2017-03-03 33:44:55+0900"], + [-10, -9.9, "", "FALSE", "nan", "2017-01-01 00:00:00+0900"], + ], + ) + writer.write_table() + + if __name__ == "__main__": + main() + +:Output: + .. code-block:: + + # example_table + |int|float|str |bool | mix | time | + |--:|----:|----|-----|-------:|------------------------| + | 0| 0.10|hoge|True | 0|2017-01-01 03:04:05+0900| + | 2|-2.23|foo |False| |2017-12-23 12:34:51+0900| + | 3| 0.00|bar |True |Infinity|2017-03-03 22:44:55+0900| + |-10|-9.90| |False| NaN|2017-01-01 00:00:00+0900| + +:Rendering Result: + .. figure:: https://cdn.jsdelivr.net/gh/thombashi/pytablewriter@master/docs/pages/examples/table_format/text/ss/markdown.png + :alt: https://github.com/thombashi/pytablewriter/blob/master/docs/pages/examples/table_format/text/ss/markdown.png + + Rendered markdown at GitHub + +Write a Markdown table with margins +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +:Sample Code: + .. code-block:: python + + from pytablewriter import MarkdownTableWriter + + def main(): + writer = MarkdownTableWriter( + table_name="write a table with margins", + headers=["int", "float", "str", "bool", "mix", "time"], + value_matrix=[ + [0, 0.1, "hoge", True, 0, "2017-01-01 03:04:05+0900"], + [2, "-2.23", "foo", False, None, "2017-12-23 45:01:23+0900"], + [3, 0, "bar", "true", "inf", "2017-03-03 33:44:55+0900"], + [-10, -9.9, "", "FALSE", "nan", "2017-01-01 00:00:00+0900"], + ], + margin=1 # add a whitespace for both sides of each cell + ) + writer.write_table() + + if __name__ == "__main__": + main() + +:Output: + .. code-block:: + + # write a table with margins + | int | float | str | bool | mix | time | + | --: | ----: | ---- | ----- | -------: | ------------------------ | + | 0 | 0.10 | hoge | True | 0 | 2017-01-01 03:04:05+0900 | + | 2 | -2.23 | foo | False | | 2017-12-23 12:34:51+0900 | + | 3 | 0.00 | bar | True | Infinity | 2017-03-03 22:44:55+0900 | + | -10 | -9.90 | | False | NaN | 2017-01-01 00:00:00+0900 | + +``margin`` attribute can be available for all of the text format writer classes. + +Write a GitHub Flavored Markdown (GFM) table +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +If you set ``flavor`` keyword argument of ``MarkdownTableWriter`` class to ``"github"`` or ``"gfm"``, the writer will output markdown tables with GitHub flavor. +GFM can apply some additional styles to tables such as ``fg_color`` (text color). + +:Sample Code: + .. code-block:: python + + from pytablewriter import MarkdownTableWriter + from pytablewriter.style import Style + + writer = MarkdownTableWriter( + column_styles=[ + Style(fg_color="red"), + Style(fg_color="green", decoration_line="underline"), + ], + headers=["A", "B"], + value_matrix=[ + ["abc", 1], + ["efg", 2], + ], + margin=1, + flavor="github", + enable_ansi_escape=False, + ) + writer.write_table() + +Rendered results can be found at `here `__ + +Apply styles to GFM table with programmatically +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +Applying style filters to GFM allows for more flexible style settings for cells. +See also the `example <#style-filter>`_ + +Write a Markdown table to a stream or a file +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +`Refer an example `__ + +Write a table to an Excel sheet +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +:Sample Code: + .. code-block:: python + + from pytablewriter import ExcelXlsxTableWriter + + def main(): + writer = ExcelXlsxTableWriter() + writer.table_name = "example" + writer.headers = ["int", "float", "str", "bool", "mix", "time"] + writer.value_matrix = [ + [0, 0.1, "hoge", True, 0, "2017-01-01 03:04:05+0900"], + [2, "-2.23", "foo", False, None, "2017-12-23 12:34:51+0900"], + [3, 0, "bar", "true", "inf", "2017-03-03 22:44:55+0900"], + [-10, -9.9, "", "FALSE", "nan", "2017-01-01 00:00:00+0900"], + ] + writer.dump("sample.xlsx") + + if __name__ == "__main__": + main() + +:Output: + .. figure:: https://cdn.jsdelivr.net/gh/thombashi/pytablewriter@master/docs/pages/examples/table_format/binary/spreadsheet/ss/excel_single.png + :alt: https://github.com/thombashi/pytablewriter/blob/master/docs/pages/examples/table_format/binary/spreadsheet/ss/excel_single.png + + Output excel file (``sample_single.xlsx``) + +Write a Unicode table +~~~~~~~~~~~~~~~~~~~~~~~ +:Sample Code: + .. code-block:: python + + from pytablewriter import UnicodeTableWriter + + def main(): + writer = UnicodeTableWriter( + table_name="example_table", + headers=["int", "float", "str", "bool", "mix", "time"], + value_matrix=[ + [0, 0.1, "hoge", True, 0, "2017-01-01 03:04:05+0900"], + [2, "-2.23", "foo", False, None, "2017-12-23 45:01:23+0900"], + [3, 0, "bar", "true", "inf", "2017-03-03 33:44:55+0900"], + [-10, -9.9, "", "FALSE", "nan", "2017-01-01 00:00:00+0900"], + ] + ) + writer.write_table() + + if __name__ == "__main__": + main() + +:Output: + .. code-block:: + + ┌───┬─────┬────┬─────┬────────┬────────────────────────┐ + │int│float│str │bool │ mix │ time │ + ├───┼─────┼────┼─────┼────────┼────────────────────────┤ + │ 0│ 0.10│hoge│True │ 0│2017-01-01 03:04:05+0900│ + ├───┼─────┼────┼─────┼────────┼────────────────────────┤ + │ 2│-2.23│foo │False│ │2017-12-23 12:34:51+0900│ + ├───┼─────┼────┼─────┼────────┼────────────────────────┤ + │ 3│ 0.00│bar │True │Infinity│2017-03-03 22:44:55+0900│ + ├───┼─────┼────┼─────┼────────┼────────────────────────┤ + │-10│-9.90│ │False│ NaN│2017-01-01 00:00:00+0900│ + └───┴─────┴────┴─────┴────────┴────────────────────────┘ + +Write a table with JavaScript format (as a nested list variable definition) +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +:Sample Code: + .. code-block:: python + + import pytablewriter as ptw + + + def main(): + writer = ptw.JavaScriptTableWriter( + table_name="js_variable", + headers=["int", "float", "str", "bool", "mix", "time"], + value_matrix=[ + [0, 0.1, "hoge", True, 0, "2017-01-01 03:04:05+0900"], + [2, "-2.23", "foo", False, None, "2017-12-23 45:01:23+0900"], + [3, 0, "bar", "true", "inf", "2017-03-03 33:44:55+0900"], + [-10, -9.9, "", "FALSE", "nan", "2017-01-01 00:00:00+0900"], + ], + ) + + writer.write_table() + + + if __name__ == "__main__": + main() + +:Output: + .. code-block:: js + + const js_variable = [ + ["int", "float", "str", "bool", "mix", "time"], + [0, 0.1, "hoge", true, 0, "2017-01-01 03:04:05+0900"], + [2, -2.23, "foo", false, null, "2017-12-23 45:01:23+0900"], + [3, 0, "bar", true, Infinity, "2017-03-03 33:44:55+0900"], + [-10, -9.9, "", "FALSE", NaN, "2017-01-01 00:00:00+0900"] + ]; + +Write a Markdown table from ``pandas.DataFrame`` instance +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +``from_dataframe`` method of writer classes will set up tabular data from ``pandas.DataFrame``: + +:Sample Code: + .. code-block:: python + + from textwrap import dedent + import pandas as pd + import io + from pytablewriter import MarkdownTableWriter + + def main(): + csv_data = io.StringIO(dedent("""\ + "i","f","c","if","ifc","bool","inf","nan","mix_num","time" + 1,1.10,"aa",1.0,"1",True,Infinity,NaN,1,"2017-01-01 00:00:00+09:00" + 2,2.20,"bbb",2.2,"2.2",False,Infinity,NaN,Infinity,"2017-01-02 03:04:05+09:00" + 3,3.33,"cccc",-3.0,"ccc",True,Infinity,NaN,NaN,"2017-01-01 00:00:00+09:00" + """)) + df = pd.read_csv(csv_data, sep=',') + + writer = MarkdownTableWriter(dataframe=df) + writer.write_table() + + if __name__ == "__main__": + main() + +:Output: + .. code-block:: + + | i | f | c | if |ifc|bool | inf |nan|mix_num | time | + |--:|---:|----|---:|---|-----|--------|---|-------:|-------------------------| + | 1|1.10|aa | 1.0| 1|True |Infinity|NaN| 1|2017-01-01 00:00:00+09:00| + | 2|2.20|bbb | 2.2|2.2|False|Infinity|NaN|Infinity|2017-01-02 03:04:05+09:00| + | 3|3.33|cccc|-3.0|ccc|True |Infinity|NaN| NaN|2017-01-01 00:00:00+09:00| + + +Adding a column of the DataFrame index if you specify ``add_index_column=True``: + +:Sample Code: + .. code-block:: python + + import pandas as pd + import pytablewriter as ptw + + def main(): + writer = ptw.MarkdownTableWriter(table_name="add_index_column") + writer.from_dataframe( + pd.DataFrame({"A": [1, 2], "B": [10, 11]}, index=["a", "b"]), + add_index_column=True, + ) + writer.write_table() + + if __name__ == "__main__": + main() + +:Output: + .. code-block:: + + # add_index_column + | | A | B | + |---|--:|--:| + |a | 1| 10| + |b | 2| 11| + +Write a Markdown table from space-separated values +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +:Sample Code: + .. code-block:: python + + import pytablewriter as ptw + + + def main(): + writer = ptw.MarkdownTableWriter(table_name="ps") + writer.from_csv( + """ + USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND + root 1 0.0 0.4 77664 8784 ? Ss May11 0:02 /sbin/init + root 2 0.0 0.0 0 0 ? S May11 0:00 [kthreadd] + root 4 0.0 0.0 0 0 ? I< May11 0:00 [kworker/0:0H] + root 6 0.0 0.0 0 0 ? I< May11 0:00 [mm_percpu_wq] + root 7 0.0 0.0 0 0 ? S May11 0:01 [ksoftirqd/0] + """, + delimiter=" ", + ) + writer.write_table() + + + if __name__ == "__main__": + main() + +:Output: + .. code-block:: + + # ps + |USER|PID|%CPU|%MEM| VSZ |RSS |TTY|STAT|START|TIME| COMMAND | + |----|--:|---:|---:|----:|---:|---|----|-----|----|--------------| + |root| 1| 0| 0.4|77664|8784|? |Ss |May11|0:02|/sbin/init | + |root| 2| 0| 0.0| 0| 0|? |S |May11|0:00|[kthreadd] | + |root| 4| 0| 0.0| 0| 0|? |I< |May11|0:00|[kworker/0:0H]| + |root| 6| 0| 0.0| 0| 0|? |I< |May11|0:00|[mm_percpu_wq]| + |root| 7| 0| 0.0| 0| 0|? |S |May11|0:01|[ksoftirqd/0] | + +Get rendered tabular text as str +---------------------------------- +``dumps`` method returns rendered tabular text. +``dumps`` only available for text format writers. + +:Sample Code: + .. code-block:: python + + import pytablewriter as ptw + + + def main(): + writer = ptw.MarkdownTableWriter( + headers=["int", "float", "str", "bool", "mix", "time"], + value_matrix=[ + [0, 0.1, "hoge", True, 0, "2017-01-01 03:04:05+0900"], + [2, "-2.23", "foo", False, None, "2017-12-23 45:01:23+0900"], + [3, 0, "bar", "true", "inf", "2017-03-03 33:44:55+0900"], + [-10, -9.9, "", "FALSE", "nan", "2017-01-01 00:00:00+0900"], + ], + ) + + print(writer.dumps()) + + + if __name__ == "__main__": + main() + +:Output: + .. code-block:: + + |int|float|str |bool | mix | time | + |--:|----:|----|-----|-------:|------------------------| + | 0| 0.10|hoge|True | 0|2017-01-01 03:04:05+0900| + | 2|-2.23|foo |False| |2017-12-23 45:01:23+0900| + | 3| 0.00|bar |True |Infinity|2017-03-03 33:44:55+0900| + |-10|-9.90| |False| NaN|2017-01-01 00:00:00+0900| + +Configure table styles +------------------------ +Column styles +~~~~~~~~~~~~~~~ +Writers can specify +`Style `__ +for each column by ``column_styles`` attribute of writer classes. + +:Sample Code: + .. code-block:: python + + import pytablewriter as ptw + from pytablewriter.style import Style + + + def main(): + writer = ptw.MarkdownTableWriter( + table_name="set style by column_styles", + headers=[ + "auto align", + "left align", + "center align", + "bold", + "italic", + "bold italic ts", + ], + value_matrix=[ + [11, 11, 11, 11, 11, 11], + [1234, 1234, 1234, 1234, 1234, 1234], + ], + column_styles=[ + Style(), + Style(align="left"), + Style(align="center"), + Style(font_weight="bold"), + Style(font_style="italic"), + Style(font_weight="bold", font_style="italic", thousand_separator=","), + ], # specify styles for each column + ) + writer.write_table() + + + if __name__ == "__main__": + main() + +:Output: + .. code-block:: + + # set style by styles + |auto align|left align|center align| bold |italic|bold italic ts| + |---------:|----------|:----------:|-------:|-----:|-------------:| + | 11|11 | 11 | **11**| _11_| _**11**_| + | 1234|1234 | 1234 |**1234**|_1234_| _**1,234**_| + + `Rendering result `__ + + +You can also set ``Style`` to a specific column with an index or header by using ``set_style`` method: + +:Sample Code: + .. code-block:: python + + from pytablewriter import MarkdownTableWriter + from pytablewriter.style import Style + + def main(): + writer = MarkdownTableWriter() + writer.headers = ["A", "B", "C",] + writer.value_matrix = [[11, 11, 11], [1234, 1234, 1234]] + + writer.table_name = "set style by column index" + writer.set_style(1, Style(align="center", font_weight="bold")) + writer.set_style(2, Style(thousand_separator=" ")) + writer.write_table() + writer.write_null_line() + + writer.table_name = "set style by header" + writer.set_style("B", Style(font_style="italic")) + writer.write_table() + + if __name__ == "__main__": + main() + +:Output: + .. code-block:: + + # set style by column index + | A | B | C | + |---:|:------:|----:| + | 11| **11** | 11| + |1234|**1234**|1 234| + + # set style by header + | A | B | C | + |---:|-----:|----:| + | 11| _11_| 11| + |1234|_1234_|1 234| + +Style filter +~~~~~~~~~~~~~~ +You can apply styles to specific cells by using style filters. +Style filters will be written as Python functions. +Examples of a style filter function and how you apply it are as follows: + +:Sample Code: + .. code-block:: python + + from typing import Any, Optional + + from pytablewriter import MarkdownTableWriter + from pytablewriter.style import Cell, Style + + + def style_filter(cell: Cell, **kwargs: Any) -> Optional[Style]: + if cell.is_header_row(): + return None + + if cell.col == 0: + return Style(font_weight="bold") + + value = int(cell.value) + + if value > 80: + return Style(fg_color="red", font_weight="bold", decoration_line="underline") + elif value > 50: + return Style(fg_color="yellow", font_weight="bold") + elif value > 20: + return Style(fg_color="green") + + return Style(fg_color="lightblue") + + + writer = MarkdownTableWriter( + table_name="style filter example", + headers=["Key", "Value 1", "Value 2"], + value_matrix=[ + ["A", 95, 40], + ["B", 55, 5], + ["C", 30, 85], + ["D", 0, 69], + ], + flavor="github", + enable_ansi_escape=False, + ) + writer.add_style_filter(style_filter) + writer.write_table() + +Rendered results can be found at `here `__ + +Theme +~~~~~~~ +`Theme ` +consists of a set of style filters. +The following command will install external predefined themes: + +:: + + pip install pytablewriter[theme] + +Themes can be set via the constructor of the writer classes or the ``set_theme`` method. +The following is an example of setting the ``altrow`` theme via the constructor. +``altrow`` theme will be colored rows alternatively: + +:Sample Code: + .. code-block:: python + + import pytablewriter as ptw + + writer = ptw.TableWriterFactory.create_from_format_name( + "markdown", + headers=["INT", "STR"], + value_matrix=[[1, "hoge"], [2, "foo"], [3, "bar"]], + margin=1, + theme="altrow", + ) + writer.write_table() + +:Output: + .. figure:: https://cdn.jsdelivr.net/gh/thombashi/pytablewriter-altrow-theme@master/ss/ptw-altrow-theme_example_default.png + :alt: https://github.com/thombashi/pytablewriter-altrow-theme/blob/master/ss/ptw-altrow-theme_example_default.png + +`[theme]` extras includes the following themes: + +- `pytablewriter-altrow-theme `__ + - `Generated HTML table example `__ +- `pytablewriter-altcol-theme `__ + - `Generated HTML table example `__ + +Make tables for specific applications +--------------------------------------- +Render a table on Jupyter Notebook +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +All table writer class instances in ``pytablewriter`` can render in Jupyter Notebook. +To render writers at notebook cells, you will require the dependency packages to be installed either by: + +- ``pip install pytablewriter[html]`` or +- ``pip install pytablewriter[all]`` + +Jupyter Notebook code examples can be found `here `__: + +.. figure:: https://cdn.jsdelivr.net/gh/thombashi/pytablewriter@master/ss/jupyter_notebook.png + :alt: https://github.com/thombashi/pytablewriter/blob/master/ss/jupyter_notebook.png + + Table rendering results of Jupyter Notebook + +Multibyte character support +----------------------------- +Write a table using multibyte character +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +You can use multibyte characters as table data. +Multibyte characters are also properly padded and aligned. + +:Sample Code: + .. code-block:: python + + import pytablewriter as ptw + + + def main(): + writer = ptw.RstSimpleTableWriter( + table_name="生成に関するパターン", + headers=["パターン名", "概要", "GoF", "Code Complete[1]"], + value_matrix=[ + ["Abstract Factory", "関連する一連のインスタンスを状況に応じて、適切に生成する方法を提供する。", "Yes", "Yes"], + ["Builder", "複合化されたインスタンスの生成過程を隠蔽する。", "Yes", "No"], + ["Factory Method", "実際に生成されるインスタンスに依存しない、インスタンスの生成方法を提供する。", "Yes", "Yes"], + ["Prototype", "同様のインスタンスを生成するために、原型のインスタンスを複製する。", "Yes", "No"], + ["Singleton", "あるクラスについて、インスタンスが単一であることを保証する。", "Yes", "Yes"], + ], + ) + writer.write_table() + + + if __name__ == "__main__": + main() + +:Output: + .. figure:: https://cdn.jsdelivr.net/gh/thombashi/pytablewriter@master/docs/pages/examples/multibyte/ss/multi_byte_char.png + :alt: https://github.com/thombashi/pytablewriter/blob/master/docs/pages/examples/multibyte/ss/multi_byte_char.png + + Output of multi-byte character table + +Multiprocessing +----------------- +You can increase the number of workers to process table data via ``max_workers`` attribute of a writer. +The more ``max_workers`` the less processing time when tabular data is large and the execution environment has available cores. + +If you increase ``max_workers`` larger than one, recommend using main guarded as follows to avoid problems caused by multi-processing: + +.. code-block:: python + + from multiprocessing import cpu_count + import pytablewriter as ptw + + def main(): + writer = ptw.MarkdownTableWriter() + writer.max_workers = cpu_count() + ... + + if __name__ == "__main__": + main() + +For more information +---------------------- +More examples are available at +https://pytablewriter.rtfd.io/en/latest/pages/examples/index.html + +Dependencies +============ +- Python 3.9+ +- `Python package dependencies (automatically installed) `__ + + +Optional dependencies +--------------------- +- ``logging`` extras + - `loguru `__: Used for logging if the package installed +- ``from`` extras + - `pytablereader `__ +- ``es`` extra + - `elasticsearch `__ +- ``excel`` extras + - `xlwt `__ + - `XlsxWriter `__ +- ``html`` extras + - `dominate `__ +- ``sqlite`` extras + - `SimpleSQLite `__ +- ``theme`` extras + - `pytablewriter-altrow-theme `__ + - `pytablewriter-altcol-theme `__ +- ``toml`` extras + - `toml `__ + +Documentation +=============== +https://pytablewriter.rtfd.io/ + +Projects using pytablewriter +================================== +- `pytest-md-report `__ + + +Related Projects +================================== +- `pytablereader `__ + - Tabular data loaded by ``pytablereader`` can be written another tabular data format with ``pytablewriter``. + +Sponsors +==================================== +|chasbecker| |shiguredo| |b4tman| |Arturi0| |github| + +.. |chasbecker| image:: https://avatars.githubusercontent.com/u/44389260?s=48&u=6da7176e51ae2654bcfd22564772ef8a3bb22318&v=4 + :target: https://github.com/chasbecker + :alt: ex-sponsor: Charles Becker (chasbecker) +.. |shiguredo| image:: https://avatars.githubusercontent.com/u/2549434?s=48&v=4 + :target: https://github.com/shiguredo + :alt: ex-sponsor: 時雨堂 (shiguredo) +.. |b4tman| image:: https://avatars.githubusercontent.com/u/3658062?s=48&v=4 + :target: https://github.com/b4tman + :alt: onetime: Dmitry Belyaev (b4tman) +.. |Arturi0| image:: https://avatars.githubusercontent.com/u/46711571?s=48&u=57687c0e02d5d6e8eeaf9177f7b7af4c9f275eb5&v=4 + :target: https://github.com/Arturi0 + :alt: onetime: Arturi0 +.. |github| image:: https://avatars.githubusercontent.com/u/9919?s=48&v=4 + :target: https://github.com/github + :alt: onetime: GitHub (github) + +`Become a sponsor `__ + diff --git a/venv/lib/python3.10/site-packages/pytablewriter-1.2.1.dist-info/RECORD b/venv/lib/python3.10/site-packages/pytablewriter-1.2.1.dist-info/RECORD new file mode 100644 index 0000000000000000000000000000000000000000..e92c62f41b702b7789bb1da7e3f67c41758c3210 --- /dev/null +++ b/venv/lib/python3.10/site-packages/pytablewriter-1.2.1.dist-info/RECORD @@ -0,0 +1,137 @@ +pytablewriter-1.2.1.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +pytablewriter-1.2.1.dist-info/LICENSE,sha256=Ewo1uRffGVGu-_NmEgSR1RJARah97RI_IN7SFSH046I,1089 +pytablewriter-1.2.1.dist-info/METADATA,sha256=Egd2rPMhFcp60Ff2zC2VEmUjSIV6V6Vnn7mTDeb8PR4,38178 +pytablewriter-1.2.1.dist-info/RECORD,, +pytablewriter-1.2.1.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91 +pytablewriter-1.2.1.dist-info/top_level.txt,sha256=4qovxzrpT62Feu8LLdPGtIqYBswTr4QcU4mRmpM61-k,14 +pytablewriter/__init__.py,sha256=E2Y4TxopUWgqMateYeM22S6pGZct8qa_S78a1J_x9ao,2942 +pytablewriter/__pycache__/__init__.cpython-310.pyc,, +pytablewriter/__pycache__/__version__.cpython-310.pyc,, +pytablewriter/__pycache__/_converter.cpython-310.pyc,, +pytablewriter/__pycache__/_factory.cpython-310.pyc,, +pytablewriter/__pycache__/_function.cpython-310.pyc,, +pytablewriter/__pycache__/_table_format.cpython-310.pyc,, +pytablewriter/__pycache__/error.cpython-310.pyc,, +pytablewriter/__version__.py,sha256=Yl4cZCSg_uar8nSXzhiZUTsEIwUveZ9Wn1et0RO9RL8,268 +pytablewriter/_converter.py,sha256=iPlzCNzbGPJ4eSfgMz7DwD7GjaV0n1zxBm_iIzbvG7E,238 +pytablewriter/_factory.py,sha256=JEzLpd5ri6DqGynTvMQ7DVhK36aoKKe-IedMxXjyVds,10847 +pytablewriter/_function.py,sha256=HkZK5rZRRzzOG0qCtLfoLQE8s6ruifdMvQYXePOUgrw,2396 +pytablewriter/_logger/__init__.py,sha256=DzORajZGSzcVR5wMlNgQ2b54Pr1CBgaN3OycGTp9s7g,107 +pytablewriter/_logger/__pycache__/__init__.cpython-310.pyc,, +pytablewriter/_logger/__pycache__/_logger.cpython-310.pyc,, +pytablewriter/_logger/__pycache__/_null_logger.cpython-310.pyc,, +pytablewriter/_logger/_logger.py,sha256=OFQ-ZwE7Ly_HCW2fATCowChDvkFF2G_CjFwu6A2f5v8,3311 +pytablewriter/_logger/_null_logger.py,sha256=QJuaErUIV_x6NjQ9qNX9eNSi_GB_9CrO7lKeXYZnuaw,1088 +pytablewriter/_table_format.py,sha256=0OMnMrF0H9Wms7FKQM-JaMGob2qjgaIKWb3shQqXeuM,9479 +pytablewriter/error.py,sha256=MwPbc4EtUklc7X3eVWADVCA6rrzelfsBcH16E0pJQeE,787 +pytablewriter/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +pytablewriter/sanitizer/__init__.py,sha256=Ob9cbVV0DBI6W6fupmMIHEgoSCdaGeyxo_VhfvNizEM,703 +pytablewriter/sanitizer/__pycache__/__init__.cpython-310.pyc,, +pytablewriter/sanitizer/__pycache__/_base.cpython-310.pyc,, +pytablewriter/sanitizer/__pycache__/_elasticsearch.cpython-310.pyc,, +pytablewriter/sanitizer/__pycache__/_excel.cpython-310.pyc,, +pytablewriter/sanitizer/__pycache__/_interface.cpython-310.pyc,, +pytablewriter/sanitizer/__pycache__/_javascript.cpython-310.pyc,, +pytablewriter/sanitizer/__pycache__/_python.cpython-310.pyc,, +pytablewriter/sanitizer/_base.py,sha256=jSpUcAA532hUAB9FFmYmh4Syp2hDlWsb_MnTIoCe6oc,2957 +pytablewriter/sanitizer/_elasticsearch.py,sha256=SB8GCeR_yl509Lz2uyblGnpYI56P4DSFaC3byB0BdQI,732 +pytablewriter/sanitizer/_excel.py,sha256=G5hot3llV_qMyziwOJwjZhSR1rTwqNdjRDEO3-29BnE,2510 +pytablewriter/sanitizer/_interface.py,sha256=YRioPeXRAPnDBgZ7G30CnpjivNwfbaxBemjWYi7P6e8,901 +pytablewriter/sanitizer/_javascript.py,sha256=WpX6Pq9JvcxTxK9nlb3IXl-YglE_YHcfp_PDk5jFMRY,3620 +pytablewriter/sanitizer/_python.py,sha256=GLF9rDttSEklwpnMRzAI6VLQVqext6O9_QGWEcgHqDM,3115 +pytablewriter/style/__init__.py,sha256=OmdQIAKEu8o5E9Xu9fN_kQ1SAtCZZPebFEY8QQjGFpQ,1107 +pytablewriter/style/__pycache__/__init__.cpython-310.pyc,, +pytablewriter/style/__pycache__/_cell.cpython-310.pyc,, +pytablewriter/style/__pycache__/_font.cpython-310.pyc,, +pytablewriter/style/__pycache__/_style.cpython-310.pyc,, +pytablewriter/style/__pycache__/_styler.cpython-310.pyc,, +pytablewriter/style/__pycache__/_styler_interface.cpython-310.pyc,, +pytablewriter/style/__pycache__/_theme.cpython-310.pyc,, +pytablewriter/style/_cell.py,sha256=Ggaq9xm2r_oXUv_W2eV1YLZeI-U0AVsTpAJBfj1Dozw,549 +pytablewriter/style/_font.py,sha256=f3e9bKB83JYu7Yow7EYA_6XCJvqyCSMvjrIXC-Uelfc,341 +pytablewriter/style/_style.py,sha256=QJImo6VRWMSZT64yEqpeOyaVuYYbuOCVrlvrvmGvQ0E,12448 +pytablewriter/style/_styler.py,sha256=ceB6An1OIg-cx6lwPvSwRxUriF0EEUwHpmTOrucil9Y,9963 +pytablewriter/style/_styler_interface.py,sha256=rM1OX8rYIQsk9vtPmbrrcTlf4e0_So2XrHT3L4z1bF8,828 +pytablewriter/style/_theme.py,sha256=CpYbRacbIFWoMLxfG4qp2otbtLXLmQIDWyyp2VSSNcc,2836 +pytablewriter/typehint/__init__.py,sha256=FDTB4uiJDm2b0A6IsYtTVO2Z994tb5o3kcXbwkDDKYQ,545 +pytablewriter/typehint/__pycache__/__init__.cpython-310.pyc,, +pytablewriter/writer/__init__.py,sha256=r0ZSklAeSM84jA4xzvTFaXHVe0Il0GjAQ8vk2_mtplQ,1766 +pytablewriter/writer/__pycache__/__init__.cpython-310.pyc,, +pytablewriter/writer/__pycache__/_common.cpython-310.pyc,, +pytablewriter/writer/__pycache__/_elasticsearch.cpython-310.pyc,, +pytablewriter/writer/__pycache__/_interface.cpython-310.pyc,, +pytablewriter/writer/__pycache__/_msgfy.cpython-310.pyc,, +pytablewriter/writer/__pycache__/_null.cpython-310.pyc,, +pytablewriter/writer/__pycache__/_table_writer.cpython-310.pyc,, +pytablewriter/writer/_common.py,sha256=BjKw-NvsyNQw9D8Zrpg8RyjLjgQjc0QiLbp1bQoGROE,221 +pytablewriter/writer/_elasticsearch.py,sha256=OSfj__QgUmz5TKOdlL9iCZ7256iwLEi6ca8t7q0HrFc,6308 +pytablewriter/writer/_interface.py,sha256=SBLhByN6K5EUi3B8hyWZKMIg14P_lLGHA_WjV-sM2jA,2671 +pytablewriter/writer/_msgfy.py,sha256=Qf3VIhuCfstgGOEaYQswrW9R1lgYFknjw33YZJGNyFo,1777 +pytablewriter/writer/_null.py,sha256=YPBm1lc23wCQbVHuYKPPOTtdlZKfZOBIEWpkuBKQEw4,1590 +pytablewriter/writer/_table_writer.py,sha256=86W952psHB-jIzLN9uhCFjsLVKgugn8w-q56bfBAJiA,42116 +pytablewriter/writer/binary/__init__.py,sha256=akvPmDxtQjvKEac2yx9c-96CURTFx0809iPPskpa25c,281 +pytablewriter/writer/binary/__pycache__/__init__.cpython-310.pyc,, +pytablewriter/writer/binary/__pycache__/_excel.cpython-310.pyc,, +pytablewriter/writer/binary/__pycache__/_excel_workbook.cpython-310.pyc,, +pytablewriter/writer/binary/__pycache__/_interface.cpython-310.pyc,, +pytablewriter/writer/binary/__pycache__/_pandas.cpython-310.pyc,, +pytablewriter/writer/binary/__pycache__/_sqlite.cpython-310.pyc,, +pytablewriter/writer/binary/_excel.py,sha256=BzH-PEkUd90F-e5WvFNTmGiUXo5Om35ntw_Js5sM-3E,15543 +pytablewriter/writer/binary/_excel_workbook.py,sha256=ZQyXi3FOms6z5GhcGq6-18sY9Y3GM2GqRmLfQEyKij0,3954 +pytablewriter/writer/binary/_interface.py,sha256=U48pCiVMUgeYSKCINncSN5Sy9OnYQ90LMhC7Ls1C8O0,1487 +pytablewriter/writer/binary/_pandas.py,sha256=7UVtUNYGIIywe7GyOT8uDYLtYezoK9FZzk_NhwHNYQo,2660 +pytablewriter/writer/binary/_sqlite.py,sha256=ZnXqvidGUri1SM-Cxls1NwgVg9riDaPkFnr9iQjGchQ,2982 +pytablewriter/writer/text/__init__.py,sha256=_rk5sczp6H9sag4PXgKIbxSTrgW8HktmlJqN0cXR01M,1384 +pytablewriter/writer/text/__pycache__/__init__.cpython-310.pyc,, +pytablewriter/writer/text/__pycache__/_asciidoc.cpython-310.pyc,, +pytablewriter/writer/text/__pycache__/_borderless.cpython-310.pyc,, +pytablewriter/writer/text/__pycache__/_common.cpython-310.pyc,, +pytablewriter/writer/text/__pycache__/_css.cpython-310.pyc,, +pytablewriter/writer/text/__pycache__/_csv.cpython-310.pyc,, +pytablewriter/writer/text/__pycache__/_html.cpython-310.pyc,, +pytablewriter/writer/text/__pycache__/_interface.cpython-310.pyc,, +pytablewriter/writer/text/__pycache__/_json.cpython-310.pyc,, +pytablewriter/writer/text/__pycache__/_jsonlines.cpython-310.pyc,, +pytablewriter/writer/text/__pycache__/_latex.cpython-310.pyc,, +pytablewriter/writer/text/__pycache__/_ltsv.cpython-310.pyc,, +pytablewriter/writer/text/__pycache__/_markdown.cpython-310.pyc,, +pytablewriter/writer/text/__pycache__/_mediawiki.cpython-310.pyc,, +pytablewriter/writer/text/__pycache__/_rst.cpython-310.pyc,, +pytablewriter/writer/text/__pycache__/_spacealigned.cpython-310.pyc,, +pytablewriter/writer/text/__pycache__/_text_writer.cpython-310.pyc,, +pytablewriter/writer/text/__pycache__/_toml.cpython-310.pyc,, +pytablewriter/writer/text/__pycache__/_tsv.cpython-310.pyc,, +pytablewriter/writer/text/__pycache__/_unicode.cpython-310.pyc,, +pytablewriter/writer/text/__pycache__/_yaml.cpython-310.pyc,, +pytablewriter/writer/text/_asciidoc.py,sha256=E2MO-Z3yVuF3eviwMqNvgkk5_-1R_u-I31bvH85xVHI,4410 +pytablewriter/writer/text/_borderless.py,sha256=4RhWiSppkS2bRIl8osmqkSst-hwDzaAT-GaSyHyHft4,1010 +pytablewriter/writer/text/_common.py,sha256=1YRanAyjyEgo9muaUM3n9pPieKsX0d5Y-_ktI92B_tA,554 +pytablewriter/writer/text/_css.py,sha256=kXaOogifXdFcDgV83D3zd2k1MlfDotv2gTEjgYaJ6cI,5496 +pytablewriter/writer/text/_csv.py,sha256=MBkHpdC7u9L8p9FNws-IpTECzn2-LpbsT9lg1sKEJzg,1484 +pytablewriter/writer/text/_html.py,sha256=lgCJYXuCtWJ9maF4HooylRaYtwYPPrUpHYHAb_VWEAU,6328 +pytablewriter/writer/text/_interface.py,sha256=Qcwjq6w_dz5Lk7Txr42ESnomW0316-LqPBo1HmcRP7I,642 +pytablewriter/writer/text/_json.py,sha256=kAGiwnbFWyLoqbNZL6at4u_DcS1JrUzJV5wOYQZk_J0,5081 +pytablewriter/writer/text/_jsonlines.py,sha256=si6GB85HhqIaTjBYNjg8xD4HhqvYlCHnOTOSl7xY0G4,1296 +pytablewriter/writer/text/_latex.py,sha256=_w_2c2fimZk2TL402lInpWzb3FtQpH6r6KdWbQaGet4,6336 +pytablewriter/writer/text/_ltsv.py,sha256=xsMAMMU2F5UdznagXnQJbz62-nstSiSbjm7vgHlLm_s,1517 +pytablewriter/writer/text/_markdown.py,sha256=ZfBhMN1CgLt5a-2ZxV4QHpiIs3pY-Sh8Fla3w1BXvkA,6201 +pytablewriter/writer/text/_mediawiki.py,sha256=lNGMwtLClFIMYWQeNTZ52wk8SHiT7FO93C580vPqMqU,3312 +pytablewriter/writer/text/_rst.py,sha256=aiE7zHflwU6RnOGQAowbhTF6onBjmPhx6QvQyaDco4Y,6906 +pytablewriter/writer/text/_spacealigned.py,sha256=osMTS0cvNl8qWthlUkB6noAaKGlBUL02MW-YEvMXEgA,897 +pytablewriter/writer/text/_text_writer.py,sha256=u21ijkBHg3KAtOT58yz5gQWeNTy82hAYxSQiO2RxFNE,20556 +pytablewriter/writer/text/_toml.py,sha256=oUQRIiNIXQ47ccGasVohbDGBksMMxDETv0mnbCngVC8,2265 +pytablewriter/writer/text/_tsv.py,sha256=xLXiOznMZ8W8fKa-xfZCNlTl2Q4_HWFTUQlR4__DjuU,467 +pytablewriter/writer/text/_unicode.py,sha256=-2W2O-FaBkPDAJuwBKLEutGS09y7DcasK4Q83K0GXiE,3532 +pytablewriter/writer/text/_yaml.py,sha256=ERDWX60MWjPRHf0Gs3q-m38n49NGf460YRR0ru_RF0s,1968 +pytablewriter/writer/text/sourcecode/__init__.py,sha256=25ju5UpRUV7DBNsusSj4YLzOLY5akmmEW7gKegSVtu4,297 +pytablewriter/writer/text/sourcecode/__pycache__/__init__.cpython-310.pyc,, +pytablewriter/writer/text/sourcecode/__pycache__/_javascript.cpython-310.pyc,, +pytablewriter/writer/text/sourcecode/__pycache__/_numpy.cpython-310.pyc,, +pytablewriter/writer/text/sourcecode/__pycache__/_pandas.cpython-310.pyc,, +pytablewriter/writer/text/sourcecode/__pycache__/_python.cpython-310.pyc,, +pytablewriter/writer/text/sourcecode/__pycache__/_sourcecode.cpython-310.pyc,, +pytablewriter/writer/text/sourcecode/_javascript.py,sha256=MHxFDde91ekZ8J0SfblFa7yO8vE8zKsKRJVY6hEsPok,4725 +pytablewriter/writer/text/sourcecode/_numpy.py,sha256=XGIHnGIpu7r5RPBhaadPXuPSSOWLAd2rss8OiI2huNM,1902 +pytablewriter/writer/text/sourcecode/_pandas.py,sha256=3wgXSSpD7UVNp9vmhmNb-lgZrdpZ66Ol8KEFeXLMl1k,2550 +pytablewriter/writer/text/sourcecode/_python.py,sha256=IQwuSTULsksIqp0tH6lpHGkuOQfC4IxxGrlmG-CGrbI,2535 +pytablewriter/writer/text/sourcecode/_sourcecode.py,sha256=BDr9hGrzmukvZzO48jsEInmeOSigJSBblhtgO5OEC7Y,2239 diff --git a/venv/lib/python3.10/site-packages/pytablewriter-1.2.1.dist-info/WHEEL b/venv/lib/python3.10/site-packages/pytablewriter-1.2.1.dist-info/WHEEL new file mode 100644 index 0000000000000000000000000000000000000000..ae527e7d64811439e61b93aa375defb30e06edfe --- /dev/null +++ b/venv/lib/python3.10/site-packages/pytablewriter-1.2.1.dist-info/WHEEL @@ -0,0 +1,5 @@ +Wheel-Version: 1.0 +Generator: setuptools (75.6.0) +Root-Is-Purelib: true +Tag: py3-none-any + diff --git a/venv/lib/python3.10/site-packages/pytablewriter-1.2.1.dist-info/top_level.txt b/venv/lib/python3.10/site-packages/pytablewriter-1.2.1.dist-info/top_level.txt new file mode 100644 index 0000000000000000000000000000000000000000..ee171b9ce88fa902be1b06281de4ce7ade6e10f9 --- /dev/null +++ b/venv/lib/python3.10/site-packages/pytablewriter-1.2.1.dist-info/top_level.txt @@ -0,0 +1 @@ +pytablewriter diff --git a/venv/lib/python3.10/site-packages/python_multipart/__init__.py b/venv/lib/python3.10/site-packages/python_multipart/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e4265264586f827d7ee24ee95040143d54b10e9d --- /dev/null +++ b/venv/lib/python3.10/site-packages/python_multipart/__init__.py @@ -0,0 +1,25 @@ +# This is the canonical package information. +__author__ = "Andrew Dunham" +__license__ = "Apache" +__copyright__ = "Copyright (c) 2012-2013, Andrew Dunham" +__version__ = "0.0.20" + +from .multipart import ( + BaseParser, + FormParser, + MultipartParser, + OctetStreamParser, + QuerystringParser, + create_form_parser, + parse_form, +) + +__all__ = ( + "BaseParser", + "FormParser", + "MultipartParser", + "OctetStreamParser", + "QuerystringParser", + "create_form_parser", + "parse_form", +) diff --git a/venv/lib/python3.10/site-packages/python_multipart/__pycache__/__init__.cpython-310.pyc b/venv/lib/python3.10/site-packages/python_multipart/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8272c031a225057cc8be5274b3be0ce34e127a71 Binary files /dev/null and b/venv/lib/python3.10/site-packages/python_multipart/__pycache__/__init__.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/python_multipart/__pycache__/decoders.cpython-310.pyc b/venv/lib/python3.10/site-packages/python_multipart/__pycache__/decoders.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fcd38ed644df5ca0689d219ae074ccc6d6d24a54 Binary files /dev/null and b/venv/lib/python3.10/site-packages/python_multipart/__pycache__/decoders.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/python_multipart/__pycache__/exceptions.cpython-310.pyc b/venv/lib/python3.10/site-packages/python_multipart/__pycache__/exceptions.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0c24f306d6961286f94e97680fdab66fdced4054 Binary files /dev/null and b/venv/lib/python3.10/site-packages/python_multipart/__pycache__/exceptions.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/python_multipart/__pycache__/multipart.cpython-310.pyc b/venv/lib/python3.10/site-packages/python_multipart/__pycache__/multipart.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c904f08fedc61bfa32e5fec11a4a83735889e77a Binary files /dev/null and b/venv/lib/python3.10/site-packages/python_multipart/__pycache__/multipart.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/python_multipart/decoders.py b/venv/lib/python3.10/site-packages/python_multipart/decoders.py new file mode 100644 index 0000000000000000000000000000000000000000..82b56a1e22f5fe912c4a961e14716e3c92321bf8 --- /dev/null +++ b/venv/lib/python3.10/site-packages/python_multipart/decoders.py @@ -0,0 +1,185 @@ +import base64 +import binascii +from typing import TYPE_CHECKING + +from .exceptions import DecodeError + +if TYPE_CHECKING: # pragma: no cover + from typing import Protocol, TypeVar + + _T_contra = TypeVar("_T_contra", contravariant=True) + + class SupportsWrite(Protocol[_T_contra]): + def write(self, __b: _T_contra) -> object: ... + + # No way to specify optional methods. See + # https://github.com/python/typing/issues/601 + # close() [Optional] + # finalize() [Optional] + + +class Base64Decoder: + """This object provides an interface to decode a stream of Base64 data. It + is instantiated with an "underlying object", and whenever a write() + operation is performed, it will decode the incoming data as Base64, and + call write() on the underlying object. This is primarily used for decoding + form data encoded as Base64, but can be used for other purposes:: + + from python_multipart.decoders import Base64Decoder + fd = open("notb64.txt", "wb") + decoder = Base64Decoder(fd) + try: + decoder.write("Zm9vYmFy") # "foobar" in Base64 + decoder.finalize() + finally: + decoder.close() + + # The contents of "notb64.txt" should be "foobar". + + This object will also pass all finalize() and close() calls to the + underlying object, if the underlying object supports them. + + Note that this class maintains a cache of base64 chunks, so that a write of + arbitrary size can be performed. You must call :meth:`finalize` on this + object after all writes are completed to ensure that all data is flushed + to the underlying object. + + :param underlying: the underlying object to pass writes to + """ + + def __init__(self, underlying: "SupportsWrite[bytes]") -> None: + self.cache = bytearray() + self.underlying = underlying + + def write(self, data: bytes) -> int: + """Takes any input data provided, decodes it as base64, and passes it + on to the underlying object. If the data provided is invalid base64 + data, then this method will raise + a :class:`python_multipart.exceptions.DecodeError` + + :param data: base64 data to decode + """ + + # Prepend any cache info to our data. + if len(self.cache) > 0: + data = self.cache + data + + # Slice off a string that's a multiple of 4. + decode_len = (len(data) // 4) * 4 + val = data[:decode_len] + + # Decode and write, if we have any. + if len(val) > 0: + try: + decoded = base64.b64decode(val) + except binascii.Error: + raise DecodeError("There was an error raised while decoding base64-encoded data.") + + self.underlying.write(decoded) + + # Get the remaining bytes and save in our cache. + remaining_len = len(data) % 4 + if remaining_len > 0: + self.cache[:] = data[-remaining_len:] + else: + self.cache[:] = b"" + + # Return the length of the data to indicate no error. + return len(data) + + def close(self) -> None: + """Close this decoder. If the underlying object has a `close()` + method, this function will call it. + """ + if hasattr(self.underlying, "close"): + self.underlying.close() + + def finalize(self) -> None: + """Finalize this object. This should be called when no more data + should be written to the stream. This function can raise a + :class:`python_multipart.exceptions.DecodeError` if there is some remaining + data in the cache. + + If the underlying object has a `finalize()` method, this function will + call it. + """ + if len(self.cache) > 0: + raise DecodeError( + "There are %d bytes remaining in the Base64Decoder cache when finalize() is called" % len(self.cache) + ) + + if hasattr(self.underlying, "finalize"): + self.underlying.finalize() + + def __repr__(self) -> str: + return f"{self.__class__.__name__}(underlying={self.underlying!r})" + + +class QuotedPrintableDecoder: + """This object provides an interface to decode a stream of quoted-printable + data. It is instantiated with an "underlying object", in the same manner + as the :class:`python_multipart.decoders.Base64Decoder` class. This class behaves + in exactly the same way, including maintaining a cache of quoted-printable + chunks. + + :param underlying: the underlying object to pass writes to + """ + + def __init__(self, underlying: "SupportsWrite[bytes]") -> None: + self.cache = b"" + self.underlying = underlying + + def write(self, data: bytes) -> int: + """Takes any input data provided, decodes it as quoted-printable, and + passes it on to the underlying object. + + :param data: quoted-printable data to decode + """ + # Prepend any cache info to our data. + if len(self.cache) > 0: + data = self.cache + data + + # If the last 2 characters have an '=' sign in it, then we won't be + # able to decode the encoded value and we'll need to save it for the + # next decoding step. + if data[-2:].find(b"=") != -1: + enc, rest = data[:-2], data[-2:] + else: + enc = data + rest = b"" + + # Encode and write, if we have data. + if len(enc) > 0: + self.underlying.write(binascii.a2b_qp(enc)) + + # Save remaining in cache. + self.cache = rest + return len(data) + + def close(self) -> None: + """Close this decoder. If the underlying object has a `close()` + method, this function will call it. + """ + if hasattr(self.underlying, "close"): + self.underlying.close() + + def finalize(self) -> None: + """Finalize this object. This should be called when no more data + should be written to the stream. This function will not raise any + exceptions, but it may write more data to the underlying object if + there is data remaining in the cache. + + If the underlying object has a `finalize()` method, this function will + call it. + """ + # If we have a cache, write and then remove it. + if len(self.cache) > 0: # pragma: no cover + self.underlying.write(binascii.a2b_qp(self.cache)) + self.cache = b"" + + # Finalize our underlying stream. + if hasattr(self.underlying, "finalize"): + self.underlying.finalize() + + def __repr__(self) -> str: + return f"{self.__class__.__name__}(underlying={self.underlying!r})" diff --git a/venv/lib/python3.10/site-packages/python_multipart/exceptions.py b/venv/lib/python3.10/site-packages/python_multipart/exceptions.py new file mode 100644 index 0000000000000000000000000000000000000000..cc3671f518dd1768a968b8ceb09b286d17840a7e --- /dev/null +++ b/venv/lib/python3.10/site-packages/python_multipart/exceptions.py @@ -0,0 +1,34 @@ +class FormParserError(ValueError): + """Base error class for our form parser.""" + + +class ParseError(FormParserError): + """This exception (or a subclass) is raised when there is an error while + parsing something. + """ + + #: This is the offset in the input data chunk (*NOT* the overall stream) in + #: which the parse error occurred. It will be -1 if not specified. + offset = -1 + + +class MultipartParseError(ParseError): + """This is a specific error that is raised when the MultipartParser detects + an error while parsing. + """ + + +class QuerystringParseError(ParseError): + """This is a specific error that is raised when the QuerystringParser + detects an error while parsing. + """ + + +class DecodeError(ParseError): + """This exception is raised when there is a decoding error - for example + with the Base64Decoder or QuotedPrintableDecoder. + """ + + +class FileError(FormParserError, OSError): + """Exception class for problems with the File class.""" diff --git a/venv/lib/python3.10/site-packages/python_multipart/multipart.py b/venv/lib/python3.10/site-packages/python_multipart/multipart.py new file mode 100644 index 0000000000000000000000000000000000000000..f26a815a41ee24f382986609609f20b25f421170 --- /dev/null +++ b/venv/lib/python3.10/site-packages/python_multipart/multipart.py @@ -0,0 +1,1873 @@ +from __future__ import annotations + +import logging +import os +import shutil +import sys +import tempfile +from email.message import Message +from enum import IntEnum +from io import BufferedRandom, BytesIO +from numbers import Number +from typing import TYPE_CHECKING, cast + +from .decoders import Base64Decoder, QuotedPrintableDecoder +from .exceptions import FileError, FormParserError, MultipartParseError, QuerystringParseError + +if TYPE_CHECKING: # pragma: no cover + from typing import Any, Callable, Literal, Protocol, TypedDict + + from typing_extensions import TypeAlias + + class SupportsRead(Protocol): + def read(self, __n: int) -> bytes: ... + + class QuerystringCallbacks(TypedDict, total=False): + on_field_start: Callable[[], None] + on_field_name: Callable[[bytes, int, int], None] + on_field_data: Callable[[bytes, int, int], None] + on_field_end: Callable[[], None] + on_end: Callable[[], None] + + class OctetStreamCallbacks(TypedDict, total=False): + on_start: Callable[[], None] + on_data: Callable[[bytes, int, int], None] + on_end: Callable[[], None] + + class MultipartCallbacks(TypedDict, total=False): + on_part_begin: Callable[[], None] + on_part_data: Callable[[bytes, int, int], None] + on_part_end: Callable[[], None] + on_header_begin: Callable[[], None] + on_header_field: Callable[[bytes, int, int], None] + on_header_value: Callable[[bytes, int, int], None] + on_header_end: Callable[[], None] + on_headers_finished: Callable[[], None] + on_end: Callable[[], None] + + class FormParserConfig(TypedDict): + UPLOAD_DIR: str | None + UPLOAD_KEEP_FILENAME: bool + UPLOAD_KEEP_EXTENSIONS: bool + UPLOAD_ERROR_ON_BAD_CTE: bool + MAX_MEMORY_FILE_SIZE: int + MAX_BODY_SIZE: float + + class FileConfig(TypedDict, total=False): + UPLOAD_DIR: str | bytes | None + UPLOAD_DELETE_TMP: bool + UPLOAD_KEEP_FILENAME: bool + UPLOAD_KEEP_EXTENSIONS: bool + MAX_MEMORY_FILE_SIZE: int + + class _FormProtocol(Protocol): + def write(self, data: bytes) -> int: ... + + def finalize(self) -> None: ... + + def close(self) -> None: ... + + class FieldProtocol(_FormProtocol, Protocol): + def __init__(self, name: bytes | None) -> None: ... + + def set_none(self) -> None: ... + + class FileProtocol(_FormProtocol, Protocol): + def __init__(self, file_name: bytes | None, field_name: bytes | None, config: FileConfig) -> None: ... + + OnFieldCallback = Callable[[FieldProtocol], None] + OnFileCallback = Callable[[FileProtocol], None] + + CallbackName: TypeAlias = Literal[ + "start", + "data", + "end", + "field_start", + "field_name", + "field_data", + "field_end", + "part_begin", + "part_data", + "part_end", + "header_begin", + "header_field", + "header_value", + "header_end", + "headers_finished", + ] + +# Unique missing object. +_missing = object() + + +class QuerystringState(IntEnum): + """Querystring parser states. + + These are used to keep track of the state of the parser, and are used to determine + what to do when new data is encountered. + """ + + BEFORE_FIELD = 0 + FIELD_NAME = 1 + FIELD_DATA = 2 + + +class MultipartState(IntEnum): + """Multipart parser states. + + These are used to keep track of the state of the parser, and are used to determine + what to do when new data is encountered. + """ + + START = 0 + START_BOUNDARY = 1 + HEADER_FIELD_START = 2 + HEADER_FIELD = 3 + HEADER_VALUE_START = 4 + HEADER_VALUE = 5 + HEADER_VALUE_ALMOST_DONE = 6 + HEADERS_ALMOST_DONE = 7 + PART_DATA_START = 8 + PART_DATA = 9 + PART_DATA_END = 10 + END_BOUNDARY = 11 + END = 12 + + +# Flags for the multipart parser. +FLAG_PART_BOUNDARY = 1 +FLAG_LAST_BOUNDARY = 2 + +# Get constants. Since iterating over a str on Python 2 gives you a 1-length +# string, but iterating over a bytes object on Python 3 gives you an integer, +# we need to save these constants. +CR = b"\r"[0] +LF = b"\n"[0] +COLON = b":"[0] +SPACE = b" "[0] +HYPHEN = b"-"[0] +AMPERSAND = b"&"[0] +SEMICOLON = b";"[0] +LOWER_A = b"a"[0] +LOWER_Z = b"z"[0] +NULL = b"\x00"[0] + +# fmt: off +# Mask for ASCII characters that can be http tokens. +# Per RFC7230 - 3.2.6, this is all alpha-numeric characters +# and these: !#$%&'*+-.^_`|~ +TOKEN_CHARS_SET = frozenset( + b"ABCDEFGHIJKLMNOPQRSTUVWXYZ" + b"abcdefghijklmnopqrstuvwxyz" + b"0123456789" + b"!#$%&'*+-.^_`|~") +# fmt: on + + +def parse_options_header(value: str | bytes | None) -> tuple[bytes, dict[bytes, bytes]]: + """Parses a Content-Type header into a value in the following format: (content_type, {parameters}).""" + # Uses email.message.Message to parse the header as described in PEP 594. + # Ref: https://peps.python.org/pep-0594/#cgi + if not value: + return (b"", {}) + + # If we are passed bytes, we assume that it conforms to WSGI, encoding in latin-1. + if isinstance(value, bytes): # pragma: no cover + value = value.decode("latin-1") + + # For types + assert isinstance(value, str), "Value should be a string by now" + + # If we have no options, return the string as-is. + if ";" not in value: + return (value.lower().strip().encode("latin-1"), {}) + + # Split at the first semicolon, to get our value and then options. + # ctype, rest = value.split(b';', 1) + message = Message() + message["content-type"] = value + params = message.get_params() + # If there were no parameters, this would have already returned above + assert params, "At least the content type value should be present" + ctype = params.pop(0)[0].encode("latin-1") + options: dict[bytes, bytes] = {} + for param in params: + key, value = param + # If the value returned from get_params() is a 3-tuple, the last + # element corresponds to the value. + # See: https://docs.python.org/3/library/email.compat32-message.html + if isinstance(value, tuple): + value = value[-1] + # If the value is a filename, we need to fix a bug on IE6 that sends + # the full file path instead of the filename. + if key == "filename": + if value[1:3] == ":\\" or value[:2] == "\\\\": + value = value.split("\\")[-1] + options[key.encode("latin-1")] = value.encode("latin-1") + return ctype, options + + +class Field: + """A Field object represents a (parsed) form field. It represents a single + field with a corresponding name and value. + + The name that a :class:`Field` will be instantiated with is the same name + that would be found in the following HTML:: + + + + This class defines two methods, :meth:`on_data` and :meth:`on_end`, that + will be called when data is written to the Field, and when the Field is + finalized, respectively. + + Args: + name: The name of the form field. + """ + + def __init__(self, name: bytes | None) -> None: + self._name = name + self._value: list[bytes] = [] + + # We cache the joined version of _value for speed. + self._cache = _missing + + @classmethod + def from_value(cls, name: bytes, value: bytes | None) -> Field: + """Create an instance of a :class:`Field`, and set the corresponding + value - either None or an actual value. This method will also + finalize the Field itself. + + Args: + name: the name of the form field. + value: the value of the form field - either a bytestring or None. + + Returns: + A new instance of a [`Field`][python_multipart.Field]. + """ + + f = cls(name) + if value is None: + f.set_none() + else: + f.write(value) + f.finalize() + return f + + def write(self, data: bytes) -> int: + """Write some data into the form field. + + Args: + data: The data to write to the field. + + Returns: + The number of bytes written. + """ + return self.on_data(data) + + def on_data(self, data: bytes) -> int: + """This method is a callback that will be called whenever data is + written to the Field. + + Args: + data: The data to write to the field. + + Returns: + The number of bytes written. + """ + self._value.append(data) + self._cache = _missing + return len(data) + + def on_end(self) -> None: + """This method is called whenever the Field is finalized.""" + if self._cache is _missing: + self._cache = b"".join(self._value) + + def finalize(self) -> None: + """Finalize the form field.""" + self.on_end() + + def close(self) -> None: + """Close the Field object. This will free any underlying cache.""" + # Free our value array. + if self._cache is _missing: + self._cache = b"".join(self._value) + + del self._value + + def set_none(self) -> None: + """Some fields in a querystring can possibly have a value of None - for + example, the string "foo&bar=&baz=asdf" will have a field with the + name "foo" and value None, one with name "bar" and value "", and one + with name "baz" and value "asdf". Since the write() interface doesn't + support writing None, this function will set the field value to None. + """ + self._cache = None + + @property + def field_name(self) -> bytes | None: + """This property returns the name of the field.""" + return self._name + + @property + def value(self) -> bytes | None: + """This property returns the value of the form field.""" + if self._cache is _missing: + self._cache = b"".join(self._value) + + assert isinstance(self._cache, bytes) or self._cache is None + return self._cache + + def __eq__(self, other: object) -> bool: + if isinstance(other, Field): + return self.field_name == other.field_name and self.value == other.value + else: + return NotImplemented + + def __repr__(self) -> str: + if self.value is not None and len(self.value) > 97: + # We get the repr, and then insert three dots before the final + # quote. + v = repr(self.value[:97])[:-1] + "...'" + else: + v = repr(self.value) + + return "{}(field_name={!r}, value={})".format(self.__class__.__name__, self.field_name, v) + + +class File: + """This class represents an uploaded file. It handles writing file data to + either an in-memory file or a temporary file on-disk, if the optional + threshold is passed. + + There are some options that can be passed to the File to change behavior + of the class. Valid options are as follows: + + | Name | Type | Default | Description | + |-----------------------|-------|---------|-------------| + | UPLOAD_DIR | `str` | None | The directory to store uploaded files in. If this is None, a temporary file will be created in the system's standard location. | + | UPLOAD_DELETE_TMP | `bool`| True | Delete automatically created TMP file | + | UPLOAD_KEEP_FILENAME | `bool`| False | Whether or not to keep the filename of the uploaded file. If True, then the filename will be converted to a safe representation (e.g. by removing any invalid path segments), and then saved with the same name). Otherwise, a temporary name will be used. | + | UPLOAD_KEEP_EXTENSIONS| `bool`| False | Whether or not to keep the uploaded file's extension. If False, the file will be saved with the default temporary extension (usually ".tmp"). Otherwise, the file's extension will be maintained. Note that this will properly combine with the UPLOAD_KEEP_FILENAME setting. | + | MAX_MEMORY_FILE_SIZE | `int` | 1 MiB | The maximum number of bytes of a File to keep in memory. By default, the contents of a File are kept into memory until a certain limit is reached, after which the contents of the File are written to a temporary file. This behavior can be disabled by setting this value to an appropriately large value (or, for example, infinity, such as `float('inf')`. | + + Args: + file_name: The name of the file that this [`File`][python_multipart.File] represents. + field_name: The name of the form field that this file was uploaded with. This can be None, if, for example, + the file was uploaded with Content-Type application/octet-stream. + config: The configuration for this File. See above for valid configuration keys and their corresponding values. + """ # noqa: E501 + + def __init__(self, file_name: bytes | None, field_name: bytes | None = None, config: FileConfig = {}) -> None: + # Save configuration, set other variables default. + self.logger = logging.getLogger(__name__) + self._config = config + self._in_memory = True + self._bytes_written = 0 + self._fileobj: BytesIO | BufferedRandom = BytesIO() + + # Save the provided field/file name. + self._field_name = field_name + self._file_name = file_name + + # Our actual file name is None by default, since, depending on our + # config, we may not actually use the provided name. + self._actual_file_name: bytes | None = None + + # Split the extension from the filename. + if file_name is not None: + base, ext = os.path.splitext(file_name) + self._file_base = base + self._ext = ext + + @property + def field_name(self) -> bytes | None: + """The form field associated with this file. May be None if there isn't + one, for example when we have an application/octet-stream upload. + """ + return self._field_name + + @property + def file_name(self) -> bytes | None: + """The file name given in the upload request.""" + return self._file_name + + @property + def actual_file_name(self) -> bytes | None: + """The file name that this file is saved as. Will be None if it's not + currently saved on disk. + """ + return self._actual_file_name + + @property + def file_object(self) -> BytesIO | BufferedRandom: + """The file object that we're currently writing to. Note that this + will either be an instance of a :class:`io.BytesIO`, or a regular file + object. + """ + return self._fileobj + + @property + def size(self) -> int: + """The total size of this file, counted as the number of bytes that + currently have been written to the file. + """ + return self._bytes_written + + @property + def in_memory(self) -> bool: + """A boolean representing whether or not this file object is currently + stored in-memory or on-disk. + """ + return self._in_memory + + def flush_to_disk(self) -> None: + """If the file is already on-disk, do nothing. Otherwise, copy from + the in-memory buffer to a disk file, and then reassign our internal + file object to this new disk file. + + Note that if you attempt to flush a file that is already on-disk, a + warning will be logged to this module's logger. + """ + if not self._in_memory: + self.logger.warning("Trying to flush to disk when we're not in memory") + return + + # Go back to the start of our file. + self._fileobj.seek(0) + + # Open a new file. + new_file = self._get_disk_file() + + # Copy the file objects. + shutil.copyfileobj(self._fileobj, new_file) + + # Seek to the new position in our new file. + new_file.seek(self._bytes_written) + + # Reassign the fileobject. + old_fileobj = self._fileobj + self._fileobj = new_file + + # We're no longer in memory. + self._in_memory = False + + # Close the old file object. + old_fileobj.close() + + def _get_disk_file(self) -> BufferedRandom: + """This function is responsible for getting a file object on-disk for us.""" + self.logger.info("Opening a file on disk") + + file_dir = self._config.get("UPLOAD_DIR") + keep_filename = self._config.get("UPLOAD_KEEP_FILENAME", False) + keep_extensions = self._config.get("UPLOAD_KEEP_EXTENSIONS", False) + delete_tmp = self._config.get("UPLOAD_DELETE_TMP", True) + tmp_file: None | BufferedRandom = None + + # If we have a directory and are to keep the filename... + if file_dir is not None and keep_filename: + self.logger.info("Saving with filename in: %r", file_dir) + + # Build our filename. + # TODO: what happens if we don't have a filename? + fname = self._file_base + self._ext if keep_extensions else self._file_base + + path = os.path.join(file_dir, fname) # type: ignore[arg-type] + try: + self.logger.info("Opening file: %r", path) + tmp_file = open(path, "w+b") + except OSError: + tmp_file = None + + self.logger.exception("Error opening temporary file") + raise FileError("Error opening temporary file: %r" % path) + else: + # Build options array. + # Note that on Python 3, tempfile doesn't support byte names. We + # encode our paths using the default filesystem encoding. + suffix = self._ext.decode(sys.getfilesystemencoding()) if keep_extensions else None + + if file_dir is None: + dir = None + elif isinstance(file_dir, bytes): + dir = file_dir.decode(sys.getfilesystemencoding()) + else: + dir = file_dir # pragma: no cover + + # Create a temporary (named) file with the appropriate settings. + self.logger.info( + "Creating a temporary file with options: %r", {"suffix": suffix, "delete": delete_tmp, "dir": dir} + ) + try: + tmp_file = cast(BufferedRandom, tempfile.NamedTemporaryFile(suffix=suffix, delete=delete_tmp, dir=dir)) + except OSError: + self.logger.exception("Error creating named temporary file") + raise FileError("Error creating named temporary file") + + assert tmp_file is not None + # Encode filename as bytes. + if isinstance(tmp_file.name, str): + fname = tmp_file.name.encode(sys.getfilesystemencoding()) + else: + fname = cast(bytes, tmp_file.name) # pragma: no cover + + self._actual_file_name = fname + return tmp_file + + def write(self, data: bytes) -> int: + """Write some data to the File. + + :param data: a bytestring + """ + return self.on_data(data) + + def on_data(self, data: bytes) -> int: + """This method is a callback that will be called whenever data is + written to the File. + + Args: + data: The data to write to the file. + + Returns: + The number of bytes written. + """ + bwritten = self._fileobj.write(data) + + # If the bytes written isn't the same as the length, just return. + if bwritten != len(data): + self.logger.warning("bwritten != len(data) (%d != %d)", bwritten, len(data)) + return bwritten + + # Keep track of how many bytes we've written. + self._bytes_written += bwritten + + # If we're in-memory and are over our limit, we create a file. + max_memory_file_size = self._config.get("MAX_MEMORY_FILE_SIZE") + if self._in_memory and max_memory_file_size is not None and (self._bytes_written > max_memory_file_size): + self.logger.info("Flushing to disk") + self.flush_to_disk() + + # Return the number of bytes written. + return bwritten + + def on_end(self) -> None: + """This method is called whenever the Field is finalized.""" + # Flush the underlying file object + self._fileobj.flush() + + def finalize(self) -> None: + """Finalize the form file. This will not close the underlying file, + but simply signal that we are finished writing to the File. + """ + self.on_end() + + def close(self) -> None: + """Close the File object. This will actually close the underlying + file object (whether it's a :class:`io.BytesIO` or an actual file + object). + """ + self._fileobj.close() + + def __repr__(self) -> str: + return "{}(file_name={!r}, field_name={!r})".format(self.__class__.__name__, self.file_name, self.field_name) + + +class BaseParser: + """This class is the base class for all parsers. It contains the logic for + calling and adding callbacks. + + A callback can be one of two different forms. "Notification callbacks" are + callbacks that are called when something happens - for example, when a new + part of a multipart message is encountered by the parser. "Data callbacks" + are called when we get some sort of data - for example, part of the body of + a multipart chunk. Notification callbacks are called with no parameters, + whereas data callbacks are called with three, as follows:: + + data_callback(data, start, end) + + The "data" parameter is a bytestring (i.e. "foo" on Python 2, or b"foo" on + Python 3). "start" and "end" are integer indexes into the "data" string + that represent the data of interest. Thus, in a data callback, the slice + `data[start:end]` represents the data that the callback is "interested in". + The callback is not passed a copy of the data, since copying severely hurts + performance. + """ + + def __init__(self) -> None: + self.logger = logging.getLogger(__name__) + self.callbacks: QuerystringCallbacks | OctetStreamCallbacks | MultipartCallbacks = {} + + def callback( + self, name: CallbackName, data: bytes | None = None, start: int | None = None, end: int | None = None + ) -> None: + """This function calls a provided callback with some data. If the + callback is not set, will do nothing. + + Args: + name: The name of the callback to call (as a string). + data: Data to pass to the callback. If None, then it is assumed that the callback is a notification + callback, and no parameters are given. + end: An integer that is passed to the data callback. + start: An integer that is passed to the data callback. + """ + on_name = "on_" + name + func = self.callbacks.get(on_name) + if func is None: + return + func = cast("Callable[..., Any]", func) + # Depending on whether we're given a buffer... + if data is not None: + # Don't do anything if we have start == end. + if start is not None and start == end: + return + + self.logger.debug("Calling %s with data[%d:%d]", on_name, start, end) + func(data, start, end) + else: + self.logger.debug("Calling %s with no data", on_name) + func() + + def set_callback(self, name: CallbackName, new_func: Callable[..., Any] | None) -> None: + """Update the function for a callback. Removes from the callbacks dict + if new_func is None. + + :param name: The name of the callback to call (as a string). + + :param new_func: The new function for the callback. If None, then the + callback will be removed (with no error if it does not + exist). + """ + if new_func is None: + self.callbacks.pop("on_" + name, None) # type: ignore[misc] + else: + self.callbacks["on_" + name] = new_func # type: ignore[literal-required] + + def close(self) -> None: + pass # pragma: no cover + + def finalize(self) -> None: + pass # pragma: no cover + + def __repr__(self) -> str: + return "%s()" % self.__class__.__name__ + + +class OctetStreamParser(BaseParser): + """This parser parses an octet-stream request body and calls callbacks when + incoming data is received. Callbacks are as follows: + + | Callback Name | Parameters | Description | + |----------------|-----------------|-----------------------------------------------------| + | on_start | None | Called when the first data is parsed. | + | on_data | data, start, end| Called for each data chunk that is parsed. | + | on_end | None | Called when the parser is finished parsing all data.| + + Args: + callbacks: A dictionary of callbacks. See the documentation for [`BaseParser`][python_multipart.BaseParser]. + max_size: The maximum size of body to parse. Defaults to infinity - i.e. unbounded. + """ + + def __init__(self, callbacks: OctetStreamCallbacks = {}, max_size: float = float("inf")): + super().__init__() + self.callbacks = callbacks + self._started = False + + if not isinstance(max_size, Number) or max_size < 1: + raise ValueError("max_size must be a positive number, not %r" % max_size) + self.max_size: int | float = max_size + self._current_size = 0 + + def write(self, data: bytes) -> int: + """Write some data to the parser, which will perform size verification, + and then pass the data to the underlying callback. + + Args: + data: The data to write to the parser. + + Returns: + The number of bytes written. + """ + if not self._started: + self.callback("start") + self._started = True + + # Truncate data length. + data_len = len(data) + if (self._current_size + data_len) > self.max_size: + # We truncate the length of data that we are to process. + new_size = int(self.max_size - self._current_size) + self.logger.warning( + "Current size is %d (max %d), so truncating data length from %d to %d", + self._current_size, + self.max_size, + data_len, + new_size, + ) + data_len = new_size + + # Increment size, then callback, in case there's an exception. + self._current_size += data_len + self.callback("data", data, 0, data_len) + return data_len + + def finalize(self) -> None: + """Finalize this parser, which signals to that we are finished parsing, + and sends the on_end callback. + """ + self.callback("end") + + def __repr__(self) -> str: + return "%s()" % self.__class__.__name__ + + +class QuerystringParser(BaseParser): + """This is a streaming querystring parser. It will consume data, and call + the callbacks given when it has data. + + | Callback Name | Parameters | Description | + |----------------|-----------------|-----------------------------------------------------| + | on_field_start | None | Called when a new field is encountered. | + | on_field_name | data, start, end| Called when a portion of a field's name is encountered. | + | on_field_data | data, start, end| Called when a portion of a field's data is encountered. | + | on_field_end | None | Called when the end of a field is encountered. | + | on_end | None | Called when the parser is finished parsing all data.| + + Args: + callbacks: A dictionary of callbacks. See the documentation for [`BaseParser`][python_multipart.BaseParser]. + strict_parsing: Whether or not to parse the body strictly. Defaults to False. If this is set to True, then the + behavior of the parser changes as the following: if a field has a value with an equal sign + (e.g. "foo=bar", or "foo="), it is always included. If a field has no equals sign (e.g. "...&name&..."), + it will be treated as an error if 'strict_parsing' is True, otherwise included. If an error is encountered, + then a [`QuerystringParseError`][python_multipart.exceptions.QuerystringParseError] will be raised. + max_size: The maximum size of body to parse. Defaults to infinity - i.e. unbounded. + """ # noqa: E501 + + state: QuerystringState + + def __init__( + self, callbacks: QuerystringCallbacks = {}, strict_parsing: bool = False, max_size: float = float("inf") + ) -> None: + super().__init__() + self.state = QuerystringState.BEFORE_FIELD + self._found_sep = False + + self.callbacks = callbacks + + # Max-size stuff + if not isinstance(max_size, Number) or max_size < 1: + raise ValueError("max_size must be a positive number, not %r" % max_size) + self.max_size: int | float = max_size + self._current_size = 0 + + # Should parsing be strict? + self.strict_parsing = strict_parsing + + def write(self, data: bytes) -> int: + """Write some data to the parser, which will perform size verification, + parse into either a field name or value, and then pass the + corresponding data to the underlying callback. If an error is + encountered while parsing, a QuerystringParseError will be raised. The + "offset" attribute of the raised exception will be set to the offset in + the input data chunk (NOT the overall stream) that caused the error. + + Args: + data: The data to write to the parser. + + Returns: + The number of bytes written. + """ + # Handle sizing. + data_len = len(data) + if (self._current_size + data_len) > self.max_size: + # We truncate the length of data that we are to process. + new_size = int(self.max_size - self._current_size) + self.logger.warning( + "Current size is %d (max %d), so truncating data length from %d to %d", + self._current_size, + self.max_size, + data_len, + new_size, + ) + data_len = new_size + + l = 0 + try: + l = self._internal_write(data, data_len) + finally: + self._current_size += l + + return l + + def _internal_write(self, data: bytes, length: int) -> int: + state = self.state + strict_parsing = self.strict_parsing + found_sep = self._found_sep + + i = 0 + while i < length: + ch = data[i] + + # Depending on our state... + if state == QuerystringState.BEFORE_FIELD: + # If the 'found_sep' flag is set, we've already encountered + # and skipped a single separator. If so, we check our strict + # parsing flag and decide what to do. Otherwise, we haven't + # yet reached a separator, and thus, if we do, we need to skip + # it as it will be the boundary between fields that's supposed + # to be there. + if ch == AMPERSAND or ch == SEMICOLON: + if found_sep: + # If we're parsing strictly, we disallow blank chunks. + if strict_parsing: + e = QuerystringParseError("Skipping duplicate ampersand/semicolon at %d" % i) + e.offset = i + raise e + else: + self.logger.debug("Skipping duplicate ampersand/semicolon at %d", i) + else: + # This case is when we're skipping the (first) + # separator between fields, so we just set our flag + # and continue on. + found_sep = True + else: + # Emit a field-start event, and go to that state. Also, + # reset the "found_sep" flag, for the next time we get to + # this state. + self.callback("field_start") + i -= 1 + state = QuerystringState.FIELD_NAME + found_sep = False + + elif state == QuerystringState.FIELD_NAME: + # Try and find a separator - we ensure that, if we do, we only + # look for the equal sign before it. + sep_pos = data.find(b"&", i) + if sep_pos == -1: + sep_pos = data.find(b";", i) + + # See if we can find an equals sign in the remaining data. If + # so, we can immediately emit the field name and jump to the + # data state. + if sep_pos != -1: + equals_pos = data.find(b"=", i, sep_pos) + else: + equals_pos = data.find(b"=", i) + + if equals_pos != -1: + # Emit this name. + self.callback("field_name", data, i, equals_pos) + + # Jump i to this position. Note that it will then have 1 + # added to it below, which means the next iteration of this + # loop will inspect the character after the equals sign. + i = equals_pos + state = QuerystringState.FIELD_DATA + else: + # No equals sign found. + if not strict_parsing: + # See also comments in the QuerystringState.FIELD_DATA case below. + # If we found the separator, we emit the name and just + # end - there's no data callback at all (not even with + # a blank value). + if sep_pos != -1: + self.callback("field_name", data, i, sep_pos) + self.callback("field_end") + + i = sep_pos - 1 + state = QuerystringState.BEFORE_FIELD + else: + # Otherwise, no separator in this block, so the + # rest of this chunk must be a name. + self.callback("field_name", data, i, length) + i = length + + else: + # We're parsing strictly. If we find a separator, + # this is an error - we require an equals sign. + if sep_pos != -1: + e = QuerystringParseError( + "When strict_parsing is True, we require an " + "equals sign in all field chunks. Did not " + "find one in the chunk that starts at %d" % (i,) + ) + e.offset = i + raise e + + # No separator in the rest of this chunk, so it's just + # a field name. + self.callback("field_name", data, i, length) + i = length + + elif state == QuerystringState.FIELD_DATA: + # Try finding either an ampersand or a semicolon after this + # position. + sep_pos = data.find(b"&", i) + if sep_pos == -1: + sep_pos = data.find(b";", i) + + # If we found it, callback this bit as data and then go back + # to expecting to find a field. + if sep_pos != -1: + self.callback("field_data", data, i, sep_pos) + self.callback("field_end") + + # Note that we go to the separator, which brings us to the + # "before field" state. This allows us to properly emit + # "field_start" events only when we actually have data for + # a field of some sort. + i = sep_pos - 1 + state = QuerystringState.BEFORE_FIELD + + # Otherwise, emit the rest as data and finish. + else: + self.callback("field_data", data, i, length) + i = length + + else: # pragma: no cover (error case) + msg = "Reached an unknown state %d at %d" % (state, i) + self.logger.warning(msg) + e = QuerystringParseError(msg) + e.offset = i + raise e + + i += 1 + + self.state = state + self._found_sep = found_sep + return len(data) + + def finalize(self) -> None: + """Finalize this parser, which signals to that we are finished parsing, + if we're still in the middle of a field, an on_field_end callback, and + then the on_end callback. + """ + # If we're currently in the middle of a field, we finish it. + if self.state == QuerystringState.FIELD_DATA: + self.callback("field_end") + self.callback("end") + + def __repr__(self) -> str: + return "{}(strict_parsing={!r}, max_size={!r})".format( + self.__class__.__name__, self.strict_parsing, self.max_size + ) + + +class MultipartParser(BaseParser): + """This class is a streaming multipart/form-data parser. + + | Callback Name | Parameters | Description | + |--------------------|-----------------|-------------| + | on_part_begin | None | Called when a new part of the multipart message is encountered. | + | on_part_data | data, start, end| Called when a portion of a part's data is encountered. | + | on_part_end | None | Called when the end of a part is reached. | + | on_header_begin | None | Called when we've found a new header in a part of a multipart message | + | on_header_field | data, start, end| Called each time an additional portion of a header is read (i.e. the part of the header that is before the colon; the "Foo" in "Foo: Bar"). | + | on_header_value | data, start, end| Called when we get data for a header. | + | on_header_end | None | Called when the current header is finished - i.e. we've reached the newline at the end of the header. | + | on_headers_finished| None | Called when all headers are finished, and before the part data starts. | + | on_end | None | Called when the parser is finished parsing all data. | + + Args: + boundary: The multipart boundary. This is required, and must match what is given in the HTTP request - usually in the Content-Type header. + callbacks: A dictionary of callbacks. See the documentation for [`BaseParser`][python_multipart.BaseParser]. + max_size: The maximum size of body to parse. Defaults to infinity - i.e. unbounded. + """ # noqa: E501 + + def __init__( + self, boundary: bytes | str, callbacks: MultipartCallbacks = {}, max_size: float = float("inf") + ) -> None: + # Initialize parser state. + super().__init__() + self.state = MultipartState.START + self.index = self.flags = 0 + + self.callbacks = callbacks + + if not isinstance(max_size, Number) or max_size < 1: + raise ValueError("max_size must be a positive number, not %r" % max_size) + self.max_size = max_size + self._current_size = 0 + + # Setup marks. These are used to track the state of data received. + self.marks: dict[str, int] = {} + + # Save our boundary. + if isinstance(boundary, str): # pragma: no cover + boundary = boundary.encode("latin-1") + self.boundary = b"\r\n--" + boundary + + def write(self, data: bytes) -> int: + """Write some data to the parser, which will perform size verification, + and then parse the data into the appropriate location (e.g. header, + data, etc.), and pass this on to the underlying callback. If an error + is encountered, a MultipartParseError will be raised. The "offset" + attribute on the raised exception will be set to the offset of the byte + in the input chunk that caused the error. + + Args: + data: The data to write to the parser. + + Returns: + The number of bytes written. + """ + # Handle sizing. + data_len = len(data) + if (self._current_size + data_len) > self.max_size: + # We truncate the length of data that we are to process. + new_size = int(self.max_size - self._current_size) + self.logger.warning( + "Current size is %d (max %d), so truncating data length from %d to %d", + self._current_size, + self.max_size, + data_len, + new_size, + ) + data_len = new_size + + l = 0 + try: + l = self._internal_write(data, data_len) + finally: + self._current_size += l + + return l + + def _internal_write(self, data: bytes, length: int) -> int: + # Get values from locals. + boundary = self.boundary + + # Get our state, flags and index. These are persisted between calls to + # this function. + state = self.state + index = self.index + flags = self.flags + + # Our index defaults to 0. + i = 0 + + # Set a mark. + def set_mark(name: str) -> None: + self.marks[name] = i + + # Remove a mark. + def delete_mark(name: str, reset: bool = False) -> None: + self.marks.pop(name, None) + + # Helper function that makes calling a callback with data easier. The + # 'remaining' parameter will callback from the marked value until the + # end of the buffer, and reset the mark, instead of deleting it. This + # is used at the end of the function to call our callbacks with any + # remaining data in this chunk. + def data_callback(name: CallbackName, end_i: int, remaining: bool = False) -> None: + marked_index = self.marks.get(name) + if marked_index is None: + return + + # Otherwise, we call it from the mark to the current byte we're + # processing. + if end_i <= marked_index: + # There is no additional data to send. + pass + elif marked_index >= 0: + # We are emitting data from the local buffer. + self.callback(name, data, marked_index, end_i) + else: + # Some of the data comes from a partial boundary match. + # and requires look-behind. + # We need to use self.flags (and not flags) because we care about + # the state when we entered the loop. + lookbehind_len = -marked_index + if lookbehind_len <= len(boundary): + self.callback(name, boundary, 0, lookbehind_len) + elif self.flags & FLAG_PART_BOUNDARY: + lookback = boundary + b"\r\n" + self.callback(name, lookback, 0, lookbehind_len) + elif self.flags & FLAG_LAST_BOUNDARY: + lookback = boundary + b"--\r\n" + self.callback(name, lookback, 0, lookbehind_len) + else: # pragma: no cover (error case) + self.logger.warning("Look-back buffer error") + + if end_i > 0: + self.callback(name, data, 0, end_i) + # If we're getting remaining data, we have got all the data we + # can be certain is not a boundary, leaving only a partial boundary match. + if remaining: + self.marks[name] = end_i - length + else: + self.marks.pop(name, None) + + # For each byte... + while i < length: + c = data[i] + + if state == MultipartState.START: + # Skip leading newlines + if c == CR or c == LF: + i += 1 + continue + + # index is used as in index into our boundary. Set to 0. + index = 0 + + # Move to the next state, but decrement i so that we re-process + # this character. + state = MultipartState.START_BOUNDARY + i -= 1 + + elif state == MultipartState.START_BOUNDARY: + # Check to ensure that the last 2 characters in our boundary + # are CRLF. + if index == len(boundary) - 2: + if c == HYPHEN: + # Potential empty message. + state = MultipartState.END_BOUNDARY + elif c != CR: + # Error! + msg = "Did not find CR at end of boundary (%d)" % (i,) + self.logger.warning(msg) + e = MultipartParseError(msg) + e.offset = i + raise e + + index += 1 + + elif index == len(boundary) - 2 + 1: + if c != LF: + msg = "Did not find LF at end of boundary (%d)" % (i,) + self.logger.warning(msg) + e = MultipartParseError(msg) + e.offset = i + raise e + + # The index is now used for indexing into our boundary. + index = 0 + + # Callback for the start of a part. + self.callback("part_begin") + + # Move to the next character and state. + state = MultipartState.HEADER_FIELD_START + + else: + # Check to ensure our boundary matches + if c != boundary[index + 2]: + msg = "Expected boundary character %r, got %r at index %d" % (boundary[index + 2], c, index + 2) + self.logger.warning(msg) + e = MultipartParseError(msg) + e.offset = i + raise e + + # Increment index into boundary and continue. + index += 1 + + elif state == MultipartState.HEADER_FIELD_START: + # Mark the start of a header field here, reset the index, and + # continue parsing our header field. + index = 0 + + # Set a mark of our header field. + set_mark("header_field") + + # Notify that we're starting a header if the next character is + # not a CR; a CR at the beginning of the header will cause us + # to stop parsing headers in the MultipartState.HEADER_FIELD state, + # below. + if c != CR: + self.callback("header_begin") + + # Move to parsing header fields. + state = MultipartState.HEADER_FIELD + i -= 1 + + elif state == MultipartState.HEADER_FIELD: + # If we've reached a CR at the beginning of a header, it means + # that we've reached the second of 2 newlines, and so there are + # no more headers to parse. + if c == CR and index == 0: + delete_mark("header_field") + state = MultipartState.HEADERS_ALMOST_DONE + i += 1 + continue + + # Increment our index in the header. + index += 1 + + # If we've reached a colon, we're done with this header. + if c == COLON: + # A 0-length header is an error. + if index == 1: + msg = "Found 0-length header at %d" % (i,) + self.logger.warning(msg) + e = MultipartParseError(msg) + e.offset = i + raise e + + # Call our callback with the header field. + data_callback("header_field", i) + + # Move to parsing the header value. + state = MultipartState.HEADER_VALUE_START + + elif c not in TOKEN_CHARS_SET: + msg = "Found invalid character %r in header at %d" % (c, i) + self.logger.warning(msg) + e = MultipartParseError(msg) + e.offset = i + raise e + + elif state == MultipartState.HEADER_VALUE_START: + # Skip leading spaces. + if c == SPACE: + i += 1 + continue + + # Mark the start of the header value. + set_mark("header_value") + + # Move to the header-value state, reprocessing this character. + state = MultipartState.HEADER_VALUE + i -= 1 + + elif state == MultipartState.HEADER_VALUE: + # If we've got a CR, we're nearly done our headers. Otherwise, + # we do nothing and just move past this character. + if c == CR: + data_callback("header_value", i) + self.callback("header_end") + state = MultipartState.HEADER_VALUE_ALMOST_DONE + + elif state == MultipartState.HEADER_VALUE_ALMOST_DONE: + # The last character should be a LF. If not, it's an error. + if c != LF: + msg = "Did not find LF character at end of header " "(found %r)" % (c,) + self.logger.warning(msg) + e = MultipartParseError(msg) + e.offset = i + raise e + + # Move back to the start of another header. Note that if that + # state detects ANOTHER newline, it'll trigger the end of our + # headers. + state = MultipartState.HEADER_FIELD_START + + elif state == MultipartState.HEADERS_ALMOST_DONE: + # We're almost done our headers. This is reached when we parse + # a CR at the beginning of a header, so our next character + # should be a LF, or it's an error. + if c != LF: + msg = f"Did not find LF at end of headers (found {c!r})" + self.logger.warning(msg) + e = MultipartParseError(msg) + e.offset = i + raise e + + self.callback("headers_finished") + state = MultipartState.PART_DATA_START + + elif state == MultipartState.PART_DATA_START: + # Mark the start of our part data. + set_mark("part_data") + + # Start processing part data, including this character. + state = MultipartState.PART_DATA + i -= 1 + + elif state == MultipartState.PART_DATA: + # We're processing our part data right now. During this, we + # need to efficiently search for our boundary, since any data + # on any number of lines can be a part of the current data. + + # Save the current value of our index. We use this in case we + # find part of a boundary, but it doesn't match fully. + prev_index = index + + # Set up variables. + boundary_length = len(boundary) + data_length = length + + # If our index is 0, we're starting a new part, so start our + # search. + if index == 0: + # The most common case is likely to be that the whole + # boundary is present in the buffer. + # Calling `find` is much faster than iterating here. + i0 = data.find(boundary, i, data_length) + if i0 >= 0: + # We matched the whole boundary string. + index = boundary_length - 1 + i = i0 + boundary_length - 1 + else: + # No match found for whole string. + # There may be a partial boundary at the end of the + # data, which the find will not match. + # Since the length should to be searched is limited to + # the boundary length, just perform a naive search. + i = max(i, data_length - boundary_length) + + # Search forward until we either hit the end of our buffer, + # or reach a potential start of the boundary. + while i < data_length - 1 and data[i] != boundary[0]: + i += 1 + + c = data[i] + + # Now, we have a couple of cases here. If our index is before + # the end of the boundary... + if index < boundary_length: + # If the character matches... + if boundary[index] == c: + # The current character matches, so continue! + index += 1 + else: + index = 0 + + # Our index is equal to the length of our boundary! + elif index == boundary_length: + # First we increment it. + index += 1 + + # Now, if we've reached a newline, we need to set this as + # the potential end of our boundary. + if c == CR: + flags |= FLAG_PART_BOUNDARY + + # Otherwise, if this is a hyphen, we might be at the last + # of all boundaries. + elif c == HYPHEN: + flags |= FLAG_LAST_BOUNDARY + + # Otherwise, we reset our index, since this isn't either a + # newline or a hyphen. + else: + index = 0 + + # Our index is right after the part boundary, which should be + # a LF. + elif index == boundary_length + 1: + # If we're at a part boundary (i.e. we've seen a CR + # character already)... + if flags & FLAG_PART_BOUNDARY: + # We need a LF character next. + if c == LF: + # Unset the part boundary flag. + flags &= ~FLAG_PART_BOUNDARY + + # We have identified a boundary, callback for any data before it. + data_callback("part_data", i - index) + # Callback indicating that we've reached the end of + # a part, and are starting a new one. + self.callback("part_end") + self.callback("part_begin") + + # Move to parsing new headers. + index = 0 + state = MultipartState.HEADER_FIELD_START + i += 1 + continue + + # We didn't find an LF character, so no match. Reset + # our index and clear our flag. + index = 0 + flags &= ~FLAG_PART_BOUNDARY + + # Otherwise, if we're at the last boundary (i.e. we've + # seen a hyphen already)... + elif flags & FLAG_LAST_BOUNDARY: + # We need a second hyphen here. + if c == HYPHEN: + # We have identified a boundary, callback for any data before it. + data_callback("part_data", i - index) + # Callback to end the current part, and then the + # message. + self.callback("part_end") + self.callback("end") + state = MultipartState.END + else: + # No match, so reset index. + index = 0 + + # Otherwise, our index is 0. If the previous index is not, it + # means we reset something, and we need to take the data we + # thought was part of our boundary and send it along as actual + # data. + if index == 0 and prev_index > 0: + # Overwrite our previous index. + prev_index = 0 + + # Re-consider the current character, since this could be + # the start of the boundary itself. + i -= 1 + + elif state == MultipartState.END_BOUNDARY: + if index == len(boundary) - 2 + 1: + if c != HYPHEN: + msg = "Did not find - at end of boundary (%d)" % (i,) + self.logger.warning(msg) + e = MultipartParseError(msg) + e.offset = i + raise e + index += 1 + self.callback("end") + state = MultipartState.END + + elif state == MultipartState.END: + # Don't do anything if chunk ends with CRLF. + if c == CR and i + 1 < length and data[i + 1] == LF: + i += 2 + continue + # Skip data after the last boundary. + self.logger.warning("Skipping data after last boundary") + i = length + break + + else: # pragma: no cover (error case) + # We got into a strange state somehow! Just stop processing. + msg = "Reached an unknown state %d at %d" % (state, i) + self.logger.warning(msg) + e = MultipartParseError(msg) + e.offset = i + raise e + + # Move to the next byte. + i += 1 + + # We call our callbacks with any remaining data. Note that we pass + # the 'remaining' flag, which sets the mark back to 0 instead of + # deleting it, if it's found. This is because, if the mark is found + # at this point, we assume that there's data for one of these things + # that has been parsed, but not yet emitted. And, as such, it implies + # that we haven't yet reached the end of this 'thing'. So, by setting + # the mark to 0, we cause any data callbacks that take place in future + # calls to this function to start from the beginning of that buffer. + data_callback("header_field", length, True) + data_callback("header_value", length, True) + data_callback("part_data", length - index, True) + + # Save values to locals. + self.state = state + self.index = index + self.flags = flags + + # Return our data length to indicate no errors, and that we processed + # all of it. + return length + + def finalize(self) -> None: + """Finalize this parser, which signals to that we are finished parsing. + + Note: It does not currently, but in the future, it will verify that we + are in the final state of the parser (i.e. the end of the multipart + message is well-formed), and, if not, throw an error. + """ + # TODO: verify that we're in the state MultipartState.END, otherwise throw an + # error or otherwise state that we're not finished parsing. + pass + + def __repr__(self) -> str: + return f"{self.__class__.__name__}(boundary={self.boundary!r})" + + +class FormParser: + """This class is the all-in-one form parser. Given all the information + necessary to parse a form, it will instantiate the correct parser, create + the proper :class:`Field` and :class:`File` classes to store the data that + is parsed, and call the two given callbacks with each field and file as + they become available. + + Args: + content_type: The Content-Type of the incoming request. This is used to select the appropriate parser. + on_field: The callback to call when a field has been parsed and is ready for usage. See above for parameters. + on_file: The callback to call when a file has been parsed and is ready for usage. See above for parameters. + on_end: An optional callback to call when all fields and files in a request has been parsed. Can be None. + boundary: If the request is a multipart/form-data request, this should be the boundary of the request, as given + in the Content-Type header, as a bytestring. + file_name: If the request is of type application/octet-stream, then the body of the request will not contain any + information about the uploaded file. In such cases, you can provide the file name of the uploaded file + manually. + FileClass: The class to use for uploaded files. Defaults to :class:`File`, but you can provide your own class + if you wish to customize behaviour. The class will be instantiated as FileClass(file_name, field_name), and + it must provide the following functions:: + - file_instance.write(data) + - file_instance.finalize() + - file_instance.close() + FieldClass: The class to use for uploaded fields. Defaults to :class:`Field`, but you can provide your own + class if you wish to customize behaviour. The class will be instantiated as FieldClass(field_name), and it + must provide the following functions:: + - field_instance.write(data) + - field_instance.finalize() + - field_instance.close() + - field_instance.set_none() + config: Configuration to use for this FormParser. The default values are taken from the DEFAULT_CONFIG value, + and then any keys present in this dictionary will overwrite the default values. + """ + + #: This is the default configuration for our form parser. + #: Note: all file sizes should be in bytes. + DEFAULT_CONFIG: FormParserConfig = { + "MAX_BODY_SIZE": float("inf"), + "MAX_MEMORY_FILE_SIZE": 1 * 1024 * 1024, + "UPLOAD_DIR": None, + "UPLOAD_KEEP_FILENAME": False, + "UPLOAD_KEEP_EXTENSIONS": False, + # Error on invalid Content-Transfer-Encoding? + "UPLOAD_ERROR_ON_BAD_CTE": False, + } + + def __init__( + self, + content_type: str, + on_field: OnFieldCallback | None, + on_file: OnFileCallback | None, + on_end: Callable[[], None] | None = None, + boundary: bytes | str | None = None, + file_name: bytes | None = None, + FileClass: type[FileProtocol] = File, + FieldClass: type[FieldProtocol] = Field, + config: dict[Any, Any] = {}, + ) -> None: + self.logger = logging.getLogger(__name__) + + # Save variables. + self.content_type = content_type + self.boundary = boundary + self.bytes_received = 0 + self.parser = None + + # Save callbacks. + self.on_field = on_field + self.on_file = on_file + self.on_end = on_end + + # Save classes. + self.FileClass = File + self.FieldClass = Field + + # Set configuration options. + self.config: FormParserConfig = self.DEFAULT_CONFIG.copy() + self.config.update(config) # type: ignore[typeddict-item] + + parser: OctetStreamParser | MultipartParser | QuerystringParser | None = None + + # Depending on the Content-Type, we instantiate the correct parser. + if content_type == "application/octet-stream": + file: FileProtocol = None # type: ignore + + def on_start() -> None: + nonlocal file + file = FileClass(file_name, None, config=cast("FileConfig", self.config)) + + def on_data(data: bytes, start: int, end: int) -> None: + nonlocal file + file.write(data[start:end]) + + def _on_end() -> None: + nonlocal file + # Finalize the file itself. + file.finalize() + + # Call our callback. + if on_file: + on_file(file) + + # Call the on-end callback. + if self.on_end is not None: + self.on_end() + + # Instantiate an octet-stream parser + parser = OctetStreamParser( + callbacks={"on_start": on_start, "on_data": on_data, "on_end": _on_end}, + max_size=self.config["MAX_BODY_SIZE"], + ) + + elif content_type == "application/x-www-form-urlencoded" or content_type == "application/x-url-encoded": + name_buffer: list[bytes] = [] + + f: FieldProtocol | None = None + + def on_field_start() -> None: + pass + + def on_field_name(data: bytes, start: int, end: int) -> None: + name_buffer.append(data[start:end]) + + def on_field_data(data: bytes, start: int, end: int) -> None: + nonlocal f + if f is None: + f = FieldClass(b"".join(name_buffer)) + del name_buffer[:] + f.write(data[start:end]) + + def on_field_end() -> None: + nonlocal f + # Finalize and call callback. + if f is None: + # If we get here, it's because there was no field data. + # We create a field, set it to None, and then continue. + f = FieldClass(b"".join(name_buffer)) + del name_buffer[:] + f.set_none() + + f.finalize() + if on_field: + on_field(f) + f = None + + def _on_end() -> None: + if self.on_end is not None: + self.on_end() + + # Instantiate parser. + parser = QuerystringParser( + callbacks={ + "on_field_start": on_field_start, + "on_field_name": on_field_name, + "on_field_data": on_field_data, + "on_field_end": on_field_end, + "on_end": _on_end, + }, + max_size=self.config["MAX_BODY_SIZE"], + ) + + elif content_type == "multipart/form-data": + if boundary is None: + self.logger.error("No boundary given") + raise FormParserError("No boundary given") + + header_name: list[bytes] = [] + header_value: list[bytes] = [] + headers: dict[bytes, bytes] = {} + + f_multi: FileProtocol | FieldProtocol | None = None + writer = None + is_file = False + + def on_part_begin() -> None: + # Reset headers in case this isn't the first part. + nonlocal headers + headers = {} + + def on_part_data(data: bytes, start: int, end: int) -> None: + nonlocal writer + assert writer is not None + writer.write(data[start:end]) + # TODO: check for error here. + + def on_part_end() -> None: + nonlocal f_multi, is_file + assert f_multi is not None + f_multi.finalize() + if is_file: + if on_file: + on_file(f_multi) + else: + if on_field: + on_field(cast("FieldProtocol", f_multi)) + + def on_header_field(data: bytes, start: int, end: int) -> None: + header_name.append(data[start:end]) + + def on_header_value(data: bytes, start: int, end: int) -> None: + header_value.append(data[start:end]) + + def on_header_end() -> None: + headers[b"".join(header_name)] = b"".join(header_value) + del header_name[:] + del header_value[:] + + def on_headers_finished() -> None: + nonlocal is_file, f_multi, writer + # Reset the 'is file' flag. + is_file = False + + # Parse the content-disposition header. + # TODO: handle mixed case + content_disp = headers.get(b"Content-Disposition") + disp, options = parse_options_header(content_disp) + + # Get the field and filename. + field_name = options.get(b"name") + file_name = options.get(b"filename") + # TODO: check for errors + + # Create the proper class. + if file_name is None: + f_multi = FieldClass(field_name) + else: + f_multi = FileClass(file_name, field_name, config=cast("FileConfig", self.config)) + is_file = True + + # Parse the given Content-Transfer-Encoding to determine what + # we need to do with the incoming data. + # TODO: check that we properly handle 8bit / 7bit encoding. + transfer_encoding = headers.get(b"Content-Transfer-Encoding", b"7bit") + + if transfer_encoding in (b"binary", b"8bit", b"7bit"): + writer = f_multi + + elif transfer_encoding == b"base64": + writer = Base64Decoder(f_multi) + + elif transfer_encoding == b"quoted-printable": + writer = QuotedPrintableDecoder(f_multi) + + else: + self.logger.warning("Unknown Content-Transfer-Encoding: %r", transfer_encoding) + if self.config["UPLOAD_ERROR_ON_BAD_CTE"]: + raise FormParserError('Unknown Content-Transfer-Encoding "{!r}"'.format(transfer_encoding)) + else: + # If we aren't erroring, then we just treat this as an + # unencoded Content-Transfer-Encoding. + writer = f_multi + + def _on_end() -> None: + nonlocal writer + if writer is not None: + writer.finalize() + if self.on_end is not None: + self.on_end() + + # Instantiate a multipart parser. + parser = MultipartParser( + boundary, + callbacks={ + "on_part_begin": on_part_begin, + "on_part_data": on_part_data, + "on_part_end": on_part_end, + "on_header_field": on_header_field, + "on_header_value": on_header_value, + "on_header_end": on_header_end, + "on_headers_finished": on_headers_finished, + "on_end": _on_end, + }, + max_size=self.config["MAX_BODY_SIZE"], + ) + + else: + self.logger.warning("Unknown Content-Type: %r", content_type) + raise FormParserError("Unknown Content-Type: {}".format(content_type)) + + self.parser = parser + + def write(self, data: bytes) -> int: + """Write some data. The parser will forward this to the appropriate + underlying parser. + + Args: + data: The data to write. + + Returns: + The number of bytes processed. + """ + self.bytes_received += len(data) + # TODO: check the parser's return value for errors? + assert self.parser is not None + return self.parser.write(data) + + def finalize(self) -> None: + """Finalize the parser.""" + if self.parser is not None and hasattr(self.parser, "finalize"): + self.parser.finalize() + + def close(self) -> None: + """Close the parser.""" + if self.parser is not None and hasattr(self.parser, "close"): + self.parser.close() + + def __repr__(self) -> str: + return "{}(content_type={!r}, parser={!r})".format(self.__class__.__name__, self.content_type, self.parser) + + +def create_form_parser( + headers: dict[str, bytes], + on_field: OnFieldCallback | None, + on_file: OnFileCallback | None, + trust_x_headers: bool = False, + config: dict[Any, Any] = {}, +) -> FormParser: + """This function is a helper function to aid in creating a FormParser + instances. Given a dictionary-like headers object, it will determine + the correct information needed, instantiate a FormParser with the + appropriate values and given callbacks, and then return the corresponding + parser. + + Args: + headers: A dictionary-like object of HTTP headers. The only required header is Content-Type. + on_field: Callback to call with each parsed field. + on_file: Callback to call with each parsed file. + trust_x_headers: Whether or not to trust information received from certain X-Headers - for example, the file + name from X-File-Name. + config: Configuration variables to pass to the FormParser. + """ + content_type: str | bytes | None = headers.get("Content-Type") + if content_type is None: + logging.getLogger(__name__).warning("No Content-Type header given") + raise ValueError("No Content-Type header given!") + + # Boundaries are optional (the FormParser will raise if one is needed + # but not given). + content_type, params = parse_options_header(content_type) + boundary = params.get(b"boundary") + + # We need content_type to be a string, not a bytes object. + content_type = content_type.decode("latin-1") + + # File names are optional. + file_name = headers.get("X-File-Name") + + # Instantiate a form parser. + form_parser = FormParser(content_type, on_field, on_file, boundary=boundary, file_name=file_name, config=config) + + # Return our parser. + return form_parser + + +def parse_form( + headers: dict[str, bytes], + input_stream: SupportsRead, + on_field: OnFieldCallback | None, + on_file: OnFileCallback | None, + chunk_size: int = 1048576, +) -> None: + """This function is useful if you just want to parse a request body, + without too much work. Pass it a dictionary-like object of the request's + headers, and a file-like object for the input stream, along with two + callbacks that will get called whenever a field or file is parsed. + + Args: + headers: A dictionary-like object of HTTP headers. The only required header is Content-Type. + input_stream: A file-like object that represents the request body. The read() method must return bytestrings. + on_field: Callback to call with each parsed field. + on_file: Callback to call with each parsed file. + chunk_size: The maximum size to read from the input stream and write to the parser at one time. + Defaults to 1 MiB. + """ + # Create our form parser. + parser = create_form_parser(headers, on_field, on_file) + + # Read chunks of 1MiB and write to the parser, but never read more than + # the given Content-Length, if any. + content_length: int | float | bytes | None = headers.get("Content-Length") + if content_length is not None: + content_length = int(content_length) + else: + content_length = float("inf") + bytes_read = 0 + + while True: + # Read only up to the Content-Length given. + max_readable = int(min(content_length - bytes_read, chunk_size)) + buff = input_stream.read(max_readable) + + # Write to the parser and update our length. + parser.write(buff) + bytes_read += len(buff) + + # If we get a buffer that's smaller than the size requested, or if we + # have read up to our content length, we're done. + if len(buff) != max_readable or bytes_read == content_length: + break + + # Tell our parser that we're done writing data. + parser.finalize() diff --git a/venv/lib/python3.10/site-packages/python_multipart/py.typed b/venv/lib/python3.10/site-packages/python_multipart/py.typed new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/venv/lib/python3.10/site-packages/regex-2025.7.34.dist-info/INSTALLER b/venv/lib/python3.10/site-packages/regex-2025.7.34.dist-info/INSTALLER new file mode 100644 index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68 --- /dev/null +++ b/venv/lib/python3.10/site-packages/regex-2025.7.34.dist-info/INSTALLER @@ -0,0 +1 @@ +pip diff --git a/venv/lib/python3.10/site-packages/regex-2025.7.34.dist-info/METADATA b/venv/lib/python3.10/site-packages/regex-2025.7.34.dist-info/METADATA new file mode 100644 index 0000000000000000000000000000000000000000..eb482e0d2fbbe88bad107d65dfd54ee306feb9e8 --- /dev/null +++ b/venv/lib/python3.10/site-packages/regex-2025.7.34.dist-info/METADATA @@ -0,0 +1,1059 @@ +Metadata-Version: 2.4 +Name: regex +Version: 2025.7.34 +Summary: Alternative regular expression module, to replace re. +Author-email: Matthew Barnett +License-Expression: Apache-2.0 AND CNRI-Python +Project-URL: Homepage, https://github.com/mrabarnett/mrab-regex +Classifier: Development Status :: 5 - Production/Stable +Classifier: Intended Audience :: Developers +Classifier: Operating System :: OS Independent +Classifier: Programming Language :: Python :: 3.9 +Classifier: Programming Language :: Python :: 3.10 +Classifier: Programming Language :: Python :: 3.11 +Classifier: Programming Language :: Python :: 3.12 +Classifier: Programming Language :: Python :: 3.13 +Classifier: Programming Language :: Python :: 3.14 +Classifier: Topic :: Scientific/Engineering :: Information Analysis +Classifier: Topic :: Software Development :: Libraries :: Python Modules +Classifier: Topic :: Text Processing +Classifier: Topic :: Text Processing :: General +Requires-Python: >=3.9 +Description-Content-Type: text/x-rst +License-File: LICENSE.txt +Dynamic: license-file + +Introduction +------------ + +This regex implementation is backwards-compatible with the standard 're' module, but offers additional functionality. + +Python 2 +-------- + +Python 2 is no longer supported. The last release that supported Python 2 was 2021.11.10. + +PyPy +---- + +This module is targeted at CPython. It expects that all codepoints are the same width, so it won't behave properly with PyPy outside U+0000..U+007F because PyPy stores strings as UTF-8. + +Multithreading +-------------- + +The regex module releases the GIL during matching on instances of the built-in (immutable) string classes, enabling other Python threads to run concurrently. It is also possible to force the regex module to release the GIL during matching by calling the matching methods with the keyword argument ``concurrent=True``. The behaviour is undefined if the string changes during matching, so use it *only* when it is guaranteed that that won't happen. + +Unicode +------- + +This module supports Unicode 16.0.0. Full Unicode case-folding is supported. + +Flags +----- + +There are 2 kinds of flag: scoped and global. Scoped flags can apply to only part of a pattern and can be turned on or off; global flags apply to the entire pattern and can only be turned on. + +The scoped flags are: ``ASCII (?a)``, ``FULLCASE (?f)``, ``IGNORECASE (?i)``, ``LOCALE (?L)``, ``MULTILINE (?m)``, ``DOTALL (?s)``, ``UNICODE (?u)``, ``VERBOSE (?x)``, ``WORD (?w)``. + +The global flags are: ``BESTMATCH (?b)``, ``ENHANCEMATCH (?e)``, ``POSIX (?p)``, ``REVERSE (?r)``, ``VERSION0 (?V0)``, ``VERSION1 (?V1)``. + +If neither the ``ASCII``, ``LOCALE`` nor ``UNICODE`` flag is specified, it will default to ``UNICODE`` if the regex pattern is a Unicode string and ``ASCII`` if it's a bytestring. + +The ``ENHANCEMATCH`` flag makes fuzzy matching attempt to improve the fit of the next match that it finds. + +The ``BESTMATCH`` flag makes fuzzy matching search for the best match instead of the next match. + +Old vs new behaviour +-------------------- + +In order to be compatible with the re module, this module has 2 behaviours: + +* **Version 0** behaviour (old behaviour, compatible with the re module): + + Please note that the re module's behaviour may change over time, and I'll endeavour to match that behaviour in version 0. + + * Indicated by the ``VERSION0`` flag. + + * Zero-width matches are not handled correctly in the re module before Python 3.7. The behaviour in those earlier versions is: + + * ``.split`` won't split a string at a zero-width match. + + * ``.sub`` will advance by one character after a zero-width match. + + * Inline flags apply to the entire pattern, and they can't be turned off. + + * Only simple sets are supported. + + * Case-insensitive matches in Unicode use simple case-folding by default. + +* **Version 1** behaviour (new behaviour, possibly different from the re module): + + * Indicated by the ``VERSION1`` flag. + + * Zero-width matches are handled correctly. + + * Inline flags apply to the end of the group or pattern, and they can be turned off. + + * Nested sets and set operations are supported. + + * Case-insensitive matches in Unicode use full case-folding by default. + +If no version is specified, the regex module will default to ``regex.DEFAULT_VERSION``. + +Case-insensitive matches in Unicode +----------------------------------- + +The regex module supports both simple and full case-folding for case-insensitive matches in Unicode. Use of full case-folding can be turned on using the ``FULLCASE`` flag. Please note that this flag affects how the ``IGNORECASE`` flag works; the ``FULLCASE`` flag itself does not turn on case-insensitive matching. + +Version 0 behaviour: the flag is off by default. + +Version 1 behaviour: the flag is on by default. + +Nested sets and set operations +------------------------------ + +It's not possible to support both simple sets, as used in the re module, and nested sets at the same time because of a difference in the meaning of an unescaped ``"["`` in a set. + +For example, the pattern ``[[a-z]--[aeiou]]`` is treated in the version 0 behaviour (simple sets, compatible with the re module) as: + +* Set containing "[" and the letters "a" to "z" + +* Literal "--" + +* Set containing letters "a", "e", "i", "o", "u" + +* Literal "]" + +but in the version 1 behaviour (nested sets, enhanced behaviour) as: + +* Set which is: + + * Set containing the letters "a" to "z" + +* but excluding: + + * Set containing the letters "a", "e", "i", "o", "u" + +Version 0 behaviour: only simple sets are supported. + +Version 1 behaviour: nested sets and set operations are supported. + +Notes on named groups +--------------------- + +All groups have a group number, starting from 1. + +Groups with the same group name will have the same group number, and groups with a different group name will have a different group number. + +The same name can be used by more than one group, with later captures 'overwriting' earlier captures. All the captures of the group will be available from the ``captures`` method of the match object. + +Group numbers will be reused across different branches of a branch reset, eg. ``(?|(first)|(second))`` has only group 1. If groups have different group names then they will, of course, have different group numbers, eg. ``(?|(?Pfirst)|(?Psecond))`` has group 1 ("foo") and group 2 ("bar"). + +In the regex ``(\s+)(?|(?P[A-Z]+)|(\w+) (?P[0-9]+)`` there are 2 groups: + +* ``(\s+)`` is group 1. + +* ``(?P[A-Z]+)`` is group 2, also called "foo". + +* ``(\w+)`` is group 2 because of the branch reset. + +* ``(?P[0-9]+)`` is group 2 because it's called "foo". + +If you want to prevent ``(\w+)`` from being group 2, you need to name it (different name, different group number). + +Additional features +------------------- + +The issue numbers relate to the Python bug tracker, except where listed otherwise. + +Added ``\p{Horiz_Space}`` and ``\p{Vert_Space}`` (`GitHub issue 477 `_) +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +``\p{Horiz_Space}`` or ``\p{H}`` matches horizontal whitespace and ``\p{Vert_Space}`` or ``\p{V}`` matches vertical whitespace. + +Added support for lookaround in conditional pattern (`Hg issue 163 `_) +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +The test of a conditional pattern can be a lookaround. + +.. sourcecode:: python + + >>> regex.match(r'(?(?=\d)\d+|\w+)', '123abc') + + >>> regex.match(r'(?(?=\d)\d+|\w+)', 'abc123') + + +This is not quite the same as putting a lookaround in the first branch of a pair of alternatives. + +.. sourcecode:: python + + >>> print(regex.match(r'(?:(?=\d)\d+\b|\w+)', '123abc')) + + >>> print(regex.match(r'(?(?=\d)\d+\b|\w+)', '123abc')) + None + +In the first example, the lookaround matched, but the remainder of the first branch failed to match, and so the second branch was attempted, whereas in the second example, the lookaround matched, and the first branch failed to match, but the second branch was **not** attempted. + +Added POSIX matching (leftmost longest) (`Hg issue 150 `_) +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +The POSIX standard for regex is to return the leftmost longest match. This can be turned on using the ``POSIX`` flag. + +.. sourcecode:: python + + >>> # Normal matching. + >>> regex.search(r'Mr|Mrs', 'Mrs') + + >>> regex.search(r'one(self)?(selfsufficient)?', 'oneselfsufficient') + + >>> # POSIX matching. + >>> regex.search(r'(?p)Mr|Mrs', 'Mrs') + + >>> regex.search(r'(?p)one(self)?(selfsufficient)?', 'oneselfsufficient') + + +Note that it will take longer to find matches because when it finds a match at a certain position, it won't return that immediately, but will keep looking to see if there's another longer match there. + +Added ``(?(DEFINE)...)`` (`Hg issue 152 `_) +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +If there's no group called "DEFINE", then ... will be ignored except that any groups defined within it can be called and that the normal rules for numbering groups still apply. + +.. sourcecode:: python + + >>> regex.search(r'(?(DEFINE)(?P\d+)(?P\w+))(?&quant) (?&item)', '5 elephants') + + +Added ``(*PRUNE)``, ``(*SKIP)`` and ``(*FAIL)`` (`Hg issue 153 `_) +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +``(*PRUNE)`` discards the backtracking info up to that point. When used in an atomic group or a lookaround, it won't affect the enclosing pattern. + +``(*SKIP)`` is similar to ``(*PRUNE)``, except that it also sets where in the text the next attempt to match will start. When used in an atomic group or a lookaround, it won't affect the enclosing pattern. + +``(*FAIL)`` causes immediate backtracking. ``(*F)`` is a permitted abbreviation. + +Added ``\K`` (`Hg issue 151 `_) +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +Keeps the part of the entire match after the position where ``\K`` occurred; the part before it is discarded. + +It does not affect what groups return. + +.. sourcecode:: python + + >>> m = regex.search(r'(\w\w\K\w\w\w)', 'abcdef') + >>> m[0] + 'cde' + >>> m[1] + 'abcde' + >>> + >>> m = regex.search(r'(?r)(\w\w\K\w\w\w)', 'abcdef') + >>> m[0] + 'bc' + >>> m[1] + 'bcdef' + +Added capture subscripting for ``expandf`` and ``subf``/``subfn`` (`Hg issue 133 `_) +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +You can use subscripting to get the captures of a repeated group. + +.. sourcecode:: python + + >>> m = regex.match(r"(\w)+", "abc") + >>> m.expandf("{1}") + 'c' + >>> m.expandf("{1[0]} {1[1]} {1[2]}") + 'a b c' + >>> m.expandf("{1[-1]} {1[-2]} {1[-3]}") + 'c b a' + >>> + >>> m = regex.match(r"(?P\w)+", "abc") + >>> m.expandf("{letter}") + 'c' + >>> m.expandf("{letter[0]} {letter[1]} {letter[2]}") + 'a b c' + >>> m.expandf("{letter[-1]} {letter[-2]} {letter[-3]}") + 'c b a' + +Added support for referring to a group by number using ``(?P=...)`` +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +This is in addition to the existing ``\g<...>``. + +Fixed the handling of locale-sensitive regexes +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +The ``LOCALE`` flag is intended for legacy code and has limited support. You're still recommended to use Unicode instead. + +Added partial matches (`Hg issue 102 `_) +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +A partial match is one that matches up to the end of string, but that string has been truncated and you want to know whether a complete match could be possible if the string had not been truncated. + +Partial matches are supported by ``match``, ``search``, ``fullmatch`` and ``finditer`` with the ``partial`` keyword argument. + +Match objects have a ``partial`` attribute, which is ``True`` if it's a partial match. + +For example, if you wanted a user to enter a 4-digit number and check it character by character as it was being entered: + +.. sourcecode:: python + + >>> pattern = regex.compile(r'\d{4}') + + >>> # Initially, nothing has been entered: + >>> print(pattern.fullmatch('', partial=True)) + + + >>> # An empty string is OK, but it's only a partial match. + >>> # The user enters a letter: + >>> print(pattern.fullmatch('a', partial=True)) + None + >>> # It'll never match. + + >>> # The user deletes that and enters a digit: + >>> print(pattern.fullmatch('1', partial=True)) + + >>> # It matches this far, but it's only a partial match. + + >>> # The user enters 2 more digits: + >>> print(pattern.fullmatch('123', partial=True)) + + >>> # It matches this far, but it's only a partial match. + + >>> # The user enters another digit: + >>> print(pattern.fullmatch('1234', partial=True)) + + >>> # It's a complete match. + + >>> # If the user enters another digit: + >>> print(pattern.fullmatch('12345', partial=True)) + None + >>> # It's no longer a match. + + >>> # This is a partial match: + >>> pattern.match('123', partial=True).partial + True + + >>> # This is a complete match: + >>> pattern.match('1233', partial=True).partial + False + +``*`` operator not working correctly with sub() (`Hg issue 106 `_) +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +Sometimes it's not clear how zero-width matches should be handled. For example, should ``.*`` match 0 characters directly after matching >0 characters? + +.. sourcecode:: python + + >>> regex.sub('.*', 'x', 'test') + 'xx' + >>> regex.sub('.*?', '|', 'test') + '|||||||||' + +Added ``capturesdict`` (`Hg issue 86 `_) +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +``capturesdict`` is a combination of ``groupdict`` and ``captures``: + +``groupdict`` returns a dict of the named groups and the last capture of those groups. + +``captures`` returns a list of all the captures of a group + +``capturesdict`` returns a dict of the named groups and lists of all the captures of those groups. + +.. sourcecode:: python + + >>> m = regex.match(r"(?:(?P\w+) (?P\d+)\n)+", "one 1\ntwo 2\nthree 3\n") + >>> m.groupdict() + {'word': 'three', 'digits': '3'} + >>> m.captures("word") + ['one', 'two', 'three'] + >>> m.captures("digits") + ['1', '2', '3'] + >>> m.capturesdict() + {'word': ['one', 'two', 'three'], 'digits': ['1', '2', '3']} + +Added ``allcaptures`` and ``allspans`` (`Git issue 474 `_) +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +``allcaptures`` returns a list of all the captures of all the groups. + +``allspans`` returns a list of all the spans of the all captures of all the groups. + +.. sourcecode:: python + + >>> m = regex.match(r"(?:(?P\w+) (?P\d+)\n)+", "one 1\ntwo 2\nthree 3\n") + >>> m.allcaptures() + (['one 1\ntwo 2\nthree 3\n'], ['one', 'two', 'three'], ['1', '2', '3']) + >>> m.allspans() + ([(0, 20)], [(0, 3), (6, 9), (12, 17)], [(4, 5), (10, 11), (18, 19)]) + +Allow duplicate names of groups (`Hg issue 87 `_) +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +Group names can be duplicated. + +.. sourcecode:: python + + >>> # With optional groups: + >>> + >>> # Both groups capture, the second capture 'overwriting' the first. + >>> m = regex.match(r"(?P\w+)? or (?P\w+)?", "first or second") + >>> m.group("item") + 'second' + >>> m.captures("item") + ['first', 'second'] + >>> # Only the second group captures. + >>> m = regex.match(r"(?P\w+)? or (?P\w+)?", " or second") + >>> m.group("item") + 'second' + >>> m.captures("item") + ['second'] + >>> # Only the first group captures. + >>> m = regex.match(r"(?P\w+)? or (?P\w+)?", "first or ") + >>> m.group("item") + 'first' + >>> m.captures("item") + ['first'] + >>> + >>> # With mandatory groups: + >>> + >>> # Both groups capture, the second capture 'overwriting' the first. + >>> m = regex.match(r"(?P\w*) or (?P\w*)?", "first or second") + >>> m.group("item") + 'second' + >>> m.captures("item") + ['first', 'second'] + >>> # Again, both groups capture, the second capture 'overwriting' the first. + >>> m = regex.match(r"(?P\w*) or (?P\w*)", " or second") + >>> m.group("item") + 'second' + >>> m.captures("item") + ['', 'second'] + >>> # And yet again, both groups capture, the second capture 'overwriting' the first. + >>> m = regex.match(r"(?P\w*) or (?P\w*)", "first or ") + >>> m.group("item") + '' + >>> m.captures("item") + ['first', ''] + +Added ``fullmatch`` (`issue #16203 `_) +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +``fullmatch`` behaves like ``match``, except that it must match all of the string. + +.. sourcecode:: python + + >>> print(regex.fullmatch(r"abc", "abc").span()) + (0, 3) + >>> print(regex.fullmatch(r"abc", "abcx")) + None + >>> print(regex.fullmatch(r"abc", "abcx", endpos=3).span()) + (0, 3) + >>> print(regex.fullmatch(r"abc", "xabcy", pos=1, endpos=4).span()) + (1, 4) + >>> + >>> regex.match(r"a.*?", "abcd").group(0) + 'a' + >>> regex.fullmatch(r"a.*?", "abcd").group(0) + 'abcd' + +Added ``subf`` and ``subfn`` +^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +``subf`` and ``subfn`` are alternatives to ``sub`` and ``subn`` respectively. When passed a replacement string, they treat it as a format string. + +.. sourcecode:: python + + >>> regex.subf(r"(\w+) (\w+)", "{0} => {2} {1}", "foo bar") + 'foo bar => bar foo' + >>> regex.subf(r"(?P\w+) (?P\w+)", "{word2} {word1}", "foo bar") + 'bar foo' + +Added ``expandf`` to match object +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +``expandf`` is an alternative to ``expand``. When passed a replacement string, it treats it as a format string. + +.. sourcecode:: python + + >>> m = regex.match(r"(\w+) (\w+)", "foo bar") + >>> m.expandf("{0} => {2} {1}") + 'foo bar => bar foo' + >>> + >>> m = regex.match(r"(?P\w+) (?P\w+)", "foo bar") + >>> m.expandf("{word2} {word1}") + 'bar foo' + +Detach searched string +^^^^^^^^^^^^^^^^^^^^^^ + +A match object contains a reference to the string that was searched, via its ``string`` attribute. The ``detach_string`` method will 'detach' that string, making it available for garbage collection, which might save valuable memory if that string is very large. + +.. sourcecode:: python + + >>> m = regex.search(r"\w+", "Hello world") + >>> print(m.group()) + Hello + >>> print(m.string) + Hello world + >>> m.detach_string() + >>> print(m.group()) + Hello + >>> print(m.string) + None + +Recursive patterns (`Hg issue 27 `_) +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +Recursive and repeated patterns are supported. + +``(?R)`` or ``(?0)`` tries to match the entire regex recursively. ``(?1)``, ``(?2)``, etc, try to match the relevant group. + +``(?&name)`` tries to match the named group. + +.. sourcecode:: python + + >>> regex.match(r"(Tarzan|Jane) loves (?1)", "Tarzan loves Jane").groups() + ('Tarzan',) + >>> regex.match(r"(Tarzan|Jane) loves (?1)", "Jane loves Tarzan").groups() + ('Jane',) + + >>> m = regex.search(r"(\w)(?:(?R)|(\w?))\1", "kayak") + >>> m.group(0, 1, 2) + ('kayak', 'k', None) + +The first two examples show how the subpattern within the group is reused, but is _not_ itself a group. In other words, ``"(Tarzan|Jane) loves (?1)"`` is equivalent to ``"(Tarzan|Jane) loves (?:Tarzan|Jane)"``. + +It's possible to backtrack into a recursed or repeated group. + +You can't call a group if there is more than one group with that group name or group number (``"ambiguous group reference"``). + +The alternative forms ``(?P>name)`` and ``(?P&name)`` are also supported. + +Full Unicode case-folding is supported +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +In version 1 behaviour, the regex module uses full case-folding when performing case-insensitive matches in Unicode. + +.. sourcecode:: python + + >>> regex.match(r"(?iV1)strasse", "stra\N{LATIN SMALL LETTER SHARP S}e").span() + (0, 6) + >>> regex.match(r"(?iV1)stra\N{LATIN SMALL LETTER SHARP S}e", "STRASSE").span() + (0, 7) + +In version 0 behaviour, it uses simple case-folding for backward compatibility with the re module. + +Approximate "fuzzy" matching (`Hg issue 12 `_, `Hg issue 41 `_, `Hg issue 109 `_) +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +Regex usually attempts an exact match, but sometimes an approximate, or "fuzzy", match is needed, for those cases where the text being searched may contain errors in the form of inserted, deleted or substituted characters. + +A fuzzy regex specifies which types of errors are permitted, and, optionally, either the minimum and maximum or only the maximum permitted number of each type. (You cannot specify only a minimum.) + +The 3 types of error are: + +* Insertion, indicated by "i" + +* Deletion, indicated by "d" + +* Substitution, indicated by "s" + +In addition, "e" indicates any type of error. + +The fuzziness of a regex item is specified between "{" and "}" after the item. + +Examples: + +* ``foo`` match "foo" exactly + +* ``(?:foo){i}`` match "foo", permitting insertions + +* ``(?:foo){d}`` match "foo", permitting deletions + +* ``(?:foo){s}`` match "foo", permitting substitutions + +* ``(?:foo){i,s}`` match "foo", permitting insertions and substitutions + +* ``(?:foo){e}`` match "foo", permitting errors + +If a certain type of error is specified, then any type not specified will **not** be permitted. + +In the following examples I'll omit the item and write only the fuzziness: + +* ``{d<=3}`` permit at most 3 deletions, but no other types + +* ``{i<=1,s<=2}`` permit at most 1 insertion and at most 2 substitutions, but no deletions + +* ``{1<=e<=3}`` permit at least 1 and at most 3 errors + +* ``{i<=2,d<=2,e<=3}`` permit at most 2 insertions, at most 2 deletions, at most 3 errors in total, but no substitutions + +It's also possible to state the costs of each type of error and the maximum permitted total cost. + +Examples: + +* ``{2i+2d+1s<=4}`` each insertion costs 2, each deletion costs 2, each substitution costs 1, the total cost must not exceed 4 + +* ``{i<=1,d<=1,s<=1,2i+2d+1s<=4}`` at most 1 insertion, at most 1 deletion, at most 1 substitution; each insertion costs 2, each deletion costs 2, each substitution costs 1, the total cost must not exceed 4 + +You can also use "<" instead of "<=" if you want an exclusive minimum or maximum. + +You can add a test to perform on a character that's substituted or inserted. + +Examples: + +* ``{s<=2:[a-z]}`` at most 2 substitutions, which must be in the character set ``[a-z]``. + +* ``{s<=2,i<=3:\d}`` at most 2 substitutions, at most 3 insertions, which must be digits. + +By default, fuzzy matching searches for the first match that meets the given constraints. The ``ENHANCEMATCH`` flag will cause it to attempt to improve the fit (i.e. reduce the number of errors) of the match that it has found. + +The ``BESTMATCH`` flag will make it search for the best match instead. + +Further examples to note: + +* ``regex.search("(dog){e}", "cat and dog")[1]`` returns ``"cat"`` because that matches ``"dog"`` with 3 errors (an unlimited number of errors is permitted). + +* ``regex.search("(dog){e<=1}", "cat and dog")[1]`` returns ``" dog"`` (with a leading space) because that matches ``"dog"`` with 1 error, which is within the limit. + +* ``regex.search("(?e)(dog){e<=1}", "cat and dog")[1]`` returns ``"dog"`` (without a leading space) because the fuzzy search matches ``" dog"`` with 1 error, which is within the limit, and the ``(?e)`` then it attempts a better fit. + +In the first two examples there are perfect matches later in the string, but in neither case is it the first possible match. + +The match object has an attribute ``fuzzy_counts`` which gives the total number of substitutions, insertions and deletions. + +.. sourcecode:: python + + >>> # A 'raw' fuzzy match: + >>> regex.fullmatch(r"(?:cats|cat){e<=1}", "cat").fuzzy_counts + (0, 0, 1) + >>> # 0 substitutions, 0 insertions, 1 deletion. + + >>> # A better match might be possible if the ENHANCEMATCH flag used: + >>> regex.fullmatch(r"(?e)(?:cats|cat){e<=1}", "cat").fuzzy_counts + (0, 0, 0) + >>> # 0 substitutions, 0 insertions, 0 deletions. + +The match object also has an attribute ``fuzzy_changes`` which gives a tuple of the positions of the substitutions, insertions and deletions. + +.. sourcecode:: python + + >>> m = regex.search('(fuu){i<=2,d<=2,e<=5}', 'anaconda foo bar') + >>> m + + >>> m.fuzzy_changes + ([], [7, 8], [10, 11]) + +What this means is that if the matched part of the string had been: + +.. sourcecode:: python + + 'anacondfuuoo bar' + +it would've been an exact match. + +However, there were insertions at positions 7 and 8: + +.. sourcecode:: python + + 'anaconda fuuoo bar' + ^^ + +and deletions at positions 10 and 11: + +.. sourcecode:: python + + 'anaconda f~~oo bar' + ^^ + +So the actual string was: + +.. sourcecode:: python + + 'anaconda foo bar' + +Named lists ``\L`` (`Hg issue 11 `_) +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +There are occasions where you may want to include a list (actually, a set) of options in a regex. + +One way is to build the pattern like this: + +.. sourcecode:: python + + >>> p = regex.compile(r"first|second|third|fourth|fifth") + +but if the list is large, parsing the resulting regex can take considerable time, and care must also be taken that the strings are properly escaped and properly ordered, for example, "cats" before "cat". + +The new alternative is to use a named list: + +.. sourcecode:: python + + >>> option_set = ["first", "second", "third", "fourth", "fifth"] + >>> p = regex.compile(r"\L", options=option_set) + +The order of the items is irrelevant, they are treated as a set. The named lists are available as the ``.named_lists`` attribute of the pattern object : + +.. sourcecode:: python + + >>> print(p.named_lists) + {'options': frozenset({'third', 'first', 'fifth', 'fourth', 'second'})} + +If there are any unused keyword arguments, ``ValueError`` will be raised unless you tell it otherwise: + +.. sourcecode:: python + + >>> option_set = ["first", "second", "third", "fourth", "fifth"] + >>> p = regex.compile(r"\L", options=option_set, other_options=[]) + Traceback (most recent call last): + File "", line 1, in + File "C:\Python310\lib\site-packages\regex\regex.py", line 353, in compile + return _compile(pattern, flags, ignore_unused, kwargs, cache_pattern) + File "C:\Python310\lib\site-packages\regex\regex.py", line 500, in _compile + complain_unused_args() + File "C:\Python310\lib\site-packages\regex\regex.py", line 483, in complain_unused_args + raise ValueError('unused keyword argument {!a}'.format(any_one)) + ValueError: unused keyword argument 'other_options' + >>> p = regex.compile(r"\L", options=option_set, other_options=[], ignore_unused=True) + >>> p = regex.compile(r"\L", options=option_set, other_options=[], ignore_unused=False) + Traceback (most recent call last): + File "", line 1, in + File "C:\Python310\lib\site-packages\regex\regex.py", line 353, in compile + return _compile(pattern, flags, ignore_unused, kwargs, cache_pattern) + File "C:\Python310\lib\site-packages\regex\regex.py", line 500, in _compile + complain_unused_args() + File "C:\Python310\lib\site-packages\regex\regex.py", line 483, in complain_unused_args + raise ValueError('unused keyword argument {!a}'.format(any_one)) + ValueError: unused keyword argument 'other_options' + >>> + +Start and end of word +^^^^^^^^^^^^^^^^^^^^^ + +``\m`` matches at the start of a word. + +``\M`` matches at the end of a word. + +Compare with ``\b``, which matches at the start or end of a word. + +Unicode line separators +^^^^^^^^^^^^^^^^^^^^^^^ + +Normally the only line separator is ``\n`` (``\x0A``), but if the ``WORD`` flag is turned on then the line separators are ``\x0D\x0A``, ``\x0A``, ``\x0B``, ``\x0C`` and ``\x0D``, plus ``\x85``, ``\u2028`` and ``\u2029`` when working with Unicode. + +This affects the regex dot ``"."``, which, with the ``DOTALL`` flag turned off, matches any character except a line separator. It also affects the line anchors ``^`` and ``$`` (in multiline mode). + +Set operators +^^^^^^^^^^^^^ + +**Version 1 behaviour only** + +Set operators have been added, and a set ``[...]`` can include nested sets. + +The operators, in order of increasing precedence, are: + +* ``||`` for union ("x||y" means "x or y") + +* ``~~`` (double tilde) for symmetric difference ("x~~y" means "x or y, but not both") + +* ``&&`` for intersection ("x&&y" means "x and y") + +* ``--`` (double dash) for difference ("x--y" means "x but not y") + +Implicit union, ie, simple juxtaposition like in ``[ab]``, has the highest precedence. Thus, ``[ab&&cd]`` is the same as ``[[a||b]&&[c||d]]``. + +Examples: + +* ``[ab]`` # Set containing 'a' and 'b' + +* ``[a-z]`` # Set containing 'a' .. 'z' + +* ``[[a-z]--[qw]]`` # Set containing 'a' .. 'z', but not 'q' or 'w' + +* ``[a-z--qw]`` # Same as above + +* ``[\p{L}--QW]`` # Set containing all letters except 'Q' and 'W' + +* ``[\p{N}--[0-9]]`` # Set containing all numbers except '0' .. '9' + +* ``[\p{ASCII}&&\p{Letter}]`` # Set containing all characters which are ASCII and letter + +regex.escape (`issue #2650 `_) +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +regex.escape has an additional keyword parameter ``special_only``. When True, only 'special' regex characters, such as '?', are escaped. + +.. sourcecode:: python + + >>> regex.escape("foo!?", special_only=False) + 'foo\\!\\?' + >>> regex.escape("foo!?", special_only=True) + 'foo!\\?' + +regex.escape (`Hg issue 249 `_) +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +regex.escape has an additional keyword parameter ``literal_spaces``. When True, spaces are not escaped. + +.. sourcecode:: python + + >>> regex.escape("foo bar!?", literal_spaces=False) + 'foo\\ bar!\\?' + >>> regex.escape("foo bar!?", literal_spaces=True) + 'foo bar!\\?' + +Repeated captures (`issue #7132 `_) +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +A match object has additional methods which return information on all the successful matches of a repeated group. These methods are: + +* ``matchobject.captures([group1, ...])`` + + * Returns a list of the strings matched in a group or groups. Compare with ``matchobject.group([group1, ...])``. + +* ``matchobject.starts([group])`` + + * Returns a list of the start positions. Compare with ``matchobject.start([group])``. + +* ``matchobject.ends([group])`` + + * Returns a list of the end positions. Compare with ``matchobject.end([group])``. + +* ``matchobject.spans([group])`` + + * Returns a list of the spans. Compare with ``matchobject.span([group])``. + +.. sourcecode:: python + + >>> m = regex.search(r"(\w{3})+", "123456789") + >>> m.group(1) + '789' + >>> m.captures(1) + ['123', '456', '789'] + >>> m.start(1) + 6 + >>> m.starts(1) + [0, 3, 6] + >>> m.end(1) + 9 + >>> m.ends(1) + [3, 6, 9] + >>> m.span(1) + (6, 9) + >>> m.spans(1) + [(0, 3), (3, 6), (6, 9)] + +Atomic grouping ``(?>...)`` (`issue #433030 `_) +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +If the following pattern subsequently fails, then the subpattern as a whole will fail. + +Possessive quantifiers +^^^^^^^^^^^^^^^^^^^^^^ + +``(?:...)?+`` ; ``(?:...)*+`` ; ``(?:...)++`` ; ``(?:...){min,max}+`` + +The subpattern is matched up to 'max' times. If the following pattern subsequently fails, then all the repeated subpatterns will fail as a whole. For example, ``(?:...)++`` is equivalent to ``(?>(?:...)+)``. + +Scoped flags (`issue #433028 `_) +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +``(?flags-flags:...)`` + +The flags will apply only to the subpattern. Flags can be turned on or off. + +Definition of 'word' character (`issue #1693050 `_) +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +The definition of a 'word' character has been expanded for Unicode. It conforms to the Unicode specification at ``http://www.unicode.org/reports/tr29/``. + +Variable-length lookbehind +^^^^^^^^^^^^^^^^^^^^^^^^^^ + +A lookbehind can match a variable-length string. + +Flags argument for regex.split, regex.sub and regex.subn (`issue #3482 `_) +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +``regex.split``, ``regex.sub`` and ``regex.subn`` support a 'flags' argument. + +Pos and endpos arguments for regex.sub and regex.subn +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +``regex.sub`` and ``regex.subn`` support 'pos' and 'endpos' arguments. + +'Overlapped' argument for regex.findall and regex.finditer +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +``regex.findall`` and ``regex.finditer`` support an 'overlapped' flag which permits overlapped matches. + +Splititer +^^^^^^^^^ + +``regex.splititer`` has been added. It's a generator equivalent of ``regex.split``. + +Subscripting match objects for groups +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +A match object accepts access to the groups via subscripting and slicing: + +.. sourcecode:: python + + >>> m = regex.search(r"(?P.*?)(?P\d+)(?P.*)", "pqr123stu") + >>> print(m["before"]) + pqr + >>> print(len(m)) + 4 + >>> print(m[:]) + ('pqr123stu', 'pqr', '123', 'stu') + +Named groups +^^^^^^^^^^^^ + +Groups can be named with ``(?...)`` as well as the existing ``(?P...)``. + +Group references +^^^^^^^^^^^^^^^^ + +Groups can be referenced within a pattern with ``\g``. This also allows there to be more than 99 groups. + +Named characters ``\N{name}`` +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +Named characters are supported. Note that only those known by Python's Unicode database will be recognised. + +Unicode codepoint properties, including scripts and blocks +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +``\p{property=value}``; ``\P{property=value}``; ``\p{value}`` ; ``\P{value}`` + +Many Unicode properties are supported, including blocks and scripts. ``\p{property=value}`` or ``\p{property:value}`` matches a character whose property ``property`` has value ``value``. The inverse of ``\p{property=value}`` is ``\P{property=value}`` or ``\p{^property=value}``. + +If the short form ``\p{value}`` is used, the properties are checked in the order: ``General_Category``, ``Script``, ``Block``, binary property: + +* ``Latin``, the 'Latin' script (``Script=Latin``). + +* ``BasicLatin``, the 'BasicLatin' block (``Block=BasicLatin``). + +* ``Alphabetic``, the 'Alphabetic' binary property (``Alphabetic=Yes``). + +A short form starting with ``Is`` indicates a script or binary property: + +* ``IsLatin``, the 'Latin' script (``Script=Latin``). + +* ``IsAlphabetic``, the 'Alphabetic' binary property (``Alphabetic=Yes``). + +A short form starting with ``In`` indicates a block property: + +* ``InBasicLatin``, the 'BasicLatin' block (``Block=BasicLatin``). + +POSIX character classes +^^^^^^^^^^^^^^^^^^^^^^^ + +``[[:alpha:]]``; ``[[:^alpha:]]`` + +POSIX character classes are supported. These are normally treated as an alternative form of ``\p{...}``. + +The exceptions are ``alnum``, ``digit``, ``punct`` and ``xdigit``, whose definitions are different from those of Unicode. + +``[[:alnum:]]`` is equivalent to ``\p{posix_alnum}``. + +``[[:digit:]]`` is equivalent to ``\p{posix_digit}``. + +``[[:punct:]]`` is equivalent to ``\p{posix_punct}``. + +``[[:xdigit:]]`` is equivalent to ``\p{posix_xdigit}``. + +Search anchor ``\G`` +^^^^^^^^^^^^^^^^^^^^ + +A search anchor has been added. It matches at the position where each search started/continued and can be used for contiguous matches or in negative variable-length lookbehinds to limit how far back the lookbehind goes: + +.. sourcecode:: python + + >>> regex.findall(r"\w{2}", "abcd ef") + ['ab', 'cd', 'ef'] + >>> regex.findall(r"\G\w{2}", "abcd ef") + ['ab', 'cd'] + +* The search starts at position 0 and matches 'ab'. + +* The search continues at position 2 and matches 'cd'. + +* The search continues at position 4 and fails to match any letters. + +* The anchor stops the search start position from being advanced, so there are no more results. + +Reverse searching +^^^^^^^^^^^^^^^^^ + +Searches can also work backwards: + +.. sourcecode:: python + + >>> regex.findall(r".", "abc") + ['a', 'b', 'c'] + >>> regex.findall(r"(?r).", "abc") + ['c', 'b', 'a'] + +Note that the result of a reverse search is not necessarily the reverse of a forward search: + +.. sourcecode:: python + + >>> regex.findall(r"..", "abcde") + ['ab', 'cd'] + >>> regex.findall(r"(?r)..", "abcde") + ['de', 'bc'] + +Matching a single grapheme ``\X`` +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +The grapheme matcher is supported. It conforms to the Unicode specification at ``http://www.unicode.org/reports/tr29/``. + +Branch reset ``(?|...|...)`` +^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +Group numbers will be reused across the alternatives, but groups with different names will have different group numbers. + +.. sourcecode:: python + + >>> regex.match(r"(?|(first)|(second))", "first").groups() + ('first',) + >>> regex.match(r"(?|(first)|(second))", "second").groups() + ('second',) + +Note that there is only one group. + +Default Unicode word boundary +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +The ``WORD`` flag changes the definition of a 'word boundary' to that of a default Unicode word boundary. This applies to ``\b`` and ``\B``. + +Timeout +^^^^^^^ + +The matching methods and functions support timeouts. The timeout (in seconds) applies to the entire operation: + +.. sourcecode:: python + + >>> from time import sleep + >>> + >>> def fast_replace(m): + ... return 'X' + ... + >>> def slow_replace(m): + ... sleep(0.5) + ... return 'X' + ... + >>> regex.sub(r'[a-z]', fast_replace, 'abcde', timeout=2) + 'XXXXX' + >>> regex.sub(r'[a-z]', slow_replace, 'abcde', timeout=2) + Traceback (most recent call last): + File "", line 1, in + File "C:\Python310\lib\site-packages\regex\regex.py", line 278, in sub + return pat.sub(repl, string, count, pos, endpos, concurrent, timeout) + TimeoutError: regex timed out diff --git a/venv/lib/python3.10/site-packages/regex-2025.7.34.dist-info/RECORD b/venv/lib/python3.10/site-packages/regex-2025.7.34.dist-info/RECORD new file mode 100644 index 0000000000000000000000000000000000000000..c22980c0bec8b980003ad04ae8da11c936cd75f5 --- /dev/null +++ b/venv/lib/python3.10/site-packages/regex-2025.7.34.dist-info/RECORD @@ -0,0 +1,15 @@ +regex-2025.7.34.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +regex-2025.7.34.dist-info/METADATA,sha256=xHIrqeYkp3kbUI7wgoHiknwPM0nycHg0LWTkliBwGio,40467 +regex-2025.7.34.dist-info/RECORD,, +regex-2025.7.34.dist-info/WHEEL,sha256=DZl4yYurviXJJQsilHH1qAzCRDsdz--oNtDZ-hUrZUk,190 +regex-2025.7.34.dist-info/licenses/LICENSE.txt,sha256=v_Ve9M3MjBTOJZ-OirYOJkQYRA1jNfTcE4Jz-9UGFE0,11584 +regex-2025.7.34.dist-info/top_level.txt,sha256=aQmiDMhNTF26cCK4_7D-qaVvhbxClG0wyCTnEhkzYBs,6 +regex/__init__.py,sha256=9slNQEb4SCZ9LncNzcQvqmkyxXlcOAF7QwAwigxWjsw,65 +regex/__pycache__/__init__.cpython-310.pyc,, +regex/__pycache__/_regex_core.cpython-310.pyc,, +regex/__pycache__/regex.cpython-310.pyc,, +regex/__pycache__/test_regex.cpython-310.pyc,, +regex/_regex.cpython-310-x86_64-linux-gnu.so,sha256=42nektdDhM97dMC5pNkDPLgOE0qwKFPh3_tsVWCQE40,2522304 +regex/_regex_core.py,sha256=g3fppovLhW_FSsVnmH7xIbvXlRyqc-BVQ2Fdf63iJIk,144497 +regex/regex.py,sha256=hJyp77wCaXEmBCcPUOZdx3Z-ZvILXY2zdYLjrensvGk,32683 +regex/test_regex.py,sha256=0xcR2P7T1BbQkxGul_L_oMZ1yhNmFLyNS0RHH9c1S9U,225497 diff --git a/venv/lib/python3.10/site-packages/regex-2025.7.34.dist-info/WHEEL b/venv/lib/python3.10/site-packages/regex-2025.7.34.dist-info/WHEEL new file mode 100644 index 0000000000000000000000000000000000000000..6d6bf82d678c683effaf22b612f4dea70dd9933d --- /dev/null +++ b/venv/lib/python3.10/site-packages/regex-2025.7.34.dist-info/WHEEL @@ -0,0 +1,7 @@ +Wheel-Version: 1.0 +Generator: setuptools (80.9.0) +Root-Is-Purelib: false +Tag: cp310-cp310-manylinux_2_17_x86_64 +Tag: cp310-cp310-manylinux2014_x86_64 +Tag: cp310-cp310-manylinux_2_28_x86_64 + diff --git a/venv/lib/python3.10/site-packages/regex-2025.7.34.dist-info/licenses/LICENSE.txt b/venv/lib/python3.10/site-packages/regex-2025.7.34.dist-info/licenses/LICENSE.txt new file mode 100644 index 0000000000000000000000000000000000000000..99c19cf844141395a87c34325da3a537f1e95815 --- /dev/null +++ b/venv/lib/python3.10/site-packages/regex-2025.7.34.dist-info/licenses/LICENSE.txt @@ -0,0 +1,208 @@ +This work was derived from the 're' module of CPython 2.6 and CPython 3.1, +copyright (c) 1998-2001 by Secret Labs AB and licensed under CNRI's Python 1.6 +license. + +All additions and alterations are licensed under the Apache 2.0 License. + + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright 2020 Matthew Barnett + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/venv/lib/python3.10/site-packages/regex-2025.7.34.dist-info/top_level.txt b/venv/lib/python3.10/site-packages/regex-2025.7.34.dist-info/top_level.txt new file mode 100644 index 0000000000000000000000000000000000000000..4f9256d62325c75de027d1cd48f1ff520117413e --- /dev/null +++ b/venv/lib/python3.10/site-packages/regex-2025.7.34.dist-info/top_level.txt @@ -0,0 +1 @@ +regex diff --git a/venv/lib/python3.10/site-packages/safetensors/__init__.py b/venv/lib/python3.10/site-packages/safetensors/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..0aea2154eb6b993974d3e2874f2d3ad09e21d9c0 --- /dev/null +++ b/venv/lib/python3.10/site-packages/safetensors/__init__.py @@ -0,0 +1,10 @@ +# Re-export this +from ._safetensors_rust import ( # noqa: F401 + SafetensorError, + __version__, + deserialize, + safe_open, + _safe_open_handle, + serialize, + serialize_file, +) diff --git a/venv/lib/python3.10/site-packages/safetensors/paddle.py b/venv/lib/python3.10/site-packages/safetensors/paddle.py new file mode 100644 index 0000000000000000000000000000000000000000..5ec459e3ac45ea56583376ecbffd77734bf82381 --- /dev/null +++ b/venv/lib/python3.10/site-packages/safetensors/paddle.py @@ -0,0 +1,144 @@ +import os +from typing import Dict, Optional, Union + +import numpy as np + +import paddle +from safetensors import numpy + + +def save( + tensors: Dict[str, paddle.Tensor], metadata: Optional[Dict[str, str]] = None +) -> bytes: + """ + Saves a dictionary of tensors into raw bytes in safetensors format. + + Args: + tensors (`Dict[str, paddle.Tensor]`): + The incoming tensors. Tensors need to be contiguous and dense. + metadata (`Dict[str, str]`, *optional*, defaults to `None`): + Optional text only metadata you might want to save in your header. + For instance it can be useful to specify more about the underlying + tensors. This is purely informative and does not affect tensor loading. + + Returns: + `bytes`: The raw bytes representing the format + + Example: + + ```python + from safetensors.paddle import save + import paddle + + tensors = {"embedding": paddle.zeros((512, 1024)), "attention": paddle.zeros((256, 256))} + byte_data = save(tensors) + ``` + """ + np_tensors = _paddle2np(tensors) + return numpy.save(np_tensors, metadata=metadata) + + +def save_file( + tensors: Dict[str, paddle.Tensor], + filename: Union[str, os.PathLike], + metadata: Optional[Dict[str, str]] = None, +) -> None: + """ + Saves a dictionary of tensors into raw bytes in safetensors format. + + Args: + tensors (`Dict[str, paddle.Tensor]`): + The incoming tensors. Tensors need to be contiguous and dense. + filename (`str`, or `os.PathLike`)): + The filename we're saving into. + metadata (`Dict[str, str]`, *optional*, defaults to `None`): + Optional text only metadata you might want to save in your header. + For instance it can be useful to specify more about the underlying + tensors. This is purely informative and does not affect tensor loading. + + Returns: + `None` + + Example: + + ```python + from safetensors.paddle import save_file + import paddle + + tensors = {"embedding": paddle.zeros((512, 1024)), "attention": paddle.zeros((256, 256))} + save_file(tensors, "model.safetensors") + ``` + """ + np_tensors = _paddle2np(tensors) + return numpy.save_file(np_tensors, filename, metadata=metadata) + + +def load(data: bytes, device: str = "cpu") -> Dict[str, paddle.Tensor]: + """ + Loads a safetensors file into paddle format from pure bytes. + + Args: + data (`bytes`): + The content of a safetensors file + + Returns: + `Dict[str, paddle.Tensor]`: dictionary that contains name as key, value as `paddle.Tensor` on cpu + + Example: + + ```python + from safetensors.paddle import load + + file_path = "./my_folder/bert.safetensors" + with open(file_path, "rb") as f: + data = f.read() + + loaded = load(data) + ``` + """ + flat = numpy.load(data) + return _np2paddle(flat, device) + + +def load_file( + filename: Union[str, os.PathLike], device="cpu" +) -> Dict[str, paddle.Tensor]: + """ + Loads a safetensors file into paddle format. + + Args: + filename (`str`, or `os.PathLike`)): + The name of the file which contains the tensors + device (`Union[Dict[str, any], str]`, *optional*, defaults to `cpu`): + The device where the tensors need to be located after load. + available options are all regular paddle device locations + + Returns: + `Dict[str, paddle.Tensor]`: dictionary that contains name as key, value as `paddle.Tensor` + + Example: + + ```python + from safetensors.paddle import load_file + + file_path = "./my_folder/bert.safetensors" + loaded = load_file(file_path) + ``` + """ + flat = numpy.load_file(filename) + output = _np2paddle(flat, device) + return output + + +def _np2paddle( + numpy_dict: Dict[str, np.ndarray], device: str = "cpu" +) -> Dict[str, paddle.Tensor]: + for k, v in numpy_dict.items(): + numpy_dict[k] = paddle.to_tensor(v, place=device) + return numpy_dict + + +def _paddle2np(paddle_dict: Dict[str, paddle.Tensor]) -> Dict[str, np.array]: + for k, v in paddle_dict.items(): + paddle_dict[k] = v.detach().cpu().numpy() + return paddle_dict diff --git a/venv/lib/python3.10/site-packages/triton-3.2.0.dist-info/INSTALLER b/venv/lib/python3.10/site-packages/triton-3.2.0.dist-info/INSTALLER new file mode 100644 index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68 --- /dev/null +++ b/venv/lib/python3.10/site-packages/triton-3.2.0.dist-info/INSTALLER @@ -0,0 +1 @@ +pip diff --git a/venv/lib/python3.10/site-packages/triton-3.2.0.dist-info/METADATA b/venv/lib/python3.10/site-packages/triton-3.2.0.dist-info/METADATA new file mode 100644 index 0000000000000000000000000000000000000000..3c296c8d892606cf442f810a616e3051849f9d7d --- /dev/null +++ b/venv/lib/python3.10/site-packages/triton-3.2.0.dist-info/METADATA @@ -0,0 +1,39 @@ +Metadata-Version: 2.2 +Name: triton +Version: 3.2.0 +Summary: A language and compiler for custom Deep Learning operations +Home-page: https://github.com/triton-lang/triton/ +Author: Philippe Tillet +Author-email: phil@openai.com +Keywords: Compiler,Deep Learning +Classifier: Development Status :: 4 - Beta +Classifier: Intended Audience :: Developers +Classifier: Topic :: Software Development :: Build Tools +Classifier: License :: OSI Approved :: MIT License +Classifier: Programming Language :: Python :: 3.9 +Classifier: Programming Language :: Python :: 3.10 +Classifier: Programming Language :: Python :: 3.11 +Classifier: Programming Language :: Python :: 3.12 +Classifier: Programming Language :: Python :: 3.13 +Provides-Extra: build +Requires-Dist: cmake>=3.20; extra == "build" +Requires-Dist: lit; extra == "build" +Provides-Extra: tests +Requires-Dist: autopep8; extra == "tests" +Requires-Dist: flake8; extra == "tests" +Requires-Dist: isort; extra == "tests" +Requires-Dist: numpy; extra == "tests" +Requires-Dist: pytest; extra == "tests" +Requires-Dist: scipy>=1.7.1; extra == "tests" +Requires-Dist: llnl-hatchet; extra == "tests" +Provides-Extra: tutorials +Requires-Dist: matplotlib; extra == "tutorials" +Requires-Dist: pandas; extra == "tutorials" +Requires-Dist: tabulate; extra == "tutorials" +Dynamic: author +Dynamic: author-email +Dynamic: classifier +Dynamic: home-page +Dynamic: keywords +Dynamic: provides-extra +Dynamic: summary diff --git a/venv/lib/python3.10/site-packages/triton-3.2.0.dist-info/RECORD b/venv/lib/python3.10/site-packages/triton-3.2.0.dist-info/RECORD new file mode 100644 index 0000000000000000000000000000000000000000..bc4a1f045b3710b14632f30d6620a441b125eb0b --- /dev/null +++ b/venv/lib/python3.10/site-packages/triton-3.2.0.dist-info/RECORD @@ -0,0 +1,376 @@ +../../../bin/proton,sha256=Wf40QdLHINeUD4pF_xoWMIX7A34IJN8dqmoXvoQ73io,291 +../../../bin/proton-viewer,sha256=3AuVf1pMi7NHYw0JddiMjqtmPd5ap41UQb-136_Wr-A,291 +triton-3.2.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +triton-3.2.0.dist-info/METADATA,sha256=60U7BH_G-oh95wpQW9hoEjlXtYzxLHgSnwAgsQRqbVg,1423 +triton-3.2.0.dist-info/RECORD,, +triton-3.2.0.dist-info/WHEEL,sha256=ViyZsTV2upbIniGkknQiIrLPLs1cJIoIfr1wsV7PMic,151 +triton-3.2.0.dist-info/entry_points.txt,sha256=SAiHYj5xxm1U5d8569PbMXmtWkKGNtiyy7LeTlUHalM,99 +triton-3.2.0.dist-info/top_level.txt,sha256=cG17rIqlZ8ppA2uLVwUB95KPu9agPMZPuHkrMnQCppQ,227 +triton/_C/libproton.so,sha256=Y6DhcSfX-4eysyerrd6SqPqOpGL1eOgMYQts5jEZ6qY,18083272 +triton/_C/libtriton.so,sha256=tHhxn9zUvRdymyUEf9CA9ao8zWC7QzPrMjg1ijSkeVk,534321632 +triton/__init__.py,sha256=buC26NIOMT6cwmoYkc5jk46jb3fploY6_bOZYKwzdKQ,1347 +triton/__pycache__/__init__.cpython-310.pyc,, +triton/__pycache__/_internal_testing.cpython-310.pyc,, +triton/__pycache__/errors.cpython-310.pyc,, +triton/__pycache__/testing.cpython-310.pyc,, +triton/_internal_testing.py,sha256=4pzyc_36u05khUveZ1TWL3MQ-7EVMJ1C2c1dRd8BMsw,4269 +triton/backends/__init__.py,sha256=opAo_vgEMt3tLO_bYFrYGksnIu0qohbmyuu_s3-rNAs,1595 +triton/backends/__pycache__/__init__.cpython-310.pyc,, +triton/backends/__pycache__/compiler.cpython-310.pyc,, +triton/backends/__pycache__/driver.cpython-310.pyc,, +triton/backends/amd/__pycache__/compiler.cpython-310.pyc,, +triton/backends/amd/__pycache__/driver.cpython-310.pyc,, +triton/backends/amd/compiler.py,sha256=0FnS5mBLsPB9FQzNr3I9BPd3-KEB1Do29hDsnFGu25k,16203 +triton/backends/amd/driver.c,sha256=obiiiPndny5NyhUcJ8iyrVHrXU1ruLpLGd_LgaKQEbU,8459 +triton/backends/amd/driver.py,sha256=leVYGX_wugGapdDc7o5hwMVduTrNRVp4XTa93FViVa8,18593 +triton/backends/amd/include/hip/amd_detail/amd_channel_descriptor.h,sha256=_2myGIdBTE0plFbGKOSx8HUqGZd0UBHo-YvKe2xkpbU,11708 +triton/backends/amd/include/hip/amd_detail/amd_device_functions.h,sha256=zfYTHJE_M_y2Y2ssP8ZH_EOczMBg4Iq2guglaKcI5js,31425 +triton/backends/amd/include/hip/amd_detail/amd_hip_atomic.h,sha256=PJRRTp83M0jIEBA_iWzfWwHZelSbL3TBrSDqlO3SQtk,49919 +triton/backends/amd/include/hip/amd_detail/amd_hip_bf16.h,sha256=fucv1_06JHVm82T0TmvERBbmtZTDQK6WJi_58oGQOXg,40634 +triton/backends/amd/include/hip/amd_detail/amd_hip_bfloat16.h,sha256=cFJlQEELGau_9geACeuiiFHyuAWCD6-VuSqcTnqajX0,9484 +triton/backends/amd/include/hip/amd_detail/amd_hip_common.h,sha256=dzkuIzuklqTRaNJjKLqfFEm6Fh4tK_FkTjYHFsZkmCI,1370 +triton/backends/amd/include/hip/amd_detail/amd_hip_complex.h,sha256=SEygl8X_MCXDVXxNIBm5Ds0eWwa-ojVXUUW48SIgsX8,5855 +triton/backends/amd/include/hip/amd_detail/amd_hip_cooperative_groups.h,sha256=SvrkniHiDGt-ztZRBvbkyajfUxTbGQzpZC1gnd4T-i8,31624 +triton/backends/amd/include/hip/amd_detail/amd_hip_fp16.h,sha256=86Nw97iaiC4QV5xBv8d3Bwc4FioMh5DQuCHj3sh_Yrw,57854 +triton/backends/amd/include/hip/amd_detail/amd_hip_gl_interop.h,sha256=9vxiV6rYRMGx12TPnrAVRvrfLyoRp74XRgKSPBPa2hk,3860 +triton/backends/amd/include/hip/amd_detail/amd_hip_math_constants.h,sha256=u1fIaf-AiWF70ZA1zxVkUIbRqoJLu5lrfYbgt_usySk,5890 +triton/backends/amd/include/hip/amd_detail/amd_hip_runtime.h,sha256=ZvDsQ0AiZnJ178NuAsA7AuHrySXbN3aFs5Z9m2tsIDg,13954 +triton/backends/amd/include/hip/amd_detail/amd_hip_runtime_pt_api.h,sha256=fc4mtHBkWmiSRh8m-dxIxvu9zsweLTwEgohkntYcgJw,9997 +triton/backends/amd/include/hip/amd_detail/amd_hip_unsafe_atomics.h,sha256=w9nJ1S32GRl_ejDiGacteM6Zf84iovIifAzWX8Bze0Q,24202 +triton/backends/amd/include/hip/amd_detail/amd_hip_vector_types.h,sha256=qPdmRJnzlgtjVshkafoHxdHoMLkoYS9U-ZD-TjLznr0,57088 +triton/backends/amd/include/hip/amd_detail/amd_math_functions.h,sha256=46wiaEMStCczEsHtccgHlATfw_0O5j6Z8rlFkC7bmUA,3171 +triton/backends/amd/include/hip/amd_detail/amd_surface_functions.h,sha256=rsQuylNqmNhLb7PZjBz7WbruD_6YIXtOptY2BNJDxVU,11062 +triton/backends/amd/include/hip/amd_detail/amd_warp_functions.h,sha256=p8DdtuxqlgGHzKdVPMHDnZOD8zA5f6GjLHYMr0_FKjQ,18966 +triton/backends/amd/include/hip/amd_detail/concepts.hpp,sha256=7EOkpr2w2-jclUQ115yxtFCkBWJ7btUzhBOe-mR0N0M,1252 +triton/backends/amd/include/hip/amd_detail/device_library_decls.h,sha256=4clSpgf898UVjfZFVnDkcYi75A27crPsuFtLcs1s4KU,7457 +triton/backends/amd/include/hip/amd_detail/functional_grid_launch.hpp,sha256=u7hRB9kQXX575a5C7cV3gKow55DSBUCwO0dTjIswlag,8129 +triton/backends/amd/include/hip/amd_detail/grid_launch.h,sha256=tNS7CQw9gy-z930CElH3n6c5iMvpsQ_WFZK024mNzEo,1830 +triton/backends/amd/include/hip/amd_detail/grid_launch.hpp,sha256=EuAlM3olyrArebqwW5eSxo4gfjvWCGOAGAuLLmFttgw,1370 +triton/backends/amd/include/hip/amd_detail/grid_launch_GGL.hpp,sha256=KpQAuyy1Dyt45WcPaR_x-Ex-onPGEHA01DBbla7TT-k,1219 +triton/backends/amd/include/hip/amd_detail/helpers.hpp,sha256=hi2pW1mXQnbIwvmwWt_nG6A38sqLOd-QP5S9sETTs60,5707 +triton/backends/amd/include/hip/amd_detail/hip_api_trace.hpp,sha256=d01j4SFQP_6ALwUHByxznZV8SrQHbuujRYon8rxFw-I,94612 +triton/backends/amd/include/hip/amd_detail/hip_assert.h,sha256=fNsG23KISuY-k5JFoX-5hZ7qGQScisXuHcdEwYlXOqw,3978 +triton/backends/amd/include/hip/amd_detail/hip_cooperative_groups_helper.h,sha256=tQ_XIvGKhvrj1h7gY-IVLmKvIPhsQa0YsBflxdhUHP8,7957 +triton/backends/amd/include/hip/amd_detail/hip_fp16_gcc.h,sha256=BtFsKmTptN4TOHocEicfNbBl2JCdZWKm_bd5mc5OzYY,6660 +triton/backends/amd/include/hip/amd_detail/hip_fp16_math_fwd.h,sha256=63tKWMPdW56qWlH_HbCaF_isVXufm514ol_SxL4YjTQ,5134 +triton/backends/amd/include/hip/amd_detail/hip_ldg.h,sha256=KAEZb9H4z4DDrkaloMOeWzahiDfI2V6c68vWT3jb5fU,3652 +triton/backends/amd/include/hip/amd_detail/hip_prof_str.h,sha256=s1T2IrCwYzZQOuCs5ppuegFQbjXSF2JA1eUSCmZg9AA,621355 +triton/backends/amd/include/hip/amd_detail/hip_runtime_prof.h,sha256=6GVfh1la0wtBVwdKX5y0C32dPD9shJp1o8wZdHsjZHA,2715 +triton/backends/amd/include/hip/amd_detail/host_defines.h,sha256=h_ZpFE4Clm2iyRyJevDb57Y-gC-6RVPjhnZ5rzPxiUo,7038 +triton/backends/amd/include/hip/amd_detail/hsa_helpers.hpp,sha256=Os-sJQOFI_0Abh8Ql05s0Rtfruk4NsSMfg7BtugxMgg,3232 +triton/backends/amd/include/hip/amd_detail/macro_based_grid_launch.hpp,sha256=6ocsArNa9_R6D6XCuNy8Zq23KG-j2uYsjqNCtnMrJws,67925 +triton/backends/amd/include/hip/amd_detail/math_fwd.h,sha256=nup5YhceJnngoLJCESI8qX08dNpbZci0i78WKu-wfdI,17000 +triton/backends/amd/include/hip/amd_detail/ockl_image.h,sha256=LzRPGMb515_iIAIIcbb2uQB-bTvT4xOjY51VdARD7lc,10538 +triton/backends/amd/include/hip/amd_detail/program_state.hpp,sha256=8QE9OmB8OKTy7rBr3EYEizJI2s-_1tgXpgU7zCA2Ky0,3154 +triton/backends/amd/include/hip/amd_detail/texture_fetch_functions.h,sha256=Ex1lF2gBWJxtC3yP9pXRSFywMp3gbEmyl0Sw8iL91yM,17787 +triton/backends/amd/include/hip/amd_detail/texture_indirect_functions.h,sha256=KkW5o5gMpoVMTRwzfXHA7-kZ9ynI8OaIw6jJ1EB1s98,18447 +triton/backends/amd/include/hip/channel_descriptor.h,sha256=gTYe7SzIg-m3ThOQY2vr5Rh6-uWvUP_d37v8F4T2Q14,1773 +triton/backends/amd/include/hip/device_functions.h,sha256=vkybrdk6wyZP-T1I5PRjtfcMqGYXDeBpB5jhYj358GU,1589 +triton/backends/amd/include/hip/driver_types.h,sha256=m1HI80HC80qkTeco2Jd07woL_jTy48lz9JiDCV_8zsg,18985 +triton/backends/amd/include/hip/hip_bf16.h,sha256=lLw6K5ltb6AqSuINYTq8flxxsDkBP8Y2zbqmUjBcG9c,1571 +triton/backends/amd/include/hip/hip_bfloat16.h,sha256=Nqoy9VjfjglVx2_NJcp8hyT1sJUukXRWj8XMlidv1yA,1755 +triton/backends/amd/include/hip/hip_common.h,sha256=q5aPhG3DHW0iUJ7ayS5lfM_ZnZQNbMmLmfdHlOwbPdA,3450 +triton/backends/amd/include/hip/hip_complex.h,sha256=TmdzQP5oVPfhBVARJYcR5eyv9HInmKMFuFoQ_1ECk_I,1594 +triton/backends/amd/include/hip/hip_cooperative_groups.h,sha256=gMLvaYQ3b-f1vcoMtEwtkN0hO5__zNfP5p5oBKmv_SE,1878 +triton/backends/amd/include/hip/hip_deprecated.h,sha256=gFLuCuKn7R_xCfum_i_Q-vi3Lg8NWHKphKZKze8DwEo,6340 +triton/backends/amd/include/hip/hip_ext.h,sha256=jK1Qc-SXgUyRTj8bBa9ZP__95Qgd2-W1mwnJo6Qpnoo,8560 +triton/backends/amd/include/hip/hip_fp16.h,sha256=vKJh-zgDWUW7NyXxtv2ho6aVLXX8BIPfzCigEQ5d6I4,1523 +triton/backends/amd/include/hip/hip_gl_interop.h,sha256=-GwkSFMBneM8akFE7pqlhi0k-Ft2uz5674wGoiaU43Q,1438 +triton/backends/amd/include/hip/hip_hcc.h,sha256=RYrArDlnTEP89xKbzIpW17_bsBY5moCitq00PL-4oWI,1307 +triton/backends/amd/include/hip/hip_math_constants.h,sha256=8bSfve5E7cDuvNAUkFUeQwSLg3iJJHuqhuD4FmHNxEM,1588 +triton/backends/amd/include/hip/hip_profile.h,sha256=sjsNuduu5Jd6s7sJndZvZLlE0RZ0wN1rTVwv5nR7If0,1304 +triton/backends/amd/include/hip/hip_runtime.h,sha256=uy90l8Nep6xNUzeGcHMoDv84BT3hMpieTV-5ijkpL5A,3058 +triton/backends/amd/include/hip/hip_runtime_api.h,sha256=fzb_xktisCVcp2pWG-ZKhIG-YVQzDjGyPt4wvA4iayM,386498 +triton/backends/amd/include/hip/hip_texture_types.h,sha256=AhkvjG4cDjf_ZFLg5SsSTfBnXG614PBK1XVPa7irZbk,1237 +triton/backends/amd/include/hip/hip_vector_types.h,sha256=6FcBMBkP3ZN1Enalpa9hV0VopxdBJvbUCuaxISgzbTY,1630 +triton/backends/amd/include/hip/hip_version.h,sha256=J3vgzfZH0UkK8RYvyHVj1PbUNSZH1JPtlcmXxLBgwVk,407 +triton/backends/amd/include/hip/hiprtc.h,sha256=npK6f2ZkYIe5blJIGuofuTG0PrSMS2mkFBUqrdOp0A0,15631 +triton/backends/amd/include/hip/library_types.h,sha256=tPOJTQedPH5qC9meawLgKpnbFrQC2WKlfo6s0rhKoZc,2370 +triton/backends/amd/include/hip/math_functions.h,sha256=frzdJ4veBG8n9ALO4EmRrdOiDguR6FP6ygLnvOnVVSM,1815 +triton/backends/amd/include/hip/surface_types.h,sha256=uQHjITphDM7k4pnuEoDEupMUxBobzvhJpSy0unpegh4,1959 +triton/backends/amd/include/hip/texture_types.h,sha256=CtmdykZfDikhnrVfdJk3w2VK5X3Af_6rEKzU-VgLu24,6687 +triton/backends/amd/include/hsa/Brig.h,sha256=5H-btCHq40qgjjpwVAoRWf3E0ccf-J6UCPEcKx_hGKw,32705 +triton/backends/amd/include/hsa/amd_hsa_common.h,sha256=q_zN0eq-dwR7FnQ84PcpV3yZyvjHsouIAjJgKltGoX8,3912 +triton/backends/amd/include/hsa/amd_hsa_elf.h,sha256=r3xymEjYeTIBCPvlKBDJxKyI1Dfg6KDXc5VqO9Uy1iM,16352 +triton/backends/amd/include/hsa/amd_hsa_kernel_code.h,sha256=C55F8a480QsW16-iwN9TIT3cKnGh6GoeoEaEv3aVh4g,12659 +triton/backends/amd/include/hsa/amd_hsa_queue.h,sha256=ZJ-k5wY30heLmQnGB0VUz36XCiVHRmspg5FRNMGIk_U,4766 +triton/backends/amd/include/hsa/amd_hsa_signal.h,sha256=FDegZnWQC04GtnqHjXOBsB-AoVSaqdhNY6Mwbua5FGA,2947 +triton/backends/amd/include/hsa/hsa.h,sha256=Jft1K5uFAcasOD9IYW6wD5GsGQcPQTrmbpjie-0Wh00,190916 +triton/backends/amd/include/hsa/hsa_amd_tool.h,sha256=pyZSyIVl-UA5AOhte78jvn4V3hCd0dxJAIv7KeADsPs,2843 +triton/backends/amd/include/hsa/hsa_api_trace.h,sha256=2iuwHcpyW9wvr-WPKCgatQzYBaA8rTa3w1BRMXBGcSI,28982 +triton/backends/amd/include/hsa/hsa_ext_amd.h,sha256=Riw3Ii-AYts1w_yjVD96ZXuY6-BBpnlx_bnnltThK1s,116016 +triton/backends/amd/include/hsa/hsa_ext_finalize.h,sha256=sv0AZbDM-B1wIdQ3cHTMlpUtNacQN2PkOgX90IZol_o,20227 +triton/backends/amd/include/hsa/hsa_ext_image.h,sha256=t5YJm_aw9EePCeFL1hoIfQ8ubIjBte-ptfReq6Ts-8Y,54232 +triton/backends/amd/include/hsa/hsa_ven_amd_aqlprofile.h,sha256=9uev2nT29MCdu7-HMkg9iItHop6QMOBMQL5DAFnftSg,19777 +triton/backends/amd/include/hsa/hsa_ven_amd_loader.h,sha256=c6cxPAzAox7u6IbFzEkQZfCuRl-Kr39WhY2_w23X1R4,26146 +triton/backends/amd/include/roctracer/ext/prof_protocol.h,sha256=6FAcvVD-dNM7uulFs2B-aTxw5xOAWGy6evdD4yUaebA,3849 +triton/backends/amd/include/roctracer/hip_ostream_ops.h,sha256=WNXFZxawBXHmFGMDFIOZqXkCw6VzyDexwGPkGJre4w0,184840 +triton/backends/amd/include/roctracer/hsa_ostream_ops.h,sha256=AYwF-IT9Dhl2FX-GuvCJZX6fSmHK0xkKLORx9QxuSK8,57857 +triton/backends/amd/include/roctracer/hsa_prof_str.h,sha256=ctT-KKsIGayp7RUGUsFNR-dE65VydyXla_Qgvf-efTU,122884 +triton/backends/amd/include/roctracer/roctracer.h,sha256=B8sHz2DMNprP7EqNWIGwVLY1KQMpxmhfVy4UoR8dzzY,23849 +triton/backends/amd/include/roctracer/roctracer_ext.h,sha256=vLaZ8peAxSy0cwrdEalKnUApkKspfa04iw1Mr_Zcio0,2940 +triton/backends/amd/include/roctracer/roctracer_hcc.h,sha256=NlF3R8JQ9oX9lGpm0b2n-EWJ0r3y9sP9wbwnoucaCuY,1303 +triton/backends/amd/include/roctracer/roctracer_hip.h,sha256=RCzYuNw1vLR7xK4rb06TtM9TU546UYKHJ83IMHmZEm8,1432 +triton/backends/amd/include/roctracer/roctracer_hsa.h,sha256=M8APM64XNAWSslxQisM-pcmKoUQaUdTMaKvSACyt0Ag,4108 +triton/backends/amd/include/roctracer/roctracer_plugin.h,sha256=8GGE1zDbdPCVJtbmwOCYq7X0mwFjfWRtzDYKLD4cKys,4786 +triton/backends/amd/include/roctracer/roctracer_roctx.h,sha256=gBjBk5vb0l3PbBSQ7V9iFtaM_RzkIDJEW1A_PXBihBM,2014 +triton/backends/amd/include/roctracer/roctx.h,sha256=RhJXUXRhSJ5LRE_1gm7E6-bjEMrfcFBLDLuf3UxAIh8,6717 +triton/backends/amd/lib/ockl.bc,sha256=wQKCzkKukIHbu0lyjKUYlhndc7S27xto6L54J0Bn-C0,246124 +triton/backends/amd/lib/ocml.bc,sha256=UPNTXW0gCXUNB-c6orSYwb-mz9_mjUc7zny_vfFza44,205964 +triton/backends/compiler.py,sha256=JZiiEbB9Wws3tjU6KXrydKtlOQI7Suk-mTYPlafa0Qk,11388 +triton/backends/driver.py,sha256=QX_6P1Go9ajdlHZi4Hv3nCtdHyDA6o8_lM3NMnlH1mk,1386 +triton/backends/nvidia/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +triton/backends/nvidia/__pycache__/__init__.cpython-310.pyc,, +triton/backends/nvidia/__pycache__/compiler.cpython-310.pyc,, +triton/backends/nvidia/__pycache__/driver.cpython-310.pyc,, +triton/backends/nvidia/bin/cuobjdump,sha256=FLKFErTLe_YgWmaukj-B8lkDrW6il4BbWWX2S0X_b1s,663040 +triton/backends/nvidia/bin/nvdisasm,sha256=rwo7W-VxMOzwUKMQdn01SkxzCzCjvzuIwQDcPJvL6-o,50683112 +triton/backends/nvidia/bin/ptxas,sha256=lN2lShZzlA1W0wcsZO96rLEloeZDlFhuEPd6el_w_4c,30314080 +triton/backends/nvidia/compiler.py,sha256=6o2KR0Rnm7QGuRRIWxdDZp62hfJJSc0hD4-3LBA9LkY,16095 +triton/backends/nvidia/driver.c,sha256=q4oIpkjOtdHHfi8xBkm4jC4JWIk5AjKtN8WRkZb8MD8,17300 +triton/backends/nvidia/driver.py,sha256=dHteVmBJrGaxu7KKl6PbzidGDdEYPUO2Y7PqX-399DY,16371 +triton/backends/nvidia/include/Openacc/cupti_openacc.h,sha256=Z0OM5e_hbd3cxdXyn3SCHqBBQawLg4QORnlm57Cr2-M,3513 +triton/backends/nvidia/include/Openmp/cupti_openmp.h,sha256=E1WNmeb_7HaUSmBegtUNe4IV1i7pXeNxgzIlyKn1zrM,3491 +triton/backends/nvidia/include/Openmp/omp-tools.h,sha256=AmuC_xPC7VPu3B-W4PmXuCNufFawhY8PjNXePaQFAOg,37403 +triton/backends/nvidia/include/builtin_types.h,sha256=JxT9Vf2q2snxTBOL9ACzNmYzTWACO2VOVUu1KdFt7_g,3150 +triton/backends/nvidia/include/channel_descriptor.h,sha256=no_vNky02LeMLI0CF8GDVGHaPm_uRUGcVUMYdt_Xn4U,21482 +triton/backends/nvidia/include/common_functions.h,sha256=22LTZRVcPZzEH6MJda7nNMCvMgIjSTe0OKR7sEQj6kc,3410 +triton/backends/nvidia/include/cooperative_groups.h,sha256=JUBW-C1x_7WWuNOaoorTKQab0qzrykkG8oAw1mEHZ2s,60332 +triton/backends/nvidia/include/cooperative_groups/details/async.h,sha256=xsEHCZP3nuEY3l2p8SU2d1226XiXumUvDP_Gyh8PdVY,19122 +triton/backends/nvidia/include/cooperative_groups/details/coalesced_reduce.h,sha256=pBQgFY7i64V87XNATg1UEIQHVNYOItQtHjS5B4yn8pc,4257 +triton/backends/nvidia/include/cooperative_groups/details/coalesced_scan.h,sha256=DfZv5d5W0XJv-tZVhgrIdjLjs6aCx_u0oy1lDIpjo1Q,7314 +triton/backends/nvidia/include/cooperative_groups/details/driver_abi.h,sha256=v-ZUb4UgGKJk6NR2WCWHD3x_42y-togI1urFn70Gi-g,3964 +triton/backends/nvidia/include/cooperative_groups/details/functional.h,sha256=2BV8i8Bidz0kgxuYkJCAbwFxOIZRyzHgG-c_rVKhRzc,8905 +triton/backends/nvidia/include/cooperative_groups/details/helpers.h,sha256=K9jvxnXc5-6Fum1KG4EQKJJrVZ4BhHOSAJbZR4uDL0c,26476 +triton/backends/nvidia/include/cooperative_groups/details/info.h,sha256=Ij_cqIrcXCcwlaQqCL7AHzMD4H89y0tJeQXCbjTGsFo,12578 +triton/backends/nvidia/include/cooperative_groups/details/invoke.h,sha256=Osq3K-tZuXHVCMQJ708PjPo-BwMhjhjApO4b0TYLFJg,8616 +triton/backends/nvidia/include/cooperative_groups/details/memory.h,sha256=WU28eUcYLA1z131VYGulR4eVCSN9xK9KSxbV656YPs0,5484 +triton/backends/nvidia/include/cooperative_groups/details/partitioning.h,sha256=4UXuvUmZvGANy0hd4erdBNllpgnn4K4qFWWlfzAsHO8,7125 +triton/backends/nvidia/include/cooperative_groups/details/reduce.h,sha256=UfMezM5pqRIotJjmuFgOmiMvbu49sYgjraHutmVVr0w,22111 +triton/backends/nvidia/include/cooperative_groups/details/scan.h,sha256=-Ttwb2AfEEY_tsmqJjR2dojkPpoRx387SoqxgvfdBtQ,17166 +triton/backends/nvidia/include/cooperative_groups/details/sync.h,sha256=zoiBicvB7rlXa_r_VSNuvHVwrLIM7EjF_KdmhvPj1LM,10638 +triton/backends/nvidia/include/cooperative_groups/memcpy_async.h,sha256=erOIHuObdfxRhBWfrXE3wsZF4B2GUuqwzQrsPwKPpbg,2960 +triton/backends/nvidia/include/cooperative_groups/reduce.h,sha256=B0hgDkqM-6ueqTTgb3b34A0RH4vGz8mBf5e2jT1dJ1o,2949 +triton/backends/nvidia/include/cooperative_groups/scan.h,sha256=2EU6T5cWNwftm2B7FicV31PojoI61yo5fHXGRYkGk40,2940 +triton/backends/nvidia/include/crt/common_functions.h,sha256=-U44f4yUGmwDPwd7Q_3Cz5if05xHGPSlAzz5zMylLSQ,13559 +triton/backends/nvidia/include/crt/cudacc_ext.h,sha256=KW6n0ImOZKS0VqVmBHWTXtHI816hh88YeEgUg2aYdVU,3224 +triton/backends/nvidia/include/crt/device_double_functions.h,sha256=A1vB3g0qwnNEfcpT1d9RiGDaxqPXXgYr-Vxe2oMHyxY,39938 +triton/backends/nvidia/include/crt/device_double_functions.hpp,sha256=YYIbqYhb5Qmf8c4YfcC_jytg4FRwcXPjv3TFTwhb24E,8568 +triton/backends/nvidia/include/crt/device_functions.h,sha256=txuWyo2qoqRZTomi3BSjwUbFvtD9Ea0WKamRgMFQzjQ,136370 +triton/backends/nvidia/include/crt/device_functions.hpp,sha256=9BxQiHjRuETOIntxXAlmTPKp8wlXrBKTPcBaSUQmwfQ,38985 +triton/backends/nvidia/include/crt/func_macro.h,sha256=EOpDlaM917bh9cwBiFBPF689DCMBw5hFarxLxFt-i74,1755 +triton/backends/nvidia/include/crt/host_config.h,sha256=ZnNRtvunIV0ctARy5qbTC1fa5-JpSK5eZ5u5SCcu_BM,12169 +triton/backends/nvidia/include/crt/host_defines.h,sha256=agpWQb4K25fhOP_RsrIuz1L_vPeC2AkbmJY12QgpXKc,9950 +triton/backends/nvidia/include/crt/host_runtime.h,sha256=lOpmkxFZVkEp8dcMAGEZRITsh-19o9jy39kdSNLc3Ng,10284 +triton/backends/nvidia/include/crt/math_functions.h,sha256=iYVBIFDocDsPxqaeKHeeTxAsY-zf04-zfkmETyeahuc,396266 +triton/backends/nvidia/include/crt/math_functions.hpp,sha256=u-CGbd0R2FZWdKG-6bdmGSor9KT_wnmISj63lPQKASM,100207 +triton/backends/nvidia/include/crt/mma.h,sha256=BgSSvJ_IR75W-3uLlC2yE6B7rHeWtamaNn6-XzYU73U,62564 +triton/backends/nvidia/include/crt/mma.hpp,sha256=spo0LX71tUCipxK517Bssj0nc-ZHf8oMWzvHoYYB_6I,66599 +triton/backends/nvidia/include/crt/nvfunctional,sha256=FDM0zqWO6bl9jpJKz9U8CMbjt6iTKh18tQalxAvRsag,16900 +triton/backends/nvidia/include/crt/sm_70_rt.h,sha256=Kf830xymA-zmF7LsunFHLSNyhhT5UiJMocgoHBQeNns,6837 +triton/backends/nvidia/include/crt/sm_70_rt.hpp,sha256=3a_rU-Y0MSB4htBDFY4PCQ_jXiWFTe7WT1ZyhMuCJOA,7837 +triton/backends/nvidia/include/crt/sm_80_rt.h,sha256=MdJHWCRzLM__nDDf1go61rDsl9ydOW3oi6SZBfjUyc8,7743 +triton/backends/nvidia/include/crt/sm_80_rt.hpp,sha256=o-rJu-jpehCeyABGgv-8dYRB7oJTCwuNdvSCq0VURdE,6705 +triton/backends/nvidia/include/crt/sm_90_rt.h,sha256=an47m0XFBaJ3pUX9MlE4-nktP1jb3eJUXhQ3ntZtzc8,11445 +triton/backends/nvidia/include/crt/sm_90_rt.hpp,sha256=YuqVygGV6rgtWtx1J9cPpEI3BXKQBII-Ez6oZFP3wrE,9228 +triton/backends/nvidia/include/crt/storage_class.h,sha256=dzcOZ16pLaN8ejqHaXw4iHbBJ6fXWxfaU-sj2QjYzzg,4791 +triton/backends/nvidia/include/cuComplex.h,sha256=WpcgpaiPhU_o9sTPMcNTEZuyXDIc8x3sz4dUWSztL2g,12186 +triton/backends/nvidia/include/cuda.h,sha256=29OuNnfs8Hb2sqCXHUKy3VudXxzN8050d0oW_C33ysE,1048458 +triton/backends/nvidia/include/cudaEGL.h,sha256=_CwaQ4cEP1vfNyBSSd5qFxznPCYOovF6Cpj-QWSIBq4,39544 +triton/backends/nvidia/include/cudaEGLTypedefs.h,sha256=xF_FAN1Kar9oyHJ3cCU7jztTpxX8WylpiuYyYpGGHek,5645 +triton/backends/nvidia/include/cudaGL.h,sha256=gMT1HPGa-siuji0gAsKYr4X45Lc29HKglC_ttNSGyUM,22501 +triton/backends/nvidia/include/cudaGLTypedefs.h,sha256=dClpQI-LuXgF9rPSBsj7OkIg8g_fXDjT0hLZS8TGpOg,6576 +triton/backends/nvidia/include/cudaProfilerTypedefs.h,sha256=F2aWLIKv_AhNbxNOaZVcRsxIh0kuscnV8UMWWxkBAlY,3297 +triton/backends/nvidia/include/cudaTypedefs.h,sha256=0hWYyV-KM7R5Qjagz9UP1ldhAZDHGIcJmYtYvB_nwNc,110387 +triton/backends/nvidia/include/cudaVDPAU.h,sha256=Np7Nc2Wjaz--hkpbhW6f9aapr-NbcPDAgkot0sJerco,12694 +triton/backends/nvidia/include/cudaVDPAUTypedefs.h,sha256=wz8nyOUdwM9mH9JO3QZW-A9dyxt-IufSX7nggSXpCNs,4144 +triton/backends/nvidia/include/cuda_awbarrier.h,sha256=3ZH-ZlXODhSiwSY9rqSni_EQwi25QMHP6Tm-zOdxBwE,9340 +triton/backends/nvidia/include/cuda_awbarrier_helpers.h,sha256=OCskCts5bCKl_RKBe9M74zKSIsVpePn44S_aJp1tFXE,12489 +triton/backends/nvidia/include/cuda_awbarrier_primitives.h,sha256=n5__E1jYYDhlgH-f3u8MQjtz57UZ7v5VshhMye1eicM,4699 +triton/backends/nvidia/include/cuda_bf16.h,sha256=2BKEN_8pbieiBHShSfIawa-Oy_3jJzQAl74TqoLQ3MQ,185707 +triton/backends/nvidia/include/cuda_bf16.hpp,sha256=ZJlZSkQJ65G0yhMPDAq3m-oMaEJ3ia9FOsbgnzCtPS0,137924 +triton/backends/nvidia/include/cuda_device_runtime_api.h,sha256=bIhfusirXe5-osOTPAILDh6pY8MW1hefyZvTD_IzgqM,46249 +triton/backends/nvidia/include/cuda_egl_interop.h,sha256=PNWYns30MIytJQHSOh7UbZYlaTX5e0bavzK14tde_C8,37109 +triton/backends/nvidia/include/cuda_fp16.h,sha256=1J7SldpmJk8SNDGD3SO0yVrsLoHkpN1VnMtRZr2Gbcs,175974 +triton/backends/nvidia/include/cuda_fp16.hpp,sha256=JyedVIUALPBiR_Ci3Rxef_sUs9VvDiP4MDc97Yk_Ys8,123259 +triton/backends/nvidia/include/cuda_fp8.h,sha256=Q3OP5o_3rSYbKtVIlcXVr_CncU3SPM-09j605e2Zegw,13833 +triton/backends/nvidia/include/cuda_fp8.hpp,sha256=b-PcyZgei5MmIp6op0QQ40BgNupO_ei648hG_dUS-FQ,64246 +triton/backends/nvidia/include/cuda_gl_interop.h,sha256=VQEswFeOBF6JN6Q0pdlkvc5WT7bD1FnTfKewvANulCc,19150 +triton/backends/nvidia/include/cuda_occupancy.h,sha256=Kr9HyOe-hlRjBAzbINwUYkNgbbIgIjuvKs09UZhMYQo,67179 +triton/backends/nvidia/include/cuda_pipeline.h,sha256=0enXG49wN4JajlQi3ahbp2ei_ufTY_Mznic7zfWmKHM,8130 +triton/backends/nvidia/include/cuda_pipeline_helpers.h,sha256=bo1L7e6vCuM-K3Il8K1z4wJUja5DyXQKdo_hSWUME-E,13852 +triton/backends/nvidia/include/cuda_pipeline_primitives.h,sha256=FnJJtuV6rHr6LgL56XDwilcSbFr6W1Hj6mf1AJaMI20,8675 +triton/backends/nvidia/include/cuda_runtime.h,sha256=a-OXWPsmKSPst7mRCCxHNZV7m-uRLCAY8oGRi-dJzPA,90683 +triton/backends/nvidia/include/cuda_runtime_api.h,sha256=7Ys9yv_2trFEVybtbh-UJKnDKG8fHWvUjSX4cgZGCck,608580 +triton/backends/nvidia/include/cuda_stdint.h,sha256=XbFOk9CtJjKqk7PpYNqbSVsDxAsVM8avA4rWpPi0BjQ,4093 +triton/backends/nvidia/include/cuda_surface_types.h,sha256=Mw5Lo4b8Q-f9mogOvATGyHhu9d2t2K6XOxuqtZrSh3A,3688 +triton/backends/nvidia/include/cuda_texture_types.h,sha256=ITbX-JNnP7Rm-JSgNVdJ9pq6k8FVor8RbnruDsKq6sk,3688 +triton/backends/nvidia/include/cuda_vdpau_interop.h,sha256=bXQanWc2IFXZAKWNGl2xAz9nLvFmQpWyGrsDvfeS9FA,7727 +triton/backends/nvidia/include/cudart_platform.h,sha256=YN6sKhB0b9w5tGX1IYL7ulJVPrWAiX9A44qLv4EtW5Q,2717 +triton/backends/nvidia/include/cupti.h,sha256=JkVyAGTIMYzwm62dfVqas3nMcILhgP_Wdz6fh4_NED0,4697 +triton/backends/nvidia/include/cupti_activity.h,sha256=1aNI_zmQnjAguMBU0UqqMR_heE77FiafQkZl9or_1Ww,210387 +triton/backends/nvidia/include/cupti_activity_deprecated.h,sha256=rYJsoAJxA2BTT50-olN8EYcSzdlXBpRbR1ATLG3rVIM,121526 +triton/backends/nvidia/include/cupti_callbacks.h,sha256=zrEVRb0hubSfD69QUmHsJiL8oAfvqyuKGcTVRihQrnc,29729 +triton/backends/nvidia/include/cupti_checkpoint.h,sha256=rTz8JoWxqESBXyZWUhZJGm4xeYcx4OJOtJ7Ld13T_b0,5264 +triton/backends/nvidia/include/cupti_common.h,sha256=85m74bxUgXp3tEaPQpezeazmpsNMw41PsjNSYmQdT20,3514 +triton/backends/nvidia/include/cupti_driver_cbid.h,sha256=dHKyQYZbBbdlxixzFkIoNHg5IfGXdgriyjN1Bu1i6g4,74462 +triton/backends/nvidia/include/cupti_events.h,sha256=f7lLGmD2e8FzvMhRgnn0-v7U0vTpUkiQHIpQxgARGb0,51896 +triton/backends/nvidia/include/cupti_metrics.h,sha256=iLAOlDrcbHEsIIUmgq0Tp1ZOY9O3Ot3wj2-bI8iYbSs,32148 +triton/backends/nvidia/include/cupti_nvtx_cbid.h,sha256=_azPtR1g4qivvX7qbvHRUg0RHCWF7iEOJyHMN9qZe9E,5912 +triton/backends/nvidia/include/cupti_pcsampling.h,sha256=ycJHT36DmPIaVzHsB3xxjXkhFyEfMCJOl3LbCsHFgyA,32144 +triton/backends/nvidia/include/cupti_pcsampling_util.h,sha256=lx8CaNXowJe5Zvc06LE-u_Zry_jODs1mM6j9Q5WIX9E,12430 +triton/backends/nvidia/include/cupti_profiler_target.h,sha256=JsceoDuhllWNEzaO0xxT81dJ55NrbF0UtRJJgit0P_E,32131 +triton/backends/nvidia/include/cupti_result.h,sha256=a-C4Y7LAYCiCT1ngOfoDuTi2stEG1YTafwwn6UfL-LU,12603 +triton/backends/nvidia/include/cupti_runtime_cbid.h,sha256=11pXl0MdmTtxUngel-ru4JdqWvF_gEIG14aQExRyfzI,46436 +triton/backends/nvidia/include/cupti_sass_metrics.h,sha256=3RW9snJuFQdOhrEn3wDJOru05q0V_zssWrqD7tvVJKw,19674 +triton/backends/nvidia/include/cupti_target.h,sha256=x4Vz1Upb6m9ixmVpmGaKQldDWYQI3OZ-ocEXGzNK0EE,1263 +triton/backends/nvidia/include/cupti_version.h,sha256=sjd-aUoTGkEWyvA2VUWIpZwXyXAaclqC8gbwNnuK5D0,4425 +triton/backends/nvidia/include/device_atomic_functions.h,sha256=OR2jNSfSKzaFri74zh4Vtz5M0z9UDBU3rKeC1rYaVQs,9500 +triton/backends/nvidia/include/device_atomic_functions.hpp,sha256=0e7MOiNNUnnloXpB_r9WT5YOws5cxgzQQAzRCYvgaFA,10486 +triton/backends/nvidia/include/device_double_functions.h,sha256=KUxId5Z1fx8SWfLRTxPD7RB-zN7zslzb4n7JaJLfL3I,3452 +triton/backends/nvidia/include/device_functions.h,sha256=bWSrhTYE9NQlss7xMSMEVusvto9j2fgUDXWVH2W_cOA,3410 +triton/backends/nvidia/include/device_launch_parameters.h,sha256=H1_CC-vvAaS26ys4XsTFkMgTxUTciAjdjswjizkisvQ,3846 +triton/backends/nvidia/include/device_types.h,sha256=2LFxoZBJPoA5V0H1EbKTEaXDi3GDJPtzOPdRHDaucIQ,3588 +triton/backends/nvidia/include/driver_functions.h,sha256=cN3IjRAz2Mj2Pj35SyxJIkZNDDusnJqaqzBdMzpQKbA,4625 +triton/backends/nvidia/include/driver_types.h,sha256=4eBQ10Nzgfs2BlxGaGHVMWLvnJfKrEnMml9zfFi0DyA,177782 +triton/backends/nvidia/include/fatbinary_section.h,sha256=NnuUfy358yGJx4enq0pBnetjv17UWa-nOlgYToUitrw,1809 +triton/backends/nvidia/include/generated_cudaGL_meta.h,sha256=dfd2QuaRdEjbStOKvaQLi1Md_qrpRQh8PfyZznJ8bWY,3115 +triton/backends/nvidia/include/generated_cudaVDPAU_meta.h,sha256=fAedsoQxaU3hIAApAWDOKsa9kgcuQw4tdyf8klLm-3k,1453 +triton/backends/nvidia/include/generated_cuda_gl_interop_meta.h,sha256=LXOqvQCej0sCgAT1LUKKYZ466EFxN4hIwf9oIhXOLF0,2250 +triton/backends/nvidia/include/generated_cuda_meta.h,sha256=hawYpDe0xpaDFDnClXI91JjwCRxWb-AS0FS8ydUMgxc,94639 +triton/backends/nvidia/include/generated_cuda_runtime_api_meta.h,sha256=D8CbAN3-jLuF2KGfsBHXEELSgL92KrUAiDvugWE8B8M,69706 +triton/backends/nvidia/include/generated_cuda_vdpau_interop_meta.h,sha256=8OLqWN26aEYpTWUXtbHJvA5GYhVv3ybYVOTW7yK37z8,1367 +triton/backends/nvidia/include/generated_cudart_removed_meta.h,sha256=X3I5WXmhtsJNNlgY7coJ5vg4t11G5FRR6Xo7MboIeck,5172 +triton/backends/nvidia/include/generated_nvtx_meta.h,sha256=YHb_RD8g3s4m8PJn7Z0wnxvUHarl7BOAX5ADr-BL3HI,7513 +triton/backends/nvidia/include/host_config.h,sha256=BscH_GazAZbbotddVzL5RmafbQ-QjRx8f-I1O01IBW8,3380 +triton/backends/nvidia/include/host_defines.h,sha256=bBQwQF5C1N1c2qpLV56g1c-weu9Ysgz-gIf2Kn3uz_A,3386 +triton/backends/nvidia/include/library_types.h,sha256=p6746aCd_A_1VlgKRhLJChzeZ4tN7e4HBH2Hm7hDjbU,4836 +triton/backends/nvidia/include/math_constants.h,sha256=cV6hAyQe8X7f7MBtaKjjIJq3BycOUDp6I5cizJX5HLw,7608 +triton/backends/nvidia/include/math_functions.h,sha256=5XcC6j-fJKttvhwc4hZNoLHNw808a2ZYIOtZ7ry7yd0,3398 +triton/backends/nvidia/include/mma.h,sha256=IY_VenxuEncwGq92MhrWUb-Xswh0ekAXLy9Rbxhxa2Y,2932 +triton/backends/nvidia/include/nvPTXCompiler.h,sha256=z_v0P6Sj0KfDQBmAKIdgFoPOylhsO4B221w3KDUqbM0,12076 +triton/backends/nvidia/include/nvfunctional,sha256=IkFoCi_Q4OhP9nEuBI-5jWwFlR_PfG05hJH7lSMsfWc,2975 +triton/backends/nvidia/include/nvperf_common.h,sha256=BqPml9AxyN10-ptWT3hQzh2JUWqQX57Q5BjQ3ZuaKNs,17255 +triton/backends/nvidia/include/nvperf_cuda_host.h,sha256=aBnyIr_hexPDGBkP6WSujN1mI_DYP25sEIXWYY1O7VI,8298 +triton/backends/nvidia/include/nvperf_host.h,sha256=afdHG6eraeo4ltlF9ihskqhU7IccxcRCaZDZ6_ikjkg,68506 +triton/backends/nvidia/include/nvperf_target.h,sha256=ZDA-JI459tLBW4iLLCQjYYRAMeHwfqDIgXbVqVLDYZ4,22539 +triton/backends/nvidia/include/sm_20_atomic_functions.h,sha256=x4ycINVq__l9B4SQPD-I48jQbKxxdBmgp8Vf2GO0Qfg,4478 +triton/backends/nvidia/include/sm_20_atomic_functions.hpp,sha256=1l5NLM8DhDbqYZ_E51LoqElQJXObkbwo57d3r-4uEbE,4107 +triton/backends/nvidia/include/sm_20_intrinsics.h,sha256=a4jDSp_DUW0d09g5wgEm_I7bGTAe73HKRinkhBKQBis,51048 +triton/backends/nvidia/include/sm_20_intrinsics.hpp,sha256=BhEBuXSKBsNGJDBJDtYL0cGRI3wX_w_OIgA5D-YxIWk,7694 +triton/backends/nvidia/include/sm_30_intrinsics.h,sha256=b6W8Vxp9vD9OCJI6lZuGyZYXEdQ3Ei8PTAloHNkwCcQ,16978 +triton/backends/nvidia/include/sm_30_intrinsics.hpp,sha256=yX0ebd265tJ-BDhvluP2BhadPuWXpRZPI2eeQFFt5ys,24567 +triton/backends/nvidia/include/sm_32_atomic_functions.h,sha256=HGnZgQHACE2AAb6zabGUURc53IsVZelc2BSJqvs9OgY,5703 +triton/backends/nvidia/include/sm_32_atomic_functions.hpp,sha256=CQTTvOEYp-s5hqAgLvAon11vLYDrDp8cTHdel-XRzBQ,6592 +triton/backends/nvidia/include/sm_32_intrinsics.h,sha256=Xdkogdsjy1vh8u3eGu0i5xTmHxBGAjj6_vVGR-spdOE,33539 +triton/backends/nvidia/include/sm_32_intrinsics.hpp,sha256=Gl8aSLDLcit4W3pKQS19GsDG8RYcwD65HwYB_CeZe8M,70616 +triton/backends/nvidia/include/sm_35_atomic_functions.h,sha256=a3XoEsKRCEOf0Q_5Y__rMfmC4pScv4VkUggVgVJVn44,2909 +triton/backends/nvidia/include/sm_35_intrinsics.h,sha256=0mS5-LCgvZiTvL7-MG_4YwI-zWGvM-s4xyRuMkunMC8,2664 +triton/backends/nvidia/include/sm_60_atomic_functions.h,sha256=_anfNaJsvQpDEorYeUKIkbizYkwrinBcG_ZCiECtLqI,13178 +triton/backends/nvidia/include/sm_60_atomic_functions.hpp,sha256=cgIKddDn2B3QzYlzeBILAP1IRys74QCCxsH0QqaVGls,22903 +triton/backends/nvidia/include/sm_61_intrinsics.h,sha256=h_MBL1UUDxQX_qOddSImzqyFjcrhhm_63G97pGDyreU,10902 +triton/backends/nvidia/include/sm_61_intrinsics.hpp,sha256=N-nQvcBsPMT2Umy5zR69c9K1q366W-Jqe7NpoLTqTmg,6787 +triton/backends/nvidia/include/surface_functions.h,sha256=b1O82SAvEgWWxA9uZTWQcGimzZUoem2QbAET3wh3fZc,6782 +triton/backends/nvidia/include/surface_indirect_functions.h,sha256=vy9QuFVV-ezZP-x2RT9RLp2qIUgdngACOCmalSfVFPA,10877 +triton/backends/nvidia/include/surface_types.h,sha256=XkFXD1nHbeSMgajR-UJE9uQ7TByzJnjdnUL4-yGiufk,4530 +triton/backends/nvidia/include/texture_fetch_functions.h,sha256=KLCmUxf5aY5_UalX8tSFB6e4TrjA8hyUPxLOkMFltAo,12468 +triton/backends/nvidia/include/texture_indirect_functions.h,sha256=lH_y3Ni-hq4RZ0_PMFbBM0th5-OmTn3TtqtpkHHhA8w,21163 +triton/backends/nvidia/include/texture_types.h,sha256=73ntVyg8r8fzKy5VIk6yuvC45GDeWepaLIqIk-M3Ri8,6360 +triton/backends/nvidia/include/vector_functions.h,sha256=WypGkL-IDbGOlay7g_G0p3HO7OLGRE0Do__JtiFoWxY,8003 +triton/backends/nvidia/include/vector_functions.hpp,sha256=afXhNSd3LFTZo96EPtesTLfvxd4nTmLVzgkj967rTRg,10060 +triton/backends/nvidia/include/vector_types.h,sha256=6CJ4yt3KD7zQVfm1NhrgqNYYEDEIZWwaivlFx12nhNg,13396 +triton/backends/nvidia/lib/cupti/libcheckpoint.so,sha256=EGsm1PpJorzbPRR1EiWN4r_itT9gggP-hWFf7-vNc_4,1507009 +triton/backends/nvidia/lib/cupti/libcupti.so,sha256=mc-9PurtJImbLjpzvErDJT04BaJcQMBe6MLIf17HgWQ,7756057 +triton/backends/nvidia/lib/cupti/libcupti.so.12,sha256=mc-9PurtJImbLjpzvErDJT04BaJcQMBe6MLIf17HgWQ,7756057 +triton/backends/nvidia/lib/cupti/libcupti.so.2024.1.0,sha256=mc-9PurtJImbLjpzvErDJT04BaJcQMBe6MLIf17HgWQ,7756057 +triton/backends/nvidia/lib/cupti/libnvperf_host.so,sha256=hd_RMT1D7g6B3q9auwMqgn05ylkAvIf35MmpDVG9hGo,28159049 +triton/backends/nvidia/lib/cupti/libnvperf_target.so,sha256=p9-QHrZfD0PViRXSqL4WxENogAheR9_4ELS-1NSR-6k,5609441 +triton/backends/nvidia/lib/cupti/libpcsamplingutil.so,sha256=2ayD-Sns2y2Fcb-ZwWu8_50wCJvKddviHBEqm4hACHI,916321 +triton/backends/nvidia/lib/libdevice.10.bc,sha256=XC-uN8huaMOjhgWpX1EtfRLV89uYYxC-R_VzBKpype4,473728 +triton/compiler/__init__.py,sha256=kSVpmv2ro25zaF-fVJcpeyxMpRRb5uCiXQo7DqhG1CQ,239 +triton/compiler/__pycache__/__init__.cpython-310.pyc,, +triton/compiler/__pycache__/code_generator.cpython-310.pyc,, +triton/compiler/__pycache__/compiler.cpython-310.pyc,, +triton/compiler/__pycache__/errors.cpython-310.pyc,, +triton/compiler/__pycache__/make_launcher.cpython-310.pyc,, +triton/compiler/code_generator.py,sha256=g80O73MyM9acg7XNfcHgrq6I4bNgEd5_LY7gYp3vPsE,57574 +triton/compiler/compiler.py,sha256=Oazjlobciua1N9FK4UBXUkK1gzdGtRnm4ymzVfXZ42Q,17481 +triton/compiler/errors.py,sha256=I9Y15pDWcL9heY4SWWdLeMDtW6Iiq2pFXzKfJ6dY_C0,1732 +triton/compiler/make_launcher.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +triton/errors.py,sha256=8WfnuRKLG578mgY6cBA3ECruVMf9ULEKFNgRcJ6IhWM,89 +triton/instrumentation/libGPUInstrumentationTestLib.so,sha256=BU6ZPuWdF7OoobCmlWXgmJsLYVo325LmwKjZ115v6ao,12379168 +triton/language/__init__.py,sha256=jGmSXwL_gpfWobg5qwlU124HNi_aLX5cNgx_Y9NiBX0,4852 +triton/language/__pycache__/__init__.cpython-310.pyc,, +triton/language/__pycache__/_utils.cpython-310.pyc,, +triton/language/__pycache__/core.cpython-310.pyc,, +triton/language/__pycache__/math.cpython-310.pyc,, +triton/language/__pycache__/random.cpython-310.pyc,, +triton/language/__pycache__/semantic.cpython-310.pyc,, +triton/language/__pycache__/standard.cpython-310.pyc,, +triton/language/_utils.py,sha256=bkp98MH2y3mfSI7h1u_T33VPwYqsbnIJkjuwIsNsfE4,646 +triton/language/core.py,sha256=a9A4B5uUBn1ijuqSZFMP7APU1wJ_-DTom51vvDGui9k,93793 +triton/language/extra/__init__.py,sha256=XRXFvr7416pRsh_Rh-X6qV66SiEyVDVbxp4GSAE1mfc,655 +triton/language/extra/__pycache__/__init__.cpython-310.pyc,, +triton/language/extra/__pycache__/libdevice.cpython-310.pyc,, +triton/language/extra/cuda/__init__.py,sha256=JqiuryHnWRkfFztXgxbiQ62XA4dEKhsjhIHGobLuzcQ,414 +triton/language/extra/cuda/__pycache__/__init__.cpython-310.pyc,, +triton/language/extra/cuda/__pycache__/_experimental_tma.cpython-310.pyc,, +triton/language/extra/cuda/__pycache__/libdevice.cpython-310.pyc,, +triton/language/extra/cuda/__pycache__/utils.cpython-310.pyc,, +triton/language/extra/cuda/_experimental_tma.py,sha256=FwtsItBySF70RzS3qMKrlcdxznjFom6JD40QOs_RfNU,3555 +triton/language/extra/cuda/libdevice.py,sha256=crwXcdixYPuvzVOQ0e5styRAwQrUg0RRRlqek7QvXRw,56165 +triton/language/extra/cuda/utils.py,sha256=e1BslV7lZGhi2uVIlo5lI9dcN61HUMIU2asPaRjsyIo,4379 +triton/language/extra/hip/__init__.py,sha256=ieSER4LeX9_0horChGUUVwpuKAprkuka8uGAkEBDyDM,49 +triton/language/extra/hip/__pycache__/__init__.cpython-310.pyc,, +triton/language/extra/hip/__pycache__/libdevice.cpython-310.pyc,, +triton/language/extra/hip/libdevice.py,sha256=EVraUfeXzQmN3F5Lleg2mohVcbFWOWlLaAH1nkbqtV4,16841 +triton/language/extra/libdevice.py,sha256=Dki14elRNmQsz-Ytw9CnOaLCCnte4T6cI8bOzWjN63A,6318 +triton/language/math.py,sha256=Lkr348qTen3UxyB-tu4_j368LzCRK1KnIE7qwEC9Kg8,7442 +triton/language/random.py,sha256=s664rmyx6UCFJUo8M2EhNHUsckROwhmWXdf6UuAQp2I,6864 +triton/language/semantic.py,sha256=yJhocGpO3_X4YSk9GTRQMalbhDt7eh9SOzDq02Djg34,79854 +triton/language/standard.py,sha256=NMo6NQOJt81Zxy9s-U9o4xmg5DlKhY04H7WTRKfMBS4,13747 +triton/profiler/__init__.py,sha256=8MMGWMNsHxvgFva8l6o9lzUcAdGjpxiQouuTwJ4qkdQ,184 +triton/profiler/__pycache__/__init__.cpython-310.pyc,, +triton/profiler/__pycache__/flags.cpython-310.pyc,, +triton/profiler/__pycache__/hook.cpython-310.pyc,, +triton/profiler/__pycache__/profile.cpython-310.pyc,, +triton/profiler/__pycache__/proton.cpython-310.pyc,, +triton/profiler/__pycache__/scope.cpython-310.pyc,, +triton/profiler/__pycache__/viewer.cpython-310.pyc,, +triton/profiler/flags.py,sha256=BFBKQnozRN9Jp18_S5MuIeu5CJMW7_I38pM55qOg2oQ,604 +triton/profiler/hook.py,sha256=u5QsT4n4N94Xk2Cq23na7EuwUns1ZCNeShacUBgdwyo,1112 +triton/profiler/profile.py,sha256=iKoHJ_TxbaUUWgx6FvL9GyxnUFAE-fZKHVb7J4tk01o,6343 +triton/profiler/proton.py,sha256=ekp-_WPCn55Y0Xb4dLHVF-BOq07TLO5_BINILEeVPUA,2896 +triton/profiler/scope.py,sha256=9G87t4SpolCn0AzB8veK-xMM0x3hQ8ML7wdySbrJ0EQ,3169 +triton/profiler/viewer.py,sha256=oH8JtTFZ_VX1MCsZgT0FtzX8N5PPr76F_h9rrjyk1yM,13814 +triton/runtime/__init__.py,sha256=mKL5cqIBDUw2WO80NRCh4s1G8KYaqgM59TTAbTkPPjQ,621 +triton/runtime/__pycache__/__init__.cpython-310.pyc,, +triton/runtime/__pycache__/autotuner.cpython-310.pyc,, +triton/runtime/__pycache__/build.cpython-310.pyc,, +triton/runtime/__pycache__/cache.cpython-310.pyc,, +triton/runtime/__pycache__/driver.cpython-310.pyc,, +triton/runtime/__pycache__/errors.cpython-310.pyc,, +triton/runtime/__pycache__/interpreter.cpython-310.pyc,, +triton/runtime/__pycache__/jit.cpython-310.pyc,, +triton/runtime/autotuner.py,sha256=BJe69v9MSMSzdkvYSUDrvXrAFeLZ1x6A-7aUmpz2Le0,17271 +triton/runtime/build.py,sha256=KJgXirU54S8qTGsFpnG7DFuz5fK_kIUwReOhSgVEAnU,2830 +triton/runtime/cache.py,sha256=OQhUkwIW38-kayOL8P6SizWMAYSoVa_TbOYdTUHBkU0,10268 +triton/runtime/driver.py,sha256=VZ-883Xri71R72lHB6usIpLo3gGLbZJkAlLP3ewWSpc,1509 +triton/runtime/errors.py,sha256=oj73dn34qJbLhOjakakAuZPSv-laZyIYylJiJwREA8Y,787 +triton/runtime/interpreter.py,sha256=0SPiXDlM7X7DbCdu2JXoLmxJ8ugCwH_3NPoxuU0tJyg,53201 +triton/runtime/jit.py,sha256=8C8OgvZ0pRRL-8S2PbK9Knp6m6kbGE6O1immZpXVIzA,35303 +triton/testing.py,sha256=fX3pn9bjC3Z-z5qzSKW56C_2WF8h3mHLy5RJqpZ-HsA,19382 +triton/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +triton/tools/__pycache__/__init__.cpython-310.pyc,, +triton/tools/__pycache__/build_extern.cpython-310.pyc,, +triton/tools/__pycache__/compile.cpython-310.pyc,, +triton/tools/__pycache__/disasm.cpython-310.pyc,, +triton/tools/__pycache__/experimental_descriptor.cpython-310.pyc,, +triton/tools/__pycache__/link.cpython-310.pyc,, +triton/tools/build_extern.py,sha256=jCr-2hu3nLGBIJhCGUQ1jAyzLttughjkiPGEwRFjLR0,13673 +triton/tools/compile.c,sha256=rjuAQ8b-2DTtbj29SgK1NxJI5BSU2P9ccp9wa5p8Iyc,2090 +triton/tools/compile.h,sha256=n9QKIFZTL4RSsiXtAxBP9XGSnxjyaevQQ9bBpwDsvAg,332 +triton/tools/compile.py,sha256=b3yNnVgoBk8WzOs87JrZPDIyasdSgAslOWmxse1J6yM,6761 +triton/tools/disasm.py,sha256=BBO4bALdLcWgWDLhQdYHLlTx3oo8g_d8maeE_Uu-FmU,5088 +triton/tools/experimental_descriptor.py,sha256=0Wqy96Cc6YLh9o0eTknW-Lfvha6lfRSfe8bswkcPHMs,1260 +triton/tools/link.py,sha256=u7qtfZRLriZkAMEGNvj8YF-k1cthmLL7BwHYqBgT63E,11871 diff --git a/venv/lib/python3.10/site-packages/triton-3.2.0.dist-info/WHEEL b/venv/lib/python3.10/site-packages/triton-3.2.0.dist-info/WHEEL new file mode 100644 index 0000000000000000000000000000000000000000..91ee8fda184e552c2904a70107ce044d35988068 --- /dev/null +++ b/venv/lib/python3.10/site-packages/triton-3.2.0.dist-info/WHEEL @@ -0,0 +1,6 @@ +Wheel-Version: 1.0 +Generator: setuptools (75.8.0) +Root-Is-Purelib: false +Tag: cp310-cp310-manylinux_2_17_x86_64 +Tag: cp310-cp310-manylinux2014_x86_64 + diff --git a/venv/lib/python3.10/site-packages/triton-3.2.0.dist-info/entry_points.txt b/venv/lib/python3.10/site-packages/triton-3.2.0.dist-info/entry_points.txt new file mode 100644 index 0000000000000000000000000000000000000000..fec7e033ca5aee50e0b944b9c14f2987c668d505 --- /dev/null +++ b/venv/lib/python3.10/site-packages/triton-3.2.0.dist-info/entry_points.txt @@ -0,0 +1,3 @@ +[console_scripts] +proton = triton.profiler.proton:main +proton-viewer = triton.profiler.viewer:main diff --git a/venv/lib/python3.10/site-packages/triton-3.2.0.dist-info/top_level.txt b/venv/lib/python3.10/site-packages/triton-3.2.0.dist-info/top_level.txt new file mode 100644 index 0000000000000000000000000000000000000000..9bcbb7a6a4fa823eb1d1828c32e080e3214caddf --- /dev/null +++ b/venv/lib/python3.10/site-packages/triton-3.2.0.dist-info/top_level.txt @@ -0,0 +1,13 @@ +triton +triton/_C +triton/backends +triton/backends/amd +triton/backends/nvidia +triton/compiler +triton/language +triton/language/extra +triton/language/extra/cuda +triton/language/extra/hip +triton/profiler +triton/runtime +triton/tools diff --git a/venv/lib/python3.10/site-packages/uvloop-0.21.0.dist-info/INSTALLER b/venv/lib/python3.10/site-packages/uvloop-0.21.0.dist-info/INSTALLER new file mode 100644 index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68 --- /dev/null +++ b/venv/lib/python3.10/site-packages/uvloop-0.21.0.dist-info/INSTALLER @@ -0,0 +1 @@ +pip diff --git a/venv/lib/python3.10/site-packages/uvloop-0.21.0.dist-info/LICENSE-APACHE b/venv/lib/python3.10/site-packages/uvloop-0.21.0.dist-info/LICENSE-APACHE new file mode 100644 index 0000000000000000000000000000000000000000..5f66d4ee6e85dc68fc36a027dddb2368e3f71fb4 --- /dev/null +++ b/venv/lib/python3.10/site-packages/uvloop-0.21.0.dist-info/LICENSE-APACHE @@ -0,0 +1,203 @@ +Copyright (C) 2016-present the uvloop authors and contributors. + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright (c) 2015-present MagicStack Inc. http://magic.io + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/venv/lib/python3.10/site-packages/uvloop-0.21.0.dist-info/LICENSE-MIT b/venv/lib/python3.10/site-packages/uvloop-0.21.0.dist-info/LICENSE-MIT new file mode 100644 index 0000000000000000000000000000000000000000..40fd0230d7010bf08f207bf92874e3166d10f647 --- /dev/null +++ b/venv/lib/python3.10/site-packages/uvloop-0.21.0.dist-info/LICENSE-MIT @@ -0,0 +1,21 @@ +The MIT License + +Copyright (C) 2016-present the uvloop authors and contributors. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. diff --git a/venv/lib/python3.10/site-packages/uvloop-0.21.0.dist-info/METADATA b/venv/lib/python3.10/site-packages/uvloop-0.21.0.dist-info/METADATA new file mode 100644 index 0000000000000000000000000000000000000000..49012e493220ab4158fd4c8549ceaf8ca334b078 --- /dev/null +++ b/venv/lib/python3.10/site-packages/uvloop-0.21.0.dist-info/METADATA @@ -0,0 +1,175 @@ +Metadata-Version: 2.1 +Name: uvloop +Version: 0.21.0 +Summary: Fast implementation of asyncio event loop on top of libuv +Author-email: Yury Selivanov +License: MIT License +Project-URL: github, https://github.com/MagicStack/uvloop +Keywords: asyncio,networking +Classifier: Development Status :: 5 - Production/Stable +Classifier: Framework :: AsyncIO +Classifier: Intended Audience :: Developers +Classifier: License :: OSI Approved :: Apache Software License +Classifier: License :: OSI Approved :: MIT License +Classifier: Operating System :: POSIX +Classifier: Operating System :: MacOS :: MacOS X +Classifier: Programming Language :: Python :: 3 :: Only +Classifier: Programming Language :: Python :: 3.8 +Classifier: Programming Language :: Python :: 3.9 +Classifier: Programming Language :: Python :: 3.10 +Classifier: Programming Language :: Python :: 3.11 +Classifier: Programming Language :: Python :: 3.12 +Classifier: Programming Language :: Python :: 3.13 +Classifier: Programming Language :: Python :: Implementation :: CPython +Classifier: Topic :: System :: Networking +Requires-Python: >=3.8.0 +Description-Content-Type: text/x-rst +License-File: LICENSE-APACHE +License-File: LICENSE-MIT +Provides-Extra: dev +Requires-Dist: setuptools>=60; extra == "dev" +Requires-Dist: Cython~=3.0; extra == "dev" +Provides-Extra: docs +Requires-Dist: Sphinx~=4.1.2; extra == "docs" +Requires-Dist: sphinxcontrib-asyncio~=0.3.0; extra == "docs" +Requires-Dist: sphinx-rtd-theme~=0.5.2; extra == "docs" +Provides-Extra: test +Requires-Dist: aiohttp>=3.10.5; extra == "test" +Requires-Dist: flake8~=5.0; extra == "test" +Requires-Dist: psutil; extra == "test" +Requires-Dist: pycodestyle~=2.9.0; extra == "test" +Requires-Dist: pyOpenSSL~=23.0.0; extra == "test" +Requires-Dist: mypy>=0.800; extra == "test" + +.. image:: https://img.shields.io/github/actions/workflow/status/MagicStack/uvloop/tests.yml?branch=master + :target: https://github.com/MagicStack/uvloop/actions/workflows/tests.yml?query=branch%3Amaster + +.. image:: https://img.shields.io/pypi/v/uvloop.svg + :target: https://pypi.python.org/pypi/uvloop + +.. image:: https://pepy.tech/badge/uvloop + :target: https://pepy.tech/project/uvloop + :alt: PyPI - Downloads + + +uvloop is a fast, drop-in replacement of the built-in asyncio +event loop. uvloop is implemented in Cython and uses libuv +under the hood. + +The project documentation can be found +`here `_. Please also check out the +`wiki `_. + + +Performance +----------- + +uvloop makes asyncio 2-4x faster. + +.. image:: https://raw.githubusercontent.com/MagicStack/uvloop/master/performance.png + :target: http://magic.io/blog/uvloop-blazing-fast-python-networking/ + +The above chart shows the performance of an echo server with different +message sizes. The *sockets* benchmark uses ``loop.sock_recv()`` and +``loop.sock_sendall()`` methods; the *streams* benchmark uses asyncio +high-level streams, created by the ``asyncio.start_server()`` function; +and the *protocol* benchmark uses ``loop.create_server()`` with a simple +echo protocol. Read more about uvloop in a +`blog post `_ +about it. + + +Installation +------------ + +uvloop requires Python 3.8 or greater and is available on PyPI. +Use pip to install it:: + + $ pip install uvloop + +Note that it is highly recommended to **upgrade pip before** installing +uvloop with:: + + $ pip install -U pip + + +Using uvloop +------------ + +As of uvloop 0.18, the preferred way of using it is via the +``uvloop.run()`` helper function: + + +.. code:: python + + import uvloop + + async def main(): + # Main entry-point. + ... + + uvloop.run(main()) + +``uvloop.run()`` works by simply configuring ``asyncio.run()`` +to use uvloop, passing all of the arguments to it, such as ``debug``, +e.g. ``uvloop.run(main(), debug=True)``. + +With Python 3.11 and earlier the following alternative +snippet can be used: + +.. code:: python + + import asyncio + import sys + + import uvloop + + async def main(): + # Main entry-point. + ... + + if sys.version_info >= (3, 11): + with asyncio.Runner(loop_factory=uvloop.new_event_loop) as runner: + runner.run(main()) + else: + uvloop.install() + asyncio.run(main()) + + +Building From Source +-------------------- + +To build uvloop, you'll need Python 3.8 or greater: + +1. Clone the repository: + + .. code:: + + $ git clone --recursive git@github.com:MagicStack/uvloop.git + $ cd uvloop + +2. Create a virtual environment and activate it: + + .. code:: + + $ python3 -m venv uvloop-dev + $ source uvloop-dev/bin/activate + +3. Install development dependencies: + + .. code:: + + $ pip install -e .[dev] + +4. Build and run tests: + + .. code:: + + $ make + $ make test + + +License +------- + +uvloop is dual-licensed under MIT and Apache 2.0 licenses. diff --git a/venv/lib/python3.10/site-packages/uvloop-0.21.0.dist-info/RECORD b/venv/lib/python3.10/site-packages/uvloop-0.21.0.dist-info/RECORD new file mode 100644 index 0000000000000000000000000000000000000000..7eb4cab0eca4e6b87a8844cfc75ba4948e5f8ae5 --- /dev/null +++ b/venv/lib/python3.10/site-packages/uvloop-0.21.0.dist-info/RECORD @@ -0,0 +1,69 @@ +uvloop-0.21.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +uvloop-0.21.0.dist-info/LICENSE-APACHE,sha256=N3AlKHeY-dzYGeH4JvpfxeLzglKGkasFKMXPjIwoLCc,11439 +uvloop-0.21.0.dist-info/LICENSE-MIT,sha256=bdTDmfJt4EPXeirX4x20y1vwjqg2iwpC1uFYY1zIq2I,1105 +uvloop-0.21.0.dist-info/METADATA,sha256=UnacVCAjauzcbHHE4UVtxI84a9-D1B5zy0Fi_T6NGu0,4899 +uvloop-0.21.0.dist-info/RECORD,, +uvloop-0.21.0.dist-info/WHEEL,sha256=VXRyidHovicsPXAYYBPK-lnsPgFrrhXkyzySBEhHzcg,151 +uvloop-0.21.0.dist-info/top_level.txt,sha256=2cDaltyemYfQErB19s2jFmumeJRnbsZPJ7Lj9A78c6Y,7 +uvloop/__init__.py,sha256=CuY_C2LjdsJTwxAgU0tqRAU6Bb-XC0F5EUjJc70OZFc,5228 +uvloop/__pycache__/__init__.cpython-310.pyc,, +uvloop/__pycache__/_noop.cpython-310.pyc,, +uvloop/__pycache__/_testbase.cpython-310.pyc,, +uvloop/__pycache__/_version.cpython-310.pyc,, +uvloop/_noop.py,sha256=SDAJTiWhE7g3KyttbjPdliv-Uheuas-tKX4_y_nvO_Q,86 +uvloop/_testbase.py,sha256=sRZjHR-nMHv4UZ23AkSCtgEsvgo8uOqDchFNOFViiRg,15570 +uvloop/_version.py,sha256=pRhsSEFabYnSrcbRCuOkm0vrAr6wBs5E2NLUAzk-OqY,576 +uvloop/cbhandles.pxd,sha256=gW0spS84wbfuEHuYEbRSsHiKRmb5pfDHkYZvxhTC-Vo,752 +uvloop/cbhandles.pyx,sha256=PTQjEEN4yGloNP6lIHddNzDOFqowvGm_CvS9M6yHvc4,12298 +uvloop/dns.pyx,sha256=oHTr36ic6u9F-VFAAv0G92KY44O3-0x3ytcOAVvGmTs,14562 +uvloop/errors.pyx,sha256=2etYn89Th3tIsNMLl33Quc-1WkKKY7umPOVvilTzi9k,2774 +uvloop/handles/async_.pxd,sha256=xtsWSi0A67joJU4iFp5JWzQxwNj4LCq_KMDyDDMxdec,252 +uvloop/handles/async_.pyx,sha256=Hd_Bgi8I9uJZ20_2qUsHYYQtwq4LKtjTr3THQYKp-Sk,1516 +uvloop/handles/basetransport.pxd,sha256=SiDD77NPthTfjXVg12gJJGM1YYKZXw4AEK9tv22jJeE,1322 +uvloop/handles/basetransport.pyx,sha256=GtN3vdp6DDkh1g0RRPemj0r4x-Exskw-m16p_vY_E9g,9553 +uvloop/handles/check.pxd,sha256=IufFrzdMhLRc5zAjh7Lb0lAqw-UclrYVo-UgqIs6eJ0,276 +uvloop/handles/check.pyx,sha256=70d5oylnFnZjEJo_HBg5JYw2hE3PvkU3rhzALDEUOK8,1881 +uvloop/handles/fsevent.pxd,sha256=YfklQ9TeikRV2QRLNPAtkEwu_3vwrsOq9cMJxFV8VgI,325 +uvloop/handles/fsevent.pyx,sha256=RUV2-WhBo2OjXFn0N49l4th1DFZ0kdC-7YgsIZkUBoI,2823 +uvloop/handles/handle.pxd,sha256=QPjUCObkDwvjRAZFlolF1tNXFV9-jAf22V0KweiLdOA,1189 +uvloop/handles/handle.pyx,sha256=YOaN1fSPzo_IJA3IbG7E10pc-dbAN7y8DyGZoLgho-M,13248 +uvloop/handles/idle.pxd,sha256=L3Gr2tuzKHWEB2NnykwjbNyexNUlckBdGFKPufn5AZU,274 +uvloop/handles/idle.pyx,sha256=BXi_PQrgbPN2n3-QybHo0CLhW2m9N7benwSb4q7u87I,1859 +uvloop/handles/pipe.pxd,sha256=LzsEOwptkqNa52O1Iyqhxq2d4ppzmHr0x8cMwJIZZfk,933 +uvloop/handles/pipe.pyx,sha256=9xINAS1xZuPM87gS-QYVGwUn_4JhcqKwqJobjpHHGkM,7688 +uvloop/handles/poll.pxd,sha256=afAR6gAx52OnmPqaHa3y41xxtIYxam1w9XoNZRxNMwU,575 +uvloop/handles/poll.pyx,sha256=kjlhSrRyOHnH2tJJLmBtE0ePltUWTKphJ6ml8RP0Qhg,6511 +uvloop/handles/process.pxd,sha256=FKCuQWWzDL8r0N1phlwPJ_pGGY3TZsOl5rBQP4AlgYo,2314 +uvloop/handles/process.pyx,sha256=x89gE5JCApGshWqln-2qxYI_I262r5udmLCnBAyW--w,26919 +uvloop/handles/stream.pxd,sha256=1BASyhG8z9HDf4ZikWPqd-hldQgGSdHl3ta-nNEnChE,1535 +uvloop/handles/stream.pyx,sha256=bizhF7PRNmy3Zcd7anORwZRAsQx4tV31dhzqNf5_fAc,31856 +uvloop/handles/streamserver.pxd,sha256=hIDDhB2RK0lnMUscDWcGl2NRkclb6AYfche77YEdaes,786 +uvloop/handles/streamserver.pyx,sha256=quWwKo_rz4Jzq-YNLZQ7lmcBNLSzQBpf31nS64jhbrU,4632 +uvloop/handles/tcp.pxd,sha256=xNYy-df1tK5ywK3V7a0wWno9tAA7JH-FiIQ5F0296ZM,892 +uvloop/handles/tcp.pyx,sha256=22isLLJ9__U7Bx2ZQwWP3Mozt0DZ66aOLREW7adKGLs,7291 +uvloop/handles/timer.pxd,sha256=VcLZBfzd9ixuxmJrE9O3YmyVO4LfMDwcG7UNpJbTu40,440 +uvloop/handles/timer.pyx,sha256=zT35AW9Wv9H_zWa6sw7GOi4SB7HavGUobFezTFfSq6E,2416 +uvloop/handles/udp.pxd,sha256=gQn9FH4rAiXDR_kZNqaYcNMGMzFL-T1V1G8JI6JOHU8,671 +uvloop/handles/udp.pyx,sha256=_doWmjAsh3vPES_CLQ7j309f71qK_6YIBGKtimpjAO8,12039 +uvloop/includes/__init__.py,sha256=-OUZ6zr6Opdw78PKsHYi1AuP74Ep7XByxyoRYOuRtgI,361 +uvloop/includes/__pycache__/__init__.cpython-310.pyc,, +uvloop/includes/consts.pxi,sha256=m6K9HIUl8G3D9iOIzK0C3_chXKwIfsiq88j3VOvUuU4,843 +uvloop/includes/debug.pxd,sha256=cCnlyp6HkhQgVF7lAQPA31wIa1n1pn6eUY_wARYh3uA,64 +uvloop/includes/flowcontrol.pxd,sha256=7PuZtEgp4TS1Y3iNqZZInkDKI5iCylERrcLqe2ls3EY,458 +uvloop/includes/python.pxd,sha256=SSB2FPEsEt_Aif66l-SQvFpJ3I7TrgbL4lsiu_Kyu9k,846 +uvloop/includes/stdlib.pxi,sha256=k49jKoHwvBhVho5W95yQrPMKskonEhQpqi95GZe6RHM,6361 +uvloop/includes/system.pxd,sha256=pbXOeZeXaDZ0b3CIFOgObE5C-cr6vhi6io-F8wLIaNQ,2186 +uvloop/includes/uv.pxd,sha256=wkayMxCaI9RyxTb1sqkP6DdU6l_w9ql18SYAoEYSNiA,16080 +uvloop/loop.cpython-310-x86_64-linux-gnu.so,sha256=zBqYMHQ9pyz-2E3qNfo8ispdd0vU2SOd0RDq82HcwuI,13041992 +uvloop/loop.pxd,sha256=1C4lOQV6MTWmvAnL67W3CvEyBdnDNYLEtCMPTZD40s8,6224 +uvloop/loop.pyi,sha256=xLLboc-tuzlu68RcUhghA-jjSy-mMNixiVDNY6TZueU,10504 +uvloop/loop.pyx,sha256=C2jMCvqkhswEcq9rjg0lbieAIXeksLiFyXQAz9tRI6g,118619 +uvloop/lru.pyx,sha256=nBZ4zuy4XjsdLorq-JhNS7WObcLpZWMr1OjyRvv8FaI,2279 +uvloop/pseudosock.pyx,sha256=M3H7qMGFXE9ZZLvYwOgBl3ZcNA5OKSnZ7NUGLJA7AlA,5383 +uvloop/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +uvloop/request.pxd,sha256=7yx8JlG0Hu2cv_i2QCZ_WdLlsGjI0z5eM_ueOOOgK6w,143 +uvloop/request.pyx,sha256=6-8Dme6LoT88B5-MzvmpuLn3hGt1eZlekvQxG0x2y8s,2259 +uvloop/server.pxd,sha256=_zRDiZMjsmlxJRo0KDzSM0xyfg2k-TzlGln54wvXC-Y,394 +uvloop/server.pyx,sha256=6wC5vUhAHnnUs7qHOJXvRkgov38IeY8xp6w45-rCRFc,3623 +uvloop/sslproto.pxd,sha256=fCM5XWu5ZSTDpf5_-wF2jvj77Y403yk40QOiWc0wo1s,3534 +uvloop/sslproto.pyx,sha256=EL1fckxojYK42OCAIJ-geUoKc0uncPH1hXg50roBQ-0,35381 diff --git a/venv/lib/python3.10/site-packages/uvloop-0.21.0.dist-info/WHEEL b/venv/lib/python3.10/site-packages/uvloop-0.21.0.dist-info/WHEEL new file mode 100644 index 0000000000000000000000000000000000000000..0b1249e7ab4978615ea2e05101e51c0779008f78 --- /dev/null +++ b/venv/lib/python3.10/site-packages/uvloop-0.21.0.dist-info/WHEEL @@ -0,0 +1,6 @@ +Wheel-Version: 1.0 +Generator: setuptools (75.1.0) +Root-Is-Purelib: false +Tag: cp310-cp310-manylinux_2_17_x86_64 +Tag: cp310-cp310-manylinux2014_x86_64 + diff --git a/venv/lib/python3.10/site-packages/uvloop-0.21.0.dist-info/top_level.txt b/venv/lib/python3.10/site-packages/uvloop-0.21.0.dist-info/top_level.txt new file mode 100644 index 0000000000000000000000000000000000000000..99d47169df5668e3ecc365e7792595e5333d7eb5 --- /dev/null +++ b/venv/lib/python3.10/site-packages/uvloop-0.21.0.dist-info/top_level.txt @@ -0,0 +1 @@ +uvloop diff --git a/venv/lib/python3.10/site-packages/vllm-0.8.5.dist-info/INSTALLER b/venv/lib/python3.10/site-packages/vllm-0.8.5.dist-info/INSTALLER new file mode 100644 index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68 --- /dev/null +++ b/venv/lib/python3.10/site-packages/vllm-0.8.5.dist-info/INSTALLER @@ -0,0 +1 @@ +pip diff --git a/venv/lib/python3.10/site-packages/vllm-0.8.5.dist-info/METADATA b/venv/lib/python3.10/site-packages/vllm-0.8.5.dist-info/METADATA new file mode 100644 index 0000000000000000000000000000000000000000..c15826c151df578a0296079f3c2c19d64da8388c --- /dev/null +++ b/venv/lib/python3.10/site-packages/vllm-0.8.5.dist-info/METADATA @@ -0,0 +1,256 @@ +Metadata-Version: 2.4 +Name: vllm +Version: 0.8.5 +Summary: A high-throughput and memory-efficient inference and serving engine for LLMs +Author: vLLM Team +License-Expression: Apache-2.0 +Project-URL: Homepage, https://github.com/vllm-project/vllm +Project-URL: Documentation, https://vllm.readthedocs.io/en/latest/ +Project-URL: Slack, http://slack.vllm.ai/ +Classifier: Programming Language :: Python :: 3.9 +Classifier: Programming Language :: Python :: 3.10 +Classifier: Programming Language :: Python :: 3.11 +Classifier: Programming Language :: Python :: 3.12 +Classifier: Intended Audience :: Developers +Classifier: Intended Audience :: Information Technology +Classifier: Intended Audience :: Science/Research +Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence +Classifier: Topic :: Scientific/Engineering :: Information Analysis +Requires-Python: <3.13,>=3.9 +Description-Content-Type: text/markdown +License-File: LICENSE +Requires-Dist: cachetools +Requires-Dist: psutil +Requires-Dist: sentencepiece +Requires-Dist: numpy +Requires-Dist: requests>=2.26.0 +Requires-Dist: tqdm +Requires-Dist: blake3 +Requires-Dist: py-cpuinfo +Requires-Dist: transformers>=4.51.1 +Requires-Dist: huggingface-hub[hf_xet]>=0.30.0 +Requires-Dist: tokenizers>=0.21.1 +Requires-Dist: protobuf +Requires-Dist: fastapi[standard]>=0.115.0 +Requires-Dist: aiohttp +Requires-Dist: openai>=1.52.0 +Requires-Dist: pydantic>=2.9 +Requires-Dist: prometheus_client>=0.18.0 +Requires-Dist: pillow +Requires-Dist: prometheus-fastapi-instrumentator>=7.0.0 +Requires-Dist: tiktoken>=0.6.0 +Requires-Dist: lm-format-enforcer<0.11,>=0.10.11 +Requires-Dist: llguidance<0.8.0,>=0.7.9; platform_machine == "x86_64" or platform_machine == "arm64" or platform_machine == "aarch64" +Requires-Dist: outlines==0.1.11 +Requires-Dist: lark==1.2.2 +Requires-Dist: xgrammar==0.1.18; platform_machine == "x86_64" or platform_machine == "aarch64" +Requires-Dist: typing_extensions>=4.10 +Requires-Dist: filelock>=3.16.1 +Requires-Dist: partial-json-parser +Requires-Dist: pyzmq>=25.0.0 +Requires-Dist: msgspec +Requires-Dist: gguf>=0.13.0 +Requires-Dist: importlib_metadata +Requires-Dist: mistral_common[opencv]>=1.5.4 +Requires-Dist: opencv-python-headless>=4.11.0 +Requires-Dist: pyyaml +Requires-Dist: six>=1.16.0; python_version > "3.11" +Requires-Dist: setuptools>=74.1.1; python_version > "3.11" +Requires-Dist: einops +Requires-Dist: compressed-tensors==0.9.3 +Requires-Dist: depyf==0.18.0 +Requires-Dist: cloudpickle +Requires-Dist: watchfiles +Requires-Dist: python-json-logger +Requires-Dist: scipy +Requires-Dist: ninja +Requires-Dist: opentelemetry-sdk<1.27.0,>=1.26.0 +Requires-Dist: opentelemetry-api<1.27.0,>=1.26.0 +Requires-Dist: opentelemetry-exporter-otlp<1.27.0,>=1.26.0 +Requires-Dist: opentelemetry-semantic-conventions-ai<0.5.0,>=0.4.1 +Requires-Dist: numba==0.60.0; python_version == "3.9" +Requires-Dist: numba==0.61.2; python_version > "3.9" +Requires-Dist: ray[cgraph]!=2.44.*,>=2.43.0 +Requires-Dist: torch==2.6.0 +Requires-Dist: torchaudio==2.6.0 +Requires-Dist: torchvision==0.21.0 +Requires-Dist: xformers==0.0.29.post2; platform_system == "Linux" and platform_machine == "x86_64" +Provides-Extra: tensorizer +Requires-Dist: tensorizer>=2.9.0; extra == "tensorizer" +Provides-Extra: fastsafetensors +Requires-Dist: fastsafetensors>=0.1.10; extra == "fastsafetensors" +Provides-Extra: runai +Requires-Dist: runai-model-streamer; extra == "runai" +Requires-Dist: runai-model-streamer-s3; extra == "runai" +Requires-Dist: boto3; extra == "runai" +Provides-Extra: audio +Requires-Dist: librosa; extra == "audio" +Requires-Dist: soundfile; extra == "audio" +Provides-Extra: video +Dynamic: license-file +Dynamic: provides-extra +Dynamic: requires-dist + +

+ + + vLLM + +

+ +

+Easy, fast, and cheap LLM serving for everyone +

+ +

+| Documentation | Blog | Paper | Twitter/X | User Forum | Developer Slack | +

+ +--- + +*Latest News* 🔥 +- [2025/04] We hosted [Asia Developer Day](https://www.sginnovate.com/event/limited-availability-morning-evening-slots-remaining-inaugural-vllm-asia-developer-day)! Please find the meetup slides from the vLLM team [here](https://docs.google.com/presentation/d/19cp6Qu8u48ihB91A064XfaXruNYiBOUKrBxAmDOllOo/edit?usp=sharing). +- [2025/03] We hosted [vLLM x Ollama Inference Night](https://lu.ma/vllm-ollama)! Please find the meetup slides from the vLLM team [here](https://docs.google.com/presentation/d/16T2PDD1YwRnZ4Tu8Q5r6n53c5Lr5c73UV9Vd2_eBo4U/edit?usp=sharing). +- [2025/03] We hosted [the first vLLM China Meetup](https://mp.weixin.qq.com/s/n77GibL2corAtQHtVEAzfg)! Please find the meetup slides from vLLM team [here](https://docs.google.com/presentation/d/1REHvfQMKGnvz6p3Fd23HhSO4c8j5WPGZV0bKYLwnHyQ/edit?usp=sharing). +- [2025/03] We hosted [the East Coast vLLM Meetup](https://lu.ma/7mu4k4xx)! Please find the meetup slides [here](https://docs.google.com/presentation/d/1NHiv8EUFF1NLd3fEYODm56nDmL26lEeXCaDgyDlTsRs/edit#slide=id.g31441846c39_0_0). +- [2025/02] We hosted [the ninth vLLM meetup](https://lu.ma/h7g3kuj9) with Meta! Please find the meetup slides from vLLM team [here](https://docs.google.com/presentation/d/1jzC_PZVXrVNSFVCW-V4cFXb6pn7zZ2CyP_Flwo05aqg/edit?usp=sharing) and AMD [here](https://drive.google.com/file/d/1Zk5qEJIkTmlQ2eQcXQZlljAx3m9s7nwn/view?usp=sharing). The slides from Meta will not be posted. +- [2025/01] We are excited to announce the alpha release of vLLM V1: A major architectural upgrade with 1.7x speedup! Clean code, optimized execution loop, zero-overhead prefix caching, enhanced multimodal support, and more. Please check out our blog post [here](https://blog.vllm.ai/2025/01/27/v1-alpha-release.html). +- [2025/01] We hosted [the eighth vLLM meetup](https://lu.ma/zep56hui) with Google Cloud! Please find the meetup slides from vLLM team [here](https://docs.google.com/presentation/d/1epVkt4Zu8Jz_S5OhEHPc798emsYh2BwYfRuDDVEF7u4/edit?usp=sharing), and Google Cloud team [here](https://drive.google.com/file/d/1h24pHewANyRL11xy5dXUbvRC9F9Kkjix/view?usp=sharing). +- [2024/12] vLLM joins [pytorch ecosystem](https://pytorch.org/blog/vllm-joins-pytorch)! Easy, Fast, and Cheap LLM Serving for Everyone! + +
+Previous News + +- [2024/11] We hosted [the seventh vLLM meetup](https://lu.ma/h0qvrajz) with Snowflake! Please find the meetup slides from vLLM team [here](https://docs.google.com/presentation/d/1e3CxQBV3JsfGp30SwyvS3eM_tW-ghOhJ9PAJGK6KR54/edit?usp=sharing), and Snowflake team [here](https://docs.google.com/presentation/d/1qF3RkDAbOULwz9WK5TOltt2fE9t6uIc_hVNLFAaQX6A/edit?usp=sharing). +- [2024/10] We have just created a developer slack ([slack.vllm.ai](https://slack.vllm.ai)) focusing on coordinating contributions and discussing features. Please feel free to join us there! +- [2024/10] Ray Summit 2024 held a special track for vLLM! Please find the opening talk slides from the vLLM team [here](https://docs.google.com/presentation/d/1B_KQxpHBTRa_mDF-tR6i8rWdOU5QoTZNcEg2MKZxEHM/edit?usp=sharing). Learn more from the [talks](https://www.youtube.com/playlist?list=PLzTswPQNepXl6AQwifuwUImLPFRVpksjR) from other vLLM contributors and users! +- [2024/09] We hosted [the sixth vLLM meetup](https://lu.ma/87q3nvnh) with NVIDIA! Please find the meetup slides [here](https://docs.google.com/presentation/d/1wrLGwytQfaOTd5wCGSPNhoaW3nq0E-9wqyP7ny93xRs/edit?usp=sharing). +- [2024/07] We hosted [the fifth vLLM meetup](https://lu.ma/lp0gyjqr) with AWS! Please find the meetup slides [here](https://docs.google.com/presentation/d/1RgUD8aCfcHocghoP3zmXzck9vX3RCI9yfUAB2Bbcl4Y/edit?usp=sharing). +- [2024/07] In partnership with Meta, vLLM officially supports Llama 3.1 with FP8 quantization and pipeline parallelism! Please check out our blog post [here](https://blog.vllm.ai/2024/07/23/llama31.html). +- [2024/06] We hosted [the fourth vLLM meetup](https://lu.ma/agivllm) with Cloudflare and BentoML! Please find the meetup slides [here](https://docs.google.com/presentation/d/1iJ8o7V2bQEi0BFEljLTwc5G1S10_Rhv3beed5oB0NJ4/edit?usp=sharing). +- [2024/04] We hosted [the third vLLM meetup](https://robloxandvllmmeetup2024.splashthat.com/) with Roblox! Please find the meetup slides [here](https://docs.google.com/presentation/d/1A--47JAK4BJ39t954HyTkvtfwn0fkqtsL8NGFuslReM/edit?usp=sharing). +- [2024/01] We hosted [the second vLLM meetup](https://lu.ma/ygxbpzhl) with IBM! Please find the meetup slides [here](https://docs.google.com/presentation/d/12mI2sKABnUw5RBWXDYY-HtHth4iMSNcEoQ10jDQbxgA/edit?usp=sharing). +- [2023/10] We hosted [the first vLLM meetup](https://lu.ma/first-vllm-meetup) with a16z! Please find the meetup slides [here](https://docs.google.com/presentation/d/1QL-XPFXiFpDBh86DbEegFXBXFXjix4v032GhShbKf3s/edit?usp=sharing). +- [2023/08] We would like to express our sincere gratitude to [Andreessen Horowitz](https://a16z.com/2023/08/30/supporting-the-open-source-ai-community/) (a16z) for providing a generous grant to support the open-source development and research of vLLM. +- [2023/06] We officially released vLLM! FastChat-vLLM integration has powered [LMSYS Vicuna and Chatbot Arena](https://chat.lmsys.org) since mid-April. Check out our [blog post](https://vllm.ai). + +
+ +--- +## About + +vLLM is a fast and easy-to-use library for LLM inference and serving. + +Originally developed in the [Sky Computing Lab](https://sky.cs.berkeley.edu) at UC Berkeley, vLLM has evolved into a community-driven project with contributions from both academia and industry. + +vLLM is fast with: + +- State-of-the-art serving throughput +- Efficient management of attention key and value memory with [**PagedAttention**](https://blog.vllm.ai/2023/06/20/vllm.html) +- Continuous batching of incoming requests +- Fast model execution with CUDA/HIP graph +- Quantizations: [GPTQ](https://arxiv.org/abs/2210.17323), [AWQ](https://arxiv.org/abs/2306.00978), INT4, INT8, and FP8. +- Optimized CUDA kernels, including integration with FlashAttention and FlashInfer. +- Speculative decoding +- Chunked prefill + +**Performance benchmark**: We include a performance benchmark at the end of [our blog post](https://blog.vllm.ai/2024/09/05/perf-update.html). It compares the performance of vLLM against other LLM serving engines ([TensorRT-LLM](https://github.com/NVIDIA/TensorRT-LLM), [SGLang](https://github.com/sgl-project/sglang) and [LMDeploy](https://github.com/InternLM/lmdeploy)). The implementation is under [nightly-benchmarks folder](.buildkite/nightly-benchmarks/) and you can [reproduce](https://github.com/vllm-project/vllm/issues/8176) this benchmark using our one-click runnable script. + +vLLM is flexible and easy to use with: + +- Seamless integration with popular Hugging Face models +- High-throughput serving with various decoding algorithms, including *parallel sampling*, *beam search*, and more +- Tensor parallelism and pipeline parallelism support for distributed inference +- Streaming outputs +- OpenAI-compatible API server +- Support NVIDIA GPUs, AMD CPUs and GPUs, Intel CPUs and GPUs, PowerPC CPUs, TPU, and AWS Neuron. +- Prefix caching support +- Multi-lora support + +vLLM seamlessly supports most popular open-source models on HuggingFace, including: +- Transformer-like LLMs (e.g., Llama) +- Mixture-of-Expert LLMs (e.g., Mixtral, Deepseek-V2 and V3) +- Embedding Models (e.g. E5-Mistral) +- Multi-modal LLMs (e.g., LLaVA) + +Find the full list of supported models [here](https://docs.vllm.ai/en/latest/models/supported_models.html). + +## Getting Started + +Install vLLM with `pip` or [from source](https://docs.vllm.ai/en/latest/getting_started/installation/gpu/index.html#build-wheel-from-source): + +```bash +pip install vllm +``` + +Visit our [documentation](https://docs.vllm.ai/en/latest/) to learn more. +- [Installation](https://docs.vllm.ai/en/latest/getting_started/installation.html) +- [Quickstart](https://docs.vllm.ai/en/latest/getting_started/quickstart.html) +- [List of Supported Models](https://docs.vllm.ai/en/latest/models/supported_models.html) + +## Contributing + +We welcome and value any contributions and collaborations. +Please check out [Contributing to vLLM](https://docs.vllm.ai/en/stable/contributing/overview.html) for how to get involved. + +## Sponsors + +vLLM is a community project. Our compute resources for development and testing are supported by the following organizations. Thank you for your support! + + + +Cash Donations: +- a16z +- Dropbox +- Sequoia Capital +- Skywork AI +- ZhenFund + +Compute Resources: +- AMD +- Anyscale +- AWS +- Crusoe Cloud +- Databricks +- DeepInfra +- Google Cloud +- Intel +- Lambda Lab +- Nebius +- Novita AI +- NVIDIA +- Replicate +- Roblox +- RunPod +- Trainy +- UC Berkeley +- UC San Diego + +Slack Sponsor: Anyscale + +We also have an official fundraising venue through [OpenCollective](https://opencollective.com/vllm). We plan to use the fund to support the development, maintenance, and adoption of vLLM. + +## Citation + +If you use vLLM for your research, please cite our [paper](https://arxiv.org/abs/2309.06180): + +```bibtex +@inproceedings{kwon2023efficient, + title={Efficient Memory Management for Large Language Model Serving with PagedAttention}, + author={Woosuk Kwon and Zhuohan Li and Siyuan Zhuang and Ying Sheng and Lianmin Zheng and Cody Hao Yu and Joseph E. Gonzalez and Hao Zhang and Ion Stoica}, + booktitle={Proceedings of the ACM SIGOPS 29th Symposium on Operating Systems Principles}, + year={2023} +} +``` + +## Contact Us + +- For technical questions and feature requests, please use GitHub [Issues](https://github.com/vllm-project/vllm/issues) or [Discussions](https://github.com/vllm-project/vllm/discussions) +- For discussing with fellow users, please use the [vLLM Forum](https://discuss.vllm.ai) +- coordinating contributions and development, please use [Slack](https://slack.vllm.ai) +- For security disclosures, please use GitHub's [Security Advisories](https://github.com/vllm-project/vllm/security/advisories) feature +- For collaborations and partnerships, please contact us at [vllm-questions@lists.berkeley.edu](mailto:vllm-questions@lists.berkeley.edu) + +## Media Kit + +- If you wish to use vLLM's logo, please refer to [our media kit repo](https://github.com/vllm-project/media-kit). diff --git a/venv/lib/python3.10/site-packages/vllm-0.8.5.dist-info/RECORD b/venv/lib/python3.10/site-packages/vllm-0.8.5.dist-info/RECORD new file mode 100644 index 0000000000000000000000000000000000000000..641e3816dfe91d445de449e4e3facf13c588e2ad --- /dev/null +++ b/venv/lib/python3.10/site-packages/vllm-0.8.5.dist-info/RECORD @@ -0,0 +1,1860 @@ +../../../bin/vllm,sha256=cpSkNf4_pP8sRgkL6nqNQDimv6dCifp3tfgGPh2uGko,294 +vllm-0.8.5.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +vllm-0.8.5.dist-info/METADATA,sha256=SvOPdNXJ_DQt3lMGeywWEYCn3QUZ4Do2hIYZYG0_iBY,14841 +vllm-0.8.5.dist-info/RECORD,, +vllm-0.8.5.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +vllm-0.8.5.dist-info/WHEEL,sha256=PElZnck8YsV7GRbdwFsDUHlQ8Q-tiGhkHCE2c8a2gCw,102 +vllm-0.8.5.dist-info/entry_points.txt,sha256=Tzs5SimudQtsKYvM1TICJcRnD-2QYhptzMObwvRogNk,56 +vllm-0.8.5.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357 +vllm-0.8.5.dist-info/top_level.txt,sha256=fAgb8Pt4zQoKTUA3ZnKEIgcjh0L97_dwEjYDTL5MEEo,5 +vllm/_C.abi3.so,sha256=v0fKRSx88YyrR7ZRsp2cGnA9MhSeIBOdkqRycmq6bMs,237255440 +vllm/__init__.py,sha256=0YkYfsGThrlU2v8dAG5Y9GcKErsRnEo5hbYxVC5Oj2E,1915 +vllm/__pycache__/__init__.cpython-310.pyc,, +vllm/__pycache__/_custom_ops.cpython-310.pyc,, +vllm/__pycache__/_ipex_ops.cpython-310.pyc,, +vllm/__pycache__/_version.cpython-310.pyc,, +vllm/__pycache__/beam_search.cpython-310.pyc,, +vllm/__pycache__/collect_env.cpython-310.pyc,, +vllm/__pycache__/config.cpython-310.pyc,, +vllm/__pycache__/connections.cpython-310.pyc,, +vllm/__pycache__/env_override.cpython-310.pyc,, +vllm/__pycache__/envs.cpython-310.pyc,, +vllm/__pycache__/forward_context.cpython-310.pyc,, +vllm/__pycache__/jsontree.cpython-310.pyc,, +vllm/__pycache__/logger.cpython-310.pyc,, +vllm/__pycache__/logits_process.cpython-310.pyc,, +vllm/__pycache__/outputs.cpython-310.pyc,, +vllm/__pycache__/pooling_params.cpython-310.pyc,, +vllm/__pycache__/sampling_params.cpython-310.pyc,, +vllm/__pycache__/scalar_type.cpython-310.pyc,, +vllm/__pycache__/scripts.cpython-310.pyc,, +vllm/__pycache__/sequence.cpython-310.pyc,, +vllm/__pycache__/test_utils.cpython-310.pyc,, +vllm/__pycache__/tracing.cpython-310.pyc,, +vllm/__pycache__/utils.cpython-310.pyc,, +vllm/__pycache__/version.cpython-310.pyc,, +vllm/_custom_ops.py,sha256=nSfiXvbc-JHJihhQW4OkLJq3Uy74YaILzP2eB3RhRLI,63292 +vllm/_flashmla_C.abi3.so,sha256=9AY9yx6XR7CpJoDUi2tUFC88XYlK1X2gTK7Ga2b8XdI,677368 +vllm/_ipex_ops.py,sha256=RD5-a6UtbwTQ6yahU1y_2Zckh4E2j2TlUsY6-efxnRM,8687 +vllm/_moe_C.abi3.so,sha256=Bi5zkOCnE5QzMkNHWhSDmAsoLMaJyWCIWHE1_M6m_2g,119573960 +vllm/_version.py,sha256=3Z4eAPyRkF92atn8D8Yqhnpt9bN3nNnj07uUltorfs0,511 +vllm/adapter_commons/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +vllm/adapter_commons/__pycache__/__init__.cpython-310.pyc,, +vllm/adapter_commons/__pycache__/layers.cpython-310.pyc,, +vllm/adapter_commons/__pycache__/models.cpython-310.pyc,, +vllm/adapter_commons/__pycache__/request.cpython-310.pyc,, +vllm/adapter_commons/__pycache__/utils.cpython-310.pyc,, +vllm/adapter_commons/__pycache__/worker_manager.cpython-310.pyc,, +vllm/adapter_commons/layers.py,sha256=rdsvBlYTiblidwK2EYkl3UdB4xvopcrd8li3vPFTbwo,406 +vllm/adapter_commons/models.py,sha256=tuuVafwk9Yvfl8uCXSg1Whzm2Wsq8W7JqypRm_XpBzg,2807 +vllm/adapter_commons/request.py,sha256=GoLdKUNCU6x-8plK95CuLOy56QOSYW6IQAg6ZQg76C8,617 +vllm/adapter_commons/utils.py,sha256=ytCCfLdk-FwWCflWMSTazUPg2gNmXjaovEWbpvQ6fe0,3271 +vllm/adapter_commons/worker_manager.py,sha256=qBj7swkk7LJoQi2GpueMQFMbVPjphnuzOKIc36oQ6Ts,928 +vllm/assets/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +vllm/assets/__pycache__/__init__.cpython-310.pyc,, +vllm/assets/__pycache__/audio.cpython-310.pyc,, +vllm/assets/__pycache__/base.cpython-310.pyc,, +vllm/assets/__pycache__/image.cpython-310.pyc,, +vllm/assets/__pycache__/video.cpython-310.pyc,, +vllm/assets/audio.py,sha256=nUfScoi0ZPE4E0VsmcIp5-qT-0yJXMVHqbKC7HUkJTw,1082 +vllm/assets/base.py,sha256=IdwWieuPqaAaYKo2ybSfg07dt86k4-NrP1BHPCrFN2s,1196 +vllm/assets/image.py,sha256=Kn7HrcJEIXKUcx7IUUcixkslwKannvgGVXWa77bI19s,922 +vllm/assets/video.py,sha256=xh4lUSaWIKJcnAFVvxnzWDGPC23WW5GZiXDNCUpeOhI,3159 +vllm/attention/__init__.py,sha256=YW7x8Ahq9TPxx8GiduskAliKrJUM5i-kDrOjuLep7aA,610 +vllm/attention/__pycache__/__init__.cpython-310.pyc,, +vllm/attention/__pycache__/layer.cpython-310.pyc,, +vllm/attention/__pycache__/selector.cpython-310.pyc,, +vllm/attention/backends/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +vllm/attention/backends/__pycache__/__init__.cpython-310.pyc,, +vllm/attention/backends/__pycache__/abstract.cpython-310.pyc,, +vllm/attention/backends/__pycache__/blocksparse_attn.cpython-310.pyc,, +vllm/attention/backends/__pycache__/cpu_mla.cpython-310.pyc,, +vllm/attention/backends/__pycache__/flash_attn.cpython-310.pyc,, +vllm/attention/backends/__pycache__/flashinfer.cpython-310.pyc,, +vllm/attention/backends/__pycache__/flashmla.cpython-310.pyc,, +vllm/attention/backends/__pycache__/hpu_attn.cpython-310.pyc,, +vllm/attention/backends/__pycache__/ipex_attn.cpython-310.pyc,, +vllm/attention/backends/__pycache__/pallas.cpython-310.pyc,, +vllm/attention/backends/__pycache__/placeholder_attn.cpython-310.pyc,, +vllm/attention/backends/__pycache__/rocm_aiter_mla.cpython-310.pyc,, +vllm/attention/backends/__pycache__/rocm_flash_attn.cpython-310.pyc,, +vllm/attention/backends/__pycache__/torch_sdpa.cpython-310.pyc,, +vllm/attention/backends/__pycache__/triton_mla.cpython-310.pyc,, +vllm/attention/backends/__pycache__/utils.cpython-310.pyc,, +vllm/attention/backends/__pycache__/xformers.cpython-310.pyc,, +vllm/attention/backends/abstract.py,sha256=4E2pYsrrdxQ2ztuyyBQj2C_ud4O4crvrS3ipADOCXCY,9357 +vllm/attention/backends/blocksparse_attn.py,sha256=uv0BHWZJJpyqG4b-4LTKFIgtrtu2AgsVpCenGnCGd5s,18006 +vllm/attention/backends/cpu_mla.py,sha256=gUquZuAA_avJVo5cdwRTIxzc3AlihZ8ZKoPxnhQSp8U,11115 +vllm/attention/backends/flash_attn.py,sha256=iCHOfdsb7waXXokUMa4TbFqwoYaU_7DaCGlbBvNhiPs,44480 +vllm/attention/backends/flashinfer.py,sha256=CPaaTlZaN4A5FD3EEgfr4mMHBxwpvlWSwKogc-ZBWjo,47373 +vllm/attention/backends/flashmla.py,sha256=A18b0mudfHs6-KukAkXmYE4JNO5anhSdvDZcKSNF7dE,9023 +vllm/attention/backends/hpu_attn.py,sha256=J44NMVBFVi9Im7NMayWhR-FWoINsVy41Re6IQ6b7t3s,11856 +vllm/attention/backends/ipex_attn.py,sha256=TRo1vH7RcrLM8XxY1cMF0FadFNJchPUnoXGbcF1zgYs,14996 +vllm/attention/backends/mla/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +vllm/attention/backends/mla/__pycache__/__init__.cpython-310.pyc,, +vllm/attention/backends/mla/__pycache__/common.cpython-310.pyc,, +vllm/attention/backends/mla/common.py,sha256=rj86xTKsbfY12yx9m4SkVSTw_Eh3rBVMKoqHoM_IH2s,60795 +vllm/attention/backends/pallas.py,sha256=hk32u6fUdChSnwAPQeSymWtAD1eLwt63KPZxW9-EFjs,13639 +vllm/attention/backends/placeholder_attn.py,sha256=0noOZ6cJXaPmL_rhs1UKI90Xj9hnHTVfDxdAsyWQjlg,16096 +vllm/attention/backends/rocm_aiter_mla.py,sha256=NrVW5fgaPd0eum9nx2ZNOdyChHqU_l36bIrjrlBW0kg,17009 +vllm/attention/backends/rocm_flash_attn.py,sha256=SJ1b0jdYyrSjVTjjBpgEjeI0--yuCf_ahy5PFMttSuw,42404 +vllm/attention/backends/torch_sdpa.py,sha256=3IJ1wAK73YuIpeAZOMGN1gMhjD55wNJLgPEWorZLCrg,27346 +vllm/attention/backends/triton_mla.py,sha256=ZIAU3VLXDYY0o5W_pblhEkIyMfjPbWkceASUTMdYf14,3954 +vllm/attention/backends/utils.py,sha256=UgUuOyNyPu3TU71pLHWtvBFzR8uhZrIun7zFgFMP2-w,25864 +vllm/attention/backends/xformers.py,sha256=PFtsIRNkym9ceLMS_KWqUGGd0sk13-hbR5tiAqHSjn0,33633 +vllm/attention/layer.py,sha256=ow66LS13K7O3wkn9horD-OIZ-ckr2fh3nbhQUy0ddKY,18033 +vllm/attention/ops/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +vllm/attention/ops/__pycache__/__init__.cpython-310.pyc,, +vllm/attention/ops/__pycache__/chunked_prefill_paged_decode.cpython-310.pyc,, +vllm/attention/ops/__pycache__/flashmla.cpython-310.pyc,, +vllm/attention/ops/__pycache__/hpu_paged_attn.cpython-310.pyc,, +vllm/attention/ops/__pycache__/ipex_attn.cpython-310.pyc,, +vllm/attention/ops/__pycache__/merge_attn_states.cpython-310.pyc,, +vllm/attention/ops/__pycache__/nki_flash_attn.cpython-310.pyc,, +vllm/attention/ops/__pycache__/paged_attn.cpython-310.pyc,, +vllm/attention/ops/__pycache__/prefix_prefill.cpython-310.pyc,, +vllm/attention/ops/__pycache__/rocm_aiter_mla.cpython-310.pyc,, +vllm/attention/ops/__pycache__/rocm_aiter_paged_attn.cpython-310.pyc,, +vllm/attention/ops/__pycache__/triton_decode_attention.cpython-310.pyc,, +vllm/attention/ops/__pycache__/triton_flash_attention.cpython-310.pyc,, +vllm/attention/ops/__pycache__/triton_merge_attn_states.cpython-310.pyc,, +vllm/attention/ops/blocksparse_attention/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +vllm/attention/ops/blocksparse_attention/__pycache__/__init__.cpython-310.pyc,, +vllm/attention/ops/blocksparse_attention/__pycache__/blocksparse_attention_kernel.cpython-310.pyc,, +vllm/attention/ops/blocksparse_attention/__pycache__/interface.cpython-310.pyc,, +vllm/attention/ops/blocksparse_attention/__pycache__/utils.cpython-310.pyc,, +vllm/attention/ops/blocksparse_attention/blocksparse_attention_kernel.py,sha256=u_96xPRC15lmK8hK5npn3-G8DyY-I1k3spa5sfzPi3U,11535 +vllm/attention/ops/blocksparse_attention/interface.py,sha256=QfWOzV2KjpJu7goLLOFegFbkIOA484Io3T6E-T8KXwo,9326 +vllm/attention/ops/blocksparse_attention/utils.py,sha256=vitFMc2NXAqjiyWKt23ELVxzKT_1BE10TvA3wYPjooY,8085 +vllm/attention/ops/chunked_prefill_paged_decode.py,sha256=fAhWkjmY7Epy34L07KV5r0KGl_9F-Y5zq76lQY7-G6s,12441 +vllm/attention/ops/flashmla.py,sha256=Jsx27AMgaf6_XLF68n-zkBcZx8P5wap7CmAZhgX7IK4,3884 +vllm/attention/ops/hpu_paged_attn.py,sha256=Re6jJVV6Mz6IrgWwXhvFOwO6pUcRdmKl0ssh8cifiqw,3460 +vllm/attention/ops/ipex_attn.py,sha256=US7b2ANDdhbPuglGfaCcO5XcvgRB0kZiDLwT462jteU,5526 +vllm/attention/ops/merge_attn_states.py,sha256=2BvJ9H7A30OfnnntsG5tjLPZNfbNteLG_JMicqhyuFE,1637 +vllm/attention/ops/nki_flash_attn.py,sha256=0tEpBTS-QdBZvj0Zh9NWOVu7rta3ITcWjdIOBPV2u7I,32612 +vllm/attention/ops/paged_attn.py,sha256=c0lJ_5D-rniDyKadqr3h_WIGewY4rcHS1as2EWsb0ow,8319 +vllm/attention/ops/prefix_prefill.py,sha256=J6UJwFg_0wkvDqipBrdUY0OT1QhrJW-C_N1-3LCqtxk,30979 +vllm/attention/ops/rocm_aiter_mla.py,sha256=15lHeCs8TnD8YkAtcVawTIwb9mjWXwO1rlifpL2f_hY,1475 +vllm/attention/ops/rocm_aiter_paged_attn.py,sha256=WVCMDB-wDHPc8zRfmZb1M76UGGxbZO5y2dJk60GB-3o,3885 +vllm/attention/ops/triton_decode_attention.py,sha256=pQ1V0nxf2fIBxHIxr4CpAEV5bJ6ZBhKNsFHOa-AmpNQ,19124 +vllm/attention/ops/triton_flash_attention.py,sha256=TNXhU3ZBfiy2-h1Cb_YubHQS0jcDX2l1W5is9nOiUI4,51287 +vllm/attention/ops/triton_merge_attn_states.py,sha256=udVXvfHxIxHYq2mGT_5dzWsRIkXXtphyhT0s0cfR9aA,3495 +vllm/attention/selector.py,sha256=Jz6nwwL_GqmQyMfrPvt5ju9fAnM8v5sGZVpGLSHOPbU,5865 +vllm/attention/utils/__pycache__/fa_utils.cpython-310.pyc,, +vllm/attention/utils/fa_utils.py,sha256=S0UZ-Ew2gJ0rpD53YEvEf4-_X-Ppd8om4o8N_HmT2rY,2018 +vllm/beam_search.py,sha256=bL5N3-Whe38DNaBMnUywj9JoDyqpXYbNJwt9oSf2P84,2386 +vllm/benchmarks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +vllm/benchmarks/__pycache__/__init__.cpython-310.pyc,, +vllm/benchmarks/__pycache__/datasets.cpython-310.pyc,, +vllm/benchmarks/__pycache__/endpoint_request_func.cpython-310.pyc,, +vllm/benchmarks/__pycache__/latency.cpython-310.pyc,, +vllm/benchmarks/__pycache__/serve.cpython-310.pyc,, +vllm/benchmarks/__pycache__/throughput.cpython-310.pyc,, +vllm/benchmarks/__pycache__/utils.cpython-310.pyc,, +vllm/benchmarks/datasets.py,sha256=yLwGVj3GuBCnlCJaTSxZnx-CBmREwwJy1siEJ90bFi8,31245 +vllm/benchmarks/endpoint_request_func.py,sha256=3-qqeaNP0Y6mbxyoQYgSjmAW-JQiM1wpNRjN7LkRFqk,5873 +vllm/benchmarks/latency.py,sha256=aBg2dEQgPkCwy5XrLyrFxM5_cvPPwL5QennF906NbWI,6385 +vllm/benchmarks/serve.py,sha256=uuXCjdsOCp-1j4ZHrQiZsJR299nKExbAaO6DqyaLRfA,36139 +vllm/benchmarks/throughput.py,sha256=cOw0zwhN2tnTcxQg_IjijOvSvf1PV-2aBroUSPo_Czw,24771 +vllm/benchmarks/utils.py,sha256=gpiQUYOxOG6Bve3zQeOoKWpj6fTIm3pyJ8JllU0vK0Y,2178 +vllm/collect_env.py,sha256=93OZPRA19A5f5VJzD0g-HaSTD4o6JgFqPcUERPVTmy8,27285 +vllm/compilation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +vllm/compilation/__pycache__/__init__.cpython-310.pyc,, +vllm/compilation/__pycache__/backends.cpython-310.pyc,, +vllm/compilation/__pycache__/compiler_interface.cpython-310.pyc,, +vllm/compilation/__pycache__/counter.cpython-310.pyc,, +vllm/compilation/__pycache__/decorators.cpython-310.pyc,, +vllm/compilation/__pycache__/fix_functionalization.cpython-310.pyc,, +vllm/compilation/__pycache__/fusion.cpython-310.pyc,, +vllm/compilation/__pycache__/fx_utils.cpython-310.pyc,, +vllm/compilation/__pycache__/inductor_pass.cpython-310.pyc,, +vllm/compilation/__pycache__/monitor.cpython-310.pyc,, +vllm/compilation/__pycache__/multi_output_match.cpython-310.pyc,, +vllm/compilation/__pycache__/noop_elimination.cpython-310.pyc,, +vllm/compilation/__pycache__/pass_manager.cpython-310.pyc,, +vllm/compilation/__pycache__/sequence_parallelism.cpython-310.pyc,, +vllm/compilation/__pycache__/torch25_custom_graph_pass.cpython-310.pyc,, +vllm/compilation/__pycache__/vllm_inductor_pass.cpython-310.pyc,, +vllm/compilation/__pycache__/wrapper.cpython-310.pyc,, +vllm/compilation/backends.py,sha256=fEwWj-YYjgqr8vlbu5wJSfN4arzl8VzrIOtoIssBrTo,28909 +vllm/compilation/compiler_interface.py,sha256=4wyv8RFXuhwsFPSTTxqIEDRlQ-T-mv-UmqBkTkMwDMM,18234 +vllm/compilation/counter.py,sha256=lGVEXL9lTnNWEBc17xMUna4WplhdPUlQaLQPn5qjHWA,937 +vllm/compilation/decorators.py,sha256=u0kOMbxoEOtxTPAChFijXWyw3nU3QwmlkX26J5uQYsc,10246 +vllm/compilation/fix_functionalization.py,sha256=z8l6h_C6-UkbOR5uxo55R1ETOIRfCTj6dawujHzap-o,7953 +vllm/compilation/fusion.py,sha256=lxyDdi-VBQ3gRIUeOS4nhPoFP0bSsr6XYzhpduTD8nE,24533 +vllm/compilation/fx_utils.py,sha256=LdfaaWz7sReX4FYBTLDeg7SQ2enmFnXsNRin30KaLBA,2023 +vllm/compilation/inductor_pass.py,sha256=P1f2VP2ODFNx0MFYGI32bd5TPkznKg1fSbC90f5uk-Q,3388 +vllm/compilation/monitor.py,sha256=p4LQ1roNhKQE8M8zhlYwgdnSFBFi6EkDUazr6X2usc0,1346 +vllm/compilation/multi_output_match.py,sha256=FKsWQk73_olG_sIh7veaHzfBecoKURWD6SRH5_Ozw20,3839 +vllm/compilation/noop_elimination.py,sha256=Eeu6RBwaLjuNBdlp5KgvKy58whQbWDy-KLqA3k-xans,5207 +vllm/compilation/pass_manager.py,sha256=P2zVO1hOc31xR2GbX_jNpWfm5kd4xZI90-_u7PvyhoE,2656 +vllm/compilation/sequence_parallelism.py,sha256=W-MIPU-5CaIn2WizyTCOqw5iRYUxLnu9iNnSu5IzYRQ,9636 +vllm/compilation/torch25_custom_graph_pass.py,sha256=2Uegyh-fmx5OsvKOFU4byAXdvN_XqTel3VdHTU-XplQ,1361 +vllm/compilation/vllm_inductor_pass.py,sha256=I06mbGhQLX4gj2W6CUDoqw1aZ36Pr9Xi6VnQL5ypCyc,2460 +vllm/compilation/wrapper.py,sha256=pCzXlNs-_49mKiQJFE3Kg02lEkHf_CfbVk6dcPlhnok,5631 +vllm/config.py,sha256=AW8SgaBRnGNrrOEEAS_40cGZ24mroZDW2c2BDWfJGkg,183428 +vllm/connections.py,sha256=3mo1DsM_BnR4SgURHhMxea5pkKKYRv0WAXCqz9khWHA,4989 +vllm/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +vllm/core/__pycache__/__init__.cpython-310.pyc,, +vllm/core/__pycache__/block_manager.cpython-310.pyc,, +vllm/core/__pycache__/evictor.cpython-310.pyc,, +vllm/core/__pycache__/interfaces.cpython-310.pyc,, +vllm/core/__pycache__/placeholder_block_space_manager.cpython-310.pyc,, +vllm/core/__pycache__/scheduler.cpython-310.pyc,, +vllm/core/block/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +vllm/core/block/__pycache__/__init__.cpython-310.pyc,, +vllm/core/block/__pycache__/block_table.cpython-310.pyc,, +vllm/core/block/__pycache__/common.cpython-310.pyc,, +vllm/core/block/__pycache__/cpu_gpu_block_allocator.cpython-310.pyc,, +vllm/core/block/__pycache__/interfaces.cpython-310.pyc,, +vllm/core/block/__pycache__/naive_block.cpython-310.pyc,, +vllm/core/block/__pycache__/prefix_caching_block.cpython-310.pyc,, +vllm/core/block/__pycache__/utils.cpython-310.pyc,, +vllm/core/block/block_table.py,sha256=HMwMwVY8pHLjlje6gfVsrHvyvLupcd3SMAvgcsUcnxM,16022 +vllm/core/block/common.py,sha256=cfDse1iNYLehOXrSfUypTmakGAdSSXrX0YmodFPpJjI,13200 +vllm/core/block/cpu_gpu_block_allocator.py,sha256=1zWQKDaRTIkkZIwP-pJ_i2bIbIcTRk3MBhpT3V06V3k,16947 +vllm/core/block/interfaces.py,sha256=yx7jEGmrXqAKyDQ76oEGZdfCAKBIld_5Tv7mmf7ra5E,8144 +vllm/core/block/naive_block.py,sha256=EgYRm94K88DyFM3Xjfa1A8hWuGZStL0nIqiZqbVxQMI,16355 +vllm/core/block/prefix_caching_block.py,sha256=tBjZ58xTQmmzx2s24BcneVyCf5F-aaOqgJz07bxbfoo,44182 +vllm/core/block/utils.py,sha256=osLxVwSUYjOsLeal8RzpmGT72F4aU3qbTGuYMdWIsHY,928 +vllm/core/block_manager.py,sha256=XoH1P87ofSfcNqcPpKuhDlrpV_8TlO2zkodkAezveJQ,22204 +vllm/core/evictor.py,sha256=Jy-eZwgdA4Q2F0buFgDNv2fPeiIxJAUEFtyKYz1VL40,5446 +vllm/core/interfaces.py,sha256=Uou6g2s9rlGrSYtk8x-TmeFRHK-SsvB2w2-pNxgfUAs,3590 +vllm/core/placeholder_block_space_manager.py,sha256=7HEHgCYHMNdAvd7ESfplHkjUQbqf8jOn6zXBEk_ShRo,2971 +vllm/core/scheduler.py,sha256=rR1ELyMQNljfzwZmtuNOwPmXIYW-gBLS-axLczR_Whw,90120 +vllm/cumem_allocator.abi3.so,sha256=8wxQ8EldqIuL9xAVL6_EM67hkdB3wmoxQDtodtFXYz0,27872 +vllm/device_allocator/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +vllm/device_allocator/__pycache__/__init__.cpython-310.pyc,, +vllm/device_allocator/__pycache__/cumem.cpython-310.pyc,, +vllm/device_allocator/cumem.py,sha256=se3229P3JRyk_iiXngyqnno4iqMESYTJHaMSF6YSkkw,10962 +vllm/distributed/__init__.py,sha256=Rk8k7bXtcPNaihFk5qOn__toXjElImWbszyRJBzeYHA,122 +vllm/distributed/__pycache__/__init__.cpython-310.pyc,, +vllm/distributed/__pycache__/communication_op.cpython-310.pyc,, +vllm/distributed/__pycache__/parallel_state.cpython-310.pyc,, +vllm/distributed/__pycache__/utils.cpython-310.pyc,, +vllm/distributed/communication_op.py,sha256=RauC0Jv4NtSia7pdV5eZaSfzXUAt1g1d5mYaxWi6f8U,1499 +vllm/distributed/device_communicators/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +vllm/distributed/device_communicators/__pycache__/__init__.cpython-310.pyc,, +vllm/distributed/device_communicators/__pycache__/base_device_communicator.cpython-310.pyc,, +vllm/distributed/device_communicators/__pycache__/cpu_communicator.cpython-310.pyc,, +vllm/distributed/device_communicators/__pycache__/cuda_communicator.cpython-310.pyc,, +vllm/distributed/device_communicators/__pycache__/cuda_wrapper.cpython-310.pyc,, +vllm/distributed/device_communicators/__pycache__/custom_all_reduce.cpython-310.pyc,, +vllm/distributed/device_communicators/__pycache__/custom_all_reduce_utils.cpython-310.pyc,, +vllm/distributed/device_communicators/__pycache__/hpu_communicator.cpython-310.pyc,, +vllm/distributed/device_communicators/__pycache__/neuron_communicator.cpython-310.pyc,, +vllm/distributed/device_communicators/__pycache__/pynccl.cpython-310.pyc,, +vllm/distributed/device_communicators/__pycache__/pynccl_wrapper.cpython-310.pyc,, +vllm/distributed/device_communicators/__pycache__/shm_broadcast.cpython-310.pyc,, +vllm/distributed/device_communicators/__pycache__/tpu_communicator.cpython-310.pyc,, +vllm/distributed/device_communicators/__pycache__/xpu_communicator.cpython-310.pyc,, +vllm/distributed/device_communicators/base_device_communicator.py,sha256=S2m9N5_I4ilFgY9gU0hxIBNLtCa-bGoho0U1_tVq79I,6227 +vllm/distributed/device_communicators/cpu_communicator.py,sha256=5Z9j1ziqDwYs3hQPwKpMk9er605nGf9JSIW6C6ncHmY,5276 +vllm/distributed/device_communicators/cuda_communicator.py,sha256=JJl2m8gbFM5o8Hjxpiju-ImizmJDEhxOJa4iaEacpcU,5018 +vllm/distributed/device_communicators/cuda_wrapper.py,sha256=X6-QuSBtX2ImLvcLGJANUt_FxTYubJnVAKEewwdztqc,7128 +vllm/distributed/device_communicators/custom_all_reduce.py,sha256=cV6XxtIF-GTLONnJdPelX7uO3IfWaYYhsNjlyxaiKXc,12544 +vllm/distributed/device_communicators/custom_all_reduce_utils.py,sha256=g-GEhCjE6dGzRDYHKYDP5FqFW9snR-YMLcIQOYt0Zz8,10474 +vllm/distributed/device_communicators/hpu_communicator.py,sha256=LSIPK-d_v2ICOii97Du1VhDAVHq0lggXnW8GOahmYiM,1767 +vllm/distributed/device_communicators/neuron_communicator.py,sha256=qrRh1kLgdB2bBYrEJnSs5nTD0YJ6DW9n7_CPJ9x15eo,624 +vllm/distributed/device_communicators/pynccl.py,sha256=Z4QXdGf_qzz2J3PfKtU7bEG29oxbXy4dEorGB9WNB3k,9142 +vllm/distributed/device_communicators/pynccl_wrapper.py,sha256=3J0dyH47BKC4tFGkIaSoJe033WoimULq9SdM76LqMTI,13706 +vllm/distributed/device_communicators/shm_broadcast.py,sha256=P4P6ngwyzmVyYRnLGAbeWreTS52P1ihrSvBTAmYE7dc,24100 +vllm/distributed/device_communicators/tpu_communicator.py,sha256=48PMU9TmB9eFh45p3J-a4OIcm0Oa2VgWaLWyP2LclPk,3808 +vllm/distributed/device_communicators/xpu_communicator.py,sha256=mP9w-kIxqxd98-htC2QHLLQqc7T9YtXGJqLR6K4hWKA,2107 +vllm/distributed/kv_transfer/README.md,sha256=B4s4s-6F9FP4wbgmrYJDSpdUu0_Yq4EeWLEyZMNkAyk,2006 +vllm/distributed/kv_transfer/__init__.py,sha256=hgB0f7tJWprC53X4NYq-5y0YAhf-lF2OfOQcaF_14Bk,371 +vllm/distributed/kv_transfer/__pycache__/__init__.cpython-310.pyc,, +vllm/distributed/kv_transfer/__pycache__/kv_connector_agent.cpython-310.pyc,, +vllm/distributed/kv_transfer/__pycache__/kv_transfer_state.cpython-310.pyc,, +vllm/distributed/kv_transfer/disagg_prefill_workflow.jpg,sha256=fOFUEx-2Fm1uxHCGopvCREaRqdvR87Z7C0bMqEVH3Iw,142656 +vllm/distributed/kv_transfer/kv_connector/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +vllm/distributed/kv_transfer/kv_connector/__pycache__/__init__.cpython-310.pyc,, +vllm/distributed/kv_transfer/kv_connector/__pycache__/base.cpython-310.pyc,, +vllm/distributed/kv_transfer/kv_connector/__pycache__/factory.cpython-310.pyc,, +vllm/distributed/kv_transfer/kv_connector/__pycache__/lmcache_connector.cpython-310.pyc,, +vllm/distributed/kv_transfer/kv_connector/__pycache__/mooncake_store_connector.cpython-310.pyc,, +vllm/distributed/kv_transfer/kv_connector/__pycache__/simple_connector.cpython-310.pyc,, +vllm/distributed/kv_transfer/kv_connector/__pycache__/utils.cpython-310.pyc,, +vllm/distributed/kv_transfer/kv_connector/base.py,sha256=qEPxC3gSvvM3oQHr3KL-ktd_53k2fs8sVpJzZUvjyF4,4434 +vllm/distributed/kv_transfer/kv_connector/factory.py,sha256=SJPW3ZmV7bCW4C9_usjYEIelatPGmv_QLshA-NhCf4s,4005 +vllm/distributed/kv_transfer/kv_connector/lmcache_connector.py,sha256=bc90F18oq95nkPNCx5-WnZqX90aOgCdbLyeRHiLbXE8,3683 +vllm/distributed/kv_transfer/kv_connector/mooncake_store_connector.py,sha256=Y4Ry3ljzTR3przGc9x0twV0tqo-MUdJDqAa91z7cl2w,8550 +vllm/distributed/kv_transfer/kv_connector/simple_connector.py,sha256=q6kT6N4Gv9qnAqp_HNRz267v0lF5GY81R7zFcrPWiGs,13871 +vllm/distributed/kv_transfer/kv_connector/utils.py,sha256=F7b-JTvj7MGlmaQ3LktzxqQBTY65Z9O-6B8XPg9KNxs,3750 +vllm/distributed/kv_transfer/kv_connector/v1/__init__.py,sha256=vjF_iq8G1cGemr1Vtj11t7O0TJRaHuUjhb5VNegzNrQ,207 +vllm/distributed/kv_transfer/kv_connector/v1/__pycache__/__init__.cpython-310.pyc,, +vllm/distributed/kv_transfer/kv_connector/v1/__pycache__/base.cpython-310.pyc,, +vllm/distributed/kv_transfer/kv_connector/v1/__pycache__/lmcache_connector.cpython-310.pyc,, +vllm/distributed/kv_transfer/kv_connector/v1/__pycache__/shared_storage_connector.cpython-310.pyc,, +vllm/distributed/kv_transfer/kv_connector/v1/base.py,sha256=AyThfkIvLIubwvvCWhySG_BWKChgVUsZRKRqJSchKNQ,6810 +vllm/distributed/kv_transfer/kv_connector/v1/lmcache_connector.py,sha256=ACF4Z4Psxwg3EC2HeqeyCdm6qgRYGHUYzrP2sMFfb9I,4978 +vllm/distributed/kv_transfer/kv_connector/v1/shared_storage_connector.py,sha256=l4TcUH75Tl6rPUobmup1Wi-ADv1Wyk4WH9ffi-Me4lg,15572 +vllm/distributed/kv_transfer/kv_connector_agent.py,sha256=ZvPS-iDdCIqCYI5XUnwR-hiws15sjsgKoksHCthsQ90,2433 +vllm/distributed/kv_transfer/kv_lookup_buffer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +vllm/distributed/kv_transfer/kv_lookup_buffer/__pycache__/__init__.cpython-310.pyc,, +vllm/distributed/kv_transfer/kv_lookup_buffer/__pycache__/base.cpython-310.pyc,, +vllm/distributed/kv_transfer/kv_lookup_buffer/__pycache__/mooncake_store.cpython-310.pyc,, +vllm/distributed/kv_transfer/kv_lookup_buffer/__pycache__/simple_buffer.cpython-310.pyc,, +vllm/distributed/kv_transfer/kv_lookup_buffer/base.py,sha256=onwGEXNRYYiOCXHzkVbQ-WVBAWJ_w4SeBuQF_Z9TLrk,6217 +vllm/distributed/kv_transfer/kv_lookup_buffer/mooncake_store.py,sha256=qU8ulFs4EZOi0udp1DeDakHCqSHHzdGKcOxR_WMVl5c,5610 +vllm/distributed/kv_transfer/kv_lookup_buffer/simple_buffer.py,sha256=OP6qAlDx90p86x-QhRSm22aW2tuoMB7HDKws0DCpVhs,9100 +vllm/distributed/kv_transfer/kv_pipe/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +vllm/distributed/kv_transfer/kv_pipe/__pycache__/__init__.cpython-310.pyc,, +vllm/distributed/kv_transfer/kv_pipe/__pycache__/base.cpython-310.pyc,, +vllm/distributed/kv_transfer/kv_pipe/__pycache__/mooncake_pipe.cpython-310.pyc,, +vllm/distributed/kv_transfer/kv_pipe/__pycache__/pynccl_pipe.cpython-310.pyc,, +vllm/distributed/kv_transfer/kv_pipe/base.py,sha256=U4hivz-zJkjhTGgNdtcuupc_ArsoUPFuWEv_AXJ9rqs,2087 +vllm/distributed/kv_transfer/kv_pipe/mooncake_pipe.py,sha256=BXVNE9q2w6jsrrnyaFS_qBwUbfMW6rUcOhTslH1GrJ4,12042 +vllm/distributed/kv_transfer/kv_pipe/pynccl_pipe.py,sha256=v_lF2Vija5coPEFil4lIH___xvuT6XvX563Y682M_U8,9699 +vllm/distributed/kv_transfer/kv_transfer_state.py,sha256=HvxD6knnUDmnjXK-TYA27idyEIz1Th-jkTKHd2Te6Rs,2266 +vllm/distributed/parallel_state.py,sha256=SupbqBGESH9G1oMpWgYFStv8URv-AMHR-eLIwriZSLI,46729 +vllm/distributed/utils.py,sha256=FmlqkrolzZumCbBZESxtAkYnDxxOQSyUx9UF6Gke9nE,14559 +vllm/engine/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +vllm/engine/__pycache__/__init__.cpython-310.pyc,, +vllm/engine/__pycache__/arg_utils.cpython-310.pyc,, +vllm/engine/__pycache__/async_llm_engine.cpython-310.pyc,, +vllm/engine/__pycache__/async_timeout.cpython-310.pyc,, +vllm/engine/__pycache__/llm_engine.cpython-310.pyc,, +vllm/engine/__pycache__/metrics.cpython-310.pyc,, +vllm/engine/__pycache__/metrics_types.cpython-310.pyc,, +vllm/engine/__pycache__/protocol.cpython-310.pyc,, +vllm/engine/arg_utils.py,sha256=Zd-5IvV7WyQqwiYCSuaoBBzBQbWwA4MeoNNy032eHKo,77963 +vllm/engine/async_llm_engine.py,sha256=NVj01NbYxyKN7WEXJmXzciBhcMZmvOP0HzZ350sgk8o,51183 +vllm/engine/async_timeout.py,sha256=JxUaRVK_M5P5wRVkKHQ-QkDMnGxKMTt9S9OhQeQzP-s,7092 +vllm/engine/llm_engine.py,sha256=hRj6md9_j9Z4WWjBa7MPdK-Q6WxFU6b8ku_D1QuHl-o,94629 +vllm/engine/metrics.py,sha256=pgK8JsN_qIDxOAJCb7Rdabv1e5FL-xIQNq3jXeJGBfk,31380 +vllm/engine/metrics_types.py,sha256=9qcaNDFM1xfaQGjY9aPK_Cn-GObdctJiqR_t6cLzy_Y,3309 +vllm/engine/multiprocessing/__init__.py,sha256=Oxga1HyDxx_K9SJ90gd5PBeVhEQ_9edrrT-DgWT1mo4,4923 +vllm/engine/multiprocessing/__pycache__/__init__.cpython-310.pyc,, +vllm/engine/multiprocessing/__pycache__/client.cpython-310.pyc,, +vllm/engine/multiprocessing/__pycache__/engine.cpython-310.pyc,, +vllm/engine/multiprocessing/client.py,sha256=HAGfCWFxusAbfVvQJO3KmuzMVP0zK9Lk3dVQj3O1FSc,30282 +vllm/engine/multiprocessing/engine.py,sha256=iu4zUfSPqlO-aL4iSSsOZMcpA1pJwXyb5HikWz5h_L8,17848 +vllm/engine/output_processor/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +vllm/engine/output_processor/__pycache__/__init__.cpython-310.pyc,, +vllm/engine/output_processor/__pycache__/interfaces.cpython-310.pyc,, +vllm/engine/output_processor/__pycache__/multi_step.cpython-310.pyc,, +vllm/engine/output_processor/__pycache__/single_step.cpython-310.pyc,, +vllm/engine/output_processor/__pycache__/stop_checker.cpython-310.pyc,, +vllm/engine/output_processor/__pycache__/util.cpython-310.pyc,, +vllm/engine/output_processor/interfaces.py,sha256=99zPnCsA0H9k8d7uXfv8yGva69mAS1m3apR9sdWIUfY,2994 +vllm/engine/output_processor/multi_step.py,sha256=s5GKHbBFncCg4lu9ujcLOykVp_Fe1VfC3fAWTIulEns,9238 +vllm/engine/output_processor/single_step.py,sha256=ToiNI09zyU86zsB8Vbw9-eLcbNk_gsCHc2sKRmBfcF0,6015 +vllm/engine/output_processor/stop_checker.py,sha256=XtOa0t-ZErekuf9SFoxQv-nZN2ddPxEiFIwIJEUK-ig,5067 +vllm/engine/output_processor/util.py,sha256=IoNFmy8vKrK5pn3nGS26Ey5irhKr8mzNOGP30SsT1qA,1056 +vllm/engine/protocol.py,sha256=Hc2CuVEqKXfg6FzjBIkRbMUfXCYarDwRCO8GlUfQwso,10642 +vllm/entrypoints/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +vllm/entrypoints/__pycache__/__init__.cpython-310.pyc,, +vllm/entrypoints/__pycache__/api_server.cpython-310.pyc,, +vllm/entrypoints/__pycache__/chat_utils.cpython-310.pyc,, +vllm/entrypoints/__pycache__/launcher.cpython-310.pyc,, +vllm/entrypoints/__pycache__/llm.cpython-310.pyc,, +vllm/entrypoints/__pycache__/logger.cpython-310.pyc,, +vllm/entrypoints/__pycache__/score_utils.cpython-310.pyc,, +vllm/entrypoints/__pycache__/ssl.cpython-310.pyc,, +vllm/entrypoints/__pycache__/utils.cpython-310.pyc,, +vllm/entrypoints/api_server.py,sha256=rjgwdjwCsAUr3FS1CbeyxcKD-jKm4GFB1pyhu49R8Lg,5708 +vllm/entrypoints/chat_utils.py,sha256=6lWTFU91w9Agmq-QhV5MJi-KCYeYl1K2spzZt3C5chA,45402 +vllm/entrypoints/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +vllm/entrypoints/cli/__pycache__/__init__.cpython-310.pyc,, +vllm/entrypoints/cli/__pycache__/collect_env.cpython-310.pyc,, +vllm/entrypoints/cli/__pycache__/main.cpython-310.pyc,, +vllm/entrypoints/cli/__pycache__/openai.cpython-310.pyc,, +vllm/entrypoints/cli/__pycache__/serve.cpython-310.pyc,, +vllm/entrypoints/cli/__pycache__/types.cpython-310.pyc,, +vllm/entrypoints/cli/benchmark/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +vllm/entrypoints/cli/benchmark/__pycache__/__init__.cpython-310.pyc,, +vllm/entrypoints/cli/benchmark/__pycache__/base.cpython-310.pyc,, +vllm/entrypoints/cli/benchmark/__pycache__/latency.cpython-310.pyc,, +vllm/entrypoints/cli/benchmark/__pycache__/main.cpython-310.pyc,, +vllm/entrypoints/cli/benchmark/__pycache__/serve.cpython-310.pyc,, +vllm/entrypoints/cli/benchmark/__pycache__/throughput.cpython-310.pyc,, +vllm/entrypoints/cli/benchmark/base.py,sha256=blt2nY-bqD8LZV_lt73JcYdVd1f_Pb_fRHhm8wXYYtk,1105 +vllm/entrypoints/cli/benchmark/latency.py,sha256=htqbqDiw338UQ4Imrm8h4BSvHgNe7jXsSE9sHxZDI7c,810 +vllm/entrypoints/cli/benchmark/main.py,sha256=b4ANrwJgpjSMPg8bHnvxhyukxlc_s7x3jrL9n01ni00,1780 +vllm/entrypoints/cli/benchmark/serve.py,sha256=ISS4pL4Q_yF54GOICzDBGcTEDWMnU9e5SLdhosgFK_I,792 +vllm/entrypoints/cli/benchmark/throughput.py,sha256=p6_xRqPiHbXoElsDA2wIT6zIB3c_ClxDQewCk2VROQo,812 +vllm/entrypoints/cli/collect_env.py,sha256=DhsoUicPdVy4jQaYZIAQFSZlyxGomBpif9dTO_DkN_U,1089 +vllm/entrypoints/cli/main.py,sha256=ECcw2rG854LW1KxsInnwPk9Rwm-Mh0ONPuURSY0JYdE,1568 +vllm/entrypoints/cli/openai.py,sha256=zuqg82yXK6IzEd05-g5VGVGoILz6-xE8LeTYE5QrzRY,5765 +vllm/entrypoints/cli/serve.py,sha256=OAgH3VF1gZTOMoHQthyiyxBuBa6uQDSnvVueO6JkXDo,2054 +vllm/entrypoints/cli/types.py,sha256=9GDzWTOdmPeQk-Z2cXdXSk6DgQMlrhbmLPgQ69Hof0Y,637 +vllm/entrypoints/launcher.py,sha256=ZLE3YFhCKhintM-Ra34S8p8L5-eUhzoArdygX8QvVF4,5212 +vllm/entrypoints/llm.py,sha256=yU8FyVqYi_hC4u_GcEpvDLc1JnvNYD6617GdoAglCsk,64044 +vllm/entrypoints/logger.py,sha256=ThXqCnP0Ord214j4_OQh124fOT421rf4-JpXtwQdKx4,1443 +vllm/entrypoints/openai/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +vllm/entrypoints/openai/__pycache__/__init__.cpython-310.pyc,, +vllm/entrypoints/openai/__pycache__/api_server.cpython-310.pyc,, +vllm/entrypoints/openai/__pycache__/cli_args.cpython-310.pyc,, +vllm/entrypoints/openai/__pycache__/logits_processors.cpython-310.pyc,, +vllm/entrypoints/openai/__pycache__/protocol.cpython-310.pyc,, +vllm/entrypoints/openai/__pycache__/run_batch.cpython-310.pyc,, +vllm/entrypoints/openai/__pycache__/serving_chat.cpython-310.pyc,, +vllm/entrypoints/openai/__pycache__/serving_completion.cpython-310.pyc,, +vllm/entrypoints/openai/__pycache__/serving_embedding.cpython-310.pyc,, +vllm/entrypoints/openai/__pycache__/serving_engine.cpython-310.pyc,, +vllm/entrypoints/openai/__pycache__/serving_models.cpython-310.pyc,, +vllm/entrypoints/openai/__pycache__/serving_pooling.cpython-310.pyc,, +vllm/entrypoints/openai/__pycache__/serving_score.cpython-310.pyc,, +vllm/entrypoints/openai/__pycache__/serving_tokenization.cpython-310.pyc,, +vllm/entrypoints/openai/__pycache__/serving_transcription.cpython-310.pyc,, +vllm/entrypoints/openai/api_server.py,sha256=H2ylrBtj1bEYudzXHmSI3i_8luuElA1GbIqO48kMnJE,43608 +vllm/entrypoints/openai/cli_args.py,sha256=LeLIxRo7E-NnbIPnr0RCkJX3mgEi9nLG_eaFv5RCx_U,11709 +vllm/entrypoints/openai/logits_processors.py,sha256=zbAeibwgnyMxn99ZlIheZZtlN3iBzk9AzqbOC7qVUr4,3161 +vllm/entrypoints/openai/protocol.py,sha256=QQNcmm-0KvHngElREAjyn_AAm_l8qUKE_ndNeKmSmTc,66479 +vllm/entrypoints/openai/run_batch.py,sha256=7QqKfdo08-mGl7oGRB7ql1y6BHIN4vI3ldQFbk_Kpnc,16821 +vllm/entrypoints/openai/serving_chat.py,sha256=boteYCnqyhM990RuG8gy-S7IyQ9MYxNR0D3NKxO4Iao,56951 +vllm/entrypoints/openai/serving_completion.py,sha256=RGl4Q-z-Joqvahzx8MjKB4sDgV01XPis59Y8p-XDuPY,23479 +vllm/entrypoints/openai/serving_embedding.py,sha256=_zS1NUeIWxGXjOvkBO2WA2DqZ7aAVvMGWE33lH3kSXU,9164 +vllm/entrypoints/openai/serving_engine.py,sha256=lJqfR9xXL_hkPRfMot7hGNpoQSsmqZVJmD40rjVbgUU,22349 +vllm/entrypoints/openai/serving_models.py,sha256=C_NVmE_oimem4sRLOQkIyJTuIhD6fKiSemwRSQQOaoo,12728 +vllm/entrypoints/openai/serving_pooling.py,sha256=L74e9zPrfh7d4O0Alig4VnE4zMzuI6ncX3SDyEbHx2g,8876 +vllm/entrypoints/openai/serving_score.py,sha256=JtMtgtGKFMELJab0uQLEIclpdMhRoGz2TvPwbJrtl_M,16240 +vllm/entrypoints/openai/serving_tokenization.py,sha256=OiUPnXv4UY1K26BVtMHThxLsy_bdZb6vvnjYYv4-vPU,5517 +vllm/entrypoints/openai/serving_transcription.py,sha256=8w8DvHzoAma-T50asNFb66badNOCwwV-tqekxWiG50Q,15629 +vllm/entrypoints/openai/tool_parsers/__init__.py,sha256=Y5LRbwcAwjrDbB0O7zZr6BCqDWiaPA0APHptnB-jDxo,856 +vllm/entrypoints/openai/tool_parsers/__pycache__/__init__.cpython-310.pyc,, +vllm/entrypoints/openai/tool_parsers/__pycache__/abstract_tool_parser.cpython-310.pyc,, +vllm/entrypoints/openai/tool_parsers/__pycache__/granite_20b_fc_tool_parser.cpython-310.pyc,, +vllm/entrypoints/openai/tool_parsers/__pycache__/granite_tool_parser.cpython-310.pyc,, +vllm/entrypoints/openai/tool_parsers/__pycache__/hermes_tool_parser.cpython-310.pyc,, +vllm/entrypoints/openai/tool_parsers/__pycache__/internlm2_tool_parser.cpython-310.pyc,, +vllm/entrypoints/openai/tool_parsers/__pycache__/jamba_tool_parser.cpython-310.pyc,, +vllm/entrypoints/openai/tool_parsers/__pycache__/llama_tool_parser.cpython-310.pyc,, +vllm/entrypoints/openai/tool_parsers/__pycache__/mistral_tool_parser.cpython-310.pyc,, +vllm/entrypoints/openai/tool_parsers/__pycache__/phi4mini_tool_parser.cpython-310.pyc,, +vllm/entrypoints/openai/tool_parsers/__pycache__/pythonic_tool_parser.cpython-310.pyc,, +vllm/entrypoints/openai/tool_parsers/__pycache__/utils.cpython-310.pyc,, +vllm/entrypoints/openai/tool_parsers/abstract_tool_parser.py,sha256=tULmZD-It5bOOf08FFJFN-bx2A_0CT5Atr9zgvpiGBg,6026 +vllm/entrypoints/openai/tool_parsers/granite_20b_fc_tool_parser.py,sha256=OnpN_9yo148CIPT1TPH_1U67rTMR8h2NS1W3_1cZI-g,11135 +vllm/entrypoints/openai/tool_parsers/granite_tool_parser.py,sha256=QPOnvPxzWROGBD0P8TQoGCRlvkclYqTAx4GBhu2jktg,10365 +vllm/entrypoints/openai/tool_parsers/hermes_tool_parser.py,sha256=tMaFDFJk9gvnbym9nRwgTXrzq_jL7ma3C0SayUF3reg,16799 +vllm/entrypoints/openai/tool_parsers/internlm2_tool_parser.py,sha256=o1-jp-KTOTXgvO9obkMGOWREXjQV-kIwKj5ujYMZFlw,9135 +vllm/entrypoints/openai/tool_parsers/jamba_tool_parser.py,sha256=hxhk0FEsTPeD7Tc3hmItizGHT4RjZVFODT7iqJksnJI,13553 +vllm/entrypoints/openai/tool_parsers/llama_tool_parser.py,sha256=jByIKB-3-EL9url5wIxfbcGuWT4kuumd6_vveItMwhE,11959 +vllm/entrypoints/openai/tool_parsers/mistral_tool_parser.py,sha256=6-GUAAGvDMVybNR6qvIvraLJc9Z4oUmqiyePZnOc-Lg,15371 +vllm/entrypoints/openai/tool_parsers/phi4mini_tool_parser.py,sha256=ez0cTcApdl2oKpj6RDWDjS1AUUdw2dV10QDiBrC5uT4,4218 +vllm/entrypoints/openai/tool_parsers/pythonic_tool_parser.py,sha256=AqBVcgTZp5Mr-edJzdn8u8u3tev7sDMQsTHtluZ35us,11971 +vllm/entrypoints/openai/tool_parsers/utils.py,sha256=56zqKHw3Q5XqhqNpwZWnRSbzhx17qzuyFsASFXmeZZk,3805 +vllm/entrypoints/score_utils.py,sha256=HerqcBBubpl-Oh1UIYoDGkRsbqyhpuRiTopyBlil9v8,1655 +vllm/entrypoints/ssl.py,sha256=JigVmJhUkhrDPvD1z-iCCwOOLE__qD8V_2h94zvt19A,2736 +vllm/entrypoints/utils.py,sha256=varTasRl4FqK7J5FjtCfV_N5T8ZhdY4Ll1M0-Co4bFA,5574 +vllm/env_override.py,sha256=v5bFL5pZEz9a1Q8xPmyKb7mrxNIb_y7cWr4E-FcBbS4,1475 +vllm/envs.py,sha256=W9C4Ir1vvOH39QkN0Bd-yg4aftWvS4E1hRBC8EqCoF8,32112 +vllm/executor/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +vllm/executor/__pycache__/__init__.cpython-310.pyc,, +vllm/executor/__pycache__/executor_base.cpython-310.pyc,, +vllm/executor/__pycache__/mp_distributed_executor.cpython-310.pyc,, +vllm/executor/__pycache__/msgspec_utils.cpython-310.pyc,, +vllm/executor/__pycache__/multiproc_worker_utils.cpython-310.pyc,, +vllm/executor/__pycache__/ray_distributed_executor.cpython-310.pyc,, +vllm/executor/__pycache__/ray_utils.cpython-310.pyc,, +vllm/executor/__pycache__/uniproc_executor.cpython-310.pyc,, +vllm/executor/executor_base.py,sha256=WS5uXxYBWl2wGbBBgqRTUZgiwVFiNiaymMRDm-B3r3Y,15664 +vllm/executor/mp_distributed_executor.py,sha256=6mrv5wsBUw6ng08_qyn7LtmYsaGgGgTHoZSdP-hmPtY,9854 +vllm/executor/msgspec_utils.py,sha256=FG5Qh6ghtLjyI6BHiTGmJQ3sGop2Lpm4LoADP_0Hs9o,909 +vllm/executor/multiproc_worker_utils.py,sha256=yXbbNwhImWw7xgSgjoOSwbGLsuW0hCLsye0IFBVU0pU,10725 +vllm/executor/ray_distributed_executor.py,sha256=0bokBxMVvBKogFyi9a7CT8Hmq5gbLDiM_aKuFCyjRR0,30725 +vllm/executor/ray_utils.py,sha256=ADwyUzK3ciZGUNYhogA6m0-YwUFzX4bLQm9aADMijY8,16860 +vllm/executor/uniproc_executor.py,sha256=FY4XQzC1ZpIOsOpS5SDtWBKlGRMPLP-5MTwPj2ijovQ,5657 +vllm/forward_context.py,sha256=vf7Ld8ERTl0ioJmUxB_shruNfcvPW12sJ-tWu1PGS94,6528 +vllm/inputs/__init__.py,sha256=CU29-EwaGLoem47wIqFC-mR1433WZh3a67hNOlIsVlI,1155 +vllm/inputs/__pycache__/__init__.cpython-310.pyc,, +vllm/inputs/__pycache__/data.cpython-310.pyc,, +vllm/inputs/__pycache__/parse.cpython-310.pyc,, +vllm/inputs/__pycache__/preprocess.cpython-310.pyc,, +vllm/inputs/__pycache__/registry.cpython-310.pyc,, +vllm/inputs/data.py,sha256=9yF-KJ7fZY-rl5sBdeawmVo-Zon5ZqVB9ceV_YJPY2Q,8254 +vllm/inputs/parse.py,sha256=q0Kx42qRjf0NalObXwBN6eJGjHnfSsOl4mI8PJRzvEI,3716 +vllm/inputs/preprocess.py,sha256=ngy8-vDPWtSFYal1haK7GVfGOBxrrYk-Ji3Zom_YTAk,28089 +vllm/inputs/registry.py,sha256=hSPaEwBKSGmCH1ELqiEyhCMw6UZZBJHbM7oeQVmV9bw,6425 +vllm/jsontree.py,sha256=uEJ99TCQv26_ZrRmZuZAuIrh6U8n8KAAQod4WUP4pLM,2143 +vllm/logger.py,sha256=wIy4Qe8RvxqyZjebeX2sR8OE2g9Wq2MSu7H7lzTraxs,7339 +vllm/logging_utils/__init__.py,sha256=t2aDazCRc19hTrOxiW3eY-d702nQFBOJz_QIfSip9ok,136 +vllm/logging_utils/__pycache__/__init__.cpython-310.pyc,, +vllm/logging_utils/__pycache__/formatter.cpython-310.pyc,, +vllm/logging_utils/formatter.py,sha256=AAWbFV4wgQZn_Ek0MKA-TBJwCQiO3ejIuIV1rQm8ADQ,525 +vllm/logits_process.py,sha256=OBOGJ6XdkTYyAbstBAcngW4JN1mr9euaFnHES6uCX-A,4649 +vllm/lora/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +vllm/lora/__pycache__/__init__.cpython-310.pyc,, +vllm/lora/__pycache__/fully_sharded_layers.cpython-310.pyc,, +vllm/lora/__pycache__/layers.cpython-310.pyc,, +vllm/lora/__pycache__/lora.cpython-310.pyc,, +vllm/lora/__pycache__/models.cpython-310.pyc,, +vllm/lora/__pycache__/peft_helper.cpython-310.pyc,, +vllm/lora/__pycache__/request.cpython-310.pyc,, +vllm/lora/__pycache__/resolver.cpython-310.pyc,, +vllm/lora/__pycache__/utils.cpython-310.pyc,, +vllm/lora/__pycache__/worker_manager.cpython-310.pyc,, +vllm/lora/fully_sharded_layers.py,sha256=qUGiJmRn9JA_JKm4TaHWaVkdP_NrKAAf-h9QGdJjav8,12229 +vllm/lora/layers.py,sha256=GMzaA48SBSbG7pE_PoMf9QB2Ho0eciRFB9tEM4EhelY,46372 +vllm/lora/lora.py,sha256=XfOb94aCsORrhvTnHDy-gF6iGo6nULtpsRcR2wpfYBU,6222 +vllm/lora/models.py,sha256=zugnzfnOHtGnvpUjiLCDpgyBfaVFI7I3tM-cZbBi4e8,35111 +vllm/lora/ops/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +vllm/lora/ops/__pycache__/__init__.cpython-310.pyc,, +vllm/lora/ops/torch_ops/__init__.py,sha256=z03eb5aCSj_Z-_RPa3huUKuXRBvhxj_M8lK7izkQJHE,466 +vllm/lora/ops/torch_ops/__pycache__/__init__.cpython-310.pyc,, +vllm/lora/ops/torch_ops/__pycache__/lora_ops.cpython-310.pyc,, +vllm/lora/ops/torch_ops/lora_ops.py,sha256=ilxQObKw2wEz3BJJ8X87xWPHGOz0jSII3b13wpj66es,4300 +vllm/lora/ops/triton_ops/__init__.py,sha256=5-wjfUVaVmWcrM1PEFIbmzK2VJufzzPFKg8btwBShr4,309 +vllm/lora/ops/triton_ops/__pycache__/__init__.cpython-310.pyc,, +vllm/lora/ops/triton_ops/__pycache__/kernel_utils.cpython-310.pyc,, +vllm/lora/ops/triton_ops/__pycache__/lora_expand.cpython-310.pyc,, +vllm/lora/ops/triton_ops/__pycache__/lora_kernel_metadata.cpython-310.pyc,, +vllm/lora/ops/triton_ops/__pycache__/lora_shrink.cpython-310.pyc,, +vllm/lora/ops/triton_ops/__pycache__/utils.cpython-310.pyc,, +vllm/lora/ops/triton_ops/kernel_utils.py,sha256=xbjwaaJDlAW3J-db75xOdd6_Hb5z1ZEfW_9szb3NvJo,8442 +vllm/lora/ops/triton_ops/lora_expand.py,sha256=9aOvCxbKjeXWI0Bl0HgC3VQ_Lw3GcXWv-hHLT6_Gv4U,8971 +vllm/lora/ops/triton_ops/lora_kernel_metadata.py,sha256=WAI_fis0b0f5_3GG58VbvJfOY2slL-L5nX8kd665IFI,5905 +vllm/lora/ops/triton_ops/lora_shrink.py,sha256=1YcPmNXvUw9BELsV3kzHM18vYNhoSlJsfHqPLVUc32I,7998 +vllm/lora/ops/triton_ops/utils.py,sha256=reDlg9D5e97cmSgwkTiiAQLCRcW1nYbf5VnbTx1Fu9A,4885 +vllm/lora/peft_helper.py,sha256=ag2z855o72BMDHMMt1noP1XoMG875wtKOWVfuwZDiM4,4399 +vllm/lora/punica_wrapper/__init__.py,sha256=RAbrZogtmoPZNIMImJFX1REM0cydwz5C-ATIp7_qHFA,244 +vllm/lora/punica_wrapper/__pycache__/__init__.cpython-310.pyc,, +vllm/lora/punica_wrapper/__pycache__/punica_base.cpython-310.pyc,, +vllm/lora/punica_wrapper/__pycache__/punica_cpu.cpython-310.pyc,, +vllm/lora/punica_wrapper/__pycache__/punica_gpu.cpython-310.pyc,, +vllm/lora/punica_wrapper/__pycache__/punica_hpu.cpython-310.pyc,, +vllm/lora/punica_wrapper/__pycache__/punica_selector.cpython-310.pyc,, +vllm/lora/punica_wrapper/__pycache__/utils.cpython-310.pyc,, +vllm/lora/punica_wrapper/punica_base.py,sha256=Nf0l2sBxlSX43_i1DVPqgLRTdYoJknSScuxdeqUhb6M,18227 +vllm/lora/punica_wrapper/punica_cpu.py,sha256=1hzv1SchgOGiUo4kYsAN5BcTDX5XNQopMqbbXvxLqlg,12465 +vllm/lora/punica_wrapper/punica_gpu.py,sha256=3-VIBGixPXWlWPrpV4zuTA4H1uEQxcSHI0FzEVXfvCc,10829 +vllm/lora/punica_wrapper/punica_hpu.py,sha256=qmXdhyHJrv4ZBXBlT2tOQSc3Wibu6Z8YkEDd8HINL24,5792 +vllm/lora/punica_wrapper/punica_selector.py,sha256=WP5XsmWE8YJG8fmak0jNPrgYxF4_lxaJt-mcNaMfsRY,755 +vllm/lora/punica_wrapper/utils.py,sha256=CFoSN8wz2TQhQhYdiZFjN_QU4AwQ8wPfa_o7wL9Ufuk,6846 +vllm/lora/request.py,sha256=w_fGpOlDlJpOS-7iw-dKXPkr0zvDmgdB4mr3kOszin8,3059 +vllm/lora/resolver.py,sha256=Ss3VTm7LIoc6eb_7EyNJgdgzMALWnxIBNRs2TqBbTyA,2807 +vllm/lora/utils.py,sha256=oQR3bn0k5is1hbZ6mA5-B9G62QhpFH13fS1Mdrj9Hko,9162 +vllm/lora/worker_manager.py,sha256=Mh-T5-V6kFooiFmgduO4hUw3spQfPDRp_uJs1rN6QAc,10673 +vllm/model_executor/__init__.py,sha256=cRhmybV9ftoNVy7E91WIczp4wLL4E6y77KQ9vrhWqL0,505 +vllm/model_executor/__pycache__/__init__.cpython-310.pyc,, +vllm/model_executor/__pycache__/custom_op.cpython-310.pyc,, +vllm/model_executor/__pycache__/parameter.cpython-310.pyc,, +vllm/model_executor/__pycache__/pooling_metadata.cpython-310.pyc,, +vllm/model_executor/__pycache__/sampling_metadata.cpython-310.pyc,, +vllm/model_executor/__pycache__/utils.cpython-310.pyc,, +vllm/model_executor/custom_op.py,sha256=-EYQ_VHfc_JJQRGlBuBx5praOIgZA_lg_1074yh5Q7o,5626 +vllm/model_executor/guided_decoding/__init__.py,sha256=TpFJoEV4tiUOJH3q3fLcR5o3BQnUtPEfMLMykMKKidk,8329 +vllm/model_executor/guided_decoding/__pycache__/__init__.cpython-310.pyc,, +vllm/model_executor/guided_decoding/__pycache__/guidance_decoding.cpython-310.pyc,, +vllm/model_executor/guided_decoding/__pycache__/guidance_logits_processors.cpython-310.pyc,, +vllm/model_executor/guided_decoding/__pycache__/guided_fields.cpython-310.pyc,, +vllm/model_executor/guided_decoding/__pycache__/lm_format_enforcer_decoding.cpython-310.pyc,, +vllm/model_executor/guided_decoding/__pycache__/outlines_decoding.cpython-310.pyc,, +vllm/model_executor/guided_decoding/__pycache__/outlines_logits_processors.cpython-310.pyc,, +vllm/model_executor/guided_decoding/__pycache__/utils.cpython-310.pyc,, +vllm/model_executor/guided_decoding/__pycache__/xgrammar_decoding.cpython-310.pyc,, +vllm/model_executor/guided_decoding/guidance_decoding.py,sha256=l9e0FB3CXN9JXaKwd5ZHL06hkINp0rxcaalRYGC3YPQ,2579 +vllm/model_executor/guided_decoding/guidance_logits_processors.py,sha256=9zLWQfZwe2MRdLO0n17TKtfhNqn-TM7_w0BwKjvF6y8,2509 +vllm/model_executor/guided_decoding/guided_fields.py,sha256=Xy26Otb4nD52-WXAfzFvajLSiyLFFLBXOzx0sBAtqdw,1563 +vllm/model_executor/guided_decoding/lm_format_enforcer_decoding.py,sha256=uUzfxJuP1NDjgLzPdEHJqGCj17J2JInP_LksjCP2utQ,2678 +vllm/model_executor/guided_decoding/outlines_decoding.py,sha256=5fRTcp8uiGQzGSu_X7JxQE3So7VSqH46BB098OcdlGg,5506 +vllm/model_executor/guided_decoding/outlines_logits_processors.py,sha256=7Auegbg5X2GJVNE0Y8IpjZlmSx2cCXpICakNybZUzo0,10438 +vllm/model_executor/guided_decoding/reasoner/__init__.py,sha256=jtFIBQmMxyEj4_f3h5NxOJ3y7wTVDbiHRtFneCTPRBc,1243 +vllm/model_executor/guided_decoding/reasoner/__pycache__/__init__.cpython-310.pyc,, +vllm/model_executor/guided_decoding/utils.py,sha256=alzXMrED6vcIkwgh-byWqthCP9lC6dqFAxluS_yzqhY,7888 +vllm/model_executor/guided_decoding/xgrammar_decoding.py,sha256=xlYHsakhHXVZqQ3QrWBtVK4AcYVlvSaxSGQqo40DJkI,16738 +vllm/model_executor/layers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +vllm/model_executor/layers/__pycache__/__init__.cpython-310.pyc,, +vllm/model_executor/layers/__pycache__/activation.cpython-310.pyc,, +vllm/model_executor/layers/__pycache__/layernorm.cpython-310.pyc,, +vllm/model_executor/layers/__pycache__/lightning_attn.cpython-310.pyc,, +vllm/model_executor/layers/__pycache__/linear.cpython-310.pyc,, +vllm/model_executor/layers/__pycache__/logits_processor.cpython-310.pyc,, +vllm/model_executor/layers/__pycache__/pooler.cpython-310.pyc,, +vllm/model_executor/layers/__pycache__/rejection_sampler.cpython-310.pyc,, +vllm/model_executor/layers/__pycache__/resampler.cpython-310.pyc,, +vllm/model_executor/layers/__pycache__/rotary_embedding.cpython-310.pyc,, +vllm/model_executor/layers/__pycache__/sampler.cpython-310.pyc,, +vllm/model_executor/layers/__pycache__/spec_decode_base_sampler.cpython-310.pyc,, +vllm/model_executor/layers/__pycache__/typical_acceptance_sampler.cpython-310.pyc,, +vllm/model_executor/layers/__pycache__/utils.cpython-310.pyc,, +vllm/model_executor/layers/__pycache__/vocab_parallel_embedding.cpython-310.pyc,, +vllm/model_executor/layers/activation.py,sha256=j0puBjGjVj5BqTsUDtI3jF7fTdJ_gnAEGESVm1-Jdco,12522 +vllm/model_executor/layers/fused_moe/__init__.py,sha256=hH3j2O9YtTlU3G4onWuXho3zxiGYailn_99thya1v6Y,1287 +vllm/model_executor/layers/fused_moe/__pycache__/__init__.cpython-310.pyc,, +vllm/model_executor/layers/fused_moe/__pycache__/cutlass_moe.cpython-310.pyc,, +vllm/model_executor/layers/fused_moe/__pycache__/deep_gemm_moe.cpython-310.pyc,, +vllm/model_executor/layers/fused_moe/__pycache__/fused_marlin_moe.cpython-310.pyc,, +vllm/model_executor/layers/fused_moe/__pycache__/fused_moe.cpython-310.pyc,, +vllm/model_executor/layers/fused_moe/__pycache__/layer.cpython-310.pyc,, +vllm/model_executor/layers/fused_moe/__pycache__/moe_align_block_size.cpython-310.pyc,, +vllm/model_executor/layers/fused_moe/__pycache__/moe_pallas.cpython-310.pyc,, +vllm/model_executor/layers/fused_moe/__pycache__/moe_torch_iterative.cpython-310.pyc,, +vllm/model_executor/layers/fused_moe/__pycache__/rocm_aiter_fused_moe.cpython-310.pyc,, +vllm/model_executor/layers/fused_moe/__pycache__/utils.cpython-310.pyc,, +"vllm/model_executor/layers/fused_moe/configs/E=1,N=14336,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a16.json",sha256=iNGsE2ZeVnQEnN4A8UJ9Jv0d3hbRF2MJ9oBgjup5Szk,2737 +"vllm/model_executor/layers/fused_moe/configs/E=1,N=14336,device_name=NVIDIA_A100-SXM4-80GB.json",sha256=hH5rRN9Wtyv35azxMzyUMHWtiKgOHev5tNjIG8j6dsE,2751 +"vllm/model_executor/layers/fused_moe/configs/E=1,N=1792,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a16.json",sha256=qPumkNxaHMvVBnEjPe_Xiuz9ICb6Hqc-9I1DAR8s3gA,4130 +"vllm/model_executor/layers/fused_moe/configs/E=1,N=1792,device_name=NVIDIA_A100-SXM4-80GB.json",sha256=s47lb8VLnyxMgWlqcIR4BdPBsjKWL4olXF49uZvygzQ,4140 +"vllm/model_executor/layers/fused_moe/configs/E=1,N=3072,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a16.json",sha256=gzfjrYDcS0vsACq7ONGVkNA3FqVjr3e89q9fO9kokkg,4133 +"vllm/model_executor/layers/fused_moe/configs/E=1,N=3072,device_name=NVIDIA_H100_80GB_HBM3,dtype=int8_w8a16.json",sha256=Np7yRX9Z7Y7Z5Nutbl02wpKdZRltbt4WqlPlleiYs2E,4146 +"vllm/model_executor/layers/fused_moe/configs/E=1,N=3072,device_name=NVIDIA_H100_80GB_HBM3.json",sha256=XsNfNXY8v0eatazkLCDiDclI0FnTudUGLYO01e1_4aA,4149 +"vllm/model_executor/layers/fused_moe/configs/E=1,N=3584,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a16.json",sha256=H0K4_O1CMbNLi-srcycT3lSl4JaBl3EGF89GY5Rj9MU,4130 +"vllm/model_executor/layers/fused_moe/configs/E=1,N=3584,device_name=NVIDIA_A100-SXM4-80GB.json",sha256=arPqstZMzZjz8BNpY3alKT4vGCJyUj5I2hEeK02aq98,4152 +"vllm/model_executor/layers/fused_moe/configs/E=1,N=7168,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a16.json",sha256=wjnQ4v-dflJMR3iFDHBuZI_1R0xXjsNoWc2kHu6C8JI,4135 +"vllm/model_executor/layers/fused_moe/configs/E=1,N=7168,device_name=NVIDIA_A100-SXM4-80GB.json",sha256=7WHPz_0fxeI3Ed0D9VIpZVoeN9RtJVVARvptfcmQu40,4146 +"vllm/model_executor/layers/fused_moe/configs/E=128,N=1024,device_name=AMD_Instinct_MI300X,dtype=fp8_w8a8.json",sha256=2kWS9Qvy5Q3mvUFmbPVures5iZAriAXsy8WrtE5wu00,3727 +"vllm/model_executor/layers/fused_moe/configs/E=128,N=192,device_name=NVIDIA_H100_80GB_HBM3.json",sha256=I3k416HbXU_rYb8scD8gAI4fuBlElHl06PM347Qa11w,3253 +"vllm/model_executor/layers/fused_moe/configs/E=128,N=192,device_name=NVIDIA_H20.json",sha256=RgV8C4F1LO09h01YsgF_eqX6GNoBtC7ulPfJRUUbg_g,3241 +"vllm/model_executor/layers/fused_moe/configs/E=128,N=192,device_name=NVIDIA_H200.json",sha256=nsNEuDNks0tVLfQfIm7xxFwEeptTfQcoa9fJy0NS8xQ,3247 +"vllm/model_executor/layers/fused_moe/configs/E=128,N=384,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=qbqjisJ4oKmcYzumHPRk5UyOzsdi8J6xas82UWHMeAI,3263 +"vllm/model_executor/layers/fused_moe/configs/E=128,N=384,device_name=NVIDIA_H20.json",sha256=vS2DRIDOqWyiBvbG6H746ownfkD1F8Aj2YZ0ET9xll8,3232 +"vllm/model_executor/layers/fused_moe/configs/E=128,N=384,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=MlpzcrkZo78kFYr6cqmh4lBdpxKcEvlzqvRf0bmeduQ,3264 +"vllm/model_executor/layers/fused_moe/configs/E=128,N=384,device_name=NVIDIA_H200.json",sha256=xqhl748it8GV2KXX0XixitE_ywnsKksqK8AGL7tAgT8,3254 +"vllm/model_executor/layers/fused_moe/configs/E=128,N=512,device_name=NVIDIA_H100_80GB_HBM3.json",sha256=FsWbV4Q6AzAtgegVuENBDz2ZcSJsqNiwUIVfQbpP7hQ,3244 +"vllm/model_executor/layers/fused_moe/configs/E=128,N=768,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=IuvyC8TNhCVAmUZfLSoETsyCKsmejKXrs_0zuwFLPAU,3265 +"vllm/model_executor/layers/fused_moe/configs/E=128,N=768,device_name=NVIDIA_H20.json",sha256=10Ntu2aVD5vGLonx-jW0qNw-tgZWdZmzMGx7utDVeng,3237 +"vllm/model_executor/layers/fused_moe/configs/E=128,N=768,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=RFH5FcN2ZCPk6DsxviTti1Q8JU5jzBRFXvUQNgOvnmI,3265 +"vllm/model_executor/layers/fused_moe/configs/E=128,N=768,device_name=NVIDIA_H200.json",sha256=JraM-Nvbg5V_TJkSl6UPFYZN1zHHoIbr2pAcksenoTY,3248 +"vllm/model_executor/layers/fused_moe/configs/E=128,N=96,device_name=NVIDIA_H20.json",sha256=JtcHRlPz8xQEAqJ9EWI63oYvdmjQFG6VTHqtt85VOSA,3221 +"vllm/model_executor/layers/fused_moe/configs/E=16,N=1024,device_name=AMD_Instinct_MI300X.json",sha256=f3iM3xm8hGUirJ4ilAIPO6Pe9bs4sm3qaRKMswN9SKE,4731 +"vllm/model_executor/layers/fused_moe/configs/E=16,N=1024,device_name=NVIDIA_H100.json",sha256=Bq57MPQXuSib06u6OwiEmSzOr3XvPYoD6ohYDJaBnII,3244 +"vllm/model_executor/layers/fused_moe/configs/E=16,N=1344,device_name=NVIDIA_A100-SXM4-40GB.json",sha256=pCCKkdUzzuBVtljyk7AEIAbeDf12DUiieXaODZXzm5E,3254 +"vllm/model_executor/layers/fused_moe/configs/E=16,N=1344,device_name=NVIDIA_A100-SXM4-80GB.json",sha256=trX2-c4N6hTTD6zFNi6A2bT3FkhxKjkM2rPl-o1K9ss,3250 +"vllm/model_executor/layers/fused_moe/configs/E=16,N=1344,device_name=NVIDIA_H100_80GB_HBM3.json",sha256=I4d56uD7E1JMXD9RAxq3FebdPquDsnNEkVaIY9Ctm9w,3246 +"vllm/model_executor/layers/fused_moe/configs/E=16,N=14336,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a16.json",sha256=ypuAxMQ7JESPXLBltt68wly2wTrJzlnobhUMip6xAmc,2751 +"vllm/model_executor/layers/fused_moe/configs/E=16,N=14336,device_name=NVIDIA_A100-SXM4-80GB.json",sha256=tUptlureu5QgyAEedtx5sm7CFudXAE6fIXepOb9gfas,2745 +"vllm/model_executor/layers/fused_moe/configs/E=16,N=1792,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a16.json",sha256=h57svdmDlZC_D8w9XWjPRS8ciYVkJiPEYfhrD2NRVVY,4127 +"vllm/model_executor/layers/fused_moe/configs/E=16,N=1792,device_name=NVIDIA_A100-SXM4-80GB.json",sha256=JmXhUnhX6YOy8RsmT0zFLGyNCpRBPV2q2Db9Y9ctZeE,4144 +"vllm/model_executor/layers/fused_moe/configs/E=16,N=2688,device_name=NVIDIA_A100-SXM4-80GB.json",sha256=G4PKqWxh0MlBhg7QHKj0m--_fP3Ll0gs7VJaeg-NIDM,3254 +"vllm/model_executor/layers/fused_moe/configs/E=16,N=2688,device_name=NVIDIA_H100_80GB_HBM3.json",sha256=bKX9AvcxN6k-i3RUmHSchZZ3rjoYRYb4iBqhCI4L3MY,3257 +"vllm/model_executor/layers/fused_moe/configs/E=16,N=3072,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a16.json",sha256=bWR6XBZ4nJ_ROg8rEgrQGc04I3BDbwILDHMZxATO-H4,2740 +"vllm/model_executor/layers/fused_moe/configs/E=16,N=3072,device_name=NVIDIA_H100_80GB_HBM3,dtype=int8_w8a16.json",sha256=Gu1wROuky-xS0dsFgbXS2QD_hOVV8yol9a5iqiYyq3s,2749 +"vllm/model_executor/layers/fused_moe/configs/E=16,N=3200,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8.json",sha256=_9HO7SaR6aQeh6vqCDpo3kjHnGJ9BVKLiMwYYgd3SmQ,2913 +"vllm/model_executor/layers/fused_moe/configs/E=16,N=3584,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a16.json",sha256=2ONiQSa9odzdPe1dIgBpP24l5z-5wB1eos06xOj0V_Q,2738 +"vllm/model_executor/layers/fused_moe/configs/E=16,N=3584,device_name=NVIDIA_A100-SXM4-80GB.json",sha256=Twkm9DVNxijpowfvioJ_4cKwIIlAWdyNWO9TA3gxAHs,4149 +"vllm/model_executor/layers/fused_moe/configs/E=16,N=6400,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8.json",sha256=THQWP1o2bWhnJh0rq3ZIVvs_sagIJgoK4x3pJbiFbHk,2910 +"vllm/model_executor/layers/fused_moe/configs/E=16,N=7168,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a16.json",sha256=o1pR3rNpO1eW4BHOKpPIQLjviw4P2X5Fr4HQBcdHA-I,2747 +"vllm/model_executor/layers/fused_moe/configs/E=16,N=7168,device_name=NVIDIA_A100-SXM4-80GB.json",sha256=iySqae0zI_PRBLqV-vfSCwDS4Jxcl5QjWa2NnhndL0U,2752 +"vllm/model_executor/layers/fused_moe/configs/E=16,N=7168,device_name=NVIDIA_H100_80GB_HBM3,dtype=int8_w8a16.json",sha256=Uhq0SrWiCrldkWbb0ZZZhWaCZ0SsvpiNL4z30KZUN5g,2747 +"vllm/model_executor/layers/fused_moe/configs/E=16,N=800,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8.json",sha256=ydsFUdXdVE_ZSScVhUxvxOFwKG-nkTraNeN69wqzxIM,2903 +"vllm/model_executor/layers/fused_moe/configs/E=160,N=192,device_name=NVIDIA_A800-SXM4-80GB.json",sha256=TtDngG7ljrU5RtWZ7g-xxdBT3uEuawiKhP8EwPr97XM,3254 +"vllm/model_executor/layers/fused_moe/configs/E=256,N=1024,device_name=AMD_Instinct_MI325X,block_shape=[128,128].json",sha256=fT7fwjuit4HbbyREYV3ECJ9Rm88FW-V54e27nG9nA_Q,4741 +"vllm/model_executor/layers/fused_moe/configs/E=256,N=1024,device_name=AMD_Instinct_MI325_OAM,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=fT7fwjuit4HbbyREYV3ECJ9Rm88FW-V54e27nG9nA_Q,4741 +"vllm/model_executor/layers/fused_moe/configs/E=256,N=128,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a8,block_shape=[128,128].json",sha256=HNvrgcXxV-eVMLwb7zY_R5KgJ7uBz-YIyQsKq1lWnWA,3263 +"vllm/model_executor/layers/fused_moe/configs/E=256,N=128,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a8.json",sha256=bHJEVy-CeImiY9JBRCMlHfHPAUi5xO7ENxgVVboN2Yo,3258 +"vllm/model_executor/layers/fused_moe/configs/E=256,N=128,device_name=NVIDIA_A800-SXM4-80GB,dtype=int8_w8a8,block_shape=[128,128].json",sha256=PnNmKSRFznCIUzZ4ZfaYTrMHeF2_kCQr4_bsEy_9Zu8,3259 +"vllm/model_executor/layers/fused_moe/configs/E=256,N=128,device_name=NVIDIA_A800-SXM4-80GB,dtype=int8_w8a8.json",sha256=0Vlxxzp4wrvkFj-NF4OAsJAaPkm-hhisJg0tgNl-W9g,3254 +"vllm/model_executor/layers/fused_moe/configs/E=256,N=128,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=0aSYzpv_cBAlpWCPrfGgNTCfae1KdKQnT56E8XFQl7A,3262 +"vllm/model_executor/layers/fused_moe/configs/E=256,N=128,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=Lqom_VMIPduSZTZQdeL2Wl_x3r9q6RmI9bojJrYwQZ4,3255 +"vllm/model_executor/layers/fused_moe/configs/E=256,N=128,device_name=NVIDIA_L20Y,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=fd2p65T9OboKIgw7MQc4IdKaJsoO73Nu3VQiKjV6Ffk,3261 +"vllm/model_executor/layers/fused_moe/configs/E=256,N=256,device_name=AMD_Instinct_MI300X,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=FUGuYbs_QhqKfErofvbTUplhAVN465A7NR_-ryXvebE,3741 +"vllm/model_executor/layers/fused_moe/configs/E=256,N=256,device_name=AMD_Instinct_MI325X,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=bpDPbTyrXLyCSy-o0diveVVeVUF_xj-fdSzCzWmEcKA,4733 +"vllm/model_executor/layers/fused_moe/configs/E=256,N=256,device_name=AMD_Instinct_MI325_OAM,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=bpDPbTyrXLyCSy-o0diveVVeVUF_xj-fdSzCzWmEcKA,4733 +"vllm/model_executor/layers/fused_moe/configs/E=256,N=256,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=skSJdv0Pr4rba5ODxp-fHZ6dpxn8KkvACGzNf74j81I,3257 +"vllm/model_executor/layers/fused_moe/configs/E=256,N=256,device_name=NVIDIA_H20,dtype=int8_w8a8,block_shape=[128,128].json",sha256=mtm7RgEBEJJkHsOis9BtAFo1OCk3vBbt7l7eumDzd7k,3263 +"vllm/model_executor/layers/fused_moe/configs/E=256,N=256,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=R4B2n2vGt4pPo6jS4Bmnx8AYtcfF9qQJE5bD7OhmXHs,3265 +"vllm/model_executor/layers/fused_moe/configs/E=256,N=256,device_name=NVIDIA_L20,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=JnqtO0t2HBcQECdYavi18mu9_MwblGr4zfRcW4zU7_c,3265 +"vllm/model_executor/layers/fused_moe/configs/E=256,N=512,device_name=AMD_Instinct_MI325_OAM,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=bpDPbTyrXLyCSy-o0diveVVeVUF_xj-fdSzCzWmEcKA,4733 +"vllm/model_executor/layers/fused_moe/configs/E=256,N=64,device_name=NVIDIA_A800-SXM4-80GB.json",sha256=rVORXxNsxy4WmO5SJR8Sd4k7vozKqhYf50wZNCMeQzs,3239 +"vllm/model_executor/layers/fused_moe/configs/E=60,N=1408,device_name=AMD_Instinct_MI300X.json",sha256=4UXbsSNHmrSWnD85SdRMLp4cFGRufndzJjB6hoQPclU,4736 +"vllm/model_executor/layers/fused_moe/configs/E=60,N=176,device_name=AMD_Instinct_MI300X.json",sha256=p6TKUp-KDeLB9E9LqThR1e7J2-ogSXPJojISdHgCxaY,4727 +"vllm/model_executor/layers/fused_moe/configs/E=60,N=352,device_name=AMD_Instinct_MI300X.json",sha256=gHxtmO_uvpueLVlsJgXBVE3_pS1S9EeRxNmHG_ZQszg,4729 +"vllm/model_executor/layers/fused_moe/configs/E=60,N=704,device_name=AMD_Instinct_MI300X.json",sha256=tVdpbIU1scsylx6oz3IADhkcwvZaNqw-_QVb7a6oVX8,4732 +"vllm/model_executor/layers/fused_moe/configs/E=64,N=1280,device_name=NVIDIA_A100-SXM4-80GB.json",sha256=6QPLhZurIqcMVdy3w0Dd7gLViKxsyJRBz-qd8agpi6Q,3248 +"vllm/model_executor/layers/fused_moe/configs/E=64,N=1280,device_name=NVIDIA_A800-SXM4-80GB.json",sha256=WPu80-OWyEJBy1hdnewLN1H1neFW8UVJrqyeDGegXc0,3250 +"vllm/model_executor/layers/fused_moe/configs/E=64,N=1280,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8.json",sha256=PaFLbT5ftJiiVSOVkq_DH01EcbIs0sBVkCd9PdYYmw4,3253 +"vllm/model_executor/layers/fused_moe/configs/E=64,N=1280,device_name=NVIDIA_H100_80GB_HBM3.json",sha256=ozS2ECxk-Dsd4Y9DgCGGwDwJlCf5T20ANf5gnTUMuSc,3252 +"vllm/model_executor/layers/fused_moe/configs/E=64,N=1280,device_name=NVIDIA_H200,dtype=fp8_w8a8.json",sha256=KEN6xt8pgPH_FbLT2fsAD4s03_V-Z9GXuEC4IKe3cPg,3262 +"vllm/model_executor/layers/fused_moe/configs/E=64,N=1280,device_name=NVIDIA_H200.json",sha256=w18R3eHB4oUhfbcCXjHyDvp0RiDSeCrfM-VFESim2hQ,3253 +"vllm/model_executor/layers/fused_moe/configs/E=64,N=2560,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8.json",sha256=iz4W1UAV1fcz1ZFh4hNQSLJ_F1MdXW-V3msy7t0WrRM,3262 +"vllm/model_executor/layers/fused_moe/configs/E=64,N=2560,device_name=NVIDIA_H200,dtype=fp8_w8a8.json",sha256=dYpKgvuG7Jji0W0zg_E9NfIojStBAdBcKd4B3nhimqk,3263 +"vllm/model_executor/layers/fused_moe/configs/E=64,N=2560,device_name=NVIDIA_H200.json",sha256=CXiHlGpea5cEGmFi28Jec34uxEZITF2XldVFcJteZX0,3251 +"vllm/model_executor/layers/fused_moe/configs/E=64,N=320,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8.json",sha256=W1q4PfievvgJ_SiPsDhOsR0Q0eJKb4o8JZhMcVhC-_4,3264 +"vllm/model_executor/layers/fused_moe/configs/E=64,N=320,device_name=NVIDIA_H100_80GB_HBM3.json",sha256=tku4-yTbIr0H5TNrm1Pq3tJJFYTXqHpdzJDSEF3bk9A,3238 +"vllm/model_executor/layers/fused_moe/configs/E=64,N=320,device_name=NVIDIA_H200,dtype=fp8_w8a8.json",sha256=HJcV-Tzt-yojzNQkPCgi84B44F_RppXxOIicRyg20-U,3264 +"vllm/model_executor/layers/fused_moe/configs/E=64,N=320,device_name=NVIDIA_H200.json",sha256=bM9g-XpirsThO3Q2x8ChSx3PPtHuHRXLvVMnTWt8jLI,3243 +"vllm/model_executor/layers/fused_moe/configs/E=64,N=640,device_name=NVIDIA_A100-SXM4-80GB.json",sha256=oxOKFDrgmw1YmgxTtRa1uoe3p09ylTLrkj_jOTqNh1Q,3249 +"vllm/model_executor/layers/fused_moe/configs/E=64,N=640,device_name=NVIDIA_A800-SXM4-80GB.json",sha256=-B6gZAEYLwMJZOnpO81pTxqs-YVKs_144Nn9BSLaMh0,3247 +"vllm/model_executor/layers/fused_moe/configs/E=64,N=640,device_name=NVIDIA_GeForce_RTX_4090,dtype=fp8_w8a8.json",sha256=GPjPHicomrS7ntHu7nnvgNXcHCoUw9vhyTUewkXpppo,3252 +"vllm/model_executor/layers/fused_moe/configs/E=64,N=640,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8.json",sha256=ObHUCUAgHTnld8Cq9Dy1n3ilmbBzyNC4jZcz6YYhMXA,3264 +"vllm/model_executor/layers/fused_moe/configs/E=64,N=640,device_name=NVIDIA_H100_80GB_HBM3.json",sha256=WegYsHl39QVlHu_4EZJSrgA4LQ5fYxSVNWFhoL6W2Rc,3251 +"vllm/model_executor/layers/fused_moe/configs/E=64,N=640,device_name=NVIDIA_H200,dtype=fp8_w8a8.json",sha256=Hrlas0Nt7d3JMr1vTpI3OVgkzxqcRziSMfFf_U5pQ58,3267 +"vllm/model_executor/layers/fused_moe/configs/E=64,N=640,device_name=NVIDIA_H200.json",sha256=J59rmqF8NQWkqmay__ahA3t3IwaPXNu5AVNLnTaDfYA,3252 +"vllm/model_executor/layers/fused_moe/configs/E=8,N=14336,device_name=AMD_Instinct_MI300X,dtype=fp8_w8a8.json",sha256=X8FVPE7rLblDs_Dw_Iu-KDw9H7PaC417EHyVclYjfv8,3733 +"vllm/model_executor/layers/fused_moe/configs/E=8,N=14336,device_name=AMD_Instinct_MI300X.json",sha256=FsIv5bqSpkWbxK2dBfg1N6tX9epZ55ZhgkJCD7hENlY,4733 +"vllm/model_executor/layers/fused_moe/configs/E=8,N=14336,device_name=AMD_Instinct_MI325X,dtype=fp8_w8a8.json",sha256=CnjQX3SlQn6fIGsX6P_dbNO0TYgAd-sVUb1FfDcDFUo,3732 +"vllm/model_executor/layers/fused_moe/configs/E=8,N=14336,device_name=AMD_Instinct_MI325X.json",sha256=fnO-v4YqBz0vUo0UtOTTD0n7VDG_ivczeQ1tR6Qm9f0,4734 +"vllm/model_executor/layers/fused_moe/configs/E=8,N=14336,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8.json",sha256=V_sgDtEtGEuBsGVa0maYJHhhGqe1NE7l-1ek2ed9WP8,3082 +"vllm/model_executor/layers/fused_moe/configs/E=8,N=14336,device_name=NVIDIA_H200,dtype=fp8_w8a8.json",sha256=QaITFIJU4UsrOBXaGdPYJwTmYJ0nT9kiiqeUiZzvd1k,3270 +"vllm/model_executor/layers/fused_moe/configs/E=8,N=14336,device_name=NVIDIA_H200.json",sha256=CC_jsMhXzrYne7eIOroDa0fCBKNnffiaVW2TKd4P-ek,3260 +"vllm/model_executor/layers/fused_moe/configs/E=8,N=16384,device_name=AMD_Instinct_MI300X,dtype=fp8_w8a8.json",sha256=LgHbxG1kQV36zZPkJcnurHYzwAjMh04lvEHEsfzS1t0,3732 +"vllm/model_executor/layers/fused_moe/configs/E=8,N=16384,device_name=AMD_Instinct_MI300X.json",sha256=_fcdkmWvdMqHiH8ZAGke-zXhH7qVPQx5CmKELW5hRCA,4735 +"vllm/model_executor/layers/fused_moe/configs/E=8,N=16384,device_name=AMD_Instinct_MI325X,dtype=fp8_w8a8.json",sha256=mVH8Rl4sLATinf7_0A9lTS83kv1E7Cm9oC0BL-pc9n4,3732 +"vllm/model_executor/layers/fused_moe/configs/E=8,N=16384,device_name=AMD_Instinct_MI325X.json",sha256=JKYW21c0CzR0fgE5ZnYp6C1sY_tVRlm8L_lgak5V5zE,4736 +"vllm/model_executor/layers/fused_moe/configs/E=8,N=1792,device_name=AMD_Instinct_MI300X,dtype=fp8_w8a8.json",sha256=yTf2R9cngSf4OafucAYlDDn4-bftaMFKaY7qhaBZPqQ,3739 +"vllm/model_executor/layers/fused_moe/configs/E=8,N=1792,device_name=AMD_Instinct_MI300X.json",sha256=_1eVE7ok935L2V43-3D3bVNWSVaoViia19sh0VrXmXM,4735 +"vllm/model_executor/layers/fused_moe/configs/E=8,N=1792,device_name=AMD_Instinct_MI325X,dtype=fp8_w8a8.json",sha256=5exlPUKvZxGDR0UT4_Dn5fp-_ZETJ6_Dbw_Vk1u8bbE,3735 +"vllm/model_executor/layers/fused_moe/configs/E=8,N=1792,device_name=AMD_Instinct_MI325X.json",sha256=18v6YruKbQ95pXPV8ocV4VdM1zNw3aZFp3WByeUkNSM,4736 +"vllm/model_executor/layers/fused_moe/configs/E=8,N=1792,device_name=NVIDIA_A100-SXM4-40GB.json",sha256=AffDc0_51ML8HiA3757zbD10TZJdUsUDIYIqO4g0yUw,3250 +"vllm/model_executor/layers/fused_moe/configs/E=8,N=1792,device_name=NVIDIA_A100-SXM4-80GB.json",sha256=IEYBNjt9HGnzoOVSWvL0A0jUqq926QD0_BvVYR4RA1Y,3252 +"vllm/model_executor/layers/fused_moe/configs/E=8,N=1792,device_name=NVIDIA_H100_80GB_HBM3.json",sha256=Ns9Y12aZbJnFhcG3nwb67bDqqiQAo9tdTAIe8K2Ajz4,3255 +"vllm/model_executor/layers/fused_moe/configs/E=8,N=1792,device_name=NVIDIA_H200,dtype=fp8_w8a8.json",sha256=uGSLFPZXK_JQ3GTDUAEiIecDor1yjbC3bJvMolF0Xl8,3267 +"vllm/model_executor/layers/fused_moe/configs/E=8,N=1792,device_name=NVIDIA_H200.json",sha256=8q6ol5JQBWj6yVfzFOn7Gz5MSXTaW9javL7qQmYVOwg,3245 +"vllm/model_executor/layers/fused_moe/configs/E=8,N=2048,device_name=AMD_Instinct_MI300X,dtype=fp8_w8a8.json",sha256=6jRC0oOpVpq5c1xePFKNRy-Xtmb038i4LE9N2zao2W4,3730 +"vllm/model_executor/layers/fused_moe/configs/E=8,N=2048,device_name=AMD_Instinct_MI300X.json",sha256=cFWeyNJtEbs-Bfohgzclxo1rcYGU863oV0BzJyQ4T0w,4734 +"vllm/model_executor/layers/fused_moe/configs/E=8,N=2048,device_name=AMD_Instinct_MI325X,dtype=fp8_w8a8.json",sha256=SMtsqtQeqcyy8aNwl9hPxRvx_XQdT7I3SBDNJ3OIvwY,3728 +"vllm/model_executor/layers/fused_moe/configs/E=8,N=2048,device_name=AMD_Instinct_MI325X.json",sha256=ZyOFJB6GUgGZsAjjT43XJwG8P-QrZ5yTvmgzQP7ThQY,4734 +"vllm/model_executor/layers/fused_moe/configs/E=8,N=2048,device_name=NVIDIA_A100-SXM4-80GB.json",sha256=HOxWmCI2ifHmWc0or2y8nEen86jDeLDov1-tuMzuhxo,3256 +"vllm/model_executor/layers/fused_moe/configs/E=8,N=2048,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8.json",sha256=csHezh0HGWaNwrblGzMgcE95hqbqjWS8HImLRJYr_ts,3266 +"vllm/model_executor/layers/fused_moe/configs/E=8,N=2048,device_name=NVIDIA_H100_80GB_HBM3.json",sha256=_5weLBinQCDzyV75hHKIT95Y0ce94KWft2_5BC6EkbQ,3254 +"vllm/model_executor/layers/fused_moe/configs/E=8,N=2048,device_name=NVIDIA_H200,dtype=fp8_w8a8.json",sha256=DlatRLPaSr8HJuO50gRZ2lzXoelx55EP3SDUdgIT2v4,3269 +"vllm/model_executor/layers/fused_moe/configs/E=8,N=2048,device_name=NVIDIA_H200.json",sha256=TXSOoqvi-x8H13xPqrB9qz2T3opEGA-2D0v_4n5BEG4,3259 +"vllm/model_executor/layers/fused_moe/configs/E=8,N=3584,device_name=AMD_Instinct_MI300X,dtype=fp8_w8a8.json",sha256=ro3drDpWAdeXH7IjMvx8wYGhIuDPOl0bpbJaIB5Msns,3732 +"vllm/model_executor/layers/fused_moe/configs/E=8,N=3584,device_name=AMD_Instinct_MI300X.json",sha256=w_R2LL8k5jNVUARcqvSgGLvNoQiQC0Mh73ciqSIAz54,4734 +"vllm/model_executor/layers/fused_moe/configs/E=8,N=3584,device_name=AMD_Instinct_MI325X,dtype=fp8_w8a8.json",sha256=hjDoTXRmEFLKhhmBFEjPowQus_z23ISonxFljql3c9k,3732 +"vllm/model_executor/layers/fused_moe/configs/E=8,N=3584,device_name=AMD_Instinct_MI325X.json",sha256=AdOTy7ASetdAXUhNM8buoU8_rLLjcUYF0m8RGFrLWRo,4733 +"vllm/model_executor/layers/fused_moe/configs/E=8,N=3584,device_name=NVIDIA_A100-SXM4-40GB.json",sha256=Ru460ZgnUP4U8OsJfwF8n-AI-gfcolNR3_qzoxG6DtY,3254 +"vllm/model_executor/layers/fused_moe/configs/E=8,N=3584,device_name=NVIDIA_A100-SXM4-80GB.json",sha256=K6BGrKw_oHTAtHjsZldcjp-BUM1dIecKXrrRn9OpRGs,3254 +"vllm/model_executor/layers/fused_moe/configs/E=8,N=3584,device_name=NVIDIA_GeForce_RTX_4090,dtype=fp8_w8a8.json",sha256=4aK_plqztXcJ-hs5_PsAvM0jclMzcO3hd3zTo0FhDro,3251 +"vllm/model_executor/layers/fused_moe/configs/E=8,N=3584,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8.json",sha256=qqFoMaObuO8pFWcSb9q0wYsdC4eSCO7B-_ruQhR1N9M,3264 +"vllm/model_executor/layers/fused_moe/configs/E=8,N=3584,device_name=NVIDIA_H100_80GB_HBM3.json",sha256=-5nkLIunjG1ghPoUEtt2AXEQw9oGiilP7K3UvQv9CqE,3252 +"vllm/model_executor/layers/fused_moe/configs/E=8,N=3584,device_name=NVIDIA_H200,dtype=fp8_w8a8.json",sha256=WKzddrIXo-KavpuXuouW3aLLAptu5Q4XJUb5K2PLgDM,3262 +"vllm/model_executor/layers/fused_moe/configs/E=8,N=3584,device_name=NVIDIA_H200.json",sha256=ad1ZkkSyLJwRGb4Kf24qg5hW_DPmt0BXrKR85oAiV34,3257 +"vllm/model_executor/layers/fused_moe/configs/E=8,N=3584,device_name=NVIDIA_L40S.json",sha256=qX5_yErBEwDRzhv2FvxrS3pEMa8zn0GHzLp5TUMX90g,3872 +"vllm/model_executor/layers/fused_moe/configs/E=8,N=4096,device_name=AMD_Instinct_MI300X,dtype=fp8_w8a8.json",sha256=ysRCWmxV20K2BYD9XEUtxwREFGtA3QHI191vHRA0k_Q,3733 +"vllm/model_executor/layers/fused_moe/configs/E=8,N=4096,device_name=AMD_Instinct_MI300X.json",sha256=L8VA1sfygHoyLJ-Ybfs8DP5c0YWFmMkwxHT8yJ9PEFM,4732 +"vllm/model_executor/layers/fused_moe/configs/E=8,N=4096,device_name=AMD_Instinct_MI325X,dtype=fp8_w8a8.json",sha256=FJWpDLr13XF3hHiHfJykpjbLiP7Ccu2en3U6BL-QwXw,3732 +"vllm/model_executor/layers/fused_moe/configs/E=8,N=4096,device_name=AMD_Instinct_MI325X.json",sha256=FnVcfzf5gXkQRt0XgsRzIQVbDPaUDOwWJX_9qOlyvRc,4731 +"vllm/model_executor/layers/fused_moe/configs/E=8,N=4096,device_name=NVIDIA_A100-SXM4-80GB.json",sha256=DxYu8regZOSFu8ugFGA_QbwWK4g8xwQUZF9a_nNY4Cs,3255 +"vllm/model_executor/layers/fused_moe/configs/E=8,N=4096,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8.json",sha256=obzfE_9XgsbFNfC9biYOHxR-V_Bgc7PKT8qZZJaiJJc,3262 +"vllm/model_executor/layers/fused_moe/configs/E=8,N=4096,device_name=NVIDIA_H100_80GB_HBM3.json",sha256=qwKy8oaMsd3QrXgQbM_x9xcfYiHK_Ou1CEwDPL5Gbgo,3259 +"vllm/model_executor/layers/fused_moe/configs/E=8,N=4096,device_name=NVIDIA_H200,dtype=fp8_w8a8.json",sha256=qUifbWbE4cOKZbIHWmmLx68VRaslQX69eZHwRIQx-7I,3269 +"vllm/model_executor/layers/fused_moe/configs/E=8,N=4096,device_name=NVIDIA_H200.json",sha256=JT-ZMLhAqqzSkqivOW5ATTKRlyyaFQkqQDnaPS4DE10,3262 +"vllm/model_executor/layers/fused_moe/configs/E=8,N=7168,device_name=AMD_Instinct_MI300X,dtype=fp8_w8a8.json",sha256=QsR-Xr9vyuiArMTSo-dX-1DFgATfqwIGOzFuQJAuE_Y,3734 +"vllm/model_executor/layers/fused_moe/configs/E=8,N=7168,device_name=AMD_Instinct_MI300X.json",sha256=EtVorGY4khTEuimlqZu0AAlPz84PH3ZkDZmVpxLtgQw,4735 +"vllm/model_executor/layers/fused_moe/configs/E=8,N=7168,device_name=AMD_Instinct_MI325X,dtype=fp8_w8a8.json",sha256=D3wX0_s_ylo3nLIUfaWZmGYtMvX7oiieOLMdQ9k7mng,3734 +"vllm/model_executor/layers/fused_moe/configs/E=8,N=7168,device_name=AMD_Instinct_MI325X.json",sha256=JPdO0azlh4yUvbpC9dEHYpRT11ELEr5LXBSb5XP4E_4,4735 +"vllm/model_executor/layers/fused_moe/configs/E=8,N=7168,device_name=NVIDIA_A100-SXM4-80GB.json",sha256=BAJnXTZoewwCtzJLUPJ0oYuALv640MvDuLseGcsYaaw,3252 +"vllm/model_executor/layers/fused_moe/configs/E=8,N=7168,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8.json",sha256=-Tj7ImS6ZFDof_0VTyq7kVm8XD9B54RD6CUOPSf3Jjg,3265 +"vllm/model_executor/layers/fused_moe/configs/E=8,N=7168,device_name=NVIDIA_H100_80GB_HBM3.json",sha256=tme0ydWzIxdABZLk4tU8G_X2dJUYGGZNkQzNGcmcvUc,3261 +"vllm/model_executor/layers/fused_moe/configs/E=8,N=7168,device_name=NVIDIA_H200,dtype=fp8_w8a8.json",sha256=g6Ivy4wvadaCAMJ4ZElbUU-CwyTMdbaa49M7IVQhVjk,3273 +"vllm/model_executor/layers/fused_moe/configs/E=8,N=7168,device_name=NVIDIA_H200.json",sha256=GstQosPPHUn_I2DV3eMGtn3xXOw6kl1hb8L0EvRsbEU,3261 +"vllm/model_executor/layers/fused_moe/configs/E=8,N=8192,device_name=AMD_Instinct_MI300X,dtype=fp8_w8a8.json",sha256=kF4Fx0yHUmiMSLFNXT6xqAEA4AgCaHOoy_3irv4dNss,3732 +"vllm/model_executor/layers/fused_moe/configs/E=8,N=8192,device_name=AMD_Instinct_MI300X.json",sha256=uOlVzTdJl_4VrRK4wmxIb8JKfveFZRjO9syjw_oEeL0,4732 +"vllm/model_executor/layers/fused_moe/configs/E=8,N=8192,device_name=AMD_Instinct_MI325X,dtype=fp8_w8a8.json",sha256=plnx7r9jkcYXkhvapbeeNvUg3NMGdGsIgIPSrfVy2qU,3733 +"vllm/model_executor/layers/fused_moe/configs/E=8,N=8192,device_name=AMD_Instinct_MI325X.json",sha256=UC-iTgh8_dUSXRaYHOIhDH31KOiJmcfqM_Bv_UBf3ks,4733 +"vllm/model_executor/layers/fused_moe/configs/E=8,N=8192,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8.json",sha256=sY2nWMPh9lsIkhPCjkHO245wpnfFbrHmzdcZDVFPVww,3265 +"vllm/model_executor/layers/fused_moe/configs/E=8,N=8192,device_name=NVIDIA_H200,dtype=fp8_w8a8.json",sha256=WQLKugnKzlQ0avf1N-41lRHtG6wJ56DfVPv_nip6NBc,3273 +vllm/model_executor/layers/fused_moe/configs/README,sha256=W2yIZkP9O8GGlg97We9BJfTtWUtPbuz5ZH3esrrjBX0,572 +vllm/model_executor/layers/fused_moe/cutlass_moe.py,sha256=5h6pIi7pJLwyyJO-_1Ir-BrA3KdF1n8C4KMdMMCFt6s,8006 +vllm/model_executor/layers/fused_moe/deep_gemm_moe.py,sha256=pWVAazeIIZ9HdgLIGWvKEnO6pGWNT1vJi8daSAwk3dw,11542 +vllm/model_executor/layers/fused_moe/fused_marlin_moe.py,sha256=TinNuSAB3Rj7eXpS3uAbglA2Qvuw6fAHOJsXVutqq4Y,14343 +vllm/model_executor/layers/fused_moe/fused_moe.py,sha256=BFsieGtPoCz1Un1YmjRT-SCcPI1MmdeNkJTcEXfdKhI,62916 +vllm/model_executor/layers/fused_moe/layer.py,sha256=fFfPdq-vUXsGlTEXSVSG7zg5jI7dGj_wlTQH7bEvxYE,40247 +vllm/model_executor/layers/fused_moe/moe_align_block_size.py,sha256=om1dbnaefHLn8S9j7x95-85VvCAR3Wtx1rvEYAtDvMU,8280 +vllm/model_executor/layers/fused_moe/moe_pallas.py,sha256=20nVD5HOmg1D9Jol0k4IS4PF_k6QIUIZBGIUxPNlrIE,2338 +vllm/model_executor/layers/fused_moe/moe_torch_iterative.py,sha256=XSzX80m9PnrlCgGPzSud-lsro4Xx9qlWoiT9OfBZ6WQ,2087 +vllm/model_executor/layers/fused_moe/rocm_aiter_fused_moe.py,sha256=o-O-vrrYgtF6stNTqU2t73WWOV2cLFBejaHVxumwb9A,16639 +vllm/model_executor/layers/fused_moe/utils.py,sha256=TWZBVHS1XMUYxFCVL-EvcDTHf_f6KIPdk4cWxdgDC9U,1487 +vllm/model_executor/layers/layernorm.py,sha256=JO55dJIRWlYCBpQ6uYkTNTeu7iTEKudDxWJ53gQsrE0,8820 +vllm/model_executor/layers/lightning_attn.py,sha256=8yOj6NdnSqSa65lYJe5in7yYrRsSg8xiSjju_zTDtCo,20894 +vllm/model_executor/layers/linear.py,sha256=l7Pv_n76G7YKpIZGumI2ZbkoCyPsVRBTbw2b7CO-Y1s,64973 +vllm/model_executor/layers/logits_processor.py,sha256=4cmm-_PEPbWrwdfh9MC5MDwdXkbmmGrQoGwfttxdvCo,7757 +vllm/model_executor/layers/mamba/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +vllm/model_executor/layers/mamba/__pycache__/__init__.cpython-310.pyc,, +vllm/model_executor/layers/mamba/__pycache__/mamba2_metadata.cpython-310.pyc,, +vllm/model_executor/layers/mamba/__pycache__/mamba_mixer.cpython-310.pyc,, +vllm/model_executor/layers/mamba/__pycache__/mamba_mixer2.cpython-310.pyc,, +vllm/model_executor/layers/mamba/mamba2_metadata.py,sha256=R3UJ_ZGgdei4h6wzpaZqT-B7fEjk6spOM2UMgRy8ij8,4109 +vllm/model_executor/layers/mamba/mamba_mixer.py,sha256=Zf4FM5tdpJDsZwMMehWnNOjhpXnKJRPVvoLBZoONLaM,10141 +vllm/model_executor/layers/mamba/mamba_mixer2.py,sha256=srdZB5YXCDBAKjRxK3fkT1tPv7JopvKW9uvyqc4rM6c,22608 +vllm/model_executor/layers/mamba/ops/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +vllm/model_executor/layers/mamba/ops/__pycache__/__init__.cpython-310.pyc,, +vllm/model_executor/layers/mamba/ops/__pycache__/causal_conv1d.cpython-310.pyc,, +vllm/model_executor/layers/mamba/ops/__pycache__/mamba_ssm.cpython-310.pyc,, +vllm/model_executor/layers/mamba/ops/__pycache__/ssd_bmm.cpython-310.pyc,, +vllm/model_executor/layers/mamba/ops/__pycache__/ssd_chunk_scan.cpython-310.pyc,, +vllm/model_executor/layers/mamba/ops/__pycache__/ssd_chunk_state.cpython-310.pyc,, +vllm/model_executor/layers/mamba/ops/__pycache__/ssd_combined.cpython-310.pyc,, +vllm/model_executor/layers/mamba/ops/__pycache__/ssd_state_passing.cpython-310.pyc,, +vllm/model_executor/layers/mamba/ops/causal_conv1d.py,sha256=_ZiWUKMLApKDWDH8iB_8Zw_GGGAFHDJRxbcMWQlMYac,4470 +vllm/model_executor/layers/mamba/ops/mamba_ssm.py,sha256=bQX50q_1z93VsJc_t5gRqhWqqLn0LZluEVfha4CaPDk,14196 +vllm/model_executor/layers/mamba/ops/ssd_bmm.py,sha256=zXsgPJWuo-VSxzqNWJKoviGj0jtO8TLrnQo8bvZGmIY,8572 +vllm/model_executor/layers/mamba/ops/ssd_chunk_scan.py,sha256=ZRoGCYVz3LIcju1txuH0mQLbqcuqhg0muZtoPes6lK0,20837 +vllm/model_executor/layers/mamba/ops/ssd_chunk_state.py,sha256=87dl7hjZm8kkYcKjTk16eV0_RiYRmEgoFGbZgEhOFUo,25613 +vllm/model_executor/layers/mamba/ops/ssd_combined.py,sha256=0Hzm4NoZseWT278uikG88FyxCzol_II_XyYG8Sx7Wmw,9363 +vllm/model_executor/layers/mamba/ops/ssd_state_passing.py,sha256=VWtXQkc0_UMoEKx9rIDDXvbVjQ3uHdA49p9PpTqzveU,7370 +vllm/model_executor/layers/pooler.py,sha256=vT8XtX12oKqGhwAA6z9SAHbqIFuImyR32KlvdWNc0FU,11434 +vllm/model_executor/layers/quantization/__init__.py,sha256=TalnUVZVCDZF5x9UfXECwkeGW-o_5AZ8f2iNtTSbjkk,5042 +vllm/model_executor/layers/quantization/__pycache__/__init__.cpython-310.pyc,, +vllm/model_executor/layers/quantization/__pycache__/aqlm.cpython-310.pyc,, +vllm/model_executor/layers/quantization/__pycache__/awq.cpython-310.pyc,, +vllm/model_executor/layers/quantization/__pycache__/awq_marlin.cpython-310.pyc,, +vllm/model_executor/layers/quantization/__pycache__/awq_triton.cpython-310.pyc,, +vllm/model_executor/layers/quantization/__pycache__/base_config.cpython-310.pyc,, +vllm/model_executor/layers/quantization/__pycache__/bitblas.cpython-310.pyc,, +vllm/model_executor/layers/quantization/__pycache__/bitsandbytes.cpython-310.pyc,, +vllm/model_executor/layers/quantization/__pycache__/deepspeedfp.cpython-310.pyc,, +vllm/model_executor/layers/quantization/__pycache__/experts_int8.cpython-310.pyc,, +vllm/model_executor/layers/quantization/__pycache__/fbgemm_fp8.cpython-310.pyc,, +vllm/model_executor/layers/quantization/__pycache__/fp8.cpython-310.pyc,, +vllm/model_executor/layers/quantization/__pycache__/gguf.cpython-310.pyc,, +vllm/model_executor/layers/quantization/__pycache__/gptq.cpython-310.pyc,, +vllm/model_executor/layers/quantization/__pycache__/gptq_bitblas.cpython-310.pyc,, +vllm/model_executor/layers/quantization/__pycache__/gptq_marlin.cpython-310.pyc,, +vllm/model_executor/layers/quantization/__pycache__/gptq_marlin_24.cpython-310.pyc,, +vllm/model_executor/layers/quantization/__pycache__/hqq_marlin.cpython-310.pyc,, +vllm/model_executor/layers/quantization/__pycache__/ipex_quant.cpython-310.pyc,, +vllm/model_executor/layers/quantization/__pycache__/kv_cache.cpython-310.pyc,, +vllm/model_executor/layers/quantization/__pycache__/marlin.cpython-310.pyc,, +vllm/model_executor/layers/quantization/__pycache__/modelopt.cpython-310.pyc,, +vllm/model_executor/layers/quantization/__pycache__/moe_wna16.cpython-310.pyc,, +vllm/model_executor/layers/quantization/__pycache__/neuron_quant.cpython-310.pyc,, +vllm/model_executor/layers/quantization/__pycache__/ptpc_fp8.cpython-310.pyc,, +vllm/model_executor/layers/quantization/__pycache__/qqq.cpython-310.pyc,, +vllm/model_executor/layers/quantization/__pycache__/schema.cpython-310.pyc,, +vllm/model_executor/layers/quantization/__pycache__/torchao.cpython-310.pyc,, +vllm/model_executor/layers/quantization/__pycache__/tpu_int8.cpython-310.pyc,, +vllm/model_executor/layers/quantization/aqlm.py,sha256=QfdUGmbgpk8AvVcu5GhyBZILT2naouXuj9swKMAGK9k,13632 +vllm/model_executor/layers/quantization/awq.py,sha256=N25NTWjYJBKg540sEuB6ScaYOxQkVk_QR_6N-d_Rlbs,7077 +vllm/model_executor/layers/quantization/awq_marlin.py,sha256=ztPXUH2uPQbts1Q4-PFYQ9ztwXV3AWr3wwxKCXL2xrg,21336 +vllm/model_executor/layers/quantization/awq_triton.py,sha256=SNr8Xro-iH8IrPJBvGdI6R_gsV0QmNnEzWOZhx2p014,12415 +vllm/model_executor/layers/quantization/base_config.py,sha256=uo3fpOXNR-au-FXNVR6oSXTj3ZBapvRgV5xzwKrzLM8,5022 +vllm/model_executor/layers/quantization/bitblas.py,sha256=JqYdMguKdC5Gixwe1qO9CSyCckX8CRfgodhTWnx0_iY,17423 +vllm/model_executor/layers/quantization/bitsandbytes.py,sha256=sCoJs5fEGPtVoaRwmuvzlOrR2AfvncfbMCSzhVfaPTA,15220 +vllm/model_executor/layers/quantization/compressed_tensors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +vllm/model_executor/layers/quantization/compressed_tensors/__pycache__/__init__.cpython-310.pyc,, +vllm/model_executor/layers/quantization/compressed_tensors/__pycache__/compressed_tensors.cpython-310.pyc,, +vllm/model_executor/layers/quantization/compressed_tensors/__pycache__/compressed_tensors_moe.cpython-310.pyc,, +vllm/model_executor/layers/quantization/compressed_tensors/__pycache__/triton_scaled_mm.cpython-310.pyc,, +vllm/model_executor/layers/quantization/compressed_tensors/__pycache__/utils.cpython-310.pyc,, +vllm/model_executor/layers/quantization/compressed_tensors/compressed_tensors.py,sha256=U4ZRH7ltm8AvyQ0B26EhvK_aJGNPYKDrWv-AgM71-XY,27174 +vllm/model_executor/layers/quantization/compressed_tensors/compressed_tensors_moe.py,sha256=k8zxaxRSSKmNQCk_BrvRXekROO71F_MsT9w2cmuG2OE,48701 +vllm/model_executor/layers/quantization/compressed_tensors/schemes/__init__.py,sha256=BwKgT5i-Gu1d45Z72x5PUP3Yect8hO37yW9rfUeIoug,931 +vllm/model_executor/layers/quantization/compressed_tensors/schemes/__pycache__/__init__.cpython-310.pyc,, +vllm/model_executor/layers/quantization/compressed_tensors/schemes/__pycache__/compressed_tensors_24.cpython-310.pyc,, +vllm/model_executor/layers/quantization/compressed_tensors/schemes/__pycache__/compressed_tensors_scheme.cpython-310.pyc,, +vllm/model_executor/layers/quantization/compressed_tensors/schemes/__pycache__/compressed_tensors_w4a16_24.cpython-310.pyc,, +vllm/model_executor/layers/quantization/compressed_tensors/schemes/__pycache__/compressed_tensors_w8a16_fp8.cpython-310.pyc,, +vllm/model_executor/layers/quantization/compressed_tensors/schemes/__pycache__/compressed_tensors_w8a8_fp8.cpython-310.pyc,, +vllm/model_executor/layers/quantization/compressed_tensors/schemes/__pycache__/compressed_tensors_w8a8_int8.cpython-310.pyc,, +vllm/model_executor/layers/quantization/compressed_tensors/schemes/__pycache__/compressed_tensors_wNa16.cpython-310.pyc,, +vllm/model_executor/layers/quantization/compressed_tensors/schemes/compressed_tensors_24.py,sha256=-Wi5n6G025-iZdIreWf5_yNUHXwmkCTcax4nDTG-5Sk,14065 +vllm/model_executor/layers/quantization/compressed_tensors/schemes/compressed_tensors_scheme.py,sha256=Jxb5WOHR4m98DRO4y3XKJMDpT_NIp3EwkAJe8HYqwqE,1527 +vllm/model_executor/layers/quantization/compressed_tensors/schemes/compressed_tensors_w4a16_24.py,sha256=v0u6xXo4zJ530YWbnnJXbJFoMrjUVveF6z4HVKhCqrk,6207 +vllm/model_executor/layers/quantization/compressed_tensors/schemes/compressed_tensors_w8a16_fp8.py,sha256=GmDa7Kwrqj7Ja5-VZ7DRY8MTcmPChOKOK7ku3gguLT8,5409 +vllm/model_executor/layers/quantization/compressed_tensors/schemes/compressed_tensors_w8a8_fp8.py,sha256=OZWeSv-JNl0Qi8OO9xg1qCoGPuSnTNKyTb063iVWLCI,6443 +vllm/model_executor/layers/quantization/compressed_tensors/schemes/compressed_tensors_w8a8_int8.py,sha256=yns8-JTL4TM6boMggXk8E-yOalJgQ9O1neAs57oMh3g,4872 +vllm/model_executor/layers/quantization/compressed_tensors/schemes/compressed_tensors_wNa16.py,sha256=Y5XH3IUwKHPA1fqI0xrurXEkdsSEnDcVNcl4j4KN5R0,8483 +vllm/model_executor/layers/quantization/compressed_tensors/triton_scaled_mm.py,sha256=gMLaK9uSOVqYw1wv8klnGLc1qass2K-DnpWTSm0rvuM,7731 +vllm/model_executor/layers/quantization/compressed_tensors/utils.py,sha256=YSJeIjPjkJ_dZIzKEnGGz419L7rC3HJnvhhohySbntE,7707 +vllm/model_executor/layers/quantization/deepspeedfp.py,sha256=dFYeJS3w1hV488ycJaEFh9vhhYsx_L1BkVkRIULrH_Y,7141 +vllm/model_executor/layers/quantization/experts_int8.py,sha256=ylZ29BXWbbguYfjESmAYJXcPjAiJMRFcgSGClK8_f8U,7544 +vllm/model_executor/layers/quantization/fbgemm_fp8.py,sha256=3s4OcrfLBwWdwBBEmJhOD3qzAtXW-01jvn95XBDxbOg,6690 +vllm/model_executor/layers/quantization/fp8.py,sha256=SOG2TmjHXtXfWlLg_MnOlMA0FBveiEbhZZkjPtzjVzc,38798 +vllm/model_executor/layers/quantization/gguf.py,sha256=xKXwqosINZjqmH6UDxY-sgYoLqjWHhTOM3rYwN5pAUs,15605 +vllm/model_executor/layers/quantization/gptq.py,sha256=UvvQgccjma1BWX2qiEzEChAS-oksybpCyl_Ih3PRJpI,10693 +vllm/model_executor/layers/quantization/gptq_bitblas.py,sha256=WEZ9xLDkMTKs7wJN5ljGvNn2rMuZKF927OYlyynbm18,16726 +vllm/model_executor/layers/quantization/gptq_marlin.py,sha256=-BvLrewcU-BV_JYrc2TWN5DFp0fxxgECls4VLfAArMU,25889 +vllm/model_executor/layers/quantization/gptq_marlin_24.py,sha256=ofvuwNh5iMi14XVeJDccjqgmmhngH8JOGS-NfevN31c,10881 +vllm/model_executor/layers/quantization/hqq_marlin.py,sha256=8Rzl1cD3lQF6x3_9VrULM5wE4utzsfk1_PAW8svW8Wo,12722 +vllm/model_executor/layers/quantization/ipex_quant.py,sha256=5-XtI2qXAh_isk47Ym0tmI8hAz0xMGjLr9vkBIXXmXw,9761 +vllm/model_executor/layers/quantization/kernels/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +vllm/model_executor/layers/quantization/kernels/__pycache__/__init__.cpython-310.pyc,, +vllm/model_executor/layers/quantization/kernels/mixed_precision/MPLinearKernel.py,sha256=Qx5iCPjsnW69RjhPY6qRRsTWddK4gf4sbrgh6czvtYE,2879 +vllm/model_executor/layers/quantization/kernels/mixed_precision/__init__.py,sha256=qfYaz1R-8tYyZA681HiD2es0Cefy9pyMQaRxbcNF62o,3148 +vllm/model_executor/layers/quantization/kernels/mixed_precision/__pycache__/MPLinearKernel.cpython-310.pyc,, +vllm/model_executor/layers/quantization/kernels/mixed_precision/__pycache__/__init__.cpython-310.pyc,, +vllm/model_executor/layers/quantization/kernels/mixed_precision/__pycache__/allspark.cpython-310.pyc,, +vllm/model_executor/layers/quantization/kernels/mixed_precision/__pycache__/bitblas.cpython-310.pyc,, +vllm/model_executor/layers/quantization/kernels/mixed_precision/__pycache__/exllama.cpython-310.pyc,, +vllm/model_executor/layers/quantization/kernels/mixed_precision/__pycache__/machete.cpython-310.pyc,, +vllm/model_executor/layers/quantization/kernels/mixed_precision/__pycache__/marlin.cpython-310.pyc,, +vllm/model_executor/layers/quantization/kernels/mixed_precision/allspark.py,sha256=sRi51JVWhw-NAI2j4UZu1aM-GhD-3TGqjJq25naNQYE,4382 +vllm/model_executor/layers/quantization/kernels/mixed_precision/bitblas.py,sha256=rKl3U-GOjP8AHYvLT7Nb7KnmuEU0SJeFHcS0I4QLRfo,11986 +vllm/model_executor/layers/quantization/kernels/mixed_precision/exllama.py,sha256=pqVO7rcPUT28KaVAoYJ1e96JSF18scX--uz_WprnUKI,6151 +vllm/model_executor/layers/quantization/kernels/mixed_precision/machete.py,sha256=IkHizcr5RzUPsATGSqiZ4B35GatUhVZdiBkDHM6psBc,4981 +vllm/model_executor/layers/quantization/kernels/mixed_precision/marlin.py,sha256=cRqXQU_vDoSbq0dx1F6kLA9_dhZtFA65LREKpQqpl0E,5810 +vllm/model_executor/layers/quantization/kernels/scaled_mm/ScaledMMLinearKernel.py,sha256=EKNHGvrBoiElOpU-LOa4V0pui-MkLDcwxE9AScv9Sdc,2046 +vllm/model_executor/layers/quantization/kernels/scaled_mm/__init__.py,sha256=tEOkluEyfDASQrKY7k9kmyqJ7h7tC1bbXl49YrU9WGA,3456 +vllm/model_executor/layers/quantization/kernels/scaled_mm/__pycache__/ScaledMMLinearKernel.cpython-310.pyc,, +vllm/model_executor/layers/quantization/kernels/scaled_mm/__pycache__/__init__.cpython-310.pyc,, +vllm/model_executor/layers/quantization/kernels/scaled_mm/__pycache__/aiter.cpython-310.pyc,, +vllm/model_executor/layers/quantization/kernels/scaled_mm/__pycache__/cutlass.cpython-310.pyc,, +vllm/model_executor/layers/quantization/kernels/scaled_mm/__pycache__/triton.cpython-310.pyc,, +vllm/model_executor/layers/quantization/kernels/scaled_mm/__pycache__/xla.cpython-310.pyc,, +vllm/model_executor/layers/quantization/kernels/scaled_mm/aiter.py,sha256=i_V3XGjjUgq9UqqjG61jGongXwhoyFPSJpg1RSzAEgU,4822 +vllm/model_executor/layers/quantization/kernels/scaled_mm/cutlass.py,sha256=-xzsBNkRLZ9WnMq4Iq2YvXjuSDMtmNdP2oEa4QGJIcE,5989 +vllm/model_executor/layers/quantization/kernels/scaled_mm/triton.py,sha256=3ssC8LJcQ-iPtlxEdoAZfPngiAuCaAy3-RWuBGz3ldE,1283 +vllm/model_executor/layers/quantization/kernels/scaled_mm/xla.py,sha256=pDL9lpK8gSsbeUTZ2KpRx6n5G5MvgxhYLVP5FEAA8cg,4303 +vllm/model_executor/layers/quantization/kv_cache.py,sha256=za-3W4pn--yEnGmbNT7H_cTy7dq-qzrhyOtRL5J2OSo,6058 +vllm/model_executor/layers/quantization/marlin.py,sha256=2kmoUfynMW0rZtCwXFwUPktdD5gB4-yerAI67S1LUCY,9590 +vllm/model_executor/layers/quantization/modelopt.py,sha256=QxYzmdjPYnQel0IiR8Z05-UcYamAfvH0P5b9MwiCRt8,17050 +vllm/model_executor/layers/quantization/moe_wna16.py,sha256=9U8onQRLdwVfTtf5aseOMG8_d3G93jFOIUcj7sJFa0w,19705 +vllm/model_executor/layers/quantization/neuron_quant.py,sha256=rtAjtdeIxcydC1MVLUMNwZAUJiitTofmOQC0OCNdfTI,2421 +vllm/model_executor/layers/quantization/ptpc_fp8.py,sha256=KvJDkBrNNBfQcgrzVOdB0NlBUQZrPgxxXizl9b4pzKk,5206 +vllm/model_executor/layers/quantization/qqq.py,sha256=8f-hMJ2I65hrCwtItBwkNtsu2MRBmEBM67hMY-chYZA,9938 +vllm/model_executor/layers/quantization/quark/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +vllm/model_executor/layers/quantization/quark/__pycache__/__init__.cpython-310.pyc,, +vllm/model_executor/layers/quantization/quark/__pycache__/quark.cpython-310.pyc,, +vllm/model_executor/layers/quantization/quark/__pycache__/quark_moe.cpython-310.pyc,, +vllm/model_executor/layers/quantization/quark/__pycache__/utils.cpython-310.pyc,, +vllm/model_executor/layers/quantization/quark/quark.py,sha256=n2bagwPQ1X0En9wVRUDgiu9G9eR7MfJBJ5lqFtj3ok8,16645 +vllm/model_executor/layers/quantization/quark/quark_moe.py,sha256=N66KTUle8IvOpQt8lgkikXkGp0n21pS5PMVln44jWh0,10782 +vllm/model_executor/layers/quantization/quark/schemes/__init__.py,sha256=uEyTk05b5tNt-oEmSSkySwnWJ87o-oVphnSJoTf3MAM,221 +vllm/model_executor/layers/quantization/quark/schemes/__pycache__/__init__.cpython-310.pyc,, +vllm/model_executor/layers/quantization/quark/schemes/__pycache__/quark_scheme.cpython-310.pyc,, +vllm/model_executor/layers/quantization/quark/schemes/__pycache__/quark_w8a8_fp8.cpython-310.pyc,, +vllm/model_executor/layers/quantization/quark/schemes/__pycache__/quark_w8a8_int8.cpython-310.pyc,, +vllm/model_executor/layers/quantization/quark/schemes/quark_scheme.py,sha256=f_5qRmZ3SZvIgBWiMlNjfu-WN1uVwSvfLGFe9QS25R4,1491 +vllm/model_executor/layers/quantization/quark/schemes/quark_w8a8_fp8.py,sha256=2PAM1IXP9h5SvGvixnq9uETU4MglVV4iT0SJpq9f3K4,6138 +vllm/model_executor/layers/quantization/quark/schemes/quark_w8a8_int8.py,sha256=8vBLb1dXAQ11hfK4Bzq_FMXtg6idTF2MWZ0dQ3GnFQU,5404 +vllm/model_executor/layers/quantization/quark/utils.py,sha256=9VCOhQ_qNa31Se-LBuV11m1_HXNV4Fp8UJU9q0pRljM,3558 +vllm/model_executor/layers/quantization/schema.py,sha256=vb8XZXdDPgY437o96uNlQOUDhPoGeowrlwO1b4QdugE,3686 +vllm/model_executor/layers/quantization/torchao.py,sha256=sZS7l6lrRrBErqtW-8kwlY9bxs-87JDNmiwS3CefzCA,4236 +vllm/model_executor/layers/quantization/tpu_int8.py,sha256=CggIxU5-tKOS-yNuzzZCurwqfH3YHEz6feir6MABzwY,4443 +vllm/model_executor/layers/quantization/utils/__init__.py,sha256=VbdLnvlGCFpa2o9SRnEMflRyJ3NOXd6j6d1fPN_xm5w,166 +vllm/model_executor/layers/quantization/utils/__pycache__/__init__.cpython-310.pyc,, +vllm/model_executor/layers/quantization/utils/__pycache__/allspark_utils.cpython-310.pyc,, +vllm/model_executor/layers/quantization/utils/__pycache__/bitblas_utils.cpython-310.pyc,, +vllm/model_executor/layers/quantization/utils/__pycache__/fp8_utils.cpython-310.pyc,, +vllm/model_executor/layers/quantization/utils/__pycache__/gptq_utils.cpython-310.pyc,, +vllm/model_executor/layers/quantization/utils/__pycache__/int8_utils.cpython-310.pyc,, +vllm/model_executor/layers/quantization/utils/__pycache__/layer_utils.cpython-310.pyc,, +vllm/model_executor/layers/quantization/utils/__pycache__/machete_utils.cpython-310.pyc,, +vllm/model_executor/layers/quantization/utils/__pycache__/marlin_utils.cpython-310.pyc,, +vllm/model_executor/layers/quantization/utils/__pycache__/marlin_utils_fp8.cpython-310.pyc,, +vllm/model_executor/layers/quantization/utils/__pycache__/marlin_utils_test.cpython-310.pyc,, +vllm/model_executor/layers/quantization/utils/__pycache__/marlin_utils_test_24.cpython-310.pyc,, +vllm/model_executor/layers/quantization/utils/__pycache__/marlin_utils_test_qqq.cpython-310.pyc,, +vllm/model_executor/layers/quantization/utils/__pycache__/quant_utils.cpython-310.pyc,, +vllm/model_executor/layers/quantization/utils/__pycache__/w8a8_utils.cpython-310.pyc,, +vllm/model_executor/layers/quantization/utils/allspark_utils.py,sha256=OCRUcTMINyOKCWe0tik98msBXKTGXX2beZQZeTMyXz0,2191 +vllm/model_executor/layers/quantization/utils/bitblas_utils.py,sha256=z8mYjocXD6MjznFURj9RdGGFAdpu90oheDQ__IHk480,7798 +"vllm/model_executor/layers/quantization/utils/configs/N=1536,K=1536,device_name=AMD_Instinct_MI300X,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=t8TaODfMF2Nq0qg6KOc8NSTs7m90Jcu6Ih3BXUvFb04,3799 +"vllm/model_executor/layers/quantization/utils/configs/N=1536,K=1536,device_name=AMD_Instinct_MI325X,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=CNI-I9ncqHJ7ukpzgyxdJtz0bd29vsgC38tvMM6TV1U,3803 +"vllm/model_executor/layers/quantization/utils/configs/N=1536,K=1536,device_name=AMD_Instinct_MI325_OAM,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=CNI-I9ncqHJ7ukpzgyxdJtz0bd29vsgC38tvMM6TV1U,3803 +"vllm/model_executor/layers/quantization/utils/configs/N=1536,K=1536,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a8,block_shape=[128,128].json",sha256=-j7Xyk4xFaiAD90FeH4AqRSnS82f4owKRGMHbObrrHQ,3250 +"vllm/model_executor/layers/quantization/utils/configs/N=1536,K=1536,device_name=NVIDIA_A800-SXM4-80GB,dtype=int8_w8a8,block_shape=[128,128].json",sha256=sW_T-BdLbjJoFqlr-B5f9emF8E0IdKfy_1wUSIEi55g,3253 +"vllm/model_executor/layers/quantization/utils/configs/N=1536,K=1536,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=tkLjwLC_aVXhzuvo-2QHkojXZauPJsf3jNHFn1S7uRA,3244 +"vllm/model_executor/layers/quantization/utils/configs/N=1536,K=1536,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=akDNAjUZ3EXBznF9w6qUcpXxaLWq7oXnX5jy-R9cleI,3246 +"vllm/model_executor/layers/quantization/utils/configs/N=1536,K=1536,device_name=NVIDIA_L20Y,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=JAycl7EaUZtmCoXMjq4JwKXCeXxZ6S4Ts_DricRUw_o,549 +"vllm/model_executor/layers/quantization/utils/configs/N=1536,K=7168,device_name=AMD_Instinct_MI300X,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=q5KZyi9T-l07P3r1u9i6-Dpw89Upjw1gpTp3f1CluEo,3799 +"vllm/model_executor/layers/quantization/utils/configs/N=1536,K=7168,device_name=AMD_Instinct_MI325X,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=RTnTPFQNg5JULbPLWJDTRNRZHI7FsrTxqSDkZfSbmzw,3806 +"vllm/model_executor/layers/quantization/utils/configs/N=1536,K=7168,device_name=AMD_Instinct_MI325_OAM,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=RTnTPFQNg5JULbPLWJDTRNRZHI7FsrTxqSDkZfSbmzw,3806 +"vllm/model_executor/layers/quantization/utils/configs/N=1536,K=7168,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a8,block_shape=[128,128].json",sha256=DLCfW5tQ9k74AGZ2yER1etP-HgUGglPp_woJiaPuxgQ,3249 +"vllm/model_executor/layers/quantization/utils/configs/N=1536,K=7168,device_name=NVIDIA_A800-SXM4-80GB,dtype=int8_w8a8,block_shape=[128,128].json",sha256=8v9mdWPs1eXczo3iwFrNnRo2LF9wPU4Scm-r9bL7Fz8,3251 +"vllm/model_executor/layers/quantization/utils/configs/N=1536,K=7168,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=Qoj9rLLRDbKM4IKBCXvN8RcxzSmNPd0TQUiM7CXDqHI,3241 +"vllm/model_executor/layers/quantization/utils/configs/N=1536,K=7168,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=7OFCbBqqEA7vQ1oiygfW-7Tqqx8OJATaLujtcQIgyTU,3247 +"vllm/model_executor/layers/quantization/utils/configs/N=1536,K=7168,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=4D3Ku4y7BCVEJzueKvQC_KvOR026w3ONWsxfsA_YrEc,3249 +"vllm/model_executor/layers/quantization/utils/configs/N=1536,K=7168,device_name=NVIDIA_L20,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=iJZ_tAzoYGUmg9ltil4e8vzKlKi980yTmswEMWqV1Jw,546 +"vllm/model_executor/layers/quantization/utils/configs/N=1536,K=7168,device_name=NVIDIA_L20Y,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=fDomA7uBQKX8kbO_4MFcoBwHhIR_7sOkngQPv6cQq4Y,548 +"vllm/model_executor/layers/quantization/utils/configs/N=2048,K=512,device_name=AMD_Instinct_MI300X,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=ucrZBIN_ivmmfMAvkT40xQpH87LdQK38lZbeLWMyV4M,3806 +"vllm/model_executor/layers/quantization/utils/configs/N=2048,K=512,device_name=AMD_Instinct_MI325X,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=zDnVqBqgT-nLkz_Cou-KTPsNIVh-YbTBno9L2MgdRTM,3803 +"vllm/model_executor/layers/quantization/utils/configs/N=2048,K=512,device_name=AMD_Instinct_MI325_OAM,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=zDnVqBqgT-nLkz_Cou-KTPsNIVh-YbTBno9L2MgdRTM,3803 +"vllm/model_executor/layers/quantization/utils/configs/N=2048,K=512,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a8,block_shape=[128,128].json",sha256=zd5cMYrxQ6PD0jKpd3YF6ThT9RGdqgEQnCW6F4W-r4E,3249 +"vllm/model_executor/layers/quantization/utils/configs/N=2048,K=512,device_name=NVIDIA_A800-SXM4-80GB,dtype=int8_w8a8,block_shape=[128,128].json",sha256=CjO6dh_qt1iTu5kYRs98tTLL-W6FOzLO4AESMUFHz5s,3254 +"vllm/model_executor/layers/quantization/utils/configs/N=2048,K=512,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=7v4tp0RaT4vxF4urSBrkK5FR_5ikeFQ1htF3DwDl1lk,3249 +"vllm/model_executor/layers/quantization/utils/configs/N=2048,K=512,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=M5F5wzSmFokEm0X8__ogLvdE1QVC6EW8atqq-kp3rVA,3253 +"vllm/model_executor/layers/quantization/utils/configs/N=2048,K=512,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=0J2MFgaLkv-mfVE5x363lgVKYU6miLG_xRO3tJUga_M,3249 +"vllm/model_executor/layers/quantization/utils/configs/N=2048,K=512,device_name=NVIDIA_L20Y,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=983yfFeeo-BClL_H1g-owXwbA6t0l-kREiy7kLURUMw,550 +"vllm/model_executor/layers/quantization/utils/configs/N=2304,K=7168,device_name=AMD_Instinct_MI300X,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=C2eM8RudmP-qXEf_Apg-qcB5n2Ugxf8-7uG8hQDSt1g,3801 +"vllm/model_executor/layers/quantization/utils/configs/N=2304,K=7168,device_name=AMD_Instinct_MI325X,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=llI6PWlSDgQf-ouTDXkFYOoSz9u3bzklwBtZYY_fWVM,3807 +"vllm/model_executor/layers/quantization/utils/configs/N=2304,K=7168,device_name=AMD_Instinct_MI325_OAM,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=llI6PWlSDgQf-ouTDXkFYOoSz9u3bzklwBtZYY_fWVM,3807 +"vllm/model_executor/layers/quantization/utils/configs/N=2304,K=7168,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a8,block_shape=[128,128].json",sha256=q9HUcoL0cdZCOWZ8MKbcpR8NSy5iNEBq6NPTaHLgRB0,3242 +"vllm/model_executor/layers/quantization/utils/configs/N=2304,K=7168,device_name=NVIDIA_A800-SXM4-80GB,dtype=int8_w8a8,block_shape=[128,128].json",sha256=uJu6Gv4e80vxVrDyBo8_y47tOV03RmWVsMIWQ-bbW6Q,3251 +"vllm/model_executor/layers/quantization/utils/configs/N=2304,K=7168,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=4ubbhwSFX_XbefRLEkLoWxJkcetFWPzsszPu0X3_Wrw,3242 +"vllm/model_executor/layers/quantization/utils/configs/N=2304,K=7168,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=euiKvhb3DXkvPPQJLqNE_xN2evsTOoZnVIiquyN2Cm4,3246 +"vllm/model_executor/layers/quantization/utils/configs/N=2304,K=7168,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=FhyniGTx5QeCuVrBSVTQys6q05Pr5lPEcPykpAX7Iyo,3247 +"vllm/model_executor/layers/quantization/utils/configs/N=2304,K=7168,device_name=NVIDIA_L20Y,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=pLQvMaVvlet_JenEz25mxxplAaHNisl6SFTSZ7lYP2w,548 +"vllm/model_executor/layers/quantization/utils/configs/N=24576,K=7168,device_name=AMD_Instinct_MI300X,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=uAa-ZQmASwlqZbr1l1CM6FyJI9irNdLBzc1U5Hdyw1E,3802 +"vllm/model_executor/layers/quantization/utils/configs/N=24576,K=7168,device_name=AMD_Instinct_MI325X,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=RnN7lfu15CE-4ywMjAbEz8wWV743AP-1Fq5U_j8EQeI,3812 +"vllm/model_executor/layers/quantization/utils/configs/N=24576,K=7168,device_name=AMD_Instinct_MI325_OAM,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=RnN7lfu15CE-4ywMjAbEz8wWV743AP-1Fq5U_j8EQeI,3812 +"vllm/model_executor/layers/quantization/utils/configs/N=24576,K=7168,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a8,block_shape=[128,128].json",sha256=cE3BscS_zEtF_m_jr51IPfpaZZgIEojmhTHsrb9jABM,3260 +"vllm/model_executor/layers/quantization/utils/configs/N=24576,K=7168,device_name=NVIDIA_A800-SXM4-80GB,dtype=int8_w8a8,block_shape=[128,128].json",sha256=SScyo-oYCBxJR9C7ZIKu_pJJNiXdpT13kYe26rddvPQ,3261 +"vllm/model_executor/layers/quantization/utils/configs/N=24576,K=7168,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=0v17v78pETXv6S2ZoibekxOVhiTmCm807DYG4DONUck,3259 +"vllm/model_executor/layers/quantization/utils/configs/N=24576,K=7168,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=I44PvJj758-sw_fCOVROLTpG0NQ5_5PCYyQcpZC1YSY,3259 +"vllm/model_executor/layers/quantization/utils/configs/N=24576,K=7168,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=ulvOEAFO8c-UOa34FEZrjOkCR6ovhJlfFFDhmaKIBiU,3245 +"vllm/model_executor/layers/quantization/utils/configs/N=24576,K=7168,device_name=NVIDIA_H20,dtype=int8_w8a8,block_shape=[128,128].json",sha256=BiZowqExbvXftuE37SYcheOdtYX7Z5BEXyykJ6GbYSk,3254 +"vllm/model_executor/layers/quantization/utils/configs/N=24576,K=7168,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=-CVHqClROli9FWe_FnlnuAG2LiFivDFK_nghH6t-BWc,3261 +"vllm/model_executor/layers/quantization/utils/configs/N=24576,K=7168,device_name=NVIDIA_L20,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=7ok0uooTihvRSckZMNd6jInRvht_xkC5posHO66ejqc,552 +"vllm/model_executor/layers/quantization/utils/configs/N=24576,K=7168,device_name=NVIDIA_L20Y,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=h_Z6wBKdSGBEo5BfQKaxuFlxztrnbbZR0pkcYKv92sk,551 +"vllm/model_executor/layers/quantization/utils/configs/N=256,K=7168,device_name=AMD_Instinct_MI300X,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=k63VgniyN3Rl_-h1hYmT_q9QZtSFqQmXBqhEXJQkxqE,3800 +"vllm/model_executor/layers/quantization/utils/configs/N=256,K=7168,device_name=AMD_Instinct_MI325X,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=icswqRYUsUdoQMrv4YIqO46GG9BzepmBJmnTre9-VjU,3800 +"vllm/model_executor/layers/quantization/utils/configs/N=256,K=7168,device_name=AMD_Instinct_MI325_OAM,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=icswqRYUsUdoQMrv4YIqO46GG9BzepmBJmnTre9-VjU,3800 +"vllm/model_executor/layers/quantization/utils/configs/N=256,K=7168,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a8,block_shape=[128,128].json",sha256=sL0E4zZzb01g6GHaTCXltg20uSbthXHSJFQ0SaxZ7PU,3245 +"vllm/model_executor/layers/quantization/utils/configs/N=256,K=7168,device_name=NVIDIA_A800-SXM4-80GB,dtype=int8_w8a8,block_shape=[128,128].json",sha256=MZcJz7BjwVOHHHxvYqGrWw77WnxslYhwW80bZw-jSKQ,3249 +"vllm/model_executor/layers/quantization/utils/configs/N=256,K=7168,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=GsLoYkaZ2p4Qu0Coj-X90s7JWyfZBOloIHPlyNKSIes,3246 +"vllm/model_executor/layers/quantization/utils/configs/N=256,K=7168,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=4--7YWnJYUK4XmQ2zZ4M1ZYdKvUkET0VkNgIBn6xaOA,3247 +"vllm/model_executor/layers/quantization/utils/configs/N=256,K=7168,device_name=NVIDIA_L20Y,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=NjEA2QjOVXyOaVSMPch5qa1Dq3igbW7MmE986-7taW0,547 +"vllm/model_executor/layers/quantization/utils/configs/N=3072,K=1536,device_name=AMD_Instinct_MI300X,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=21Buh2aiGTHjpW45Rm-TwZD8MSaAy8NMUrK5l_hGT5k,3803 +"vllm/model_executor/layers/quantization/utils/configs/N=3072,K=1536,device_name=AMD_Instinct_MI325X,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=P8p-dZZt_D61G6k3PgUetF01xzTRmCDJAnqCIsSDW8I,3805 +"vllm/model_executor/layers/quantization/utils/configs/N=3072,K=1536,device_name=AMD_Instinct_MI325_OAM,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=P8p-dZZt_D61G6k3PgUetF01xzTRmCDJAnqCIsSDW8I,3805 +"vllm/model_executor/layers/quantization/utils/configs/N=3072,K=1536,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=8zuJhFdd6aXREpiqPFhIKEFWA5lgLVGrG0-a9UXcBqk,3262 +"vllm/model_executor/layers/quantization/utils/configs/N=3072,K=1536,device_name=NVIDIA_H20,dtype=int8_w8a8,block_shape=[128,128].json",sha256=_42bDZX4VODErI6OL-NrWja36iNHC4DzgF1l5Mk67-c,3248 +"vllm/model_executor/layers/quantization/utils/configs/N=3072,K=1536,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=Zn1TvhAoPOv0zQBYHOZhwdDw3oqyxm0zIa7IJkTCHpo,3247 +"vllm/model_executor/layers/quantization/utils/configs/N=3072,K=1536,device_name=NVIDIA_L20,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=H9wONEU0XXSxOJfkx5UkS8Ss3A2QCp9G0XNoJEqE9nQ,548 +"vllm/model_executor/layers/quantization/utils/configs/N=3072,K=7168,device_name=AMD_Instinct_MI300X,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=2T2TYZhXgC97slH92HQ8GvZS3KuUt1ZiC3RtudPVEPA,3802 +"vllm/model_executor/layers/quantization/utils/configs/N=3072,K=7168,device_name=AMD_Instinct_MI325X,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=b6_bhUuQrI9HYvvwmAvUYh4v1GZ8w0sjApOmwuj_t8Y,3806 +"vllm/model_executor/layers/quantization/utils/configs/N=3072,K=7168,device_name=AMD_Instinct_MI325_OAM,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=b6_bhUuQrI9HYvvwmAvUYh4v1GZ8w0sjApOmwuj_t8Y,3806 +"vllm/model_executor/layers/quantization/utils/configs/N=3072,K=7168,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=yqjO7zML7EseBJw6Bn5MTyHeAitkPsl1dndXeL6Rn6A,3257 +"vllm/model_executor/layers/quantization/utils/configs/N=3072,K=7168,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=-nQIhKAOVCQrxLV6HDlcD0V8HMWvqrv-vyiORVU7qls,3244 +"vllm/model_executor/layers/quantization/utils/configs/N=3072,K=7168,device_name=NVIDIA_H20,dtype=int8_w8a8,block_shape=[128,128].json",sha256=KKmCvNh5T_qfD8v7JijMqXxQ5L6-gRX7oc6c5re6EF0,3248 +"vllm/model_executor/layers/quantization/utils/configs/N=3072,K=7168,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=M3nwpZd2-0w263ywZt9gaw53z7MN673T5tl4tc43Ntk,3249 +"vllm/model_executor/layers/quantization/utils/configs/N=3072,K=7168,device_name=NVIDIA_L20,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=H9wONEU0XXSxOJfkx5UkS8Ss3A2QCp9G0XNoJEqE9nQ,548 +"vllm/model_executor/layers/quantization/utils/configs/N=32768,K=512,device_name=AMD_Instinct_MI300X,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=KmEgJ7zP2Sr_7GsAfL-12_g2S2a2wVpnxgCiF5dFiLI,3802 +"vllm/model_executor/layers/quantization/utils/configs/N=32768,K=512,device_name=AMD_Instinct_MI325X,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=J4SXwpsioBRdTXOaj2OjrdNrEuW1NF43cLds65UWzCY,3808 +"vllm/model_executor/layers/quantization/utils/configs/N=32768,K=512,device_name=AMD_Instinct_MI325_OAM,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=J4SXwpsioBRdTXOaj2OjrdNrEuW1NF43cLds65UWzCY,3808 +"vllm/model_executor/layers/quantization/utils/configs/N=32768,K=512,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a8,block_shape=[128,128].json",sha256=UjBOmVqYynBH3dJVuMJXjKnuZ6LssohzzEBpLBG4_G4,3256 +"vllm/model_executor/layers/quantization/utils/configs/N=32768,K=512,device_name=NVIDIA_A800-SXM4-80GB,dtype=int8_w8a8,block_shape=[128,128].json",sha256=8BJsjc2UUYdotrIqwyzisjrq0wcyW4jnTo_M8J3qYwA,3263 +"vllm/model_executor/layers/quantization/utils/configs/N=32768,K=512,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=vLoV3JMtvHOKpR5D1BeCQPMuYlWUAlrXu54gByNkwKY,3266 +"vllm/model_executor/layers/quantization/utils/configs/N=32768,K=512,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=Mtw7a9BSspj2TzC-aPxE82o1LEvwzgbUuIofwRxUNA0,3263 +"vllm/model_executor/layers/quantization/utils/configs/N=32768,K=512,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=N0kCPHvybNK-HvMO2EqNDLkj7m7WrHTl-3AD32LBD4k,3248 +"vllm/model_executor/layers/quantization/utils/configs/N=32768,K=512,device_name=NVIDIA_H20,dtype=int8_w8a8,block_shape=[128,128].json",sha256=mjh-AgJN_IoWAc1uwhUiB1lE3ufAPDf-KPP6vUTrDKw,3251 +"vllm/model_executor/layers/quantization/utils/configs/N=32768,K=512,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=NHdx3tZnfLF7NplswMzcTRbQEQFLtChg4rd7GU9lMbM,3262 +"vllm/model_executor/layers/quantization/utils/configs/N=32768,K=512,device_name=NVIDIA_L20,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=mcF12eQTtGxocrVIA3I98NHd1NLd0-8EyfXtqDgv0PM,549 +"vllm/model_executor/layers/quantization/utils/configs/N=32768,K=512,device_name=NVIDIA_L20Y,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=AThoa7FUcGdNXYB_v9iMpBh2X8C0iLfc7y-C0xy2cRY,548 +"vllm/model_executor/layers/quantization/utils/configs/N=36864,K=7168,device_name=AMD_Instinct_MI300X,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=MJgIvZHf01ju8IWEVO6vyMedy5OTZxDpzv6A7_8W-Tg,3813 +"vllm/model_executor/layers/quantization/utils/configs/N=36864,K=7168,device_name=AMD_Instinct_MI325X,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=AT2yrMoTvmoizi4sxwLtiULZ57P1CBhKGg9-6Gxnuc4,3819 +"vllm/model_executor/layers/quantization/utils/configs/N=36864,K=7168,device_name=AMD_Instinct_MI325_OAM,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=AT2yrMoTvmoizi4sxwLtiULZ57P1CBhKGg9-6Gxnuc4,3819 +"vllm/model_executor/layers/quantization/utils/configs/N=36864,K=7168,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=laYeH4w0iZOj2Yg3vDgtKoroNQnwBEX4GUGLrO9095I,3260 +"vllm/model_executor/layers/quantization/utils/configs/N=36864,K=7168,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=TWcPDZ2miQMD6OWDC1FteRs80ND9RC-oJL3PLVmJbtI,3257 +"vllm/model_executor/layers/quantization/utils/configs/N=4096,K=512,device_name=AMD_Instinct_MI300X,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=cPtr1UJq_B-dTqgMrVm8ptiYXA6qOy_F8rs2f7ljuEI,3811 +"vllm/model_executor/layers/quantization/utils/configs/N=4096,K=512,device_name=AMD_Instinct_MI325X,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=cobt_ZhR3dt2CySr12bGPVwn1oS98YvGLdIh9H8BDQ0,3801 +"vllm/model_executor/layers/quantization/utils/configs/N=4096,K=512,device_name=AMD_Instinct_MI325_OAM,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=cobt_ZhR3dt2CySr12bGPVwn1oS98YvGLdIh9H8BDQ0,3801 +"vllm/model_executor/layers/quantization/utils/configs/N=4096,K=512,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=6Z7kIa14RjVq3ek_C15q5mUu1IrY2r0OP8S-_pm-MYU,3252 +"vllm/model_executor/layers/quantization/utils/configs/N=4096,K=512,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=r63SZkUJJV87B00hAX074_uaC7wwQXdurlJsB1jUA0I,3254 +"vllm/model_executor/layers/quantization/utils/configs/N=4096,K=512,device_name=NVIDIA_H20,dtype=int8_w8a8,block_shape=[128,128].json",sha256=hL3doX7zzxld3UcS8p9ACSadDaE6t3xXlYwM7X3GOeI,3252 +"vllm/model_executor/layers/quantization/utils/configs/N=4096,K=512,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=xBhxdCFf3waTUsLxJxA54R90zODbC_DKI3XXBVKjKRw,3252 +"vllm/model_executor/layers/quantization/utils/configs/N=4096,K=512,device_name=NVIDIA_L20,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=2ks7TQUULAD-Zn5i69YHo_2hpmsmxlocdYmJccSh2No,552 +"vllm/model_executor/layers/quantization/utils/configs/N=4608,K=7168,device_name=AMD_Instinct_MI300X,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=eiI8X2fFNknJmiT0uHbzSaEKQwwZk5bxn676gNvcyg0,3802 +"vllm/model_executor/layers/quantization/utils/configs/N=4608,K=7168,device_name=AMD_Instinct_MI325X,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=fQQDJMlLdYsY5Cosg5HkRzvrJ4asjQmc0WGgoD4bC20,3810 +"vllm/model_executor/layers/quantization/utils/configs/N=4608,K=7168,device_name=AMD_Instinct_MI325_OAM,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=fQQDJMlLdYsY5Cosg5HkRzvrJ4asjQmc0WGgoD4bC20,3810 +"vllm/model_executor/layers/quantization/utils/configs/N=4608,K=7168,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=O_SV2vo_oaABfT6Mxqcmo12pnhKtfX4TnXfe02OcHJk,3254 +"vllm/model_executor/layers/quantization/utils/configs/N=4608,K=7168,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=g12Xkurat7oUS7LdS9pHLKFlur4_FaMGiGBvdq-iBCs,3242 +"vllm/model_executor/layers/quantization/utils/configs/N=4608,K=7168,device_name=NVIDIA_H20,dtype=int8_w8a8,block_shape=[128,128].json",sha256=EWLxbWncwGJyL-dV6EO-s8kk25wfYrESa0STjCnzD64,3244 +"vllm/model_executor/layers/quantization/utils/configs/N=4608,K=7168,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=tFdrY5nADmXUlShdN8w8Jzkxuj_RPLXCRceX9FhQ35E,3251 +"vllm/model_executor/layers/quantization/utils/configs/N=4608,K=7168,device_name=NVIDIA_L20,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=M-ewEHbgHLBLYLi1Hgz5Pp4kypnUiCRo0ut2scNnvDw,550 +"vllm/model_executor/layers/quantization/utils/configs/N=512,K=7168,device_name=AMD_Instinct_MI300X,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=zTzLbdff09HwMuWlWpoAIgQZ6NEjsFXSF0Y5z4Be7Ig,3802 +"vllm/model_executor/layers/quantization/utils/configs/N=512,K=7168,device_name=AMD_Instinct_MI325X,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=dcPHbYEbz8T9SM5-a5sP_K_npDkhH7u0KM9aiLn9esE,3806 +"vllm/model_executor/layers/quantization/utils/configs/N=512,K=7168,device_name=AMD_Instinct_MI325_OAM,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=dcPHbYEbz8T9SM5-a5sP_K_npDkhH7u0KM9aiLn9esE,3806 +"vllm/model_executor/layers/quantization/utils/configs/N=512,K=7168,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=TO2qRGmp37v53Zqu8Joeq_BSbtwM_mpVoozGyoNg0-o,3254 +"vllm/model_executor/layers/quantization/utils/configs/N=512,K=7168,device_name=NVIDIA_H20,dtype=int8_w8a8,block_shape=[128,128].json",sha256=QqijmgLqIoBUxRPnuUQGsoQASRFRMsCVQKTjEjGecVo,3247 +"vllm/model_executor/layers/quantization/utils/configs/N=512,K=7168,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=0xquf00fgfrDODpaxyre0VDcjqfzqExj939rzeJ8pMo,3244 +"vllm/model_executor/layers/quantization/utils/configs/N=512,K=7168,device_name=NVIDIA_L20,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=ipg8iK8w2ySRe1Z08YJUWAHX43rvkrXpR6svxRhSnFE,548 +"vllm/model_executor/layers/quantization/utils/configs/N=576,K=7168,device_name=AMD_Instinct_MI300X,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=-wuzdNXf3K0jfFQGB8nFSyoSZ4BfAvIkY10k6FdjnLY,3800 +"vllm/model_executor/layers/quantization/utils/configs/N=576,K=7168,device_name=AMD_Instinct_MI325X,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=-o9QqqQQ-9kRVCuDOUGBuKXHRTd0asGTzrDcHGGYJLQ,3799 +"vllm/model_executor/layers/quantization/utils/configs/N=576,K=7168,device_name=AMD_Instinct_MI325_OAM,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=-o9QqqQQ-9kRVCuDOUGBuKXHRTd0asGTzrDcHGGYJLQ,3799 +"vllm/model_executor/layers/quantization/utils/configs/N=576,K=7168,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a8,block_shape=[128,128].json",sha256=DbemSQdo2h5vGjSNB6Fovnn-aAGfjti04Bp-5KxLALk,3246 +"vllm/model_executor/layers/quantization/utils/configs/N=576,K=7168,device_name=NVIDIA_A800-SXM4-80GB,dtype=int8_w8a8,block_shape=[128,128].json",sha256=6glWpljtfiuspJv_Esg_LWCDDQ57d2HETsOIv0zr2Ec,3249 +"vllm/model_executor/layers/quantization/utils/configs/N=576,K=7168,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=qG6v3n3qF6LE2DdGT-mDIXecZ1a7vg7p3QqXYCMX85k,3254 +"vllm/model_executor/layers/quantization/utils/configs/N=576,K=7168,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=EgFTGyW_YuDwyEDUCoGglyI1ETdj9J7AR0UfJ86jMoI,3249 +"vllm/model_executor/layers/quantization/utils/configs/N=576,K=7168,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=4--7YWnJYUK4XmQ2zZ4M1ZYdKvUkET0VkNgIBn6xaOA,3247 +"vllm/model_executor/layers/quantization/utils/configs/N=576,K=7168,device_name=NVIDIA_H20,dtype=int8_w8a8,block_shape=[128,128].json",sha256=ZfPPlx0qcuR4WjaFAE-W1QZgSPAMf3NyGcpvQIvyFMs,3245 +"vllm/model_executor/layers/quantization/utils/configs/N=576,K=7168,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=NiorJgOotxkQcP49ID3z5al1UA4QQDrT8MvbCwAWL5Y,3248 +"vllm/model_executor/layers/quantization/utils/configs/N=576,K=7168,device_name=NVIDIA_L20,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=QgSlDAhlB2W4bzTd2O98UL-C_IKfJm_cVmQz8FqsLF0,361 +"vllm/model_executor/layers/quantization/utils/configs/N=576,K=7168,device_name=NVIDIA_L20Y,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=i3wy_CBO7BQQVhKReRC2F0PaRIQDdN9F5lJ7kD0xe1I,548 +"vllm/model_executor/layers/quantization/utils/configs/N=7168,K=1024,device_name=AMD_Instinct_MI300X,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=QpkqpJnyjuHH8Zo4U4QZgehUF2F2uQDZFb8fdhixXWI,3794 +"vllm/model_executor/layers/quantization/utils/configs/N=7168,K=1024,device_name=AMD_Instinct_MI325X,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=wv5GjGAA-NyJ41SYdYG3tPAgwf6JK7Zf6SaWALQ5c3Y,3806 +"vllm/model_executor/layers/quantization/utils/configs/N=7168,K=1024,device_name=AMD_Instinct_MI325_OAM,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=wv5GjGAA-NyJ41SYdYG3tPAgwf6JK7Zf6SaWALQ5c3Y,3806 +"vllm/model_executor/layers/quantization/utils/configs/N=7168,K=1024,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a8,block_shape=[128,128].json",sha256=RRMNeM_qiHvlUTOAeqwgs7ukSoAZSlK8XN4z8hgWl0k,3258 +"vllm/model_executor/layers/quantization/utils/configs/N=7168,K=1024,device_name=NVIDIA_A800-SXM4-80GB,dtype=int8_w8a8,block_shape=[128,128].json",sha256=brB0-FFr-Sv2bdrz4DQJ_NaFhETctf1g4Yzwj_Fcczc,3251 +"vllm/model_executor/layers/quantization/utils/configs/N=7168,K=1024,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=bPQWtvaJrzOOIgI-R-MIxs_f4yC_FobkDydu3OkOFtg,3252 +"vllm/model_executor/layers/quantization/utils/configs/N=7168,K=1024,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=RYLh-Uim9U2_djLkFwwpV0rNQHik0tZHzecuj1_hPLw,3248 +"vllm/model_executor/layers/quantization/utils/configs/N=7168,K=1024,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=ZRgiuHZ2SFC6u-WV5DGwau4k1RiPLI67eENO0e-5Ylg,3253 +"vllm/model_executor/layers/quantization/utils/configs/N=7168,K=1024,device_name=NVIDIA_L20Y,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=4EzbnLWHVwrjyKYPMcDxbxM2o-krjlT0YXvM8oPH5Cg,549 +"vllm/model_executor/layers/quantization/utils/configs/N=7168,K=1152,device_name=AMD_Instinct_MI300X,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=OFgOtRkUHwyOT7Hk_BQft_WzuZOwbhMSLP65Fbr4goA,3799 +"vllm/model_executor/layers/quantization/utils/configs/N=7168,K=1152,device_name=AMD_Instinct_MI325X,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=AOu05da2LZbCzD9SKsrgnzH-ih3CdXsRIdJc_4J1lps,3807 +"vllm/model_executor/layers/quantization/utils/configs/N=7168,K=1152,device_name=AMD_Instinct_MI325_OAM,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=AOu05da2LZbCzD9SKsrgnzH-ih3CdXsRIdJc_4J1lps,3807 +"vllm/model_executor/layers/quantization/utils/configs/N=7168,K=1152,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a8,block_shape=[128,128].json",sha256=qzmFm2pqxphir1LBrycDZp5JA4It8OdQeQ5iTrTwLNE,3253 +"vllm/model_executor/layers/quantization/utils/configs/N=7168,K=1152,device_name=NVIDIA_A800-SXM4-80GB,dtype=int8_w8a8,block_shape=[128,128].json",sha256=2UyOMRMdbvHt6WlZdOKALm3Or0eMCx7vvwgLiCYyoOs,3259 +"vllm/model_executor/layers/quantization/utils/configs/N=7168,K=1152,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=-hP_P8NM0K04mGzTmpGBNibQ5xxh5gPz5WtoMXhoz1E,3253 +"vllm/model_executor/layers/quantization/utils/configs/N=7168,K=1152,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=vEU4_YOMnLdYFf1BkBEdFbGRMG8KLhsO_t0gv7vaO4Y,3244 +"vllm/model_executor/layers/quantization/utils/configs/N=7168,K=1152,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=FB5Le4obvPoCgFSnC_3-Uh59n-Mt4Rol8saXVcK3RPw,3252 +"vllm/model_executor/layers/quantization/utils/configs/N=7168,K=1152,device_name=NVIDIA_L20Y,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=k1rzpgm9m19AHf_HPQcNCuSBtAwFgMePUYB1jZeFyYY,549 +"vllm/model_executor/layers/quantization/utils/configs/N=7168,K=128,device_name=AMD_Instinct_MI300X,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=9IbzTwLRgTCfFLSvjEWKiajCjG81R-wTljIV2zUYUA8,3809 +"vllm/model_executor/layers/quantization/utils/configs/N=7168,K=128,device_name=AMD_Instinct_MI325X,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=B4uEwuftvaj9gHGdoDBnVhxbNRmzUtzu4LH0u-O7voA,3804 +"vllm/model_executor/layers/quantization/utils/configs/N=7168,K=128,device_name=AMD_Instinct_MI325_OAM,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=B4uEwuftvaj9gHGdoDBnVhxbNRmzUtzu4LH0u-O7voA,3804 +"vllm/model_executor/layers/quantization/utils/configs/N=7168,K=128,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a8,block_shape=[128,128].json",sha256=ZTPWtJA3JBL2jhy7C60RdsntKCN8oQ-DDIL17ok7OB4,3257 +"vllm/model_executor/layers/quantization/utils/configs/N=7168,K=128,device_name=NVIDIA_A800-SXM4-80GB,dtype=int8_w8a8,block_shape=[128,128].json",sha256=mokCWoXdKi8p4mLYqgljjwDRJWK5I2oF6_MJuObi5sU,3254 +"vllm/model_executor/layers/quantization/utils/configs/N=7168,K=128,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=kLviGvVngpgOuelfKtvv9Is7MWQ89rGxlomMRP6t0Ic,3250 +"vllm/model_executor/layers/quantization/utils/configs/N=7168,K=128,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=bIVRtaaHThozH54VIte0Nk0sOGV67K4s2YZUE6QWx2s,3252 +"vllm/model_executor/layers/quantization/utils/configs/N=7168,K=128,device_name=NVIDIA_L20Y,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=_YXzQ6N3QpF3Ou1Fy-51YyL-J3i5gOBVCgSM42vOT9I,549 +"vllm/model_executor/layers/quantization/utils/configs/N=7168,K=16384,device_name=AMD_Instinct_MI300X,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=csaz7AaVDTvCuzaptN-e8K1PNuIwZm9OwnPSJydHI90,3803 +"vllm/model_executor/layers/quantization/utils/configs/N=7168,K=16384,device_name=AMD_Instinct_MI325X,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=scfO3_ncCtyrqcYSnIoAZTMfvBzjB4o_0_bdiiVSNh4,3803 +"vllm/model_executor/layers/quantization/utils/configs/N=7168,K=16384,device_name=AMD_Instinct_MI325_OAM,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=scfO3_ncCtyrqcYSnIoAZTMfvBzjB4o_0_bdiiVSNh4,3803 +"vllm/model_executor/layers/quantization/utils/configs/N=7168,K=16384,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a8,block_shape=[128,128].json",sha256=CE1wRLyFONo4_icKO8fcTTX-5giKNJ9_1F-2mr-lGQU,3257 +"vllm/model_executor/layers/quantization/utils/configs/N=7168,K=16384,device_name=NVIDIA_A800-SXM4-80GB,dtype=int8_w8a8,block_shape=[128,128].json",sha256=JdUaLiMmf8oEbwuhPHMIncvWzXS2SxOEgfM80ZjM7l0,3259 +"vllm/model_executor/layers/quantization/utils/configs/N=7168,K=16384,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=vlys0Zi_CaaU41OHGbWSBtbVglFi98bgqEySBMc9Sdg,3258 +"vllm/model_executor/layers/quantization/utils/configs/N=7168,K=16384,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=YWyByOlKSqp5lbcUa8eu6N2dHRKJqJDbCDSjdDQJngg,3249 +"vllm/model_executor/layers/quantization/utils/configs/N=7168,K=16384,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=GY9VBPi21K6vJlF1NOEzCyqMS7LX3xq5dRxrK0jvIHk,3244 +"vllm/model_executor/layers/quantization/utils/configs/N=7168,K=16384,device_name=NVIDIA_H20,dtype=int8_w8a8,block_shape=[128,128].json",sha256=8LWF55ZPjrOY_sEdRGqf1eLcTNySgUiiWNWsN4EGxLY,3247 +"vllm/model_executor/layers/quantization/utils/configs/N=7168,K=16384,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=j5PTW0IC4Z2yQIygcdICaOsvb639u6Mv-ZpJYkrBQ2k,3254 +"vllm/model_executor/layers/quantization/utils/configs/N=7168,K=16384,device_name=NVIDIA_L20,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=_Cc0EqUzl6d93OxWJRWYbYpEaTIp0glJhdfV-GSAi5M,552 +"vllm/model_executor/layers/quantization/utils/configs/N=7168,K=16384,device_name=NVIDIA_L20Y,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=ZSHvdnC2vOXI2HPW1iNI9HdihoLcNYlRLMF85pqjWZE,551 +"vllm/model_executor/layers/quantization/utils/configs/N=7168,K=18432,device_name=AMD_Instinct_MI300X,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=SkyMLsoxGoHdO4kgTerihone7eEi0nmHlrvZUI1I_V4,3804 +"vllm/model_executor/layers/quantization/utils/configs/N=7168,K=18432,device_name=AMD_Instinct_MI325X,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=6Jo2hw2gQpyiNoCRZpGItu4MBkYytzdW-VggWUC4fPE,3804 +"vllm/model_executor/layers/quantization/utils/configs/N=7168,K=18432,device_name=AMD_Instinct_MI325_OAM,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=6Jo2hw2gQpyiNoCRZpGItu4MBkYytzdW-VggWUC4fPE,3804 +"vllm/model_executor/layers/quantization/utils/configs/N=7168,K=18432,device_name=NVIDIA_A100-SXM4-80GB,dtype=int8_w8a8,block_shape=[128,128].json",sha256=xbDfUYLphVtZWJojZWODlxGMCoiIgxn4LsnD9ge3r9A,3257 +"vllm/model_executor/layers/quantization/utils/configs/N=7168,K=18432,device_name=NVIDIA_A800-SXM4-80GB,dtype=int8_w8a8,block_shape=[128,128].json",sha256=hqh8TQw3t5hPM9u7rmHPuaMjwgxmQ-Zt35fSTgOS0HQ,3261 +"vllm/model_executor/layers/quantization/utils/configs/N=7168,K=18432,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=Ggy4hejkcWjiw5Bi-wGzSP5JLVuvOjip_rbjXFBJZbs,3257 +"vllm/model_executor/layers/quantization/utils/configs/N=7168,K=18432,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=Xy4mgZx5iiEvuv2ydO4dFNIT8s0jgBhNHE1vu93fGJM,3250 +"vllm/model_executor/layers/quantization/utils/configs/N=7168,K=18432,device_name=NVIDIA_H20,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=qKG9hmaxN_7tCB_06L1dh0csxs3TGeya9B-X6W-tNhg,3245 +"vllm/model_executor/layers/quantization/utils/configs/N=7168,K=18432,device_name=NVIDIA_H20,dtype=int8_w8a8,block_shape=[128,128].json",sha256=jb7vGi1RJefImkT3BZU_9iOkiCulcd5oDjxpVSt7big,3246 +"vllm/model_executor/layers/quantization/utils/configs/N=7168,K=18432,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=x476nFeltB_2iO9_6y-z2P_unAbh7ghLPFi5z2LOTOo,3253 +"vllm/model_executor/layers/quantization/utils/configs/N=7168,K=18432,device_name=NVIDIA_L20,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=_Cc0EqUzl6d93OxWJRWYbYpEaTIp0glJhdfV-GSAi5M,552 +"vllm/model_executor/layers/quantization/utils/configs/N=7168,K=18432,device_name=NVIDIA_L20Y,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=TWpzs48j0QwApAsBWt3iIlu6cqR46Meslyp96MOANcc,551 +"vllm/model_executor/layers/quantization/utils/configs/N=7168,K=2048,device_name=AMD_Instinct_MI300X,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=i5b52A1Oe8kCdPrPLBGud7OMHm8779JD0rBocYO_lo4,3797 +"vllm/model_executor/layers/quantization/utils/configs/N=7168,K=2048,device_name=AMD_Instinct_MI325X,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=U20Q4JwG63kU-6cc241VHGdpettCWbBXRJ9EZ-fbkqA,3803 +"vllm/model_executor/layers/quantization/utils/configs/N=7168,K=2048,device_name=AMD_Instinct_MI325_OAM,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=U20Q4JwG63kU-6cc241VHGdpettCWbBXRJ9EZ-fbkqA,3803 +"vllm/model_executor/layers/quantization/utils/configs/N=7168,K=2048,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=4uWiQMh3cZY_EtLA0a3PU8Z1VCunF2PpolTPYeP9Rjo,3256 +"vllm/model_executor/layers/quantization/utils/configs/N=7168,K=2048,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=D0moiKqS73oril32iNj5gRJUWpT2SZ5jf-ZesUZnNv4,3254 +"vllm/model_executor/layers/quantization/utils/configs/N=7168,K=2048,device_name=NVIDIA_H20,dtype=int8_w8a8,block_shape=[128,128].json",sha256=toHzCprq0KetQI0-9IrLYCIm1bQ0nSeP1gXArU0GogI,3245 +"vllm/model_executor/layers/quantization/utils/configs/N=7168,K=2048,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=N37dUL_J2JVpgLFlnlz__Ck7Z4njROnNAO8V2oiDqr8,3253 +"vllm/model_executor/layers/quantization/utils/configs/N=7168,K=2048,device_name=NVIDIA_L20,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=pGZZj_gZms1T9Zgjs4tbIm90LhbEy1UUkkgrto9jPts,551 +"vllm/model_executor/layers/quantization/utils/configs/N=7168,K=2304,device_name=AMD_Instinct_MI300X,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=fqnjZCn0gbY7fO9JwZOHMYJJHe8gceWhWCZOFPRUlYM,3802 +"vllm/model_executor/layers/quantization/utils/configs/N=7168,K=2304,device_name=AMD_Instinct_MI325X,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=OTZt3ell0OZ7Cg5L17K2NPU4UwayAkTihV5HjUmUiAw,3810 +"vllm/model_executor/layers/quantization/utils/configs/N=7168,K=2304,device_name=AMD_Instinct_MI325_OAM,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=OTZt3ell0OZ7Cg5L17K2NPU4UwayAkTihV5HjUmUiAw,3810 +"vllm/model_executor/layers/quantization/utils/configs/N=7168,K=2304,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=LdtOyXsA9r18GiFkmDOkiRinsDSZBZ8NYapL59EZ4iM,3264 +"vllm/model_executor/layers/quantization/utils/configs/N=7168,K=2304,device_name=NVIDIA_H100_80GB_HBM3,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=07GarBHmiiYkyqn-qxEtrAcgCETuUbqm6HqlbH9yJi8,3252 +"vllm/model_executor/layers/quantization/utils/configs/N=7168,K=2304,device_name=NVIDIA_H20,dtype=int8_w8a8,block_shape=[128,128].json",sha256=xMNxtLL_8tyg4TWSt_llz_IJ2qlxc2NEwhUzhV1VsG8,3252 +"vllm/model_executor/layers/quantization/utils/configs/N=7168,K=2304,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=kEuvCsW3YNByF-DALYqPZpW3TL8ZbtQ5gUNq7-8YvZ4,3252 +"vllm/model_executor/layers/quantization/utils/configs/N=7168,K=2304,device_name=NVIDIA_L20,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=4uNqB71a6ctZ-c4tF3r66vOsHFrqcR28g_UWy0N8iBo,550 +"vllm/model_executor/layers/quantization/utils/configs/N=7168,K=256,device_name=AMD_Instinct_MI300X,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=QkrfZ69jxW_mweigtHL5R0Sv_WcSBp7wjFX75G9kbHw,3805 +"vllm/model_executor/layers/quantization/utils/configs/N=7168,K=256,device_name=AMD_Instinct_MI325X,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=xMGmoN2ZTjKQBZS-k75mFTPpAEbPR3kyMwqZVtgbEiM,3802 +"vllm/model_executor/layers/quantization/utils/configs/N=7168,K=256,device_name=AMD_Instinct_MI325_OAM,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=xMGmoN2ZTjKQBZS-k75mFTPpAEbPR3kyMwqZVtgbEiM,3802 +"vllm/model_executor/layers/quantization/utils/configs/N=7168,K=256,device_name=NVIDIA_B200,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=PD4AJYCkHfy2ivv9baMouFXzBTy0eKMumbAfxfm91HI,3256 +"vllm/model_executor/layers/quantization/utils/configs/N=7168,K=256,device_name=NVIDIA_H20,dtype=int8_w8a8,block_shape=[128,128].json",sha256=iu8M35YR-RDpKWbjXSRzk02sW9nr_dtbhalfLSNtxNs,3251 +"vllm/model_executor/layers/quantization/utils/configs/N=7168,K=256,device_name=NVIDIA_H200,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=FFBjSWlpKXMxfAUUYUqXbOK_Hd7qBeBsfbcaa9uB4qY,3249 +"vllm/model_executor/layers/quantization/utils/configs/N=7168,K=256,device_name=NVIDIA_L20,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=41m0bvskFUzVtlr_yppBr4PZ0cVkqHvy9Hrc5pUCUyY,552 +"vllm/model_executor/layers/quantization/utils/configs/N=7168,K=8192,device_name=AMD_Instinct_MI300X,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=2VxMGfWtxTzXcF0bP3d5s7rc1cKb5TNBAn-WiCKAngw,3804 +"vllm/model_executor/layers/quantization/utils/configs/N=7168,K=8192,device_name=AMD_Instinct_MI325X,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=VtQGO3fEiyhbKG4sl07cuVc6id2EtKeV05ozLmN_ENQ,3807 +"vllm/model_executor/layers/quantization/utils/configs/N=7168,K=8192,device_name=AMD_Instinct_MI325_OAM,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=VtQGO3fEiyhbKG4sl07cuVc6id2EtKeV05ozLmN_ENQ,3807 +"vllm/model_executor/layers/quantization/utils/configs/N=8192,K=1536,device_name=AMD_Instinct_MI300X,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=W3cYFteFIZLu5c1K41cOh4_-WZzFU6-jGnZocDzmKaA,3796 +"vllm/model_executor/layers/quantization/utils/configs/N=8192,K=1536,device_name=AMD_Instinct_MI325X,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=HIoWSUgAOcNaK2kj2YwDjDa23PzQVTT2C2ePW985Ovw,3805 +"vllm/model_executor/layers/quantization/utils/configs/N=8192,K=1536,device_name=AMD_Instinct_MI325_OAM,dtype=fp8_w8a8,block_shape=[128,128].json",sha256=HIoWSUgAOcNaK2kj2YwDjDa23PzQVTT2C2ePW985Ovw,3805 +vllm/model_executor/layers/quantization/utils/fp8_utils.py,sha256=mPRip_w_O2frmjtBEqhBkg37b5zF7JcPrccXpgM3ioc,17523 +vllm/model_executor/layers/quantization/utils/gptq_utils.py,sha256=ZRB27yUulJhuTEMbAncFwVAj65PQnnvLVI52VTfHuUA,3802 +vllm/model_executor/layers/quantization/utils/int8_utils.py,sha256=lMQcnPvRgmfasNxPPMweOvdMNjf69wXqkGIgbjNoSdE,14169 +vllm/model_executor/layers/quantization/utils/layer_utils.py,sha256=HmjtrTYHbc5u6kKfE8cnu5O2Nqg9ZyRy9BAGHYgenDY,1562 +vllm/model_executor/layers/quantization/utils/machete_utils.py,sha256=OeMLMQDbifbxz-HRYmjrC4RnMOutos17544P-h_dNE8,1074 +vllm/model_executor/layers/quantization/utils/marlin_utils.py,sha256=I9sz2ajMJ7dAhsyQNPUPxN5ZsPtIrmyp8zMtEQ5m_RA,16540 +vllm/model_executor/layers/quantization/utils/marlin_utils_fp8.py,sha256=bASNhLOrC-7AaC-xGUIQiDqUx0HRWPX1liD4iqzjas8,3672 +vllm/model_executor/layers/quantization/utils/marlin_utils_test.py,sha256=HkXMXXwpP4mfxpWI8p6BRjoq2ipVGpWLe1eWYSYxi-c,5311 +vllm/model_executor/layers/quantization/utils/marlin_utils_test_24.py,sha256=zk_DLYsG7n7Y9mvtEkY89fXSH9kPEsuPLfbX0W38DEA,17558 +vllm/model_executor/layers/quantization/utils/marlin_utils_test_qqq.py,sha256=ybGP1JEn-Mti_vvEs8Ch4cl1NfRK4TMDxdYWEYZSvxI,4101 +vllm/model_executor/layers/quantization/utils/quant_utils.py,sha256=XOrnnp5RJdyfggUTrMsjR4OBPaNhfTd55HvoZw5plt0,19458 +vllm/model_executor/layers/quantization/utils/w8a8_utils.py,sha256=Jl7P05H9N2c5WA1IAze-6cnbWizj0-kmuwp66Tfbvl8,16722 +vllm/model_executor/layers/rejection_sampler.py,sha256=4Rp-lgHMcZ4JFZs2ujBG2Rmm2FmPoGbq-ZbxQW_cVeU,16469 +vllm/model_executor/layers/resampler.py,sha256=fA3oc51Ku2jW2orqWVX0voeMc1zSooV6EyGteRIvGAs,10444 +vllm/model_executor/layers/rotary_embedding.py,sha256=EGzeXYeDmBYwbNIOaRlJG7Df-zsdCSYyWiRwCHgZ0uk,66024 +vllm/model_executor/layers/sampler.py,sha256=aOo-Z6NB9FEM7OMnTFe6NWOEU8_Z-tJntdVXmKzdHLo,50453 +vllm/model_executor/layers/spec_decode_base_sampler.py,sha256=iPRvd0WzUQzr8e6nSdggtKkyxYFv3-7MtnTs71wUzas,10190 +vllm/model_executor/layers/typical_acceptance_sampler.py,sha256=uzlrDmPtV19Mv17iJIceBU4Lj9IiJ1M3kXTxZ_y0mek,7047 +vllm/model_executor/layers/utils.py,sha256=Aa25A_a2vZFKIROJOWEynpZD5HRa4HC7179u-HSwaQY,4031 +vllm/model_executor/layers/vocab_parallel_embedding.py,sha256=1yd_jhRjAOwJ95f0YJvDzZqF-2e4GMgKfimrMITBUw4,22682 +vllm/model_executor/model_loader/__init__.py,sha256=SCcBIQqgBnp-uob0RHRC2La8mElcfAkXaJ_jwPLbxWI,646 +vllm/model_executor/model_loader/__pycache__/__init__.cpython-310.pyc,, +vllm/model_executor/model_loader/__pycache__/loader.cpython-310.pyc,, +vllm/model_executor/model_loader/__pycache__/neuron.cpython-310.pyc,, +vllm/model_executor/model_loader/__pycache__/tensorizer.cpython-310.pyc,, +vllm/model_executor/model_loader/__pycache__/utils.cpython-310.pyc,, +vllm/model_executor/model_loader/__pycache__/weight_utils.cpython-310.pyc,, +vllm/model_executor/model_loader/loader.py,sha256=xYk5bYtTfU00Cf4JjaVRpFPlxgga2dNEcPDl343dtQU,66049 +vllm/model_executor/model_loader/neuron.py,sha256=Dn0Qwd-YCyAjaiYjJFw5uoydNabYbYiIe04vnj4y3As,9686 +vllm/model_executor/model_loader/tensorizer.py,sha256=IrDTxwTz43NIJxiWJ-Ravu3iw20O3Opv-xKntAW4oUs,20260 +vllm/model_executor/model_loader/utils.py,sha256=44ASNuDlfDC_3QsHCBh5kzrlYMOqP5dl0VgtO8vojlI,7356 +vllm/model_executor/model_loader/weight_utils.py,sha256=Jp2te6DJ0UzJINDnbA0mUBbI6nLTNyknWAt5J4Zcf5g,28909 +vllm/model_executor/models/__init__.py,sha256=VzcvFDQ-L55rengF3g9oFlD02efze16wV6pIYiAH_RA,863 +vllm/model_executor/models/__pycache__/__init__.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/adapters.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/arctic.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/aria.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/aya_vision.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/baichuan.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/bamba.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/bart.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/bert.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/blip.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/blip2.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/bloom.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/chameleon.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/chatglm.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/clip.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/commandr.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/constant_size_cache.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/dbrx.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/deepseek.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/deepseek_mtp.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/deepseek_v2.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/deepseek_vl2.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/eagle.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/exaone.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/fairseq2_llama.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/falcon.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/florence2.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/fuyu.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/gemma.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/gemma2.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/gemma3.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/gemma3_mm.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/glm.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/glm4.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/glm4v.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/gpt2.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/gpt_bigcode.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/gpt_j.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/gpt_neox.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/granite.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/granite_speech.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/granitemoe.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/granitemoeshared.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/gritlm.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/grok1.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/h2ovl.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/idefics2_vision_model.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/idefics3.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/interfaces.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/interfaces_base.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/intern_vit.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/internlm2.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/internlm2_ve.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/internvl.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/jais.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/jamba.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/kimi_vl.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/llama.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/llama4.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/llama_eagle.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/llama_eagle3.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/llava.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/llava_next.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/llava_next_video.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/llava_onevision.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/mamba.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/mamba2.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/mamba_cache.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/medusa.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/minicpm.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/minicpm3.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/minicpmo.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/minicpmv.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/minimax_cache.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/minimax_text_01.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/mistral3.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/mixtral.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/mixtral_quant.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/mllama.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/mllama4.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/mlp_speculator.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/modernbert.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/module_mapping.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/molmo.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/moonvit.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/mpt.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/nemotron.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/nemotron_nas.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/nvlm_d.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/olmo.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/olmo2.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/olmoe.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/opt.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/orion.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/paligemma.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/persimmon.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/phi.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/phi3.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/phi3_small.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/phi3v.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/phi4mm.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/phi4mm_audio.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/phi4mm_utils.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/phimoe.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/pixtral.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/plamo2.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/prithvi_geospatial_mae.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/qwen.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/qwen2.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/qwen2_5_omni_thinker.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/qwen2_5_vl.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/qwen2_audio.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/qwen2_moe.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/qwen2_rm.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/qwen2_vl.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/qwen3.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/qwen3_moe.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/qwen_vl.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/registry.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/roberta.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/siglip.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/skyworkr1v.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/smolvlm.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/solar.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/stablelm.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/starcoder2.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/telechat2.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/teleflm.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/transformers.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/ultravox.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/utils.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/vision.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/whisper.cpython-310.pyc,, +vllm/model_executor/models/__pycache__/zamba2.cpython-310.pyc,, +vllm/model_executor/models/adapters.py,sha256=_GZXxOBj2I_xJCZlnFjlc_E8zlI8vzBb9GREAtsxVnA,8257 +vllm/model_executor/models/arctic.py,sha256=AIV_GtER1fvdJjoI6R80Ksc0YogBbOLG_HEJOB5vW5M,24491 +vllm/model_executor/models/aria.py,sha256=qyQl3ZWEll6pJIIOg3KtKOcnDQmCpp9wtkVeELkkDKQ,25583 +vllm/model_executor/models/aya_vision.py,sha256=MokcLQ0bnMcyJV2ymu7QPTYn8AfpP83_pw0Obl2tJJw,18719 +vllm/model_executor/models/baichuan.py,sha256=370cX3NY3GgPZavmDFtxaTWKgC0A6PNqQ4WX57P5OzI,18660 +vllm/model_executor/models/bamba.py,sha256=vksG42qQ80g0NkdoqWVyG7t5O9ZtZAFR-fxqAiDbbso,21325 +vllm/model_executor/models/bart.py,sha256=aiDRpWuA7mApgJ697hFBLcTW82OD-8xZdUst0nhwpvY,33800 +vllm/model_executor/models/bert.py,sha256=bZCtgl_FB--ayGiXQcQOfZQMxiB1VIrcq_amUaxakCs,28166 +vllm/model_executor/models/blip.py,sha256=Izi6sUm8nw_YxUY319DHbfBqf2l24y2ItJi-wF4e8ZI,12318 +vllm/model_executor/models/blip2.py,sha256=vljxoKINHPc2bS9EjrqdMthEcipShmZPfoDuLv8jRgw,25878 +vllm/model_executor/models/bloom.py,sha256=iUoBUbxCkiUtxt3iVcFbX9S_A-G3wxdjwL9adY20pDU,13977 +vllm/model_executor/models/chameleon.py,sha256=eFc06QWJAPosLN17mIQgGKtrBYoGDldvKEF_Xo-kM0w,45367 +vllm/model_executor/models/chatglm.py,sha256=nLjpyX6nDCiznwhwqgKRlEOmXBOmd9-sq0KGkLwBrTM,18376 +vllm/model_executor/models/clip.py,sha256=wi0JtGdnVlkyZyImEiXgDwYkvxOHaIAIOfiMntsCn-U,15085 +vllm/model_executor/models/commandr.py,sha256=4E1HtH59Meq7z2qJKn-yBtjw4pkWIb0IhuGQHkX-cds,19156 +vllm/model_executor/models/constant_size_cache.py,sha256=tfXeoXB4rKcq5MW7T2WN16V1-4GUEnHJZjDKEdyTl_k,5858 +vllm/model_executor/models/dbrx.py,sha256=umk6_ODzf1l_i02dYJB5j4qga_xlT4a4O71Xi2yX4Ks,18260 +vllm/model_executor/models/deepseek.py,sha256=1WAj2Dqp-KhsJO3qsmSQMkpiNCoVYReLWbE3htGuTaQ,19791 +vllm/model_executor/models/deepseek_mtp.py,sha256=OICW9sPppw5DIUFCflJAOU77bzVaP0Sz_P312kgDdNA,10901 +vllm/model_executor/models/deepseek_v2.py,sha256=BS1g0F6HAaO5NzDSbJ5xZBC3Kmn5u0kKklawFsgrkGk,35035 +vllm/model_executor/models/deepseek_vl2.py,sha256=WNvgAMB-Rqfqd34M7Zd4KXUvxFuhXkUKyJA-O7SqGbE,25191 +vllm/model_executor/models/eagle.py,sha256=ZMJY04MAj4EWB8pLTHN8chWAaDQxd5qwlsbYy86ZUYk,11175 +vllm/model_executor/models/exaone.py,sha256=HgACkkML5jAvbIWtLYsjkYqL2D7OyeLpxWdFjw2mSlQ,21044 +vllm/model_executor/models/fairseq2_llama.py,sha256=J983ipTj1VNjEtr8AO5zse78kpdRqnL2WzUIC-gRZSU,6489 +vllm/model_executor/models/falcon.py,sha256=dggYGIXA2eayEaBMxnwxe-QCVAkxfbR8dNpPH_vUoIs,21299 +vllm/model_executor/models/florence2.py,sha256=4ybjy_3UJMgrReWq3fEhLobdcxtiYGiRs237PznlvjM,39211 +vllm/model_executor/models/fuyu.py,sha256=0Skwsa-Bqjye6x1Ha9LkC7QV7WaAz0lHXjEwRoOHZdg,14240 +vllm/model_executor/models/gemma.py,sha256=1QQr4_hvrIw3WXWcKAFsBD4BrwXu9jCRfCc72x8UBAI,16224 +vllm/model_executor/models/gemma2.py,sha256=R0pjkiNZLgzCnzs0nLCS5x6TfHpNCfpzI_l9D2Ywn_c,17455 +vllm/model_executor/models/gemma3.py,sha256=lFhtYrcKTAmZ4sDJIE8h0XlrN_6b4lux1-9k5G4F0o4,21666 +vllm/model_executor/models/gemma3_mm.py,sha256=K-zpj013BHzybVzYLlNVaJZRHISswIhHVvRrNXw6hX8,25837 +vllm/model_executor/models/glm.py,sha256=kI2a6yL-Pa91knqI7SHxgrV5kUlACHATeiIWy_C14H4,990 +vllm/model_executor/models/glm4.py,sha256=pmtD41T0NlfE95MXSvMpBzGz_zkr0FROiAUfl0PKAhg,11780 +vllm/model_executor/models/glm4v.py,sha256=Sv1zWlKhohg-KiHBSblhxe4R52pMjW-xGlg6HWDbM7s,22106 +vllm/model_executor/models/gpt2.py,sha256=WtErZpi9ldpe4JG1awFO8R1mctJIZXd71QkL-odBxFU,12363 +vllm/model_executor/models/gpt_bigcode.py,sha256=Wk9Bs5z4UEEmOf2VJoMEkWRaQ1O6ClvFu0Osn3iws3Y,13120 +vllm/model_executor/models/gpt_j.py,sha256=1BYJxR-AZoJnjKJjR7nHPwSTVwm3ENA1Q7qm5AnMyFE,13164 +vllm/model_executor/models/gpt_neox.py,sha256=u8fiL298xnsW3tG_YukPbw0GXHwIDOEATsGDM1cr8oE,13303 +vllm/model_executor/models/granite.py,sha256=pP8Jze9pyOlQ0SmtDtuBPpg34q5rg6bkTrt93__WflM,20224 +vllm/model_executor/models/granite_speech.py,sha256=5E4zCGHm64gto8HgzcC-pGfCfU_eQgVucO_YYBPmsyI,31239 +vllm/model_executor/models/granitemoe.py,sha256=nh6OaWyIlCeHWKHZabhs2lzpR7wY_qzlJed_hu6XVYk,17892 +vllm/model_executor/models/granitemoeshared.py,sha256=HHqElp3Y8tqAbIizGwymoEoL2qz7VCGIVTRvaM-4ZBk,13679 +vllm/model_executor/models/gritlm.py,sha256=TLmcp8jMok5g_Vy5ANUl9Lor2l0nBtqEBMM0LlBWZ60,8988 +vllm/model_executor/models/grok1.py,sha256=XI-v9vhRUqBsQTcZa7AYGoSAVkPcOM6D7zrUfqKO8OU,23300 +vllm/model_executor/models/h2ovl.py,sha256=09DM8KzX9OdXS7uk7AUa1tOy-TbnVmBKb-nS_HBxkhY,18188 +vllm/model_executor/models/idefics2_vision_model.py,sha256=ymx5ptNiC4Se1quA4s4vjhAMhsIUru7ituClLqkIeJY,14948 +vllm/model_executor/models/idefics3.py,sha256=03iHweR7PCGAF2fD-OMdmp-jxQjOQxcfxSBexTS0wwU,27776 +vllm/model_executor/models/interfaces.py,sha256=PVXjyHqzRg1jE4ZYrjwOyNvgOuc0bfxBqNoeeDNUYmg,16022 +vllm/model_executor/models/interfaces_base.py,sha256=qJgt8EwFMFAHUw7jIzCD0kV39nCGyM7GRW2JuYrQ7Cg,4369 +vllm/model_executor/models/intern_vit.py,sha256=jcUq9Q6xp0BHdWs7Zgo-iDoUAiO3bcIrBsYrrGr6xsc,17332 +vllm/model_executor/models/internlm2.py,sha256=QiTjGIwiniAUDNC6ExBIGXe8dpoC97wb0-vo_TmaCXM,17186 +vllm/model_executor/models/internlm2_ve.py,sha256=M_goPBHj8PdFD7OUWFR40swNfC3oV6ddcVoZgpl6ugQ,5739 +vllm/model_executor/models/internvl.py,sha256=uhT9KxcjnUiwNYDJHLXhcr3rgaR2JLpFWM4TpVNJa6E,33749 +vllm/model_executor/models/jais.py,sha256=Qr5ov59m3vhICiwUFrAHu_BhGae90U_KIOxizSqUAiE,14531 +vllm/model_executor/models/jamba.py,sha256=p6dp3GJJgFRSdpQV-ZDbm-a6XQ9x2COIavzHHxGgdqg,24255 +vllm/model_executor/models/kimi_vl.py,sha256=GmD35Q60u0gMgP4974alNjT0w-wPgOseL3LwrmgjRjY,24399 +vllm/model_executor/models/llama.py,sha256=Ys-db2DZNyXXRL_wfsmvGPgi8kGAZ1TJnjV_O76ujsA,24996 +vllm/model_executor/models/llama4.py,sha256=znTmnqUFR4VNB7nPWnl1Z-7d7pfxakY-QBNqmJZVu9Q,21815 +vllm/model_executor/models/llama_eagle.py,sha256=HN2hTxGF7cNmWgZMzjExlPdYEPV_6sf28z0QwsjxDyQ,5399 +vllm/model_executor/models/llama_eagle3.py,sha256=pTPX7rt5O9YKkt3MPeOgKYbb87BcLWOMPuMjQn1qinI,8289 +vllm/model_executor/models/llava.py,sha256=2s4OASAETYny2HU8o-2g484yC3mlUYau-XcixcmdxeI,32449 +vllm/model_executor/models/llava_next.py,sha256=Bg7ToDnBZ_sDePfasxhBHsXZl5hFEWqOy3zGM7sO8Qw,23679 +vllm/model_executor/models/llava_next_video.py,sha256=YJ9MCQc2rTO_VJ9oS6yNg4p0-283IUGPIm262GM3_HU,17619 +vllm/model_executor/models/llava_onevision.py,sha256=drhY2vavac15GlH6CQ6rBVY7zkV_K7Uw-8_7yYKPqko,36917 +vllm/model_executor/models/mamba.py,sha256=vMuY9BDlbRQ8zGGfkhq-8o3an475aucnGO4eA0xtFnw,11564 +vllm/model_executor/models/mamba2.py,sha256=8XzlYoUalkc84Q1C_4szHSUSSH6LlsT9nbvzpg_ymaU,12391 +vllm/model_executor/models/mamba_cache.py,sha256=VsrGAeFHiPSSoK_RE9pfEfiBMZ4uTVFTBXV9xcSKmQI,2923 +vllm/model_executor/models/medusa.py,sha256=c0jYTHJXo8FfueT0-y_yYjA7e91TIFz4PYRu7G5Kqlo,8558 +vllm/model_executor/models/minicpm.py,sha256=wfBfofWrsECes9ot3GmbyK3bWAcP56z4--c1puMcuRQ,23996 +vllm/model_executor/models/minicpm3.py,sha256=7ETT1RdWTbVueHwDaZfWpQTz9IXLaQNLgTBh8AON9Dw,9366 +vllm/model_executor/models/minicpmo.py,sha256=LDxONdHDibO5XuYuYvZxjbfDA2jT-fCw9aedmj5BLMo,27349 +vllm/model_executor/models/minicpmv.py,sha256=Q9JNS2VaITCFBOibthFk28vNti52BKK9Rr0EDXB-Dvg,47256 +vllm/model_executor/models/minimax_cache.py,sha256=29FVD-sSoymCb8yrJxxE7jdvgvt5VctucnI3WkS9Yo0,1143 +vllm/model_executor/models/minimax_text_01.py,sha256=VKRyuPwcjtwcPGMlJtFzJaGcfYDOfPpUNjffWhXK7Qs,50241 +vllm/model_executor/models/mistral3.py,sha256=uycOm-vP9SZ9NgCWZT4nvMN7EbvrQ3kg75Ns5yn9ze4,22820 +vllm/model_executor/models/mixtral.py,sha256=Q5B0jFFz4kX4pyU_xk672ghtph_0MWBacwK1A3JMEkg,20127 +vllm/model_executor/models/mixtral_quant.py,sha256=gV4_4xtsb_Cr8Alr9Ofx2kUbydaKX0kWQpx0xSXjW7s,18238 +vllm/model_executor/models/mllama.py,sha256=Q_iVpzwweFs788Q5s0YvDGne3RvDPJBdfWK87wGexf0,66761 +vllm/model_executor/models/mllama4.py,sha256=LcK-yD4xu-o9jCV4P-d2uCcQ0U-CxfZDFtwu3NMcRMQ,31798 +vllm/model_executor/models/mlp_speculator.py,sha256=hv7XRnxENUo4R07K_Ox_9RVTZyKEDS96fYNECVKjz0A,7905 +vllm/model_executor/models/modernbert.py,sha256=3sg7jB2eT9sKNC5ym0XGGwh54IoQPcqaLgOXgOkl08k,12414 +vllm/model_executor/models/module_mapping.py,sha256=d_72RpeQ7wVO9LXl2eeQDIRyurGtEMsN33ey5IdDG_8,1781 +vllm/model_executor/models/molmo.py,sha256=CZ5FBB6mwmv27uJvvcZOkosK3FU7PHtx3SUePXBrzQY,54927 +vllm/model_executor/models/moonvit.py,sha256=6PUh8VsQDfU7jRTKA4f58ytNoRFJZ5y5XjXERXMVNJ0,24037 +vllm/model_executor/models/mpt.py,sha256=PtejQHucpoAKhF_b6rhOZGLxmYh2oiSyoq25Gf-no6Y,12670 +vllm/model_executor/models/nemotron.py,sha256=jgbTyggSi7qsb9NQEnHyLwrkU241nAYNOB2BPBdXAs0,20651 +vllm/model_executor/models/nemotron_nas.py,sha256=vN9RUCCUn8fS96jacX_0lchE8oe-mZwgpqRBITHPLyo,17577 +vllm/model_executor/models/nvlm_d.py,sha256=d09N62ey6RKEye3UlJJkFr0dde5tiCx-HrCYdqMuIF4,7919 +vllm/model_executor/models/olmo.py,sha256=oXpLGitcmHS5mbgWagH23Gc0Lzi3389Fj3hw41G98vE,15098 +vllm/model_executor/models/olmo2.py,sha256=JcJeWkqZaPcLK2TyLdqQwauC-kOuuycedJ_Or_DjTwQ,16078 +vllm/model_executor/models/olmoe.py,sha256=X2_wKZLXRLjyNKEVIyoO00N0rDcLRH-vgYPGK-1BPQQ,18492 +vllm/model_executor/models/opt.py,sha256=sxm4w5iBWqN31zvguGXJG6DQ8oTKRj3Jd7hLRKqJEHY,16488 +vllm/model_executor/models/orion.py,sha256=9jwSuqmAZkZal83_tKUz5eEAIr9TO9Qwidh5YK3yEs4,14096 +vllm/model_executor/models/paligemma.py,sha256=25MJ65uhdaKO_YSfALMRa0RPfB9CTJ1egrJCI4nL-Mo,14591 +vllm/model_executor/models/persimmon.py,sha256=XMXRgEisHKFzg_D52tyLcwwDxEWAz8zKSKK7jQjFmqM,14244 +vllm/model_executor/models/phi.py,sha256=SisXMazkQQRuPL5SHHOENSYEVmR2Er2PC1lxkZzPjxw,14088 +vllm/model_executor/models/phi3.py,sha256=dfxzNvOZ2XPpQIy5mdRFsxFZObV1_h5vlC-ak2hw3HI,388 +vllm/model_executor/models/phi3_small.py,sha256=t47UhryllQukBHwQ93_nG7dRfjFleHWFXOpMdFR8BCM,18198 +vllm/model_executor/models/phi3v.py,sha256=oEHNayK6qX7cFOIGN1EXakjTEkfPSe5fo_q9q34Rp8Y,28423 +vllm/model_executor/models/phi4mm.py,sha256=f6VUEV5PWoW6thRs3ZNX3fqxAAKR9JZm3lpZ1ZBRFkk,50134 +vllm/model_executor/models/phi4mm_audio.py,sha256=GZiQxE8saU4RAfaY1L2B-s3wEXSrXXCFGYyW8CHzxFw,49073 +vllm/model_executor/models/phi4mm_utils.py,sha256=HTzN13FbJhJmcWtH8yWbLRFIO6yz85XJNcH7P8fpvfw,66669 +vllm/model_executor/models/phimoe.py,sha256=2HYcPPKpQ1nxEMPEY3v0qv7aStvMr-Xu5nds7wHzvbc,24730 +vllm/model_executor/models/pixtral.py,sha256=3lPcsidgqrvdZuBP6kS64LG8lm9k0eP3fqFEViJO3Yo,46914 +vllm/model_executor/models/plamo2.py,sha256=hFxlepNKOOfz4QrMIqHLvU_UrEcUxWjXp59fPuvgrO0,30036 +vllm/model_executor/models/prithvi_geospatial_mae.py,sha256=peK17WmcwS_xRV1VGXlqC4_uL7hp2-qfYQCfHS1jknc,9199 +vllm/model_executor/models/qwen.py,sha256=mq7vPonGJ1T_c1Ruispjz9lIYeZ0s_QvJHtyJ8mGw5I,13838 +vllm/model_executor/models/qwen2.py,sha256=QqdNmJFcLMrweXV9cU7l_NgdECqu9PBZvYejZbO6lz8,21776 +vllm/model_executor/models/qwen2_5_omni_thinker.py,sha256=8Hb8Xe951jc0Dqph4VmxJViXNaBPejX4tk47_W8l5-Y,37144 +vllm/model_executor/models/qwen2_5_vl.py,sha256=NGSpoT5W06mqvP9Pml6GiH3Ue7VQGgNKo586TWJ7RVo,46525 +vllm/model_executor/models/qwen2_audio.py,sha256=UVNmNJalmX59vtuf7BamNQIrVzpRkPPxm6kkuF-v0zI,16225 +vllm/model_executor/models/qwen2_moe.py,sha256=O5A5h5qtooq9uB6xdmr9EvaaS3ZJXAV2s8q7JgXqd2M,22531 +vllm/model_executor/models/qwen2_rm.py,sha256=aeG0z9uoIUUsTGE8LA_c48c8T8Hh3p1LfrRjMFuClJU,4536 +vllm/model_executor/models/qwen2_vl.py,sha256=bYFFm2mm0h0b5tuvptSgiPggg5N4_fhXfVIE5oaQqJ4,53580 +vllm/model_executor/models/qwen3.py,sha256=6j6SSIVZdRIgrIjwxYlFNpHfPb12olnSdv1jKW6gyaQ,12420 +vllm/model_executor/models/qwen3_moe.py,sha256=mruQjfPqLGQGV2xsNy-Db34AESABKvy5yJHd1LXulLQ,22928 +vllm/model_executor/models/qwen_vl.py,sha256=VcdGeNX31d-v6JBDNhSGmO2iAVL5OfiPhV6FYW3grks,26765 +vllm/model_executor/models/registry.py,sha256=K0iMbH47XSqw-xkT9hJuDfCyJm2toVdlFAkjaQN8Prw,24956 +vllm/model_executor/models/roberta.py,sha256=qT8H5UwdGpSa6s6f3Q1Kj1CocFbNE-ikwOexMXGfRNg,13442 +vllm/model_executor/models/siglip.py,sha256=fj5XB_1xoi0IMrELjAQMdJjtvjNBVghUDP3LZKSlSS4,18685 +vllm/model_executor/models/skyworkr1v.py,sha256=QqUuPRKXhzUVe6YiIG2fI9cChgJOj8hyoIpA_fUAKuk,33947 +vllm/model_executor/models/smolvlm.py,sha256=gxdwi7cC_5AohDdTQ6kwe2L71uk8-04JjgBcKsIx0XM,1736 +vllm/model_executor/models/solar.py,sha256=aclPlsjrhMGW-Z6D-B4_ZujzQ2X9dx5hoHYEa-5J67E,19892 +vllm/model_executor/models/stablelm.py,sha256=UlKpFpOVn93UOTNCo2R-XObKnIR2zfMQnVA12ugumxQ,15209 +vllm/model_executor/models/starcoder2.py,sha256=KhkRQBSiuoUBktzHBVdfWjmpka-B34-H9Ryrg3yrScI,14571 +vllm/model_executor/models/telechat2.py,sha256=Nqk3c6Ou3XeqayxXBby-lTLmfsxPNXHbnJco6LGRBs4,5997 +vllm/model_executor/models/teleflm.py,sha256=VybsbNx-m48o364REHE8HczV5yH8G8AISCRvMs96vrA,3143 +vllm/model_executor/models/transformers.py,sha256=d98i8BFWweTnmoNnWuSJ9AOZ0ogJEVPg1YnsMgF0Q50,17546 +vllm/model_executor/models/ultravox.py,sha256=Ho3UzmhsU0OLeJrnV_G_ytR2UKVZPNc6XYfAw4sDcJc,26910 +vllm/model_executor/models/utils.py,sha256=rF4Bh94fgZaI9I-MMHvKvhKwVtypWysTT1CfLrdDogY,24220 +vllm/model_executor/models/vision.py,sha256=J6biI1Hx6ls2E-DauGCdhscdqY7dg4k__m6p5Xu-o3M,5706 +vllm/model_executor/models/whisper.py,sha256=tRVRvUNYNtXcQKpsEE3HcCTMqfcy8jPdDE-b0z9UC8A,27565 +vllm/model_executor/models/zamba2.py,sha256=VilHoaUknriXRwYOOPTGMvy2E50Ib_AFXV1ltJ8YROw,39629 +vllm/model_executor/parameter.py,sha256=uqCaKZy4iKETQMqNleUXoMKcQ0zYA1KwEO32s3d4bwM,16689 +vllm/model_executor/pooling_metadata.py,sha256=FeDxnEg8W8-ZOtg17JE1z26RfrKaU2_ZaWvwkochqKA,2077 +vllm/model_executor/sampling_metadata.py,sha256=NqPjJLXP6xdiy5hQk1lq_sRdFrjwUEQhfOudpag-Wt0,22965 +vllm/model_executor/utils.py,sha256=o1nKePmbzfAwPqVqXJbOGwDUXy_fLUGaFZlsPEbMhpI,1915 +vllm/multimodal/__init__.py,sha256=H8ox_Aiqk10St_5AgW59cvdksUl92INLWDopBY98LOY,924 +vllm/multimodal/__pycache__/__init__.cpython-310.pyc,, +vllm/multimodal/__pycache__/audio.cpython-310.pyc,, +vllm/multimodal/__pycache__/base.cpython-310.pyc,, +vllm/multimodal/__pycache__/hasher.cpython-310.pyc,, +vllm/multimodal/__pycache__/image.cpython-310.pyc,, +vllm/multimodal/__pycache__/inputs.cpython-310.pyc,, +vllm/multimodal/__pycache__/parse.cpython-310.pyc,, +vllm/multimodal/__pycache__/processing.cpython-310.pyc,, +vllm/multimodal/__pycache__/profiling.cpython-310.pyc,, +vllm/multimodal/__pycache__/registry.cpython-310.pyc,, +vllm/multimodal/__pycache__/utils.cpython-310.pyc,, +vllm/multimodal/__pycache__/video.cpython-310.pyc,, +vllm/multimodal/audio.py,sha256=pCpnPG0OhQMS-7SqVmO0VdcdwJombEhiwj2C4AMidy8,3079 +vllm/multimodal/base.py,sha256=oO4hXRWCURMmTeP6SRXNq0fo_sldIhCr2CxBcR8GpVA,7014 +vllm/multimodal/hasher.py,sha256=sHLPsqzjONd2Ra2mZirZLnxfSdV9cV5_PUGpm_IRNuA,2865 +vllm/multimodal/image.py,sha256=sRFpwj1KfKYVrUePkau3tLU65KGYGCOEXFrPTr-_qRo,2233 +vllm/multimodal/inputs.py,sha256=twLmIe_O-WReMqKLfBwwbvtyJwLke47n_ugGBTgFSf0,27246 +vllm/multimodal/parse.py,sha256=k7r6YzgQD1a7hPP8vV8WnUwUhHbSZx9NRUEP7jirRhs,14141 +vllm/multimodal/processing.py,sha256=QGgFqzsflYchwgXIiQ_o9zSBxg7xwl4ZrKBulMfoFoI,56963 +vllm/multimodal/profiling.py,sha256=c8uD2tqvJ9C4nhWxiwLWC-KXmnnBwcHxFustg_fMhB0,9185 +vllm/multimodal/registry.py,sha256=yUyvY1IdcdnfMt83qYcw4Qyp0FLqiLFH5Fwlt2p80dM,10989 +vllm/multimodal/utils.py,sha256=daLxvepBkNZbCdcbHKTr6H9hzaSpkAcCuqIqJQCnf9I,11840 +vllm/multimodal/video.py,sha256=fxRALl53g3Ryz8wC60YNIi11OWTqllwOdxh6iSCiqd0,5159 +vllm/outputs.py,sha256=dgBIWA0VrQ9KXhru_0_NtAaU35urHTcNnqhrXkOWxS4,20255 +vllm/platforms/__init__.py,sha256=ATk-4qv0zzMxRXaXjqyDvEb4bpwaOzn58xVRrXNXdws,10364 +vllm/platforms/__pycache__/__init__.cpython-310.pyc,, +vllm/platforms/__pycache__/cpu.cpython-310.pyc,, +vllm/platforms/__pycache__/cuda.cpython-310.pyc,, +vllm/platforms/__pycache__/hpu.cpython-310.pyc,, +vllm/platforms/__pycache__/interface.cpython-310.pyc,, +vllm/platforms/__pycache__/neuron.cpython-310.pyc,, +vllm/platforms/__pycache__/rocm.cpython-310.pyc,, +vllm/platforms/__pycache__/tpu.cpython-310.pyc,, +vllm/platforms/__pycache__/xpu.cpython-310.pyc,, +vllm/platforms/cpu.py,sha256=7IaxOy93fXVD-RcyIJarbxf1-9M811pHFRdzffMdXMM,7292 +vllm/platforms/cuda.py,sha256=8qgNTfVzP10DpcooYVReuK2nXfdSYNm2pmW2meKpFoE,18453 +vllm/platforms/hpu.py,sha256=9jcNjaC55sqeV6oHq9hm5JwXJu66lUupMcCArBLaCcY,3522 +vllm/platforms/interface.py,sha256=9HHuvFStExwThlA0AUe4IAzxZCHR2raxghisEpQwuMw,13801 +vllm/platforms/neuron.py,sha256=m6vNECPtIUl7o7oi2dFn9sgz7XfM-hwwbEmlhWDB1ak,2204 +vllm/platforms/rocm.py,sha256=GtILVlxitkldK-8nKqgHyEuzd_focEGa9A9XOYPPKAs,13744 +vllm/platforms/tpu.py,sha256=sPdnT5cWrLQtQjVPLdYy8ys2Utoai8rrsLyStanBzFA,6562 +vllm/platforms/xpu.py,sha256=Bgm3GepKegOQeQPT0jQQ1Asc8_8LW-O0z597FbFCrNc,5498 +vllm/plugins/__init__.py,sha256=eZT4FNCwDJhjMADo5KgKBaGLd_7YR9LzhFgnLuwhAnc,2962 +vllm/plugins/__pycache__/__init__.cpython-310.pyc,, +vllm/pooling_params.py,sha256=TQcDIM8CKnH9_Io24akBrVhZUZIl9_zhuO5szeEmBqs,2017 +vllm/profiler/__init__.py,sha256=GWIaNWjYFXuIGl4qCtZyhz-Z88ysZH-mz4G7pYKOe78,128 +vllm/profiler/__pycache__/__init__.cpython-310.pyc,, +vllm/profiler/__pycache__/layerwise_profile.cpython-310.pyc,, +vllm/profiler/__pycache__/utils.cpython-310.pyc,, +vllm/profiler/layerwise_profile.py,sha256=WIh-o0z6si4ua2sCvqRjs4OekSY5PvP7XPgBLud9DTI,13837 +vllm/profiler/utils.py,sha256=itpGYyhLXCQ07nT_dL7seAPJyDlPv9f2Dg6Grh5lpAE,4663 +vllm/prompt_adapter/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +vllm/prompt_adapter/__pycache__/__init__.cpython-310.pyc,, +vllm/prompt_adapter/__pycache__/layers.cpython-310.pyc,, +vllm/prompt_adapter/__pycache__/models.cpython-310.pyc,, +vllm/prompt_adapter/__pycache__/request.cpython-310.pyc,, +vllm/prompt_adapter/__pycache__/utils.cpython-310.pyc,, +vllm/prompt_adapter/__pycache__/worker_manager.cpython-310.pyc,, +vllm/prompt_adapter/layers.py,sha256=aoeVO5L_abEwB92Groio_5lB9al37OiEJac_GkSuCko,2726 +vllm/prompt_adapter/models.py,sha256=ut5JOYkO4AA0UIGEhIGuDqW3u0SjcObmu_c_L7k7sG8,13722 +vllm/prompt_adapter/request.py,sha256=2_iVKLKdWE3kbt7ja_wPHhCerMqVXlg6ztDw344Yd6I,838 +vllm/prompt_adapter/utils.py,sha256=fMMwK-mzuhT9Wu9araO0rSdtNkAmTNvsCAfQXfOkWQk,3668 +vllm/prompt_adapter/worker_manager.py,sha256=qMEPVkdg2_L4bYSIBg_XPEM5As8UgrPrgudoiG4kEAE,7536 +vllm/py.typed,sha256=F5LUrt0voM87SNuuOky2X9veCVDqJUgRg_VohYqDigY,65 +vllm/reasoning/__init__.py,sha256=nioiAm98By9GYD1U2CCj0wgwLpOceBoiOS7umdylkcA,374 +vllm/reasoning/__pycache__/__init__.cpython-310.pyc,, +vllm/reasoning/__pycache__/abs_reasoning_parsers.cpython-310.pyc,, +vllm/reasoning/__pycache__/deepseek_r1_reasoning_parser.cpython-310.pyc,, +vllm/reasoning/__pycache__/granite_reasoning_parser.cpython-310.pyc,, +vllm/reasoning/abs_reasoning_parsers.py,sha256=U2D3-63pXXDPpK50_r5OAM_ZIFW584A0wEywfyRNYjU,6507 +vllm/reasoning/deepseek_r1_reasoning_parser.py,sha256=ohpIV6s2j0fha3YmuxKVUFFZjirvTtq8TGTs5r9qkM4,7396 +vllm/reasoning/granite_reasoning_parser.py,sha256=4Wc3hv7tSOjg8ML0V30hRBIFAaVaCY6XCpHxKvBzwyE,15821 +vllm/sampling_params.py,sha256=yP7zdMacdcAfd_81kTolWukiMb9TY6QaaS_O1m8Qswg,26489 +vllm/scalar_type.py,sha256=WkMflqmaY02SmZAngPoP1-x8cmzfBj_rcpl2dhph-r8,11968 +vllm/scripts.py,sha256=f4JQeU_63yCFEvUth0qKfLX18lsPDgcxBveXqvG7js8,432 +vllm/sequence.py,sha256=rFgzP-vtzBEK-zsIJijhkx91bTg8DR-nIh3z_ieky28,58721 +vllm/spec_decode/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +vllm/spec_decode/__pycache__/__init__.cpython-310.pyc,, +vllm/spec_decode/__pycache__/batch_expansion.cpython-310.pyc,, +vllm/spec_decode/__pycache__/draft_model_runner.cpython-310.pyc,, +vllm/spec_decode/__pycache__/interfaces.cpython-310.pyc,, +vllm/spec_decode/__pycache__/medusa_worker.cpython-310.pyc,, +vllm/spec_decode/__pycache__/metrics.cpython-310.pyc,, +vllm/spec_decode/__pycache__/mlp_speculator_worker.cpython-310.pyc,, +vllm/spec_decode/__pycache__/mqa_scorer.cpython-310.pyc,, +vllm/spec_decode/__pycache__/multi_step_worker.cpython-310.pyc,, +vllm/spec_decode/__pycache__/ngram_worker.cpython-310.pyc,, +vllm/spec_decode/__pycache__/proposer_worker_base.cpython-310.pyc,, +vllm/spec_decode/__pycache__/smaller_tp_proposer_worker.cpython-310.pyc,, +vllm/spec_decode/__pycache__/spec_decode_worker.cpython-310.pyc,, +vllm/spec_decode/__pycache__/target_model_runner.cpython-310.pyc,, +vllm/spec_decode/__pycache__/top1_proposer.cpython-310.pyc,, +vllm/spec_decode/__pycache__/util.cpython-310.pyc,, +vllm/spec_decode/batch_expansion.py,sha256=_n2h_IcPtL1XhAEVtv0pOPNPvf9GDqfojdZhCAneUjk,22740 +vllm/spec_decode/draft_model_runner.py,sha256=QmXaBxVBHCReo9Qzjm-wJVlWSDn75RG66MRRvXTOlHc,14588 +vllm/spec_decode/interfaces.py,sha256=_hnecfFBgi-_wKMIxPobP-DRaefD769WqethORvcofA,3086 +vllm/spec_decode/medusa_worker.py,sha256=liPn4iIMqJ8owL4cXgrDTVb3bjpUKBlqeNDlFlwEvjc,4900 +vllm/spec_decode/metrics.py,sha256=DuJxAXU0jQT5bF9MXjTmHTm1rg-KkIt_ZkMBCfTcSjY,8063 +vllm/spec_decode/mlp_speculator_worker.py,sha256=NuOIAQtZxCWPs7YXWRJW3KwFCT4i3ETCobsA0gK-qVs,3737 +vllm/spec_decode/mqa_scorer.py,sha256=GdhVN2Ef3L_LlnoftqivY0rRKgPF7EV81XUu3PyMouo,7508 +vllm/spec_decode/multi_step_worker.py,sha256=6a9i56JMBL7Tkd0MY9wF-qDk2nt9vRTZeeZKwBqBX4Q,19251 +vllm/spec_decode/ngram_worker.py,sha256=ClMwq0JnlhRPiBT8hI4fBuHVPgtt-uQe6ttMR2CVIb0,7827 +vllm/spec_decode/proposer_worker_base.py,sha256=Qyl-YKE4xg9kz4RVlK6tO3ZSng3JU515oQmVZntijKQ,2089 +vllm/spec_decode/smaller_tp_proposer_worker.py,sha256=mSFul-wK6bqqd4SAl1Vy_Rso6MhaG2LFEaxPqpMznXM,6835 +vllm/spec_decode/spec_decode_worker.py,sha256=bXt84GE77IWG_43hGKMRaZ8J4VJwUrMTNgYjqZYCSu4,62887 +vllm/spec_decode/target_model_runner.py,sha256=sRW1sqPhEdEwL5MvHCRRmd-lmc-G8LjJgG7R22R6JM0,2073 +vllm/spec_decode/top1_proposer.py,sha256=sEvZMEoj_s9-aXzkX6faUZuffoPtxATuMbEmRnZKecM,12354 +vllm/spec_decode/util.py,sha256=2oG5qDatn0pc99zWPOKoYb2LPDc6fXLUelQRCxHvyBo,9888 +vllm/test_utils.py,sha256=uVMsqTrMcwyNNJaxlO6mvka5pmUE7xUAvOBapd_R7hs,5996 +vllm/third_party/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +vllm/third_party/__pycache__/__init__.cpython-310.pyc,, +vllm/third_party/__pycache__/pynvml.cpython-310.pyc,, +vllm/third_party/pynvml.py,sha256=Dw3kbk5Rn1l8hXRQgR2KvaLjEqKQM2M6r0WtEqbtANE,234584 +vllm/tracing.py,sha256=u98azd2ER4HnjempIUdqZhPOvQaK2tZfbSOUTZn_OMo,4776 +vllm/transformers_utils/__init__.py,sha256=RZEL-BvlcJuQJFMPZLM-LjViwZxSsV2o8Tnx7strgDU,617 +vllm/transformers_utils/__pycache__/__init__.cpython-310.pyc,, +vllm/transformers_utils/__pycache__/config.cpython-310.pyc,, +vllm/transformers_utils/__pycache__/detokenizer.cpython-310.pyc,, +vllm/transformers_utils/__pycache__/detokenizer_utils.cpython-310.pyc,, +vllm/transformers_utils/__pycache__/processor.cpython-310.pyc,, +vllm/transformers_utils/__pycache__/s3_utils.cpython-310.pyc,, +vllm/transformers_utils/__pycache__/tokenizer.cpython-310.pyc,, +vllm/transformers_utils/__pycache__/tokenizer_base.cpython-310.pyc,, +vllm/transformers_utils/__pycache__/tokenizer_group.cpython-310.pyc,, +vllm/transformers_utils/__pycache__/utils.cpython-310.pyc,, +vllm/transformers_utils/config.py,sha256=eyWjoufI_PRdKrbz5YXl3H_XWWUyjyur3rZiV2zooyE,30265 +vllm/transformers_utils/configs/__init__.py,sha256=3UGWqL8_bh1OB37sTPeo76aBp6VM5d048GJpJpCG3Ag,2189 +vllm/transformers_utils/configs/__pycache__/__init__.cpython-310.pyc,, +vllm/transformers_utils/configs/__pycache__/arctic.cpython-310.pyc,, +vllm/transformers_utils/configs/__pycache__/chatglm.cpython-310.pyc,, +vllm/transformers_utils/configs/__pycache__/cohere2.cpython-310.pyc,, +vllm/transformers_utils/configs/__pycache__/dbrx.cpython-310.pyc,, +vllm/transformers_utils/configs/__pycache__/deepseek_vl2.cpython-310.pyc,, +vllm/transformers_utils/configs/__pycache__/eagle.cpython-310.pyc,, +vllm/transformers_utils/configs/__pycache__/exaone.cpython-310.pyc,, +vllm/transformers_utils/configs/__pycache__/falcon.cpython-310.pyc,, +vllm/transformers_utils/configs/__pycache__/h2ovl.cpython-310.pyc,, +vllm/transformers_utils/configs/__pycache__/internvl.cpython-310.pyc,, +vllm/transformers_utils/configs/__pycache__/jais.cpython-310.pyc,, +vllm/transformers_utils/configs/__pycache__/kimi_vl.cpython-310.pyc,, +vllm/transformers_utils/configs/__pycache__/medusa.cpython-310.pyc,, +vllm/transformers_utils/configs/__pycache__/mllama.cpython-310.pyc,, +vllm/transformers_utils/configs/__pycache__/mlp_speculator.cpython-310.pyc,, +vllm/transformers_utils/configs/__pycache__/moonvit.cpython-310.pyc,, +vllm/transformers_utils/configs/__pycache__/mpt.cpython-310.pyc,, +vllm/transformers_utils/configs/__pycache__/nemotron.cpython-310.pyc,, +vllm/transformers_utils/configs/__pycache__/nvlm_d.cpython-310.pyc,, +vllm/transformers_utils/configs/__pycache__/skyworkr1v.cpython-310.pyc,, +vllm/transformers_utils/configs/__pycache__/solar.cpython-310.pyc,, +vllm/transformers_utils/configs/__pycache__/telechat2.cpython-310.pyc,, +vllm/transformers_utils/configs/__pycache__/ultravox.cpython-310.pyc,, +vllm/transformers_utils/configs/arctic.py,sha256=ifJ5ruBai3c7dyu597cTcJooj2QKzBpGx13f2VYO4no,8990 +vllm/transformers_utils/configs/chatglm.py,sha256=6H5Hv6Z_yziBZG9q4N_0Obj6eHsGL9DrxQeBhkLsZ9Y,2870 +vllm/transformers_utils/configs/cohere2.py,sha256=yeLdn79NO2kyuYH9IqRAO0WGbMJCh5ntd1jabtZaWJs,10353 +vllm/transformers_utils/configs/dbrx.py,sha256=d0xE5WH999Pxqp7v1MXJzmk10cwp0UMOOBADD8bO5rU,10957 +vllm/transformers_utils/configs/deepseek_vl2.py,sha256=QICTzlaoLil0UUXc0fwgl-CImEPpjOnTy1dAUweKLDw,7252 +vllm/transformers_utils/configs/eagle.py,sha256=SxhOrLUcBFHbqKbgjsCi5GQOv_ytGnkE4sIANYr801I,2191 +vllm/transformers_utils/configs/exaone.py,sha256=o82MCDMCtD8cHvrPzJroEpJV5e4xuVK3yzlHBq4IjvE,8883 +vllm/transformers_utils/configs/falcon.py,sha256=1w9gXJJPzvup7Hd05O1xYzp_IDXDdtxByt06U92uy7c,2917 +vllm/transformers_utils/configs/h2ovl.py,sha256=Tsyex8PgWS_WEuzgTZ9vGcgn7Pv1m0yJDs64Q2meT_Q,489 +vllm/transformers_utils/configs/internvl.py,sha256=hqm1INrEucyhhPKQhwRiwEZ6Ulw1gvnFIw1EISnE5QI,1867 +vllm/transformers_utils/configs/jais.py,sha256=VExjql0k4IoUHn9FmjpnmwlNDt0vOW4mlKkChLU5iL8,10363 +vllm/transformers_utils/configs/kimi_vl.py,sha256=IzdW_JZbZyuyhnnUa4ILY_G56TRbbFI56PsY9UIqsh4,1417 +vllm/transformers_utils/configs/medusa.py,sha256=2gSa-OtMNHi2eL_AJDgbslqb9ntcg9fRfhhgRPGoxr0,1943 +vllm/transformers_utils/configs/mllama.py,sha256=lIkiJ83huJQq7kLAV2hfLWAcUxWVT9aa1YAcSRUzz1Y,805 +vllm/transformers_utils/configs/mlp_speculator.py,sha256=MgeWpPARW5jwb8Nw1hnZaqJbdDdBOc_a_ESTeRy3O8g,2437 +vllm/transformers_utils/configs/moonvit.py,sha256=3UjfhLMqkqFcGfnZwu8oM5S11_jmSn1zzjnC-JfCRuQ,1203 +vllm/transformers_utils/configs/mpt.py,sha256=zLtFoXM4PKJK67mQoeBOwLQrT4wR-zdEMYAsGrHV108,7589 +vllm/transformers_utils/configs/nemotron.py,sha256=xw--8lmM5VzLM6Nfyha4vaeRvVYh5v3bjrAP_Z010nk,8974 +vllm/transformers_utils/configs/nvlm_d.py,sha256=2Mr9ZAI6VG0DbLDw0BnFEIgeiZd7ip3bSoVsfcEeNqQ,458 +vllm/transformers_utils/configs/skyworkr1v.py,sha256=Wg_ykY-bUNPdcJ_9KwpY2qfUhCvRfFdSBcCjjKUaJVM,1869 +vllm/transformers_utils/configs/solar.py,sha256=y5b9R4mQXdgi-fUv2ZqMIFouW7P57lT5nppn54aCOuo,10841 +vllm/transformers_utils/configs/telechat2.py,sha256=JsOuzKHPQHqtJBZNi27dtwc-FWelsQ9GlmORN2AubPE,2200 +vllm/transformers_utils/configs/ultravox.py,sha256=xjkeV_uyw_J5XI1dNysZjPGK_uqCiuLLkutkFQMQ1ss,4465 +vllm/transformers_utils/detokenizer.py,sha256=BIuRtDNEOaltof860UDWC3SOc95H4VGnBAB8iLlAFmA,7242 +vllm/transformers_utils/detokenizer_utils.py,sha256=UgzZeQN28OE-y4_VaSGCLryw07cSqM00wJsCs1Ic9YQ,7265 +vllm/transformers_utils/processor.py,sha256=zj16dQMvRA84X4Dn7dCZfnPFP-EcNP1AOuGU4dLM8Wk,7152 +vllm/transformers_utils/processors/__init__.py,sha256=WloJ524I5uG04zlyJVWoPtDGVzlRvWpVsuwcczjOM3o,165 +vllm/transformers_utils/processors/__pycache__/__init__.cpython-310.pyc,, +vllm/transformers_utils/processors/__pycache__/deepseek_vl2.cpython-310.pyc,, +vllm/transformers_utils/processors/deepseek_vl2.py,sha256=bCdlXRRXoiCMtV8eRxOuiL-6_wDHzUAD8sKurZeqYKM,14601 +vllm/transformers_utils/s3_utils.py,sha256=W1Pkv_vXDlm5thS1mPtaPxEYMuPUteHjyMzc_p1hgY4,4885 +vllm/transformers_utils/tokenizer.py,sha256=5HIzBALDZm2cMz8xTRWaVqxPF7YrvmyAr9QJ792CZFU,10437 +vllm/transformers_utils/tokenizer_base.py,sha256=ubDCoJEppRd8jMCFCiwAXjUp2AZyVezOyLOgTQohIyY,3861 +vllm/transformers_utils/tokenizer_group.py,sha256=1s24_MSQUE1qiebXjoiqXbA2m1xm7-3Ta44NzWJnBK4,4799 +vllm/transformers_utils/tokenizers/__init__.py,sha256=y-jPMUMSBejRx8frDMzFNBD_EBJGQ9gw41EL7s-yy2A,303 +vllm/transformers_utils/tokenizers/__pycache__/__init__.cpython-310.pyc,, +vllm/transformers_utils/tokenizers/__pycache__/mistral.cpython-310.pyc,, +vllm/transformers_utils/tokenizers/mistral.py,sha256=Jgqii7bUFhktqmNDNpakkvMQrOIVYYw82ftB_LsJpcE,18563 +vllm/transformers_utils/utils.py,sha256=qqwuNDdVLyQSMErmpsD5SI3McRGF2JUkGKgffncVwD0,2636 +vllm/triton_utils/__init__.py,sha256=YrkNi5zOb7oxykfHQEmAnAuwLJ6fjAz4nHHBQd7t-k8,116 +vllm/triton_utils/__pycache__/__init__.cpython-310.pyc,, +vllm/triton_utils/__pycache__/importing.cpython-310.pyc,, +vllm/triton_utils/importing.py,sha256=_LiSKQ-tG_DhCVFtFo7insrlbobG8_d71hE99c5zs9w,1632 +vllm/usage/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +vllm/usage/__pycache__/__init__.cpython-310.pyc,, +vllm/usage/__pycache__/usage_lib.cpython-310.pyc,, +vllm/usage/usage_lib.py,sha256=1SODVdJ_VB-ViFv_xRSYVpeKzxeZ7uboQ-32_Ifl_QY,8832 +vllm/utils.py,sha256=O-sWK3pQ-d8hHP6rzdDsQj0DOV7yMIFqf8PP_v_bR50,90469 +vllm/v1/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +vllm/v1/__pycache__/__init__.cpython-310.pyc,, +vllm/v1/__pycache__/kv_cache_interface.cpython-310.pyc,, +vllm/v1/__pycache__/outputs.cpython-310.pyc,, +vllm/v1/__pycache__/request.cpython-310.pyc,, +vllm/v1/__pycache__/serial_utils.cpython-310.pyc,, +vllm/v1/__pycache__/utils.cpython-310.pyc,, +vllm/v1/attention/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +vllm/v1/attention/__pycache__/__init__.cpython-310.pyc,, +vllm/v1/attention/backends/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +vllm/v1/attention/backends/__pycache__/__init__.cpython-310.pyc,, +vllm/v1/attention/backends/__pycache__/flash_attn.cpython-310.pyc,, +vllm/v1/attention/backends/__pycache__/flashinfer.cpython-310.pyc,, +vllm/v1/attention/backends/__pycache__/pallas.cpython-310.pyc,, +vllm/v1/attention/backends/__pycache__/triton_attn.cpython-310.pyc,, +vllm/v1/attention/backends/flash_attn.py,sha256=ij_Y7V7pWjvUjKA0PTOh8k-cOT89k_pn_PhHRnp0njA,33173 +vllm/v1/attention/backends/flashinfer.py,sha256=pYe1YvBLPSt44Mxwu1tiMyfZBu3w-tUQLwuTpAv-btk,26453 +vllm/v1/attention/backends/mla/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +vllm/v1/attention/backends/mla/__pycache__/__init__.cpython-310.pyc,, +vllm/v1/attention/backends/mla/__pycache__/common.cpython-310.pyc,, +vllm/v1/attention/backends/mla/__pycache__/flashmla.cpython-310.pyc,, +vllm/v1/attention/backends/mla/__pycache__/triton_mla.cpython-310.pyc,, +vllm/v1/attention/backends/mla/common.py,sha256=R1kP4ervM89OEL-4ogsiFT60xqDz1yUqgQ_6G6-0Xao,38448 +vllm/v1/attention/backends/mla/flashmla.py,sha256=ccdMmyevDPK20d-XSboFHz1JylvWiW1cPqp2y5ymMy4,5131 +vllm/v1/attention/backends/mla/triton_mla.py,sha256=4b-_WGFx2N7Iozw0Tzl9pcDUtIC6yb5sXviTKVyF9qA,4116 +vllm/v1/attention/backends/pallas.py,sha256=iItpOGwTam_4YQS5yWsXkhQONsu3C9GMQjasXnNP8vA,8011 +vllm/v1/attention/backends/triton_attn.py,sha256=iPOwnQFKK3hu2yj87rM86fyKrn27bBGvr29vHNGWlfw,7761 +vllm/v1/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +vllm/v1/core/__pycache__/__init__.cpython-310.pyc,, +vllm/v1/core/__pycache__/block_pool.cpython-310.pyc,, +vllm/v1/core/__pycache__/encoder_cache_manager.cpython-310.pyc,, +vllm/v1/core/__pycache__/kv_cache_manager.cpython-310.pyc,, +vllm/v1/core/__pycache__/kv_cache_utils.cpython-310.pyc,, +vllm/v1/core/__pycache__/specialized_manager.cpython-310.pyc,, +vllm/v1/core/block_pool.py,sha256=ZhhOyBFIkci_OIiMYCiRmK-wV658SLF8A42aWX_Ygig,11630 +vllm/v1/core/encoder_cache_manager.py,sha256=O4ODe4lL1PGZ6CrN4M_4phwrGitQiEXlsiX8Vp4i_Iw,5257 +vllm/v1/core/kv_cache_manager.py,sha256=s4LFWo93XndWF2KGr2TdUySI0KfOA13ooYsLE6dtqMA,16404 +vllm/v1/core/kv_cache_utils.py,sha256=mlFOVWFGr8_C_6xR8GeHpEm-brDmxONEwIM6H-LhrZo,28759 +vllm/v1/core/sched/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +vllm/v1/core/sched/__pycache__/__init__.cpython-310.pyc,, +vllm/v1/core/sched/__pycache__/interface.cpython-310.pyc,, +vllm/v1/core/sched/__pycache__/output.cpython-310.pyc,, +vllm/v1/core/sched/__pycache__/scheduler.cpython-310.pyc,, +vllm/v1/core/sched/__pycache__/utils.cpython-310.pyc,, +vllm/v1/core/sched/interface.py,sha256=oqqpwYsYrYlpilXKR9PmjO7j51PF0RKy6ztQfL2SgTY,5255 +vllm/v1/core/sched/output.py,sha256=xzmSlyOsxyBQ6r1MCA_wwWX_2egwP0JKDnxsgXsWx74,4438 +vllm/v1/core/sched/scheduler.py,sha256=GPNxfuBAqPm3AVnswq-KT1eiUl4cHI4YlH-ePQsHFqQ,38805 +vllm/v1/core/sched/utils.py,sha256=h5yxzYQEON09QhjJgDyOyAdBVWWNJEsTSv9Bx1G1rP0,813 +vllm/v1/core/specialized_manager.py,sha256=EQsFADKOKl6TiNj-OO00qTex0Uy8uo1dU00nAGLP-2c,6647 +vllm/v1/engine/__init__.py,sha256=ISLoPGzvbYuSbz8VazZMdI1xLmG7GcmN-jpb8Rm_JJU,5034 +vllm/v1/engine/__pycache__/__init__.cpython-310.pyc,, +vllm/v1/engine/__pycache__/async_llm.cpython-310.pyc,, +vllm/v1/engine/__pycache__/core.cpython-310.pyc,, +vllm/v1/engine/__pycache__/core_client.cpython-310.pyc,, +vllm/v1/engine/__pycache__/detokenizer.cpython-310.pyc,, +vllm/v1/engine/__pycache__/exceptions.cpython-310.pyc,, +vllm/v1/engine/__pycache__/llm_engine.cpython-310.pyc,, +vllm/v1/engine/__pycache__/logprobs.cpython-310.pyc,, +vllm/v1/engine/__pycache__/mm_input_cache.cpython-310.pyc,, +vllm/v1/engine/__pycache__/output_processor.cpython-310.pyc,, +vllm/v1/engine/__pycache__/parallel_sampling.cpython-310.pyc,, +vllm/v1/engine/__pycache__/processor.cpython-310.pyc,, +vllm/v1/engine/async_llm.py,sha256=6D-QW9h55OnIf7TORYqkU_MdBr3elFgiKCyiUdfFSnQ,20982 +vllm/v1/engine/core.py,sha256=wBsE5X3f9_JPlsFEzkQabazKZvb6zwuXFI-35oDyixg,29223 +vllm/v1/engine/core_client.py,sha256=Xm1iPhT8RXHj3bOO9E1LiMBSGHQIaruSV0PvwSmAKAU,36362 +vllm/v1/engine/detokenizer.py,sha256=IGnYsLBCx1KqvqnbXLM9p2ChCkKiT5j-vzFx4nv6OQs,9549 +vllm/v1/engine/exceptions.py,sha256=mxP2NWpoDgXiympaoPM1rhkEWEq2W76Q_wgTH7v6604,662 +vllm/v1/engine/llm_engine.py,sha256=9tmaD7YI1cGNkmwsfL8c35tFEaNFsRrFwo1HdM0hfFE,11185 +vllm/v1/engine/logprobs.py,sha256=xJ4mj9i3kXNEc_UbrZl_KwMV5eFtC463hkbVLG9R4gE,7059 +vllm/v1/engine/mm_input_cache.py,sha256=U_p50tRpmtW1lplYmF-NEYlQhoGn_8on1L8G7qBcmQg,2908 +vllm/v1/engine/output_processor.py,sha256=-w7t6ZQ9oPdiZnp8ucpwjf8gw7WmY_JO4FmH8rsIRus,15837 +vllm/v1/engine/parallel_sampling.py,sha256=OjBEE6zzWcY8jfgCiEOGaJfeM4M9-yeV2qWdxdRtLrU,4765 +vllm/v1/engine/processor.py,sha256=OTT-o-X73ATHFX7-OR28HG7c6ly-jWtwPpsw5VdH-Wo,16896 +vllm/v1/executor/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +vllm/v1/executor/__pycache__/__init__.cpython-310.pyc,, +vllm/v1/executor/__pycache__/abstract.cpython-310.pyc,, +vllm/v1/executor/__pycache__/multiproc_executor.cpython-310.pyc,, +vllm/v1/executor/__pycache__/ray_distributed_executor.cpython-310.pyc,, +vllm/v1/executor/abstract.py,sha256=RlosW-n6QNCT16VCB2PukDakpdyo318HQKBa3KrFzxI,4464 +vllm/v1/executor/multiproc_executor.py,sha256=c1zXL6iWuve5sesbCcJ1hRpQm5xErkcvS7YyOcZJwTs,18192 +vllm/v1/executor/ray_distributed_executor.py,sha256=IJYuJWHHkYUlAfGPrIeoMFnR0oaMYtZrJHv1hmIynBY,1992 +vllm/v1/kv_cache_interface.py,sha256=R80KroFDgFGltuXbzC6Qb5pB7H6sdPTqzIJPVeRsUZE,5557 +vllm/v1/metrics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +vllm/v1/metrics/__pycache__/__init__.cpython-310.pyc,, +vllm/v1/metrics/__pycache__/loggers.cpython-310.pyc,, +vllm/v1/metrics/__pycache__/stats.cpython-310.pyc,, +vllm/v1/metrics/loggers.py,sha256=_5N7YLBtflloVdZSnFB14sKx7pQ7ZzAV62p4txWJLkI,20299 +vllm/v1/metrics/stats.py,sha256=3naKGjAi9lk9Grrk1ygFUedqTxjk2A2HSfYIisqi1xs,9386 +vllm/v1/outputs.py,sha256=ST8Y30Mrf2ZnTM_JyEvHM4psWabNpxSufxI9zlnfSvs,3257 +vllm/v1/request.py,sha256=e0bPhOLjyIT-YItNO7_LJD04h5UARoPQor253ybgEik,6610 +vllm/v1/sample/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +vllm/v1/sample/__pycache__/__init__.cpython-310.pyc,, +vllm/v1/sample/__pycache__/metadata.cpython-310.pyc,, +vllm/v1/sample/__pycache__/rejection_sampler.cpython-310.pyc,, +vllm/v1/sample/__pycache__/sampler.cpython-310.pyc,, +vllm/v1/sample/metadata.py,sha256=94neEjn1GPZehdsaQ8zoz2Qzl3btezcSnVUUuKHnvTI,1094 +vllm/v1/sample/ops/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +vllm/v1/sample/ops/__pycache__/__init__.cpython-310.pyc,, +vllm/v1/sample/ops/__pycache__/bad_words.cpython-310.pyc,, +vllm/v1/sample/ops/__pycache__/penalties.cpython-310.pyc,, +vllm/v1/sample/ops/__pycache__/topk_topp_sampler.cpython-310.pyc,, +vllm/v1/sample/ops/bad_words.py,sha256=_Q9GFppyv3mOstR_3-hKVUOaq12uuHR-xUdkcFAP5Ng,1122 +vllm/v1/sample/ops/penalties.py,sha256=3W-rVWsNwuDnouIRyaqZW3HtnWyXc9Jlz_Eq_xx5mtA,2149 +vllm/v1/sample/ops/topk_topp_sampler.py,sha256=7t32UApYjnPccmtXpGRrb0uCdj8DEaAXr0WXns-RxW4,12227 +vllm/v1/sample/rejection_sampler.py,sha256=vVuw8o5AZ9YFZk0bVh_p0njQ1oG8naoz-KyKqjC59GI,22915 +vllm/v1/sample/sampler.py,sha256=nRwExvRK26q7ljiMoHZnkTUabIT6lWcr5woRFkmJcrE,10245 +vllm/v1/sample/tpu/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +vllm/v1/sample/tpu/__pycache__/__init__.cpython-310.pyc,, +vllm/v1/sample/tpu/__pycache__/metadata.cpython-310.pyc,, +vllm/v1/sample/tpu/__pycache__/sampler.cpython-310.pyc,, +vllm/v1/sample/tpu/metadata.py,sha256=p_qm2ZhbI7FqjDvTCVFag8r8deZsBrn9sZZWZ1oGKHY,4286 +vllm/v1/sample/tpu/sampler.py,sha256=b1YZCNM44SqidDMiKEESox0QkgmqW8Cb8tsUIidDawY,5472 +vllm/v1/serial_utils.py,sha256=AP1SR35HCNAMeWzTHRQ-0QIbcESdF1wnBxXJX24B75g,11569 +vllm/v1/spec_decode/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +vllm/v1/spec_decode/__pycache__/__init__.cpython-310.pyc,, +vllm/v1/spec_decode/__pycache__/eagle.cpython-310.pyc,, +vllm/v1/spec_decode/__pycache__/metadata.cpython-310.pyc,, +vllm/v1/spec_decode/__pycache__/metrics.cpython-310.pyc,, +vllm/v1/spec_decode/__pycache__/ngram_proposer.cpython-310.pyc,, +vllm/v1/spec_decode/__pycache__/utils.cpython-310.pyc,, +vllm/v1/spec_decode/eagle.py,sha256=YBjH7jWdzd6Q2CKMZHppRFNKWZviTXvuuvyIxN19td0,13481 +vllm/v1/spec_decode/metadata.py,sha256=E5jGcv8qd1LzIB35ijGHpgTquQDJsrfTzzvUBT9Ba1A,2188 +vllm/v1/spec_decode/metrics.py,sha256=VP-VTiQD1iA9NhAHakwK2pJIWEDOniUYBTwkwW8RHdc,6451 +vllm/v1/spec_decode/ngram_proposer.py,sha256=OlsaNfDwu0FYzgo0MZBBy253IR6IDXhkeEIpnolwmmQ,4224 +vllm/v1/spec_decode/utils.py,sha256=ysp1hU55Mp8VpzjLSgvMeTzmCxUddKb84PiPv4igM5Y,666 +vllm/v1/stats/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +vllm/v1/stats/__pycache__/__init__.cpython-310.pyc,, +vllm/v1/stats/__pycache__/common.cpython-310.pyc,, +vllm/v1/stats/common.py,sha256=PNWYkSP8dxUXuDNHON1f0PaLU03bWU9otB8j4kQ0YuI,17226 +vllm/v1/structured_output/__init__.py,sha256=DAccbNg12evGVBg7B8o2xuLMxgr7lJHaPvhZEbPPQj0,4725 +vllm/v1/structured_output/__pycache__/__init__.cpython-310.pyc,, +vllm/v1/structured_output/__pycache__/backend_guidance.cpython-310.pyc,, +vllm/v1/structured_output/__pycache__/backend_types.cpython-310.pyc,, +vllm/v1/structured_output/__pycache__/backend_xgrammar.cpython-310.pyc,, +vllm/v1/structured_output/__pycache__/request.cpython-310.pyc,, +vllm/v1/structured_output/__pycache__/utils.cpython-310.pyc,, +vllm/v1/structured_output/backend_guidance.py,sha256=eLJayula4vgnIRs1oBcrc1Kp42r2uOSFT2CZIl51ZeA,7986 +vllm/v1/structured_output/backend_types.py,sha256=HQ62R06dbQwO_kI4Ueix6dbVu6WkzWo8lKqzryogxN4,2646 +vllm/v1/structured_output/backend_xgrammar.py,sha256=-nLSP19LygHc7J11QHKuz9TFsJC8BQ2ohk1Ny0qx8XI,11762 +vllm/v1/structured_output/request.py,sha256=ZZyzhtm73unguoSp4aFgqBiLCwnHuHSwPPgB8kD_Klw,3108 +vllm/v1/structured_output/utils.py,sha256=vgIMRJcubDnh6nRGmIDzCkLEGpg-qdL_hSQumlv0m_Q,5788 +vllm/v1/utils.py,sha256=t6_KMCZ8R-iU26FfB4U9AL8JUH_6SIgJ40T60RXfj8Q,7866 +vllm/v1/worker/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +vllm/v1/worker/__pycache__/__init__.cpython-310.pyc,, +vllm/v1/worker/__pycache__/block_table.cpython-310.pyc,, +vllm/v1/worker/__pycache__/gpu_input_batch.cpython-310.pyc,, +vllm/v1/worker/__pycache__/gpu_model_runner.cpython-310.pyc,, +vllm/v1/worker/__pycache__/gpu_worker.cpython-310.pyc,, +vllm/v1/worker/__pycache__/lora_model_runner_mixin.cpython-310.pyc,, +vllm/v1/worker/__pycache__/tpu_model_runner.cpython-310.pyc,, +vllm/v1/worker/__pycache__/tpu_worker.cpython-310.pyc,, +vllm/v1/worker/__pycache__/utils.cpython-310.pyc,, +vllm/v1/worker/__pycache__/worker_base.cpython-310.pyc,, +vllm/v1/worker/block_table.py,sha256=hOeaO0wpiCxrpQMyTrYmWHgIjMsjJizxXTYdrjC-HbA,2804 +vllm/v1/worker/gpu_input_batch.py,sha256=2pURhfl7rUgMU6FhoMAdAB9ySPmAoAyXtf6HNOApOww,29697 +vllm/v1/worker/gpu_model_runner.py,sha256=zKSV1NhrzDib0hZ0BNB22VxNS27Ec-tFAS5D6_zJpBo,83083 +vllm/v1/worker/gpu_worker.py,sha256=KDHgJ7ZdINcmauFQl_3tLHGiV2bcf8v2cQUBx4e6eLo,14379 +vllm/v1/worker/lora_model_runner_mixin.py,sha256=w3_2YfgEHuTOCQU69F3WSNG4EpxaJZxC_ZakGGmAKC8,5781 +vllm/v1/worker/tpu_model_runner.py,sha256=RbT3vfLACFQkJxKFv6Zkz30PrO8eBowWYeH7uNa-hWo,66278 +vllm/v1/worker/tpu_worker.py,sha256=U_uNV9Vh7_bbeeXolIPJMqvMmMQfyFNoQ8iWQmi0b5g,11034 +vllm/v1/worker/utils.py,sha256=Is726LIfgtRsHmyl6HBH8Ip2zsjAlnA1gVlvyoUZuvY,2522 +vllm/v1/worker/worker_base.py,sha256=y8BsJDgREwPB8DH8dynVIDfykYydbUzcrSTHLSMqMUU,1976 +vllm/version.py,sha256=FOUZzkwMR0KzHLv4gr6R25HwulikpB9H8Vver3VX8sE,1306 +vllm/vllm_flash_attn/.gitkeep,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +vllm/vllm_flash_attn/__init__.py,sha256=jR7coJozHJu5SR8r8SunXO2TGBqzD9iMKpS7TqAsmPo,337 +vllm/vllm_flash_attn/__pycache__/__init__.cpython-310.pyc,, +vllm/vllm_flash_attn/__pycache__/flash_attn_interface.cpython-310.pyc,, +vllm/vllm_flash_attn/_vllm_fa2_C.abi3.so,sha256=0WGDXBUZMTWavHKw-zgzZd0pE0bKPPk6rupifIsXh94,220229856 +vllm/vllm_flash_attn/_vllm_fa3_C.abi3.so,sha256=7_knqqfs8ZAwMy7obBwJrlKGZfiRyXONLI3T0dib9cI,473934800 +vllm/vllm_flash_attn/flash_attn_interface.py,sha256=E-0dIwEHpBOzO65s_hWA0vQolt-VlVdfpDCod2dQHAw,26570 +vllm/vllm_flash_attn/layers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +vllm/vllm_flash_attn/layers/__pycache__/__init__.cpython-310.pyc,, +vllm/vllm_flash_attn/layers/__pycache__/rotary.cpython-310.pyc,, +vllm/vllm_flash_attn/layers/rotary.py,sha256=YZCjFSrplDVLt5tj5QntriangVCYqZzhP4BSdpc5rK4,21445 +vllm/vllm_flash_attn/ops/triton/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1 +vllm/vllm_flash_attn/ops/triton/__pycache__/__init__.cpython-310.pyc,, +vllm/vllm_flash_attn/ops/triton/__pycache__/rotary.cpython-310.pyc,, +vllm/vllm_flash_attn/ops/triton/rotary.py,sha256=8fS_mgsozFRPqIK2BijXS4kj6LR-H4Q4p69D-ntQYeQ,8737 +vllm/worker/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +vllm/worker/__pycache__/__init__.cpython-310.pyc,, +vllm/worker/__pycache__/cache_engine.cpython-310.pyc,, +vllm/worker/__pycache__/cpu_enc_dec_model_runner.cpython-310.pyc,, +vllm/worker/__pycache__/cpu_model_runner.cpython-310.pyc,, +vllm/worker/__pycache__/cpu_pooling_model_runner.cpython-310.pyc,, +vllm/worker/__pycache__/cpu_worker.cpython-310.pyc,, +vllm/worker/__pycache__/enc_dec_model_runner.cpython-310.pyc,, +vllm/worker/__pycache__/hpu_model_runner.cpython-310.pyc,, +vllm/worker/__pycache__/hpu_worker.cpython-310.pyc,, +vllm/worker/__pycache__/model_runner.cpython-310.pyc,, +vllm/worker/__pycache__/model_runner_base.cpython-310.pyc,, +vllm/worker/__pycache__/multi_step_hpu_worker.cpython-310.pyc,, +vllm/worker/__pycache__/multi_step_model_runner.cpython-310.pyc,, +vllm/worker/__pycache__/multi_step_tpu_worker.cpython-310.pyc,, +vllm/worker/__pycache__/multi_step_worker.cpython-310.pyc,, +vllm/worker/__pycache__/neuron_model_runner.cpython-310.pyc,, +vllm/worker/__pycache__/neuron_worker.cpython-310.pyc,, +vllm/worker/__pycache__/pooling_model_runner.cpython-310.pyc,, +vllm/worker/__pycache__/tpu_model_runner.cpython-310.pyc,, +vllm/worker/__pycache__/tpu_worker.cpython-310.pyc,, +vllm/worker/__pycache__/utils.cpython-310.pyc,, +vllm/worker/__pycache__/worker.cpython-310.pyc,, +vllm/worker/__pycache__/worker_base.cpython-310.pyc,, +vllm/worker/__pycache__/xpu_model_runner.cpython-310.pyc,, +vllm/worker/__pycache__/xpu_worker.cpython-310.pyc,, +vllm/worker/cache_engine.py,sha256=iR6mNFDgBUsGYqx7kBKpQB1UQsv7e-AgsB63OCYFGIQ,6006 +vllm/worker/cpu_enc_dec_model_runner.py,sha256=rXO1k-uUFlN1Rahl5ql-u8m_CgWqDSEcyJnOjcBBwmg,13014 +vllm/worker/cpu_model_runner.py,sha256=SHWy8uF-KR0bEELUGiSEy-rd5JTg7SLWQADdVUrzXsY,28276 +vllm/worker/cpu_pooling_model_runner.py,sha256=VJYQ_9wQ3roxiCETjclnUZaVQVKgEx4VTpCFm0o_Hag,4755 +vllm/worker/cpu_worker.py,sha256=b3S2jYAtr1XIy52IzM2bI9GLVdylH5bx7x-76br18oQ,16024 +vllm/worker/enc_dec_model_runner.py,sha256=G-QDKfWbT7rek6Yq_WwC3SenIlQfl_218L1IzN5vSmk,23517 +vllm/worker/hpu_model_runner.py,sha256=LPG2T6-fd2Z2w-isTeZMfIOsHhyIU_B55tajpGY8QQw,100237 +vllm/worker/hpu_worker.py,sha256=GO7xz8RVIN3qEdD5n0IYr-qn2G7NGjXe_0ZC0RBUWn0,21583 +vllm/worker/model_runner.py,sha256=RHGkj7qFBeiPI9_AHXRrCwI5yGeSHF_8MRWnzPStK0w,91952 +vllm/worker/model_runner_base.py,sha256=c76vGfi0-uqdIf-B2A0dU3HrAGd1FQmR6p9f8JVE8Oc,9370 +vllm/worker/multi_step_hpu_worker.py,sha256=3GKiJPMq_dJ0qrV8PidC3yGqvQW0z9iIMD3A02KFkLo,5296 +vllm/worker/multi_step_model_runner.py,sha256=z9ZBVJyzYwulftu6lEzbMTAOTval4m7_cPoW5wkeNPE,39186 +vllm/worker/multi_step_tpu_worker.py,sha256=c6A1A6Aagis6VyskYP6jP35Mt5paZwDV2jn750Sn5LA,4450 +vllm/worker/multi_step_worker.py,sha256=90a_O9w3bmGHjs5rGVsNEbYzMMhNVZSqLLyOVAHCxk0,9416 +vllm/worker/neuron_model_runner.py,sha256=87SwSDhX29FKfoXDlewdKdbweJ_9zPI--rsJ_-ScW68,14326 +vllm/worker/neuron_worker.py,sha256=y-YJYeZmP3g-SnzsFmnFBlRNS0Zwin8ZT_gHStNkC8k,4991 +vllm/worker/pooling_model_runner.py,sha256=l516VFqfsBcjgEsy7C7NMMi_-aV01sDWoEhxHHmszqw,8738 +vllm/worker/tpu_model_runner.py,sha256=3SBLtvsqmpBXzIujoQu--IHHfbvfkrluFQaz4aUrzv0,40781 +vllm/worker/tpu_worker.py,sha256=jZAQpPE0VYxLne4ILNnVBLNP8ItcBNvIIX-VjPGYbE0,14637 +vllm/worker/utils.py,sha256=qDJF2qtK6Pyfa6JV_ZTpIUDYl-rwn3imoshuS7yXr_A,1918 +vllm/worker/worker.py,sha256=Il_KV4ICfkq1tPc1H-8ZZQ4d5GIuWBhCv8X6xjWCr1s,25282 +vllm/worker/worker_base.py,sha256=GhIywLGVRO48Nb9-CxIXnMbvt8CrJayFkxZ7AAHnmu0,26064 +vllm/worker/xpu_model_runner.py,sha256=xUbVAClSAiYlWfJf6Kg313yR6I6PFMcJrPcBzZkT9Dg,24495 +vllm/worker/xpu_worker.py,sha256=4aLv0VO2Z8J5_QNKoUzm1dsn5Tr3K2nLOSgRxkUb1F4,7929 diff --git a/venv/lib/python3.10/site-packages/vllm-0.8.5.dist-info/REQUESTED b/venv/lib/python3.10/site-packages/vllm-0.8.5.dist-info/REQUESTED new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/venv/lib/python3.10/site-packages/vllm-0.8.5.dist-info/WHEEL b/venv/lib/python3.10/site-packages/vllm-0.8.5.dist-info/WHEEL new file mode 100644 index 0000000000000000000000000000000000000000..961f76912c141e93b4fd53fda856e9ed8f55b629 --- /dev/null +++ b/venv/lib/python3.10/site-packages/vllm-0.8.5.dist-info/WHEEL @@ -0,0 +1,5 @@ +Wheel-Version: 1.0 +Generator: setuptools (80.0.0) +Root-Is-Purelib: false +Tag: cp38-abi3-linux_x86_64 + diff --git a/venv/lib/python3.10/site-packages/vllm-0.8.5.dist-info/entry_points.txt b/venv/lib/python3.10/site-packages/vllm-0.8.5.dist-info/entry_points.txt new file mode 100644 index 0000000000000000000000000000000000000000..9cdba3371c6fb818afb0c7c2d16dc61f828c9ce6 --- /dev/null +++ b/venv/lib/python3.10/site-packages/vllm-0.8.5.dist-info/entry_points.txt @@ -0,0 +1,2 @@ +[console_scripts] +vllm = vllm.entrypoints.cli.main:main diff --git a/venv/lib/python3.10/site-packages/vllm-0.8.5.dist-info/licenses/LICENSE b/venv/lib/python3.10/site-packages/vllm-0.8.5.dist-info/licenses/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64 --- /dev/null +++ b/venv/lib/python3.10/site-packages/vllm-0.8.5.dist-info/licenses/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/venv/lib/python3.10/site-packages/vllm-0.8.5.dist-info/top_level.txt b/venv/lib/python3.10/site-packages/vllm-0.8.5.dist-info/top_level.txt new file mode 100644 index 0000000000000000000000000000000000000000..e7a6c7781dce0db526824db3fe81e3675526d398 --- /dev/null +++ b/venv/lib/python3.10/site-packages/vllm-0.8.5.dist-info/top_level.txt @@ -0,0 +1 @@ +vllm diff --git a/venv/lib/python3.10/site-packages/wheel/__init__.py b/venv/lib/python3.10/site-packages/wheel/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..3ab8f72d8b2e31b1cb8456ee1c4b8e62d4aba252 --- /dev/null +++ b/venv/lib/python3.10/site-packages/wheel/__init__.py @@ -0,0 +1,3 @@ +from __future__ import annotations + +__version__ = "0.45.1" diff --git a/venv/lib/python3.10/site-packages/wheel/__main__.py b/venv/lib/python3.10/site-packages/wheel/__main__.py new file mode 100644 index 0000000000000000000000000000000000000000..0be74537494dc2cf18c2e3b318ffd22b886aef6b --- /dev/null +++ b/venv/lib/python3.10/site-packages/wheel/__main__.py @@ -0,0 +1,23 @@ +""" +Wheel command line tool (enable python -m wheel syntax) +""" + +from __future__ import annotations + +import sys + + +def main(): # needed for console script + if __package__ == "": + # To be able to run 'python wheel-0.9.whl/wheel': + import os.path + + path = os.path.dirname(os.path.dirname(__file__)) + sys.path[0:0] = [path] + import wheel.cli + + sys.exit(wheel.cli.main()) + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/venv/lib/python3.10/site-packages/wheel/__pycache__/__init__.cpython-310.pyc b/venv/lib/python3.10/site-packages/wheel/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0b01d4d8d8f214b8c64074746fa36b3a699b9091 Binary files /dev/null and b/venv/lib/python3.10/site-packages/wheel/__pycache__/__init__.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/wheel/__pycache__/__main__.cpython-310.pyc b/venv/lib/python3.10/site-packages/wheel/__pycache__/__main__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0ccb19fb4d4756f1448f66ef33c66fc78b87586d Binary files /dev/null and b/venv/lib/python3.10/site-packages/wheel/__pycache__/__main__.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/wheel/__pycache__/_bdist_wheel.cpython-310.pyc b/venv/lib/python3.10/site-packages/wheel/__pycache__/_bdist_wheel.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9aacb65731749bdbdf54f7769737ac82e0c74992 Binary files /dev/null and b/venv/lib/python3.10/site-packages/wheel/__pycache__/_bdist_wheel.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/wheel/__pycache__/_setuptools_logging.cpython-310.pyc b/venv/lib/python3.10/site-packages/wheel/__pycache__/_setuptools_logging.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d9c145c9311b65acffb370a5fc0016231de5e52e Binary files /dev/null and b/venv/lib/python3.10/site-packages/wheel/__pycache__/_setuptools_logging.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/wheel/__pycache__/bdist_wheel.cpython-310.pyc b/venv/lib/python3.10/site-packages/wheel/__pycache__/bdist_wheel.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ec8026579dda26c5aeb8d5f4310b2318c3caaa81 Binary files /dev/null and b/venv/lib/python3.10/site-packages/wheel/__pycache__/bdist_wheel.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/wheel/__pycache__/macosx_libfile.cpython-310.pyc b/venv/lib/python3.10/site-packages/wheel/__pycache__/macosx_libfile.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..374d7edbacef09d2a7d57d2c40d0a83f31253618 Binary files /dev/null and b/venv/lib/python3.10/site-packages/wheel/__pycache__/macosx_libfile.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/wheel/__pycache__/metadata.cpython-310.pyc b/venv/lib/python3.10/site-packages/wheel/__pycache__/metadata.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b5cb33af60b699a579ae76cc65f435b9d778b38c Binary files /dev/null and b/venv/lib/python3.10/site-packages/wheel/__pycache__/metadata.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/wheel/__pycache__/util.cpython-310.pyc b/venv/lib/python3.10/site-packages/wheel/__pycache__/util.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1289784edbd665a55d3820516c8d301896441575 Binary files /dev/null and b/venv/lib/python3.10/site-packages/wheel/__pycache__/util.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/wheel/__pycache__/wheelfile.cpython-310.pyc b/venv/lib/python3.10/site-packages/wheel/__pycache__/wheelfile.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..af8a771b5b7ef71c2859724048c8d2e8570f4b58 Binary files /dev/null and b/venv/lib/python3.10/site-packages/wheel/__pycache__/wheelfile.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/wheel/_bdist_wheel.py b/venv/lib/python3.10/site-packages/wheel/_bdist_wheel.py new file mode 100644 index 0000000000000000000000000000000000000000..88973ebfb88f9521e5f0613b5cedf1204d10a8f1 --- /dev/null +++ b/venv/lib/python3.10/site-packages/wheel/_bdist_wheel.py @@ -0,0 +1,613 @@ +""" +Create a wheel (.whl) distribution. + +A wheel is a built archive format. +""" + +from __future__ import annotations + +import os +import re +import shutil +import stat +import struct +import sys +import sysconfig +import warnings +from email.generator import BytesGenerator, Generator +from email.policy import EmailPolicy +from glob import iglob +from shutil import rmtree +from typing import TYPE_CHECKING, Callable, Iterable, Literal, Sequence, cast +from zipfile import ZIP_DEFLATED, ZIP_STORED + +import setuptools +from setuptools import Command + +from . import __version__ as wheel_version +from .metadata import pkginfo_to_metadata +from .util import log +from .vendored.packaging import tags +from .vendored.packaging import version as _packaging_version +from .wheelfile import WheelFile + +if TYPE_CHECKING: + import types + +# ensure Python logging is configured +try: + __import__("setuptools.logging") +except ImportError: + # setuptools < ?? + from . import _setuptools_logging + + _setuptools_logging.configure() + + +def safe_name(name: str) -> str: + """Convert an arbitrary string to a standard distribution name + Any runs of non-alphanumeric/. characters are replaced with a single '-'. + """ + return re.sub("[^A-Za-z0-9.]+", "-", name) + + +def safe_version(version: str) -> str: + """ + Convert an arbitrary string to a standard version string + """ + try: + # normalize the version + return str(_packaging_version.Version(version)) + except _packaging_version.InvalidVersion: + version = version.replace(" ", ".") + return re.sub("[^A-Za-z0-9.]+", "-", version) + + +setuptools_major_version = int(setuptools.__version__.split(".")[0]) + +PY_LIMITED_API_PATTERN = r"cp3\d" + + +def _is_32bit_interpreter() -> bool: + return struct.calcsize("P") == 4 + + +def python_tag() -> str: + return f"py{sys.version_info[0]}" + + +def get_platform(archive_root: str | None) -> str: + """Return our platform name 'win32', 'linux_x86_64'""" + result = sysconfig.get_platform() + if result.startswith("macosx") and archive_root is not None: + from .macosx_libfile import calculate_macosx_platform_tag + + result = calculate_macosx_platform_tag(archive_root, result) + elif _is_32bit_interpreter(): + if result == "linux-x86_64": + # pip pull request #3497 + result = "linux-i686" + elif result == "linux-aarch64": + # packaging pull request #234 + # TODO armv8l, packaging pull request #690 => this did not land + # in pip/packaging yet + result = "linux-armv7l" + + return result.replace("-", "_") + + +def get_flag( + var: str, fallback: bool, expected: bool = True, warn: bool = True +) -> bool: + """Use a fallback value for determining SOABI flags if the needed config + var is unset or unavailable.""" + val = sysconfig.get_config_var(var) + if val is None: + if warn: + warnings.warn( + f"Config variable '{var}' is unset, Python ABI tag may be incorrect", + RuntimeWarning, + stacklevel=2, + ) + return fallback + return val == expected + + +def get_abi_tag() -> str | None: + """Return the ABI tag based on SOABI (if available) or emulate SOABI (PyPy2).""" + soabi: str = sysconfig.get_config_var("SOABI") + impl = tags.interpreter_name() + if not soabi and impl in ("cp", "pp") and hasattr(sys, "maxunicode"): + d = "" + m = "" + u = "" + if get_flag("Py_DEBUG", hasattr(sys, "gettotalrefcount"), warn=(impl == "cp")): + d = "d" + + if get_flag( + "WITH_PYMALLOC", + impl == "cp", + warn=(impl == "cp" and sys.version_info < (3, 8)), + ) and sys.version_info < (3, 8): + m = "m" + + abi = f"{impl}{tags.interpreter_version()}{d}{m}{u}" + elif soabi and impl == "cp" and soabi.startswith("cpython"): + # non-Windows + abi = "cp" + soabi.split("-")[1] + elif soabi and impl == "cp" and soabi.startswith("cp"): + # Windows + abi = soabi.split("-")[0] + elif soabi and impl == "pp": + # we want something like pypy36-pp73 + abi = "-".join(soabi.split("-")[:2]) + abi = abi.replace(".", "_").replace("-", "_") + elif soabi and impl == "graalpy": + abi = "-".join(soabi.split("-")[:3]) + abi = abi.replace(".", "_").replace("-", "_") + elif soabi: + abi = soabi.replace(".", "_").replace("-", "_") + else: + abi = None + + return abi + + +def safer_name(name: str) -> str: + return safe_name(name).replace("-", "_") + + +def safer_version(version: str) -> str: + return safe_version(version).replace("-", "_") + + +def remove_readonly( + func: Callable[..., object], + path: str, + excinfo: tuple[type[Exception], Exception, types.TracebackType], +) -> None: + remove_readonly_exc(func, path, excinfo[1]) + + +def remove_readonly_exc(func: Callable[..., object], path: str, exc: Exception) -> None: + os.chmod(path, stat.S_IWRITE) + func(path) + + +class bdist_wheel(Command): + description = "create a wheel distribution" + + supported_compressions = { + "stored": ZIP_STORED, + "deflated": ZIP_DEFLATED, + } + + user_options = [ + ("bdist-dir=", "b", "temporary directory for creating the distribution"), + ( + "plat-name=", + "p", + "platform name to embed in generated filenames " + f"(default: {get_platform(None)})", + ), + ( + "keep-temp", + "k", + "keep the pseudo-installation tree around after " + "creating the distribution archive", + ), + ("dist-dir=", "d", "directory to put final built distributions in"), + ("skip-build", None, "skip rebuilding everything (for testing/debugging)"), + ( + "relative", + None, + "build the archive using relative paths (default: false)", + ), + ( + "owner=", + "u", + "Owner name used when creating a tar file [default: current user]", + ), + ( + "group=", + "g", + "Group name used when creating a tar file [default: current group]", + ), + ("universal", None, "make a universal wheel (default: false)"), + ( + "compression=", + None, + "zipfile compression (one of: {}) (default: 'deflated')".format( + ", ".join(supported_compressions) + ), + ), + ( + "python-tag=", + None, + f"Python implementation compatibility tag (default: '{python_tag()}')", + ), + ( + "build-number=", + None, + "Build number for this particular version. " + "As specified in PEP-0427, this must start with a digit. " + "[default: None]", + ), + ( + "py-limited-api=", + None, + "Python tag (cp32|cp33|cpNN) for abi3 wheel tag (default: false)", + ), + ] + + boolean_options = ["keep-temp", "skip-build", "relative", "universal"] + + def initialize_options(self): + self.bdist_dir: str = None + self.data_dir = None + self.plat_name: str | None = None + self.plat_tag = None + self.format = "zip" + self.keep_temp = False + self.dist_dir: str | None = None + self.egginfo_dir = None + self.root_is_pure: bool | None = None + self.skip_build = None + self.relative = False + self.owner = None + self.group = None + self.universal: bool = False + self.compression: str | int = "deflated" + self.python_tag: str = python_tag() + self.build_number: str | None = None + self.py_limited_api: str | Literal[False] = False + self.plat_name_supplied = False + + def finalize_options(self): + if self.bdist_dir is None: + bdist_base = self.get_finalized_command("bdist").bdist_base + self.bdist_dir = os.path.join(bdist_base, "wheel") + + egg_info = self.distribution.get_command_obj("egg_info") + egg_info.ensure_finalized() # needed for correct `wheel_dist_name` + + self.data_dir = self.wheel_dist_name + ".data" + self.plat_name_supplied = self.plat_name is not None + + try: + self.compression = self.supported_compressions[self.compression] + except KeyError: + raise ValueError(f"Unsupported compression: {self.compression}") from None + + need_options = ("dist_dir", "plat_name", "skip_build") + + self.set_undefined_options("bdist", *zip(need_options, need_options)) + + self.root_is_pure = not ( + self.distribution.has_ext_modules() or self.distribution.has_c_libraries() + ) + + if self.py_limited_api and not re.match( + PY_LIMITED_API_PATTERN, self.py_limited_api + ): + raise ValueError(f"py-limited-api must match '{PY_LIMITED_API_PATTERN}'") + + # Support legacy [wheel] section for setting universal + wheel = self.distribution.get_option_dict("wheel") + if "universal" in wheel: + # please don't define this in your global configs + log.warning( + "The [wheel] section is deprecated. Use [bdist_wheel] instead.", + ) + val = wheel["universal"][1].strip() + if val.lower() in ("1", "true", "yes"): + self.universal = True + + if self.build_number is not None and not self.build_number[:1].isdigit(): + raise ValueError("Build tag (build-number) must start with a digit.") + + @property + def wheel_dist_name(self): + """Return distribution full name with - replaced with _""" + components = ( + safer_name(self.distribution.get_name()), + safer_version(self.distribution.get_version()), + ) + if self.build_number: + components += (self.build_number,) + return "-".join(components) + + def get_tag(self) -> tuple[str, str, str]: + # bdist sets self.plat_name if unset, we should only use it for purepy + # wheels if the user supplied it. + if self.plat_name_supplied: + plat_name = cast(str, self.plat_name) + elif self.root_is_pure: + plat_name = "any" + else: + # macosx contains system version in platform name so need special handle + if self.plat_name and not self.plat_name.startswith("macosx"): + plat_name = self.plat_name + else: + # on macosx always limit the platform name to comply with any + # c-extension modules in bdist_dir, since the user can specify + # a higher MACOSX_DEPLOYMENT_TARGET via tools like CMake + + # on other platforms, and on macosx if there are no c-extension + # modules, use the default platform name. + plat_name = get_platform(self.bdist_dir) + + if _is_32bit_interpreter(): + if plat_name in ("linux-x86_64", "linux_x86_64"): + plat_name = "linux_i686" + if plat_name in ("linux-aarch64", "linux_aarch64"): + # TODO armv8l, packaging pull request #690 => this did not land + # in pip/packaging yet + plat_name = "linux_armv7l" + + plat_name = ( + plat_name.lower().replace("-", "_").replace(".", "_").replace(" ", "_") + ) + + if self.root_is_pure: + if self.universal: + impl = "py2.py3" + else: + impl = self.python_tag + tag = (impl, "none", plat_name) + else: + impl_name = tags.interpreter_name() + impl_ver = tags.interpreter_version() + impl = impl_name + impl_ver + # We don't work on CPython 3.1, 3.0. + if self.py_limited_api and (impl_name + impl_ver).startswith("cp3"): + impl = self.py_limited_api + abi_tag = "abi3" + else: + abi_tag = str(get_abi_tag()).lower() + tag = (impl, abi_tag, plat_name) + # issue gh-374: allow overriding plat_name + supported_tags = [ + (t.interpreter, t.abi, plat_name) for t in tags.sys_tags() + ] + assert ( + tag in supported_tags + ), f"would build wheel with unsupported tag {tag}" + return tag + + def run(self): + build_scripts = self.reinitialize_command("build_scripts") + build_scripts.executable = "python" + build_scripts.force = True + + build_ext = self.reinitialize_command("build_ext") + build_ext.inplace = False + + if not self.skip_build: + self.run_command("build") + + install = self.reinitialize_command("install", reinit_subcommands=True) + install.root = self.bdist_dir + install.compile = False + install.skip_build = self.skip_build + install.warn_dir = False + + # A wheel without setuptools scripts is more cross-platform. + # Use the (undocumented) `no_ep` option to setuptools' + # install_scripts command to avoid creating entry point scripts. + install_scripts = self.reinitialize_command("install_scripts") + install_scripts.no_ep = True + + # Use a custom scheme for the archive, because we have to decide + # at installation time which scheme to use. + for key in ("headers", "scripts", "data", "purelib", "platlib"): + setattr(install, "install_" + key, os.path.join(self.data_dir, key)) + + basedir_observed = "" + + if os.name == "nt": + # win32 barfs if any of these are ''; could be '.'? + # (distutils.command.install:change_roots bug) + basedir_observed = os.path.normpath(os.path.join(self.data_dir, "..")) + self.install_libbase = self.install_lib = basedir_observed + + setattr( + install, + "install_purelib" if self.root_is_pure else "install_platlib", + basedir_observed, + ) + + log.info(f"installing to {self.bdist_dir}") + + self.run_command("install") + + impl_tag, abi_tag, plat_tag = self.get_tag() + archive_basename = f"{self.wheel_dist_name}-{impl_tag}-{abi_tag}-{plat_tag}" + if not self.relative: + archive_root = self.bdist_dir + else: + archive_root = os.path.join( + self.bdist_dir, self._ensure_relative(install.install_base) + ) + + self.set_undefined_options("install_egg_info", ("target", "egginfo_dir")) + distinfo_dirname = ( + f"{safer_name(self.distribution.get_name())}-" + f"{safer_version(self.distribution.get_version())}.dist-info" + ) + distinfo_dir = os.path.join(self.bdist_dir, distinfo_dirname) + self.egg2dist(self.egginfo_dir, distinfo_dir) + + self.write_wheelfile(distinfo_dir) + + # Make the archive + if not os.path.exists(self.dist_dir): + os.makedirs(self.dist_dir) + + wheel_path = os.path.join(self.dist_dir, archive_basename + ".whl") + with WheelFile(wheel_path, "w", self.compression) as wf: + wf.write_files(archive_root) + + # Add to 'Distribution.dist_files' so that the "upload" command works + getattr(self.distribution, "dist_files", []).append( + ( + "bdist_wheel", + "{}.{}".format(*sys.version_info[:2]), # like 3.7 + wheel_path, + ) + ) + + if not self.keep_temp: + log.info(f"removing {self.bdist_dir}") + if not self.dry_run: + if sys.version_info < (3, 12): + rmtree(self.bdist_dir, onerror=remove_readonly) + else: + rmtree(self.bdist_dir, onexc=remove_readonly_exc) + + def write_wheelfile( + self, wheelfile_base: str, generator: str = f"bdist_wheel ({wheel_version})" + ): + from email.message import Message + + msg = Message() + msg["Wheel-Version"] = "1.0" # of the spec + msg["Generator"] = generator + msg["Root-Is-Purelib"] = str(self.root_is_pure).lower() + if self.build_number is not None: + msg["Build"] = self.build_number + + # Doesn't work for bdist_wininst + impl_tag, abi_tag, plat_tag = self.get_tag() + for impl in impl_tag.split("."): + for abi in abi_tag.split("."): + for plat in plat_tag.split("."): + msg["Tag"] = "-".join((impl, abi, plat)) + + wheelfile_path = os.path.join(wheelfile_base, "WHEEL") + log.info(f"creating {wheelfile_path}") + with open(wheelfile_path, "wb") as f: + BytesGenerator(f, maxheaderlen=0).flatten(msg) + + def _ensure_relative(self, path: str) -> str: + # copied from dir_util, deleted + drive, path = os.path.splitdrive(path) + if path[0:1] == os.sep: + path = drive + path[1:] + return path + + @property + def license_paths(self) -> Iterable[str]: + if setuptools_major_version >= 57: + # Setuptools has resolved any patterns to actual file names + return self.distribution.metadata.license_files or () + + files: set[str] = set() + metadata = self.distribution.get_option_dict("metadata") + if setuptools_major_version >= 42: + # Setuptools recognizes the license_files option but does not do globbing + patterns = cast(Sequence[str], self.distribution.metadata.license_files) + else: + # Prior to those, wheel is entirely responsible for handling license files + if "license_files" in metadata: + patterns = metadata["license_files"][1].split() + else: + patterns = () + + if "license_file" in metadata: + warnings.warn( + 'The "license_file" option is deprecated. Use "license_files" instead.', + DeprecationWarning, + stacklevel=2, + ) + files.add(metadata["license_file"][1]) + + if not files and not patterns and not isinstance(patterns, list): + patterns = ("LICEN[CS]E*", "COPYING*", "NOTICE*", "AUTHORS*") + + for pattern in patterns: + for path in iglob(pattern): + if path.endswith("~"): + log.debug( + f'ignoring license file "{path}" as it looks like a backup' + ) + continue + + if path not in files and os.path.isfile(path): + log.info( + f'adding license file "{path}" (matched pattern "{pattern}")' + ) + files.add(path) + + return files + + def egg2dist(self, egginfo_path: str, distinfo_path: str): + """Convert an .egg-info directory into a .dist-info directory""" + + def adios(p: str) -> None: + """Appropriately delete directory, file or link.""" + if os.path.exists(p) and not os.path.islink(p) and os.path.isdir(p): + shutil.rmtree(p) + elif os.path.exists(p): + os.unlink(p) + + adios(distinfo_path) + + if not os.path.exists(egginfo_path): + # There is no egg-info. This is probably because the egg-info + # file/directory is not named matching the distribution name used + # to name the archive file. Check for this case and report + # accordingly. + import glob + + pat = os.path.join(os.path.dirname(egginfo_path), "*.egg-info") + possible = glob.glob(pat) + err = f"Egg metadata expected at {egginfo_path} but not found" + if possible: + alt = os.path.basename(possible[0]) + err += f" ({alt} found - possible misnamed archive file?)" + + raise ValueError(err) + + if os.path.isfile(egginfo_path): + # .egg-info is a single file + pkg_info = pkginfo_to_metadata(egginfo_path, egginfo_path) + os.mkdir(distinfo_path) + else: + # .egg-info is a directory + pkginfo_path = os.path.join(egginfo_path, "PKG-INFO") + pkg_info = pkginfo_to_metadata(egginfo_path, pkginfo_path) + + # ignore common egg metadata that is useless to wheel + shutil.copytree( + egginfo_path, + distinfo_path, + ignore=lambda x, y: { + "PKG-INFO", + "requires.txt", + "SOURCES.txt", + "not-zip-safe", + }, + ) + + # delete dependency_links if it is only whitespace + dependency_links_path = os.path.join(distinfo_path, "dependency_links.txt") + with open(dependency_links_path, encoding="utf-8") as dependency_links_file: + dependency_links = dependency_links_file.read().strip() + if not dependency_links: + adios(dependency_links_path) + + pkg_info_path = os.path.join(distinfo_path, "METADATA") + serialization_policy = EmailPolicy( + utf8=True, + mangle_from_=False, + max_line_length=0, + ) + with open(pkg_info_path, "w", encoding="utf-8") as out: + Generator(out, policy=serialization_policy).flatten(pkg_info) + + for license_path in self.license_paths: + filename = os.path.basename(license_path) + shutil.copy(license_path, os.path.join(distinfo_path, filename)) + + adios(egginfo_path) diff --git a/venv/lib/python3.10/site-packages/wheel/_setuptools_logging.py b/venv/lib/python3.10/site-packages/wheel/_setuptools_logging.py new file mode 100644 index 0000000000000000000000000000000000000000..a1a2482ba29ac5290c8f7d7688452ec3faf59332 --- /dev/null +++ b/venv/lib/python3.10/site-packages/wheel/_setuptools_logging.py @@ -0,0 +1,26 @@ +# copied from setuptools.logging, omitting monkeypatching +from __future__ import annotations + +import logging +import sys + + +def _not_warning(record: logging.LogRecord) -> bool: + return record.levelno < logging.WARNING + + +def configure() -> None: + """ + Configure logging to emit warning and above to stderr + and everything else to stdout. This behavior is provided + for compatibility with distutils.log but may change in + the future. + """ + err_handler = logging.StreamHandler() + err_handler.setLevel(logging.WARNING) + out_handler = logging.StreamHandler(sys.stdout) + out_handler.addFilter(_not_warning) + handlers = err_handler, out_handler + logging.basicConfig( + format="{message}", style="{", handlers=handlers, level=logging.DEBUG + ) diff --git a/venv/lib/python3.10/site-packages/wheel/bdist_wheel.py b/venv/lib/python3.10/site-packages/wheel/bdist_wheel.py new file mode 100644 index 0000000000000000000000000000000000000000..dd7b8629e5087fe35a2ea7ab6d3cbbb4cacf0031 --- /dev/null +++ b/venv/lib/python3.10/site-packages/wheel/bdist_wheel.py @@ -0,0 +1,26 @@ +from typing import TYPE_CHECKING +from warnings import warn + +warn( + "The 'wheel' package is no longer the canonical location of the 'bdist_wheel' " + "command, and will be removed in a future release. Please update to setuptools " + "v70.1 or later which contains an integrated version of this command.", + DeprecationWarning, + stacklevel=1, +) + +if TYPE_CHECKING: + from ._bdist_wheel import bdist_wheel as bdist_wheel +else: + try: + # Better integration/compatibility with setuptools: + # in the case new fixes or PEPs are implemented in setuptools + # there is no need to backport them to the deprecated code base. + # This is useful in the case of old packages in the ecosystem + # that are still used but have low maintenance. + from setuptools.command.bdist_wheel import bdist_wheel + except ImportError: + # Only used in the case of old setuptools versions. + # If the user wants to get the latest fixes/PEPs, + # they are encouraged to address the deprecation warning. + from ._bdist_wheel import bdist_wheel as bdist_wheel diff --git a/venv/lib/python3.10/site-packages/wheel/cli/__init__.py b/venv/lib/python3.10/site-packages/wheel/cli/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..6ba1217f5bdb6106c37ecc2be74d53ef2237b717 --- /dev/null +++ b/venv/lib/python3.10/site-packages/wheel/cli/__init__.py @@ -0,0 +1,155 @@ +""" +Wheel command-line utility. +""" + +from __future__ import annotations + +import argparse +import os +import sys +from argparse import ArgumentTypeError + + +class WheelError(Exception): + pass + + +def unpack_f(args: argparse.Namespace) -> None: + from .unpack import unpack + + unpack(args.wheelfile, args.dest) + + +def pack_f(args: argparse.Namespace) -> None: + from .pack import pack + + pack(args.directory, args.dest_dir, args.build_number) + + +def convert_f(args: argparse.Namespace) -> None: + from .convert import convert + + convert(args.files, args.dest_dir, args.verbose) + + +def tags_f(args: argparse.Namespace) -> None: + from .tags import tags + + names = ( + tags( + wheel, + args.python_tag, + args.abi_tag, + args.platform_tag, + args.build, + args.remove, + ) + for wheel in args.wheel + ) + + for name in names: + print(name) + + +def version_f(args: argparse.Namespace) -> None: + from .. import __version__ + + print(f"wheel {__version__}") + + +def parse_build_tag(build_tag: str) -> str: + if build_tag and not build_tag[0].isdigit(): + raise ArgumentTypeError("build tag must begin with a digit") + elif "-" in build_tag: + raise ArgumentTypeError("invalid character ('-') in build tag") + + return build_tag + + +TAGS_HELP = """\ +Make a new wheel with given tags. Any tags unspecified will remain the same. +Starting the tags with a "+" will append to the existing tags. Starting with a +"-" will remove a tag (use --option=-TAG syntax). Multiple tags can be +separated by ".". The original file will remain unless --remove is given. The +output filename(s) will be displayed on stdout for further processing. +""" + + +def parser(): + p = argparse.ArgumentParser() + s = p.add_subparsers(help="commands") + + unpack_parser = s.add_parser("unpack", help="Unpack wheel") + unpack_parser.add_argument( + "--dest", "-d", help="Destination directory", default="." + ) + unpack_parser.add_argument("wheelfile", help="Wheel file") + unpack_parser.set_defaults(func=unpack_f) + + repack_parser = s.add_parser("pack", help="Repack wheel") + repack_parser.add_argument("directory", help="Root directory of the unpacked wheel") + repack_parser.add_argument( + "--dest-dir", + "-d", + default=os.path.curdir, + help="Directory to store the wheel (default %(default)s)", + ) + repack_parser.add_argument( + "--build-number", help="Build tag to use in the wheel name" + ) + repack_parser.set_defaults(func=pack_f) + + convert_parser = s.add_parser("convert", help="Convert egg or wininst to wheel") + convert_parser.add_argument("files", nargs="*", help="Files to convert") + convert_parser.add_argument( + "--dest-dir", + "-d", + default=os.path.curdir, + help="Directory to store wheels (default %(default)s)", + ) + convert_parser.add_argument("--verbose", "-v", action="store_true") + convert_parser.set_defaults(func=convert_f) + + tags_parser = s.add_parser( + "tags", help="Add or replace the tags on a wheel", description=TAGS_HELP + ) + tags_parser.add_argument("wheel", nargs="*", help="Existing wheel(s) to retag") + tags_parser.add_argument( + "--remove", + action="store_true", + help="Remove the original files, keeping only the renamed ones", + ) + tags_parser.add_argument( + "--python-tag", metavar="TAG", help="Specify an interpreter tag(s)" + ) + tags_parser.add_argument("--abi-tag", metavar="TAG", help="Specify an ABI tag(s)") + tags_parser.add_argument( + "--platform-tag", metavar="TAG", help="Specify a platform tag(s)" + ) + tags_parser.add_argument( + "--build", type=parse_build_tag, metavar="BUILD", help="Specify a build tag" + ) + tags_parser.set_defaults(func=tags_f) + + version_parser = s.add_parser("version", help="Print version and exit") + version_parser.set_defaults(func=version_f) + + help_parser = s.add_parser("help", help="Show this help") + help_parser.set_defaults(func=lambda args: p.print_help()) + + return p + + +def main(): + p = parser() + args = p.parse_args() + if not hasattr(args, "func"): + p.print_help() + else: + try: + args.func(args) + return 0 + except WheelError as e: + print(e, file=sys.stderr) + + return 1 diff --git a/venv/lib/python3.10/site-packages/wheel/cli/__pycache__/__init__.cpython-310.pyc b/venv/lib/python3.10/site-packages/wheel/cli/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..64f22c17eb7c362cab853c48aab4940241ca3ee0 Binary files /dev/null and b/venv/lib/python3.10/site-packages/wheel/cli/__pycache__/__init__.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/wheel/cli/__pycache__/convert.cpython-310.pyc b/venv/lib/python3.10/site-packages/wheel/cli/__pycache__/convert.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..42e6b510d15cd0761c4f9dd58bc1e49db48d5da3 Binary files /dev/null and b/venv/lib/python3.10/site-packages/wheel/cli/__pycache__/convert.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/wheel/cli/__pycache__/pack.cpython-310.pyc b/venv/lib/python3.10/site-packages/wheel/cli/__pycache__/pack.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..83e36d38659f0220528edb3aaed50fbe1365d3d7 Binary files /dev/null and b/venv/lib/python3.10/site-packages/wheel/cli/__pycache__/pack.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/wheel/cli/__pycache__/tags.cpython-310.pyc b/venv/lib/python3.10/site-packages/wheel/cli/__pycache__/tags.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..49fa4233c01ba755cd898148dcf6a623c0da64e6 Binary files /dev/null and b/venv/lib/python3.10/site-packages/wheel/cli/__pycache__/tags.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/wheel/cli/__pycache__/unpack.cpython-310.pyc b/venv/lib/python3.10/site-packages/wheel/cli/__pycache__/unpack.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6fddc5f03f733e98eaf7277d85a227ccc7d0c6e9 Binary files /dev/null and b/venv/lib/python3.10/site-packages/wheel/cli/__pycache__/unpack.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/wheel/cli/convert.py b/venv/lib/python3.10/site-packages/wheel/cli/convert.py new file mode 100644 index 0000000000000000000000000000000000000000..61d4775c58596ec12a0c4d4a548de430dee579bf --- /dev/null +++ b/venv/lib/python3.10/site-packages/wheel/cli/convert.py @@ -0,0 +1,332 @@ +from __future__ import annotations + +import os.path +import re +from abc import ABCMeta, abstractmethod +from collections import defaultdict +from collections.abc import Iterator +from email.message import Message +from email.parser import Parser +from email.policy import EmailPolicy +from glob import iglob +from pathlib import Path +from textwrap import dedent +from zipfile import ZipFile + +from .. import __version__ +from ..metadata import generate_requirements +from ..vendored.packaging.tags import parse_tag +from ..wheelfile import WheelFile + +egg_filename_re = re.compile( + r""" + (?P.+?)-(?P.+?) + (-(?Ppy\d\.\d+) + (-(?P.+?))? + )?.egg$""", + re.VERBOSE, +) +egg_info_re = re.compile( + r""" + ^(?P.+?)-(?P.+?) + (-(?Ppy\d\.\d+) + )?.egg-info/""", + re.VERBOSE, +) +wininst_re = re.compile( + r"\.(?Pwin32|win-amd64)(?:-(?Ppy\d\.\d))?\.exe$" +) +pyd_re = re.compile(r"\.(?P[a-z0-9]+)-(?Pwin32|win_amd64)\.pyd$") +serialization_policy = EmailPolicy( + utf8=True, + mangle_from_=False, + max_line_length=0, +) +GENERATOR = f"wheel {__version__}" + + +def convert_requires(requires: str, metadata: Message) -> None: + extra: str | None = None + requirements: dict[str | None, list[str]] = defaultdict(list) + for line in requires.splitlines(): + line = line.strip() + if not line: + continue + + if line.startswith("[") and line.endswith("]"): + extra = line[1:-1] + continue + + requirements[extra].append(line) + + for key, value in generate_requirements(requirements): + metadata.add_header(key, value) + + +def convert_pkg_info(pkginfo: str, metadata: Message): + parsed_message = Parser().parsestr(pkginfo) + for key, value in parsed_message.items(): + key_lower = key.lower() + if value == "UNKNOWN": + continue + + if key_lower == "description": + description_lines = value.splitlines() + value = "\n".join( + ( + description_lines[0].lstrip(), + dedent("\n".join(description_lines[1:])), + "\n", + ) + ) + metadata.set_payload(value) + elif key_lower == "home-page": + metadata.add_header("Project-URL", f"Homepage, {value}") + elif key_lower == "download-url": + metadata.add_header("Project-URL", f"Download, {value}") + else: + metadata.add_header(key, value) + + metadata.replace_header("Metadata-Version", "2.4") + + +def normalize(name: str) -> str: + return re.sub(r"[-_.]+", "-", name).lower().replace("-", "_") + + +class ConvertSource(metaclass=ABCMeta): + name: str + version: str + pyver: str = "py2.py3" + abi: str = "none" + platform: str = "any" + metadata: Message + + @property + def dist_info_dir(self) -> str: + return f"{self.name}-{self.version}.dist-info" + + @abstractmethod + def generate_contents(self) -> Iterator[tuple[str, bytes]]: + pass + + +class EggFileSource(ConvertSource): + def __init__(self, path: Path): + if not (match := egg_filename_re.match(path.name)): + raise ValueError(f"Invalid egg file name: {path.name}") + + # Binary wheels are assumed to be for CPython + self.path = path + self.name = normalize(match.group("name")) + self.version = match.group("ver") + if pyver := match.group("pyver"): + self.pyver = pyver.replace(".", "") + if arch := match.group("arch"): + self.abi = self.pyver.replace("py", "cp") + self.platform = normalize(arch) + + self.metadata = Message() + + def generate_contents(self) -> Iterator[tuple[str, bytes]]: + with ZipFile(self.path, "r") as zip_file: + for filename in sorted(zip_file.namelist()): + # Skip pure directory entries + if filename.endswith("/"): + continue + + # Handle files in the egg-info directory specially, selectively moving + # them to the dist-info directory while converting as needed + if filename.startswith("EGG-INFO/"): + if filename == "EGG-INFO/requires.txt": + requires = zip_file.read(filename).decode("utf-8") + convert_requires(requires, self.metadata) + elif filename == "EGG-INFO/PKG-INFO": + pkginfo = zip_file.read(filename).decode("utf-8") + convert_pkg_info(pkginfo, self.metadata) + elif filename == "EGG-INFO/entry_points.txt": + yield ( + f"{self.dist_info_dir}/entry_points.txt", + zip_file.read(filename), + ) + + continue + + # For any other file, just pass it through + yield filename, zip_file.read(filename) + + +class EggDirectorySource(EggFileSource): + def generate_contents(self) -> Iterator[tuple[str, bytes]]: + for dirpath, _, filenames in os.walk(self.path): + for filename in sorted(filenames): + path = Path(dirpath, filename) + if path.parent.name == "EGG-INFO": + if path.name == "requires.txt": + requires = path.read_text("utf-8") + convert_requires(requires, self.metadata) + elif path.name == "PKG-INFO": + pkginfo = path.read_text("utf-8") + convert_pkg_info(pkginfo, self.metadata) + if name := self.metadata.get("Name"): + self.name = normalize(name) + + if version := self.metadata.get("Version"): + self.version = version + elif path.name == "entry_points.txt": + yield ( + f"{self.dist_info_dir}/entry_points.txt", + path.read_bytes(), + ) + + continue + + # For any other file, just pass it through + yield str(path.relative_to(self.path)), path.read_bytes() + + +class WininstFileSource(ConvertSource): + """ + Handles distributions created with ``bdist_wininst``. + + The egginfo filename has the format:: + + name-ver(-pyver)(-arch).egg-info + + The installer filename has the format:: + + name-ver.arch(-pyver).exe + + Some things to note: + + 1. The installer filename is not definitive. An installer can be renamed + and work perfectly well as an installer. So more reliable data should + be used whenever possible. + 2. The egg-info data should be preferred for the name and version, because + these come straight from the distutils metadata, and are mandatory. + 3. The pyver from the egg-info data should be ignored, as it is + constructed from the version of Python used to build the installer, + which is irrelevant - the installer filename is correct here (even to + the point that when it's not there, any version is implied). + 4. The architecture must be taken from the installer filename, as it is + not included in the egg-info data. + 5. Architecture-neutral installers still have an architecture because the + installer format itself (being executable) is architecture-specific. We + should therefore ignore the architecture if the content is pure-python. + """ + + def __init__(self, path: Path): + self.path = path + self.metadata = Message() + + # Determine the initial architecture and Python version from the file name + # (if possible) + if match := wininst_re.search(path.name): + self.platform = normalize(match.group("platform")) + if pyver := match.group("pyver"): + self.pyver = pyver.replace(".", "") + + # Look for an .egg-info directory and any .pyd files for more precise info + egg_info_found = pyd_found = False + with ZipFile(self.path) as zip_file: + for filename in zip_file.namelist(): + prefix, filename = filename.split("/", 1) + if not egg_info_found and (match := egg_info_re.match(filename)): + egg_info_found = True + self.name = normalize(match.group("name")) + self.version = match.group("ver") + if pyver := match.group("pyver"): + self.pyver = pyver.replace(".", "") + elif not pyd_found and (match := pyd_re.search(filename)): + pyd_found = True + self.abi = match.group("abi") + self.platform = match.group("platform") + + if egg_info_found and pyd_found: + break + + def generate_contents(self) -> Iterator[tuple[str, bytes]]: + dist_info_dir = f"{self.name}-{self.version}.dist-info" + data_dir = f"{self.name}-{self.version}.data" + with ZipFile(self.path, "r") as zip_file: + for filename in sorted(zip_file.namelist()): + # Skip pure directory entries + if filename.endswith("/"): + continue + + # Handle files in the egg-info directory specially, selectively moving + # them to the dist-info directory while converting as needed + prefix, target_filename = filename.split("/", 1) + if egg_info_re.search(target_filename): + basename = target_filename.rsplit("/", 1)[-1] + if basename == "requires.txt": + requires = zip_file.read(filename).decode("utf-8") + convert_requires(requires, self.metadata) + elif basename == "PKG-INFO": + pkginfo = zip_file.read(filename).decode("utf-8") + convert_pkg_info(pkginfo, self.metadata) + elif basename == "entry_points.txt": + yield ( + f"{dist_info_dir}/entry_points.txt", + zip_file.read(filename), + ) + + continue + elif prefix == "SCRIPTS": + target_filename = f"{data_dir}/scripts/{target_filename}" + + # For any other file, just pass it through + yield target_filename, zip_file.read(filename) + + +def convert(files: list[str], dest_dir: str, verbose: bool) -> None: + for pat in files: + for archive in iglob(pat): + path = Path(archive) + if path.suffix == ".egg": + if path.is_dir(): + source: ConvertSource = EggDirectorySource(path) + else: + source = EggFileSource(path) + else: + source = WininstFileSource(path) + + if verbose: + print(f"{archive}...", flush=True, end="") + + dest_path = Path(dest_dir) / ( + f"{source.name}-{source.version}-{source.pyver}-{source.abi}" + f"-{source.platform}.whl" + ) + with WheelFile(dest_path, "w") as wheelfile: + for name_or_zinfo, contents in source.generate_contents(): + wheelfile.writestr(name_or_zinfo, contents) + + # Write the METADATA file + wheelfile.writestr( + f"{source.dist_info_dir}/METADATA", + source.metadata.as_string(policy=serialization_policy).encode( + "utf-8" + ), + ) + + # Write the WHEEL file + wheel_message = Message() + wheel_message.add_header("Wheel-Version", "1.0") + wheel_message.add_header("Generator", GENERATOR) + wheel_message.add_header( + "Root-Is-Purelib", str(source.platform == "any").lower() + ) + tags = parse_tag(f"{source.pyver}-{source.abi}-{source.platform}") + for tag in sorted(tags, key=lambda tag: tag.interpreter): + wheel_message.add_header("Tag", str(tag)) + + wheelfile.writestr( + f"{source.dist_info_dir}/WHEEL", + wheel_message.as_string(policy=serialization_policy).encode( + "utf-8" + ), + ) + + if verbose: + print("OK") diff --git a/venv/lib/python3.10/site-packages/wheel/cli/pack.py b/venv/lib/python3.10/site-packages/wheel/cli/pack.py new file mode 100644 index 0000000000000000000000000000000000000000..64469c0c730c24449e77c23f46d0e3f68d647d67 --- /dev/null +++ b/venv/lib/python3.10/site-packages/wheel/cli/pack.py @@ -0,0 +1,85 @@ +from __future__ import annotations + +import email.policy +import os.path +import re +from email.generator import BytesGenerator +from email.parser import BytesParser + +from wheel.cli import WheelError +from wheel.wheelfile import WheelFile + +DIST_INFO_RE = re.compile(r"^(?P(?P.+?)-(?P\d.*?))\.dist-info$") + + +def pack(directory: str, dest_dir: str, build_number: str | None) -> None: + """Repack a previously unpacked wheel directory into a new wheel file. + + The .dist-info/WHEEL file must contain one or more tags so that the target + wheel file name can be determined. + + :param directory: The unpacked wheel directory + :param dest_dir: Destination directory (defaults to the current directory) + """ + # Find the .dist-info directory + dist_info_dirs = [ + fn + for fn in os.listdir(directory) + if os.path.isdir(os.path.join(directory, fn)) and DIST_INFO_RE.match(fn) + ] + if len(dist_info_dirs) > 1: + raise WheelError(f"Multiple .dist-info directories found in {directory}") + elif not dist_info_dirs: + raise WheelError(f"No .dist-info directories found in {directory}") + + # Determine the target wheel filename + dist_info_dir = dist_info_dirs[0] + name_version = DIST_INFO_RE.match(dist_info_dir).group("namever") + + # Read the tags and the existing build number from .dist-info/WHEEL + wheel_file_path = os.path.join(directory, dist_info_dir, "WHEEL") + with open(wheel_file_path, "rb") as f: + info = BytesParser(policy=email.policy.compat32).parse(f) + tags: list[str] = info.get_all("Tag", []) + existing_build_number = info.get("Build") + + if not tags: + raise WheelError( + f"No tags present in {dist_info_dir}/WHEEL; cannot determine target " + f"wheel filename" + ) + + # Set the wheel file name and add/replace/remove the Build tag in .dist-info/WHEEL + build_number = build_number if build_number is not None else existing_build_number + if build_number is not None: + del info["Build"] + if build_number: + info["Build"] = build_number + name_version += "-" + build_number + + if build_number != existing_build_number: + with open(wheel_file_path, "wb") as f: + BytesGenerator(f, maxheaderlen=0).flatten(info) + + # Reassemble the tags for the wheel file + tagline = compute_tagline(tags) + + # Repack the wheel + wheel_path = os.path.join(dest_dir, f"{name_version}-{tagline}.whl") + with WheelFile(wheel_path, "w") as wf: + print(f"Repacking wheel as {wheel_path}...", end="", flush=True) + wf.write_files(directory) + + print("OK") + + +def compute_tagline(tags: list[str]) -> str: + """Compute a tagline from a list of tags. + + :param tags: A list of tags + :return: A tagline + """ + impls = sorted({tag.split("-")[0] for tag in tags}) + abivers = sorted({tag.split("-")[1] for tag in tags}) + platforms = sorted({tag.split("-")[2] for tag in tags}) + return "-".join([".".join(impls), ".".join(abivers), ".".join(platforms)]) diff --git a/venv/lib/python3.10/site-packages/wheel/cli/tags.py b/venv/lib/python3.10/site-packages/wheel/cli/tags.py new file mode 100644 index 0000000000000000000000000000000000000000..88da72e9ec4a31e2427bdb2bcf2b3e0ce3c0beb0 --- /dev/null +++ b/venv/lib/python3.10/site-packages/wheel/cli/tags.py @@ -0,0 +1,139 @@ +from __future__ import annotations + +import email.policy +import itertools +import os +from collections.abc import Iterable +from email.parser import BytesParser + +from ..wheelfile import WheelFile + + +def _compute_tags(original_tags: Iterable[str], new_tags: str | None) -> set[str]: + """Add or replace tags. Supports dot-separated tags""" + if new_tags is None: + return set(original_tags) + + if new_tags.startswith("+"): + return {*original_tags, *new_tags[1:].split(".")} + + if new_tags.startswith("-"): + return set(original_tags) - set(new_tags[1:].split(".")) + + return set(new_tags.split(".")) + + +def tags( + wheel: str, + python_tags: str | None = None, + abi_tags: str | None = None, + platform_tags: str | None = None, + build_tag: str | None = None, + remove: bool = False, +) -> str: + """Change the tags on a wheel file. + + The tags are left unchanged if they are not specified. To specify "none", + use ["none"]. To append to the previous tags, a tag should start with a + "+". If a tag starts with "-", it will be removed from existing tags. + Processing is done left to right. + + :param wheel: The paths to the wheels + :param python_tags: The Python tags to set + :param abi_tags: The ABI tags to set + :param platform_tags: The platform tags to set + :param build_tag: The build tag to set + :param remove: Remove the original wheel + """ + with WheelFile(wheel, "r") as f: + assert f.filename, f"{f.filename} must be available" + + wheel_info = f.read(f.dist_info_path + "/WHEEL") + info = BytesParser(policy=email.policy.compat32).parsebytes(wheel_info) + + original_wheel_name = os.path.basename(f.filename) + namever = f.parsed_filename.group("namever") + build = f.parsed_filename.group("build") + original_python_tags = f.parsed_filename.group("pyver").split(".") + original_abi_tags = f.parsed_filename.group("abi").split(".") + original_plat_tags = f.parsed_filename.group("plat").split(".") + + tags: list[str] = info.get_all("Tag", []) + existing_build_tag = info.get("Build") + + impls = {tag.split("-")[0] for tag in tags} + abivers = {tag.split("-")[1] for tag in tags} + platforms = {tag.split("-")[2] for tag in tags} + + if impls != set(original_python_tags): + msg = f"Wheel internal tags {impls!r} != filename tags {original_python_tags!r}" + raise AssertionError(msg) + + if abivers != set(original_abi_tags): + msg = f"Wheel internal tags {abivers!r} != filename tags {original_abi_tags!r}" + raise AssertionError(msg) + + if platforms != set(original_plat_tags): + msg = ( + f"Wheel internal tags {platforms!r} != filename tags {original_plat_tags!r}" + ) + raise AssertionError(msg) + + if existing_build_tag != build: + msg = ( + f"Incorrect filename '{build}' " + f"& *.dist-info/WHEEL '{existing_build_tag}' build numbers" + ) + raise AssertionError(msg) + + # Start changing as needed + if build_tag is not None: + build = build_tag + + final_python_tags = sorted(_compute_tags(original_python_tags, python_tags)) + final_abi_tags = sorted(_compute_tags(original_abi_tags, abi_tags)) + final_plat_tags = sorted(_compute_tags(original_plat_tags, platform_tags)) + + final_tags = [ + namever, + ".".join(final_python_tags), + ".".join(final_abi_tags), + ".".join(final_plat_tags), + ] + if build: + final_tags.insert(1, build) + + final_wheel_name = "-".join(final_tags) + ".whl" + + if original_wheel_name != final_wheel_name: + del info["Tag"], info["Build"] + for a, b, c in itertools.product( + final_python_tags, final_abi_tags, final_plat_tags + ): + info["Tag"] = f"{a}-{b}-{c}" + if build: + info["Build"] = build + + original_wheel_path = os.path.join( + os.path.dirname(f.filename), original_wheel_name + ) + final_wheel_path = os.path.join(os.path.dirname(f.filename), final_wheel_name) + + with WheelFile(original_wheel_path, "r") as fin, WheelFile( + final_wheel_path, "w" + ) as fout: + fout.comment = fin.comment # preserve the comment + for item in fin.infolist(): + if item.is_dir(): + continue + if item.filename == f.dist_info_path + "/RECORD": + continue + if item.filename == f.dist_info_path + "/WHEEL": + fout.writestr(item, info.as_bytes()) + else: + fout.writestr(item, fin.read(item)) + + if remove: + os.remove(original_wheel_path) + + return final_wheel_name diff --git a/venv/lib/python3.10/site-packages/wheel/cli/unpack.py b/venv/lib/python3.10/site-packages/wheel/cli/unpack.py new file mode 100644 index 0000000000000000000000000000000000000000..d48840e6ec0512225233bf02d1d7ce203415b04c --- /dev/null +++ b/venv/lib/python3.10/site-packages/wheel/cli/unpack.py @@ -0,0 +1,30 @@ +from __future__ import annotations + +from pathlib import Path + +from ..wheelfile import WheelFile + + +def unpack(path: str, dest: str = ".") -> None: + """Unpack a wheel. + + Wheel content will be unpacked to {dest}/{name}-{ver}, where {name} + is the package name and {ver} its version. + + :param path: The path to the wheel. + :param dest: Destination directory (default to current directory). + """ + with WheelFile(path) as wf: + namever = wf.parsed_filename.group("namever") + destination = Path(dest) / namever + print(f"Unpacking to: {destination}...", end="", flush=True) + for zinfo in wf.filelist: + wf.extract(zinfo, destination) + + # Set permissions to the same values as they were set in the archive + # We have to do this manually due to + # https://github.com/python/cpython/issues/59999 + permissions = zinfo.external_attr >> 16 & 0o777 + destination.joinpath(zinfo.filename).chmod(permissions) + + print("OK") diff --git a/venv/lib/python3.10/site-packages/wheel/macosx_libfile.py b/venv/lib/python3.10/site-packages/wheel/macosx_libfile.py new file mode 100644 index 0000000000000000000000000000000000000000..abdfc9eda1d4c1f33270c155e1610fe73bd54263 --- /dev/null +++ b/venv/lib/python3.10/site-packages/wheel/macosx_libfile.py @@ -0,0 +1,482 @@ +""" +This module contains function to analyse dynamic library +headers to extract system information + +Currently only for MacOSX + +Library file on macosx system starts with Mach-O or Fat field. +This can be distinguish by first 32 bites and it is called magic number. +Proper value of magic number is with suffix _MAGIC. Suffix _CIGAM means +reversed bytes order. +Both fields can occur in two types: 32 and 64 bytes. + +FAT field inform that this library contains few version of library +(typically for different types version). It contains +information where Mach-O headers starts. + +Each section started with Mach-O header contains one library +(So if file starts with this field it contains only one version). + +After filed Mach-O there are section fields. +Each of them starts with two fields: +cmd - magic number for this command +cmdsize - total size occupied by this section information. + +In this case only sections LC_VERSION_MIN_MACOSX (for macosx 10.13 and earlier) +and LC_BUILD_VERSION (for macosx 10.14 and newer) are interesting, +because them contains information about minimal system version. + +Important remarks: +- For fat files this implementation looks for maximum number version. + It not check if it is 32 or 64 and do not compare it with currently built package. + So it is possible to false report higher version that needed. +- All structures signatures are taken form macosx header files. +- I think that binary format will be more stable than `otool` output. + and if apple introduce some changes both implementation will need to be updated. +- The system compile will set the deployment target no lower than + 11.0 for arm64 builds. For "Universal 2" builds use the x86_64 deployment + target when the arm64 target is 11.0. +""" + +from __future__ import annotations + +import ctypes +import os +import sys +from io import BufferedIOBase +from typing import TYPE_CHECKING + +if TYPE_CHECKING: + from typing import Union + + StrPath = Union[str, os.PathLike[str]] + +"""here the needed const and struct from mach-o header files""" + +FAT_MAGIC = 0xCAFEBABE +FAT_CIGAM = 0xBEBAFECA +FAT_MAGIC_64 = 0xCAFEBABF +FAT_CIGAM_64 = 0xBFBAFECA +MH_MAGIC = 0xFEEDFACE +MH_CIGAM = 0xCEFAEDFE +MH_MAGIC_64 = 0xFEEDFACF +MH_CIGAM_64 = 0xCFFAEDFE + +LC_VERSION_MIN_MACOSX = 0x24 +LC_BUILD_VERSION = 0x32 + +CPU_TYPE_ARM64 = 0x0100000C + +mach_header_fields = [ + ("magic", ctypes.c_uint32), + ("cputype", ctypes.c_int), + ("cpusubtype", ctypes.c_int), + ("filetype", ctypes.c_uint32), + ("ncmds", ctypes.c_uint32), + ("sizeofcmds", ctypes.c_uint32), + ("flags", ctypes.c_uint32), +] +""" +struct mach_header { + uint32_t magic; /* mach magic number identifier */ + cpu_type_t cputype; /* cpu specifier */ + cpu_subtype_t cpusubtype; /* machine specifier */ + uint32_t filetype; /* type of file */ + uint32_t ncmds; /* number of load commands */ + uint32_t sizeofcmds; /* the size of all the load commands */ + uint32_t flags; /* flags */ +}; +typedef integer_t cpu_type_t; +typedef integer_t cpu_subtype_t; +""" + +mach_header_fields_64 = mach_header_fields + [("reserved", ctypes.c_uint32)] +""" +struct mach_header_64 { + uint32_t magic; /* mach magic number identifier */ + cpu_type_t cputype; /* cpu specifier */ + cpu_subtype_t cpusubtype; /* machine specifier */ + uint32_t filetype; /* type of file */ + uint32_t ncmds; /* number of load commands */ + uint32_t sizeofcmds; /* the size of all the load commands */ + uint32_t flags; /* flags */ + uint32_t reserved; /* reserved */ +}; +""" + +fat_header_fields = [("magic", ctypes.c_uint32), ("nfat_arch", ctypes.c_uint32)] +""" +struct fat_header { + uint32_t magic; /* FAT_MAGIC or FAT_MAGIC_64 */ + uint32_t nfat_arch; /* number of structs that follow */ +}; +""" + +fat_arch_fields = [ + ("cputype", ctypes.c_int), + ("cpusubtype", ctypes.c_int), + ("offset", ctypes.c_uint32), + ("size", ctypes.c_uint32), + ("align", ctypes.c_uint32), +] +""" +struct fat_arch { + cpu_type_t cputype; /* cpu specifier (int) */ + cpu_subtype_t cpusubtype; /* machine specifier (int) */ + uint32_t offset; /* file offset to this object file */ + uint32_t size; /* size of this object file */ + uint32_t align; /* alignment as a power of 2 */ +}; +""" + +fat_arch_64_fields = [ + ("cputype", ctypes.c_int), + ("cpusubtype", ctypes.c_int), + ("offset", ctypes.c_uint64), + ("size", ctypes.c_uint64), + ("align", ctypes.c_uint32), + ("reserved", ctypes.c_uint32), +] +""" +struct fat_arch_64 { + cpu_type_t cputype; /* cpu specifier (int) */ + cpu_subtype_t cpusubtype; /* machine specifier (int) */ + uint64_t offset; /* file offset to this object file */ + uint64_t size; /* size of this object file */ + uint32_t align; /* alignment as a power of 2 */ + uint32_t reserved; /* reserved */ +}; +""" + +segment_base_fields = [("cmd", ctypes.c_uint32), ("cmdsize", ctypes.c_uint32)] +"""base for reading segment info""" + +segment_command_fields = [ + ("cmd", ctypes.c_uint32), + ("cmdsize", ctypes.c_uint32), + ("segname", ctypes.c_char * 16), + ("vmaddr", ctypes.c_uint32), + ("vmsize", ctypes.c_uint32), + ("fileoff", ctypes.c_uint32), + ("filesize", ctypes.c_uint32), + ("maxprot", ctypes.c_int), + ("initprot", ctypes.c_int), + ("nsects", ctypes.c_uint32), + ("flags", ctypes.c_uint32), +] +""" +struct segment_command { /* for 32-bit architectures */ + uint32_t cmd; /* LC_SEGMENT */ + uint32_t cmdsize; /* includes sizeof section structs */ + char segname[16]; /* segment name */ + uint32_t vmaddr; /* memory address of this segment */ + uint32_t vmsize; /* memory size of this segment */ + uint32_t fileoff; /* file offset of this segment */ + uint32_t filesize; /* amount to map from the file */ + vm_prot_t maxprot; /* maximum VM protection */ + vm_prot_t initprot; /* initial VM protection */ + uint32_t nsects; /* number of sections in segment */ + uint32_t flags; /* flags */ +}; +typedef int vm_prot_t; +""" + +segment_command_fields_64 = [ + ("cmd", ctypes.c_uint32), + ("cmdsize", ctypes.c_uint32), + ("segname", ctypes.c_char * 16), + ("vmaddr", ctypes.c_uint64), + ("vmsize", ctypes.c_uint64), + ("fileoff", ctypes.c_uint64), + ("filesize", ctypes.c_uint64), + ("maxprot", ctypes.c_int), + ("initprot", ctypes.c_int), + ("nsects", ctypes.c_uint32), + ("flags", ctypes.c_uint32), +] +""" +struct segment_command_64 { /* for 64-bit architectures */ + uint32_t cmd; /* LC_SEGMENT_64 */ + uint32_t cmdsize; /* includes sizeof section_64 structs */ + char segname[16]; /* segment name */ + uint64_t vmaddr; /* memory address of this segment */ + uint64_t vmsize; /* memory size of this segment */ + uint64_t fileoff; /* file offset of this segment */ + uint64_t filesize; /* amount to map from the file */ + vm_prot_t maxprot; /* maximum VM protection */ + vm_prot_t initprot; /* initial VM protection */ + uint32_t nsects; /* number of sections in segment */ + uint32_t flags; /* flags */ +}; +""" + +version_min_command_fields = segment_base_fields + [ + ("version", ctypes.c_uint32), + ("sdk", ctypes.c_uint32), +] +""" +struct version_min_command { + uint32_t cmd; /* LC_VERSION_MIN_MACOSX or + LC_VERSION_MIN_IPHONEOS or + LC_VERSION_MIN_WATCHOS or + LC_VERSION_MIN_TVOS */ + uint32_t cmdsize; /* sizeof(struct min_version_command) */ + uint32_t version; /* X.Y.Z is encoded in nibbles xxxx.yy.zz */ + uint32_t sdk; /* X.Y.Z is encoded in nibbles xxxx.yy.zz */ +}; +""" + +build_version_command_fields = segment_base_fields + [ + ("platform", ctypes.c_uint32), + ("minos", ctypes.c_uint32), + ("sdk", ctypes.c_uint32), + ("ntools", ctypes.c_uint32), +] +""" +struct build_version_command { + uint32_t cmd; /* LC_BUILD_VERSION */ + uint32_t cmdsize; /* sizeof(struct build_version_command) plus */ + /* ntools * sizeof(struct build_tool_version) */ + uint32_t platform; /* platform */ + uint32_t minos; /* X.Y.Z is encoded in nibbles xxxx.yy.zz */ + uint32_t sdk; /* X.Y.Z is encoded in nibbles xxxx.yy.zz */ + uint32_t ntools; /* number of tool entries following this */ +}; +""" + + +def swap32(x: int) -> int: + return ( + ((x << 24) & 0xFF000000) + | ((x << 8) & 0x00FF0000) + | ((x >> 8) & 0x0000FF00) + | ((x >> 24) & 0x000000FF) + ) + + +def get_base_class_and_magic_number( + lib_file: BufferedIOBase, + seek: int | None = None, +) -> tuple[type[ctypes.Structure], int]: + if seek is None: + seek = lib_file.tell() + else: + lib_file.seek(seek) + magic_number = ctypes.c_uint32.from_buffer_copy( + lib_file.read(ctypes.sizeof(ctypes.c_uint32)) + ).value + + # Handle wrong byte order + if magic_number in [FAT_CIGAM, FAT_CIGAM_64, MH_CIGAM, MH_CIGAM_64]: + if sys.byteorder == "little": + BaseClass = ctypes.BigEndianStructure + else: + BaseClass = ctypes.LittleEndianStructure + + magic_number = swap32(magic_number) + else: + BaseClass = ctypes.Structure + + lib_file.seek(seek) + return BaseClass, magic_number + + +def read_data(struct_class: type[ctypes.Structure], lib_file: BufferedIOBase): + return struct_class.from_buffer_copy(lib_file.read(ctypes.sizeof(struct_class))) + + +def extract_macosx_min_system_version(path_to_lib: str): + with open(path_to_lib, "rb") as lib_file: + BaseClass, magic_number = get_base_class_and_magic_number(lib_file, 0) + if magic_number not in [FAT_MAGIC, FAT_MAGIC_64, MH_MAGIC, MH_MAGIC_64]: + return + + if magic_number in [FAT_MAGIC, FAT_CIGAM_64]: + + class FatHeader(BaseClass): + _fields_ = fat_header_fields + + fat_header = read_data(FatHeader, lib_file) + if magic_number == FAT_MAGIC: + + class FatArch(BaseClass): + _fields_ = fat_arch_fields + + else: + + class FatArch(BaseClass): + _fields_ = fat_arch_64_fields + + fat_arch_list = [ + read_data(FatArch, lib_file) for _ in range(fat_header.nfat_arch) + ] + + versions_list: list[tuple[int, int, int]] = [] + for el in fat_arch_list: + try: + version = read_mach_header(lib_file, el.offset) + if version is not None: + if el.cputype == CPU_TYPE_ARM64 and len(fat_arch_list) != 1: + # Xcode will not set the deployment target below 11.0.0 + # for the arm64 architecture. Ignore the arm64 deployment + # in fat binaries when the target is 11.0.0, that way + # the other architectures can select a lower deployment + # target. + # This is safe because there is no arm64 variant for + # macOS 10.15 or earlier. + if version == (11, 0, 0): + continue + versions_list.append(version) + except ValueError: + pass + + if len(versions_list) > 0: + return max(versions_list) + else: + return None + + else: + try: + return read_mach_header(lib_file, 0) + except ValueError: + """when some error during read library files""" + return None + + +def read_mach_header( + lib_file: BufferedIOBase, + seek: int | None = None, +) -> tuple[int, int, int] | None: + """ + This function parses a Mach-O header and extracts + information about the minimal macOS version. + + :param lib_file: reference to opened library file with pointer + """ + base_class, magic_number = get_base_class_and_magic_number(lib_file, seek) + arch = "32" if magic_number == MH_MAGIC else "64" + + class SegmentBase(base_class): + _fields_ = segment_base_fields + + if arch == "32": + + class MachHeader(base_class): + _fields_ = mach_header_fields + + else: + + class MachHeader(base_class): + _fields_ = mach_header_fields_64 + + mach_header = read_data(MachHeader, lib_file) + for _i in range(mach_header.ncmds): + pos = lib_file.tell() + segment_base = read_data(SegmentBase, lib_file) + lib_file.seek(pos) + if segment_base.cmd == LC_VERSION_MIN_MACOSX: + + class VersionMinCommand(base_class): + _fields_ = version_min_command_fields + + version_info = read_data(VersionMinCommand, lib_file) + return parse_version(version_info.version) + elif segment_base.cmd == LC_BUILD_VERSION: + + class VersionBuild(base_class): + _fields_ = build_version_command_fields + + version_info = read_data(VersionBuild, lib_file) + return parse_version(version_info.minos) + else: + lib_file.seek(pos + segment_base.cmdsize) + continue + + +def parse_version(version: int) -> tuple[int, int, int]: + x = (version & 0xFFFF0000) >> 16 + y = (version & 0x0000FF00) >> 8 + z = version & 0x000000FF + return x, y, z + + +def calculate_macosx_platform_tag(archive_root: StrPath, platform_tag: str) -> str: + """ + Calculate proper macosx platform tag basing on files which are included to wheel + + Example platform tag `macosx-10.14-x86_64` + """ + prefix, base_version, suffix = platform_tag.split("-") + base_version = tuple(int(x) for x in base_version.split(".")) + base_version = base_version[:2] + if base_version[0] > 10: + base_version = (base_version[0], 0) + assert len(base_version) == 2 + if "MACOSX_DEPLOYMENT_TARGET" in os.environ: + deploy_target = tuple( + int(x) for x in os.environ["MACOSX_DEPLOYMENT_TARGET"].split(".") + ) + deploy_target = deploy_target[:2] + if deploy_target[0] > 10: + deploy_target = (deploy_target[0], 0) + if deploy_target < base_version: + sys.stderr.write( + "[WARNING] MACOSX_DEPLOYMENT_TARGET is set to a lower value ({}) than " + "the version on which the Python interpreter was compiled ({}), and " + "will be ignored.\n".format( + ".".join(str(x) for x in deploy_target), + ".".join(str(x) for x in base_version), + ) + ) + else: + base_version = deploy_target + + assert len(base_version) == 2 + start_version = base_version + versions_dict: dict[str, tuple[int, int]] = {} + for dirpath, _dirnames, filenames in os.walk(archive_root): + for filename in filenames: + if filename.endswith(".dylib") or filename.endswith(".so"): + lib_path = os.path.join(dirpath, filename) + min_ver = extract_macosx_min_system_version(lib_path) + if min_ver is not None: + min_ver = min_ver[0:2] + if min_ver[0] > 10: + min_ver = (min_ver[0], 0) + versions_dict[lib_path] = min_ver + + if len(versions_dict) > 0: + base_version = max(base_version, max(versions_dict.values())) + + # macosx platform tag do not support minor bugfix release + fin_base_version = "_".join([str(x) for x in base_version]) + if start_version < base_version: + problematic_files = [k for k, v in versions_dict.items() if v > start_version] + problematic_files = "\n".join(problematic_files) + if len(problematic_files) == 1: + files_form = "this file" + else: + files_form = "these files" + error_message = ( + "[WARNING] This wheel needs a higher macOS version than {} " + "To silence this warning, set MACOSX_DEPLOYMENT_TARGET to at least " + + fin_base_version + + " or recreate " + + files_form + + " with lower " + "MACOSX_DEPLOYMENT_TARGET: \n" + problematic_files + ) + + if "MACOSX_DEPLOYMENT_TARGET" in os.environ: + error_message = error_message.format( + "is set in MACOSX_DEPLOYMENT_TARGET variable." + ) + else: + error_message = error_message.format( + "the version your Python interpreter is compiled against." + ) + + sys.stderr.write(error_message) + + platform_tag = prefix + "_" + fin_base_version + "_" + suffix + return platform_tag diff --git a/venv/lib/python3.10/site-packages/wheel/metadata.py b/venv/lib/python3.10/site-packages/wheel/metadata.py new file mode 100644 index 0000000000000000000000000000000000000000..b8098fa8599a1f142ee33ee551b7a874f5f98840 --- /dev/null +++ b/venv/lib/python3.10/site-packages/wheel/metadata.py @@ -0,0 +1,183 @@ +""" +Tools for converting old- to new-style metadata. +""" + +from __future__ import annotations + +import functools +import itertools +import os.path +import re +import textwrap +from email.message import Message +from email.parser import Parser +from typing import Generator, Iterable, Iterator, Literal + +from .vendored.packaging.requirements import Requirement + + +def _nonblank(str: str) -> bool | Literal[""]: + return str and not str.startswith("#") + + +@functools.singledispatch +def yield_lines(iterable: Iterable[str]) -> Iterator[str]: + r""" + Yield valid lines of a string or iterable. + >>> list(yield_lines('')) + [] + >>> list(yield_lines(['foo', 'bar'])) + ['foo', 'bar'] + >>> list(yield_lines('foo\nbar')) + ['foo', 'bar'] + >>> list(yield_lines('\nfoo\n#bar\nbaz #comment')) + ['foo', 'baz #comment'] + >>> list(yield_lines(['foo\nbar', 'baz', 'bing\n\n\n'])) + ['foo', 'bar', 'baz', 'bing'] + """ + return itertools.chain.from_iterable(map(yield_lines, iterable)) + + +@yield_lines.register(str) +def _(text: str) -> Iterator[str]: + return filter(_nonblank, map(str.strip, text.splitlines())) + + +def split_sections( + s: str | Iterator[str], +) -> Generator[tuple[str | None, list[str]], None, None]: + """Split a string or iterable thereof into (section, content) pairs + Each ``section`` is a stripped version of the section header ("[section]") + and each ``content`` is a list of stripped lines excluding blank lines and + comment-only lines. If there are any such lines before the first section + header, they're returned in a first ``section`` of ``None``. + """ + section = None + content: list[str] = [] + for line in yield_lines(s): + if line.startswith("["): + if line.endswith("]"): + if section or content: + yield section, content + section = line[1:-1].strip() + content = [] + else: + raise ValueError("Invalid section heading", line) + else: + content.append(line) + + # wrap up last segment + yield section, content + + +def safe_extra(extra: str) -> str: + """Convert an arbitrary string to a standard 'extra' name + Any runs of non-alphanumeric characters are replaced with a single '_', + and the result is always lowercased. + """ + return re.sub("[^A-Za-z0-9.-]+", "_", extra).lower() + + +def safe_name(name: str) -> str: + """Convert an arbitrary string to a standard distribution name + Any runs of non-alphanumeric/. characters are replaced with a single '-'. + """ + return re.sub("[^A-Za-z0-9.]+", "-", name) + + +def requires_to_requires_dist(requirement: Requirement) -> str: + """Return the version specifier for a requirement in PEP 345/566 fashion.""" + if requirement.url: + return " @ " + requirement.url + + requires_dist: list[str] = [] + for spec in requirement.specifier: + requires_dist.append(spec.operator + spec.version) + + if requires_dist: + return " " + ",".join(sorted(requires_dist)) + else: + return "" + + +def convert_requirements(requirements: list[str]) -> Iterator[str]: + """Yield Requires-Dist: strings for parsed requirements strings.""" + for req in requirements: + parsed_requirement = Requirement(req) + spec = requires_to_requires_dist(parsed_requirement) + extras = ",".join(sorted(safe_extra(e) for e in parsed_requirement.extras)) + if extras: + extras = f"[{extras}]" + + yield safe_name(parsed_requirement.name) + extras + spec + + +def generate_requirements( + extras_require: dict[str | None, list[str]], +) -> Iterator[tuple[str, str]]: + """ + Convert requirements from a setup()-style dictionary to + ('Requires-Dist', 'requirement') and ('Provides-Extra', 'extra') tuples. + + extras_require is a dictionary of {extra: [requirements]} as passed to setup(), + using the empty extra {'': [requirements]} to hold install_requires. + """ + for extra, depends in extras_require.items(): + condition = "" + extra = extra or "" + if ":" in extra: # setuptools extra:condition syntax + extra, condition = extra.split(":", 1) + + extra = safe_extra(extra) + if extra: + yield "Provides-Extra", extra + if condition: + condition = "(" + condition + ") and " + condition += f"extra == '{extra}'" + + if condition: + condition = " ; " + condition + + for new_req in convert_requirements(depends): + canonical_req = str(Requirement(new_req + condition)) + yield "Requires-Dist", canonical_req + + +def pkginfo_to_metadata(egg_info_path: str, pkginfo_path: str) -> Message: + """ + Convert .egg-info directory with PKG-INFO to the Metadata 2.1 format + """ + with open(pkginfo_path, encoding="utf-8") as headers: + pkg_info = Parser().parse(headers) + + pkg_info.replace_header("Metadata-Version", "2.1") + # Those will be regenerated from `requires.txt`. + del pkg_info["Provides-Extra"] + del pkg_info["Requires-Dist"] + requires_path = os.path.join(egg_info_path, "requires.txt") + if os.path.exists(requires_path): + with open(requires_path, encoding="utf-8") as requires_file: + requires = requires_file.read() + + parsed_requirements = sorted(split_sections(requires), key=lambda x: x[0] or "") + for extra, reqs in parsed_requirements: + for key, value in generate_requirements({extra: reqs}): + if (key, value) not in pkg_info.items(): + pkg_info[key] = value + + description = pkg_info["Description"] + if description: + description_lines = pkg_info["Description"].splitlines() + dedented_description = "\n".join( + # if the first line of long_description is blank, + # the first line here will be indented. + ( + description_lines[0].lstrip(), + textwrap.dedent("\n".join(description_lines[1:])), + "\n", + ) + ) + pkg_info.set_payload(dedented_description) + del pkg_info["Description"] + + return pkg_info diff --git a/venv/lib/python3.10/site-packages/wheel/util.py b/venv/lib/python3.10/site-packages/wheel/util.py new file mode 100644 index 0000000000000000000000000000000000000000..c928aa403b75e1ae392b4af5fe13147a095bbd30 --- /dev/null +++ b/venv/lib/python3.10/site-packages/wheel/util.py @@ -0,0 +1,17 @@ +from __future__ import annotations + +import base64 +import logging + +log = logging.getLogger("wheel") + + +def urlsafe_b64encode(data: bytes) -> bytes: + """urlsafe_b64encode without padding""" + return base64.urlsafe_b64encode(data).rstrip(b"=") + + +def urlsafe_b64decode(data: bytes) -> bytes: + """urlsafe_b64decode without padding""" + pad = b"=" * (4 - (len(data) & 3)) + return base64.urlsafe_b64decode(data + pad) diff --git a/venv/lib/python3.10/site-packages/wheel/vendored/__init__.py b/venv/lib/python3.10/site-packages/wheel/vendored/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/venv/lib/python3.10/site-packages/wheel/vendored/__pycache__/__init__.cpython-310.pyc b/venv/lib/python3.10/site-packages/wheel/vendored/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f94f74982573a5a7d407e7a29cdb20d3fdf9bbb8 Binary files /dev/null and b/venv/lib/python3.10/site-packages/wheel/vendored/__pycache__/__init__.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/wheel/vendored/packaging/LICENSE b/venv/lib/python3.10/site-packages/wheel/vendored/packaging/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..6f62d44e4ef733c0e713afcd2371fed7f2b3de67 --- /dev/null +++ b/venv/lib/python3.10/site-packages/wheel/vendored/packaging/LICENSE @@ -0,0 +1,3 @@ +This software is made available under the terms of *either* of the licenses +found in LICENSE.APACHE or LICENSE.BSD. Contributions to this software is made +under the terms of *both* these licenses. diff --git a/venv/lib/python3.10/site-packages/wheel/vendored/packaging/LICENSE.APACHE b/venv/lib/python3.10/site-packages/wheel/vendored/packaging/LICENSE.APACHE new file mode 100644 index 0000000000000000000000000000000000000000..f433b1a53f5b830a205fd2df78e2b34974656c7b --- /dev/null +++ b/venv/lib/python3.10/site-packages/wheel/vendored/packaging/LICENSE.APACHE @@ -0,0 +1,177 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS diff --git a/venv/lib/python3.10/site-packages/wheel/vendored/packaging/LICENSE.BSD b/venv/lib/python3.10/site-packages/wheel/vendored/packaging/LICENSE.BSD new file mode 100644 index 0000000000000000000000000000000000000000..42ce7b75c92fb01a3f6ed17eea363f756b7da582 --- /dev/null +++ b/venv/lib/python3.10/site-packages/wheel/vendored/packaging/LICENSE.BSD @@ -0,0 +1,23 @@ +Copyright (c) Donald Stufft and individual contributors. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/venv/lib/python3.10/site-packages/wheel/vendored/packaging/__init__.py b/venv/lib/python3.10/site-packages/wheel/vendored/packaging/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/venv/lib/python3.10/site-packages/wheel/vendored/packaging/__pycache__/__init__.cpython-310.pyc b/venv/lib/python3.10/site-packages/wheel/vendored/packaging/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3c81741576c93ea668f6e4531aba924bbdf034c9 Binary files /dev/null and b/venv/lib/python3.10/site-packages/wheel/vendored/packaging/__pycache__/__init__.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/wheel/vendored/packaging/__pycache__/_elffile.cpython-310.pyc b/venv/lib/python3.10/site-packages/wheel/vendored/packaging/__pycache__/_elffile.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2de805043359a4a3ec6668bb0fad80f94656b854 Binary files /dev/null and b/venv/lib/python3.10/site-packages/wheel/vendored/packaging/__pycache__/_elffile.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/wheel/vendored/packaging/__pycache__/_manylinux.cpython-310.pyc b/venv/lib/python3.10/site-packages/wheel/vendored/packaging/__pycache__/_manylinux.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e2c13b726b709e5f383ab9fbc11dea7c35852e5e Binary files /dev/null and b/venv/lib/python3.10/site-packages/wheel/vendored/packaging/__pycache__/_manylinux.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/wheel/vendored/packaging/__pycache__/_musllinux.cpython-310.pyc b/venv/lib/python3.10/site-packages/wheel/vendored/packaging/__pycache__/_musllinux.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ea488222bfd74a4ceefbe259d9e0fc1c790884af Binary files /dev/null and b/venv/lib/python3.10/site-packages/wheel/vendored/packaging/__pycache__/_musllinux.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/wheel/vendored/packaging/__pycache__/_parser.cpython-310.pyc b/venv/lib/python3.10/site-packages/wheel/vendored/packaging/__pycache__/_parser.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..da2cda386fffde6042d3cf047392d233d822a8fa Binary files /dev/null and b/venv/lib/python3.10/site-packages/wheel/vendored/packaging/__pycache__/_parser.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/wheel/vendored/packaging/__pycache__/_structures.cpython-310.pyc b/venv/lib/python3.10/site-packages/wheel/vendored/packaging/__pycache__/_structures.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0405a3dfc5e35b6c6ce1fdf5dbd6f7261169f8af Binary files /dev/null and b/venv/lib/python3.10/site-packages/wheel/vendored/packaging/__pycache__/_structures.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/wheel/vendored/packaging/__pycache__/_tokenizer.cpython-310.pyc b/venv/lib/python3.10/site-packages/wheel/vendored/packaging/__pycache__/_tokenizer.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..869abbd007dc9c7ef53c5848c8e85710f7a97a5b Binary files /dev/null and b/venv/lib/python3.10/site-packages/wheel/vendored/packaging/__pycache__/_tokenizer.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/wheel/vendored/packaging/__pycache__/markers.cpython-310.pyc b/venv/lib/python3.10/site-packages/wheel/vendored/packaging/__pycache__/markers.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..49fb303338ea79cf9855c62ee36f44dffe704a73 Binary files /dev/null and b/venv/lib/python3.10/site-packages/wheel/vendored/packaging/__pycache__/markers.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/wheel/vendored/packaging/__pycache__/requirements.cpython-310.pyc b/venv/lib/python3.10/site-packages/wheel/vendored/packaging/__pycache__/requirements.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..db1e8cd65fe897867e98219f5c9230c9433d2372 Binary files /dev/null and b/venv/lib/python3.10/site-packages/wheel/vendored/packaging/__pycache__/requirements.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/wheel/vendored/packaging/__pycache__/specifiers.cpython-310.pyc b/venv/lib/python3.10/site-packages/wheel/vendored/packaging/__pycache__/specifiers.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..69f0acca0246f31307c807891058386ba2e89e6d Binary files /dev/null and b/venv/lib/python3.10/site-packages/wheel/vendored/packaging/__pycache__/specifiers.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/wheel/vendored/packaging/__pycache__/tags.cpython-310.pyc b/venv/lib/python3.10/site-packages/wheel/vendored/packaging/__pycache__/tags.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..986e61e35f857db2eb0f6423445acf5165fb45f8 Binary files /dev/null and b/venv/lib/python3.10/site-packages/wheel/vendored/packaging/__pycache__/tags.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/wheel/vendored/packaging/__pycache__/utils.cpython-310.pyc b/venv/lib/python3.10/site-packages/wheel/vendored/packaging/__pycache__/utils.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b345ba014508cb4980f8d10424b7b229a7ca77d7 Binary files /dev/null and b/venv/lib/python3.10/site-packages/wheel/vendored/packaging/__pycache__/utils.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/wheel/vendored/packaging/__pycache__/version.cpython-310.pyc b/venv/lib/python3.10/site-packages/wheel/vendored/packaging/__pycache__/version.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0bf25ea6285d88615a01f43bc539f6c231c47387 Binary files /dev/null and b/venv/lib/python3.10/site-packages/wheel/vendored/packaging/__pycache__/version.cpython-310.pyc differ diff --git a/venv/lib/python3.10/site-packages/wheel/vendored/packaging/_elffile.py b/venv/lib/python3.10/site-packages/wheel/vendored/packaging/_elffile.py new file mode 100644 index 0000000000000000000000000000000000000000..6fb19b30bb53c18f38a9ef02dd7c4478670fb962 --- /dev/null +++ b/venv/lib/python3.10/site-packages/wheel/vendored/packaging/_elffile.py @@ -0,0 +1,108 @@ +""" +ELF file parser. + +This provides a class ``ELFFile`` that parses an ELF executable in a similar +interface to ``ZipFile``. Only the read interface is implemented. + +Based on: https://gist.github.com/lyssdod/f51579ae8d93c8657a5564aefc2ffbca +ELF header: https://refspecs.linuxfoundation.org/elf/gabi4+/ch4.eheader.html +""" + +import enum +import os +import struct +from typing import IO, Optional, Tuple + + +class ELFInvalid(ValueError): + pass + + +class EIClass(enum.IntEnum): + C32 = 1 + C64 = 2 + + +class EIData(enum.IntEnum): + Lsb = 1 + Msb = 2 + + +class EMachine(enum.IntEnum): + I386 = 3 + S390 = 22 + Arm = 40 + X8664 = 62 + AArc64 = 183 + + +class ELFFile: + """ + Representation of an ELF executable. + """ + + def __init__(self, f: IO[bytes]) -> None: + self._f = f + + try: + ident = self._read("16B") + except struct.error: + raise ELFInvalid("unable to parse identification") + magic = bytes(ident[:4]) + if magic != b"\x7fELF": + raise ELFInvalid(f"invalid magic: {magic!r}") + + self.capacity = ident[4] # Format for program header (bitness). + self.encoding = ident[5] # Data structure encoding (endianness). + + try: + # e_fmt: Format for program header. + # p_fmt: Format for section header. + # p_idx: Indexes to find p_type, p_offset, and p_filesz. + e_fmt, self._p_fmt, self._p_idx = { + (1, 1): ("HHIIIIIHHH", ">IIIIIIII", (0, 1, 4)), # 32-bit MSB. + (2, 1): ("HHIQQQIHHH", ">IIQQQQQQ", (0, 2, 5)), # 64-bit MSB. + }[(self.capacity, self.encoding)] + except KeyError: + raise ELFInvalid( + f"unrecognized capacity ({self.capacity}) or " + f"encoding ({self.encoding})" + ) + + try: + ( + _, + self.machine, # Architecture type. + _, + _, + self._e_phoff, # Offset of program header. + _, + self.flags, # Processor-specific flags. + _, + self._e_phentsize, # Size of section. + self._e_phnum, # Number of sections. + ) = self._read(e_fmt) + except struct.error as e: + raise ELFInvalid("unable to parse machine and section information") from e + + def _read(self, fmt: str) -> Tuple[int, ...]: + return struct.unpack(fmt, self._f.read(struct.calcsize(fmt))) + + @property + def interpreter(self) -> Optional[str]: + """ + The path recorded in the ``PT_INTERP`` section header. + """ + for index in range(self._e_phnum): + self._f.seek(self._e_phoff + self._e_phentsize * index) + try: + data = self._read(self._p_fmt) + except struct.error: + continue + if data[self._p_idx[0]] != 3: # Not PT_INTERP. + continue + self._f.seek(data[self._p_idx[1]]) + return os.fsdecode(self._f.read(data[self._p_idx[2]])).strip("\0") + return None diff --git a/venv/lib/python3.10/site-packages/wheel/vendored/packaging/_manylinux.py b/venv/lib/python3.10/site-packages/wheel/vendored/packaging/_manylinux.py new file mode 100644 index 0000000000000000000000000000000000000000..1f5f4ab3e514d1846d3bd189bf081fdb1528ba08 --- /dev/null +++ b/venv/lib/python3.10/site-packages/wheel/vendored/packaging/_manylinux.py @@ -0,0 +1,260 @@ +import collections +import contextlib +import functools +import os +import re +import sys +import warnings +from typing import Dict, Generator, Iterator, NamedTuple, Optional, Sequence, Tuple + +from ._elffile import EIClass, EIData, ELFFile, EMachine + +EF_ARM_ABIMASK = 0xFF000000 +EF_ARM_ABI_VER5 = 0x05000000 +EF_ARM_ABI_FLOAT_HARD = 0x00000400 + + +# `os.PathLike` not a generic type until Python 3.9, so sticking with `str` +# as the type for `path` until then. +@contextlib.contextmanager +def _parse_elf(path: str) -> Generator[Optional[ELFFile], None, None]: + try: + with open(path, "rb") as f: + yield ELFFile(f) + except (OSError, TypeError, ValueError): + yield None + + +def _is_linux_armhf(executable: str) -> bool: + # hard-float ABI can be detected from the ELF header of the running + # process + # https://static.docs.arm.com/ihi0044/g/aaelf32.pdf + with _parse_elf(executable) as f: + return ( + f is not None + and f.capacity == EIClass.C32 + and f.encoding == EIData.Lsb + and f.machine == EMachine.Arm + and f.flags & EF_ARM_ABIMASK == EF_ARM_ABI_VER5 + and f.flags & EF_ARM_ABI_FLOAT_HARD == EF_ARM_ABI_FLOAT_HARD + ) + + +def _is_linux_i686(executable: str) -> bool: + with _parse_elf(executable) as f: + return ( + f is not None + and f.capacity == EIClass.C32 + and f.encoding == EIData.Lsb + and f.machine == EMachine.I386 + ) + + +def _have_compatible_abi(executable: str, archs: Sequence[str]) -> bool: + if "armv7l" in archs: + return _is_linux_armhf(executable) + if "i686" in archs: + return _is_linux_i686(executable) + allowed_archs = { + "x86_64", + "aarch64", + "ppc64", + "ppc64le", + "s390x", + "loongarch64", + "riscv64", + } + return any(arch in allowed_archs for arch in archs) + + +# If glibc ever changes its major version, we need to know what the last +# minor version was, so we can build the complete list of all versions. +# For now, guess what the highest minor version might be, assume it will +# be 50 for testing. Once this actually happens, update the dictionary +# with the actual value. +_LAST_GLIBC_MINOR: Dict[int, int] = collections.defaultdict(lambda: 50) + + +class _GLibCVersion(NamedTuple): + major: int + minor: int + + +def _glibc_version_string_confstr() -> Optional[str]: + """ + Primary implementation of glibc_version_string using os.confstr. + """ + # os.confstr is quite a bit faster than ctypes.DLL. It's also less likely + # to be broken or missing. This strategy is used in the standard library + # platform module. + # https://github.com/python/cpython/blob/fcf1d003bf4f0100c/Lib/platform.py#L175-L183 + try: + # Should be a string like "glibc 2.17". + version_string: Optional[str] = os.confstr("CS_GNU_LIBC_VERSION") + assert version_string is not None + _, version = version_string.rsplit() + except (AssertionError, AttributeError, OSError, ValueError): + # os.confstr() or CS_GNU_LIBC_VERSION not available (or a bad value)... + return None + return version + + +def _glibc_version_string_ctypes() -> Optional[str]: + """ + Fallback implementation of glibc_version_string using ctypes. + """ + try: + import ctypes + except ImportError: + return None + + # ctypes.CDLL(None) internally calls dlopen(NULL), and as the dlopen + # manpage says, "If filename is NULL, then the returned handle is for the + # main program". This way we can let the linker do the work to figure out + # which libc our process is actually using. + # + # We must also handle the special case where the executable is not a + # dynamically linked executable. This can occur when using musl libc, + # for example. In this situation, dlopen() will error, leading to an + # OSError. Interestingly, at least in the case of musl, there is no + # errno set on the OSError. The single string argument used to construct + # OSError comes from libc itself and is therefore not portable to + # hard code here. In any case, failure to call dlopen() means we + # can proceed, so we bail on our attempt. + try: + process_namespace = ctypes.CDLL(None) + except OSError: + return None + + try: + gnu_get_libc_version = process_namespace.gnu_get_libc_version + except AttributeError: + # Symbol doesn't exist -> therefore, we are not linked to + # glibc. + return None + + # Call gnu_get_libc_version, which returns a string like "2.5" + gnu_get_libc_version.restype = ctypes.c_char_p + version_str: str = gnu_get_libc_version() + # py2 / py3 compatibility: + if not isinstance(version_str, str): + version_str = version_str.decode("ascii") + + return version_str + + +def _glibc_version_string() -> Optional[str]: + """Returns glibc version string, or None if not using glibc.""" + return _glibc_version_string_confstr() or _glibc_version_string_ctypes() + + +def _parse_glibc_version(version_str: str) -> Tuple[int, int]: + """Parse glibc version. + + We use a regexp instead of str.split because we want to discard any + random junk that might come after the minor version -- this might happen + in patched/forked versions of glibc (e.g. Linaro's version of glibc + uses version strings like "2.20-2014.11"). See gh-3588. + """ + m = re.match(r"(?P[0-9]+)\.(?P[0-9]+)", version_str) + if not m: + warnings.warn( + f"Expected glibc version with 2 components major.minor," + f" got: {version_str}", + RuntimeWarning, + ) + return -1, -1 + return int(m.group("major")), int(m.group("minor")) + + +@functools.lru_cache +def _get_glibc_version() -> Tuple[int, int]: + version_str = _glibc_version_string() + if version_str is None: + return (-1, -1) + return _parse_glibc_version(version_str) + + +# From PEP 513, PEP 600 +def _is_compatible(arch: str, version: _GLibCVersion) -> bool: + sys_glibc = _get_glibc_version() + if sys_glibc < version: + return False + # Check for presence of _manylinux module. + try: + import _manylinux + except ImportError: + return True + if hasattr(_manylinux, "manylinux_compatible"): + result = _manylinux.manylinux_compatible(version[0], version[1], arch) + if result is not None: + return bool(result) + return True + if version == _GLibCVersion(2, 5): + if hasattr(_manylinux, "manylinux1_compatible"): + return bool(_manylinux.manylinux1_compatible) + if version == _GLibCVersion(2, 12): + if hasattr(_manylinux, "manylinux2010_compatible"): + return bool(_manylinux.manylinux2010_compatible) + if version == _GLibCVersion(2, 17): + if hasattr(_manylinux, "manylinux2014_compatible"): + return bool(_manylinux.manylinux2014_compatible) + return True + + +_LEGACY_MANYLINUX_MAP = { + # CentOS 7 w/ glibc 2.17 (PEP 599) + (2, 17): "manylinux2014", + # CentOS 6 w/ glibc 2.12 (PEP 571) + (2, 12): "manylinux2010", + # CentOS 5 w/ glibc 2.5 (PEP 513) + (2, 5): "manylinux1", +} + + +def platform_tags(archs: Sequence[str]) -> Iterator[str]: + """Generate manylinux tags compatible to the current platform. + + :param archs: Sequence of compatible architectures. + The first one shall be the closest to the actual architecture and be the part of + platform tag after the ``linux_`` prefix, e.g. ``x86_64``. + The ``linux_`` prefix is assumed as a prerequisite for the current platform to + be manylinux-compatible. + + :returns: An iterator of compatible manylinux tags. + """ + if not _have_compatible_abi(sys.executable, archs): + return + # Oldest glibc to be supported regardless of architecture is (2, 17). + too_old_glibc2 = _GLibCVersion(2, 16) + if set(archs) & {"x86_64", "i686"}: + # On x86/i686 also oldest glibc to be supported is (2, 5). + too_old_glibc2 = _GLibCVersion(2, 4) + current_glibc = _GLibCVersion(*_get_glibc_version()) + glibc_max_list = [current_glibc] + # We can assume compatibility across glibc major versions. + # https://sourceware.org/bugzilla/show_bug.cgi?id=24636 + # + # Build a list of maximum glibc versions so that we can + # output the canonical list of all glibc from current_glibc + # down to too_old_glibc2, including all intermediary versions. + for glibc_major in range(current_glibc.major - 1, 1, -1): + glibc_minor = _LAST_GLIBC_MINOR[glibc_major] + glibc_max_list.append(_GLibCVersion(glibc_major, glibc_minor)) + for arch in archs: + for glibc_max in glibc_max_list: + if glibc_max.major == too_old_glibc2.major: + min_minor = too_old_glibc2.minor + else: + # For other glibc major versions oldest supported is (x, 0). + min_minor = -1 + for glibc_minor in range(glibc_max.minor, min_minor, -1): + glibc_version = _GLibCVersion(glibc_max.major, glibc_minor) + tag = "manylinux_{}_{}".format(*glibc_version) + if _is_compatible(arch, glibc_version): + yield f"{tag}_{arch}" + # Handle the legacy manylinux1, manylinux2010, manylinux2014 tags. + if glibc_version in _LEGACY_MANYLINUX_MAP: + legacy_tag = _LEGACY_MANYLINUX_MAP[glibc_version] + if _is_compatible(arch, glibc_version): + yield f"{legacy_tag}_{arch}" diff --git a/venv/lib/python3.10/site-packages/wheel/vendored/packaging/_musllinux.py b/venv/lib/python3.10/site-packages/wheel/vendored/packaging/_musllinux.py new file mode 100644 index 0000000000000000000000000000000000000000..eb4251b5c1e82772b2b0ea539943da5141fd55ec --- /dev/null +++ b/venv/lib/python3.10/site-packages/wheel/vendored/packaging/_musllinux.py @@ -0,0 +1,83 @@ +"""PEP 656 support. + +This module implements logic to detect if the currently running Python is +linked against musl, and what musl version is used. +""" + +import functools +import re +import subprocess +import sys +from typing import Iterator, NamedTuple, Optional, Sequence + +from ._elffile import ELFFile + + +class _MuslVersion(NamedTuple): + major: int + minor: int + + +def _parse_musl_version(output: str) -> Optional[_MuslVersion]: + lines = [n for n in (n.strip() for n in output.splitlines()) if n] + if len(lines) < 2 or lines[0][:4] != "musl": + return None + m = re.match(r"Version (\d+)\.(\d+)", lines[1]) + if not m: + return None + return _MuslVersion(major=int(m.group(1)), minor=int(m.group(2))) + + +@functools.lru_cache +def _get_musl_version(executable: str) -> Optional[_MuslVersion]: + """Detect currently-running musl runtime version. + + This is done by checking the specified executable's dynamic linking + information, and invoking the loader to parse its output for a version + string. If the loader is musl, the output would be something like:: + + musl libc (x86_64) + Version 1.2.2 + Dynamic Program Loader + """ + try: + with open(executable, "rb") as f: + ld = ELFFile(f).interpreter + except (OSError, TypeError, ValueError): + return None + if ld is None or "musl" not in ld: + return None + proc = subprocess.run([ld], stderr=subprocess.PIPE, text=True) + return _parse_musl_version(proc.stderr) + + +def platform_tags(archs: Sequence[str]) -> Iterator[str]: + """Generate musllinux tags compatible to the current platform. + + :param archs: Sequence of compatible architectures. + The first one shall be the closest to the actual architecture and be the part of + platform tag after the ``linux_`` prefix, e.g. ``x86_64``. + The ``linux_`` prefix is assumed as a prerequisite for the current platform to + be musllinux-compatible. + + :returns: An iterator of compatible musllinux tags. + """ + sys_musl = _get_musl_version(sys.executable) + if sys_musl is None: # Python not dynamically linked against musl. + return + for arch in archs: + for minor in range(sys_musl.minor, -1, -1): + yield f"musllinux_{sys_musl.major}_{minor}_{arch}" + + +if __name__ == "__main__": # pragma: no cover + import sysconfig + + plat = sysconfig.get_platform() + assert plat.startswith("linux-"), "not linux" + + print("plat:", plat) + print("musl:", _get_musl_version(sys.executable)) + print("tags:", end=" ") + for t in platform_tags(re.sub(r"[.-]", "_", plat.split("-", 1)[-1])): + print(t, end="\n ") diff --git a/venv/lib/python3.10/site-packages/wheel/vendored/packaging/_parser.py b/venv/lib/python3.10/site-packages/wheel/vendored/packaging/_parser.py new file mode 100644 index 0000000000000000000000000000000000000000..513686a2190f9911c08ca1ca263f37b799f44702 --- /dev/null +++ b/venv/lib/python3.10/site-packages/wheel/vendored/packaging/_parser.py @@ -0,0 +1,356 @@ +"""Handwritten parser of dependency specifiers. + +The docstring for each __parse_* function contains EBNF-inspired grammar representing +the implementation. +""" + +import ast +from typing import Any, List, NamedTuple, Optional, Tuple, Union + +from ._tokenizer import DEFAULT_RULES, Tokenizer + + +class Node: + def __init__(self, value: str) -> None: + self.value = value + + def __str__(self) -> str: + return self.value + + def __repr__(self) -> str: + return f"<{self.__class__.__name__}('{self}')>" + + def serialize(self) -> str: + raise NotImplementedError + + +class Variable(Node): + def serialize(self) -> str: + return str(self) + + +class Value(Node): + def serialize(self) -> str: + return f'"{self}"' + + +class Op(Node): + def serialize(self) -> str: + return str(self) + + +MarkerVar = Union[Variable, Value] +MarkerItem = Tuple[MarkerVar, Op, MarkerVar] +# MarkerAtom = Union[MarkerItem, List["MarkerAtom"]] +# MarkerList = List[Union["MarkerList", MarkerAtom, str]] +# mypy does not support recursive type definition +# https://github.com/python/mypy/issues/731 +MarkerAtom = Any +MarkerList = List[Any] + + +class ParsedRequirement(NamedTuple): + name: str + url: str + extras: List[str] + specifier: str + marker: Optional[MarkerList] + + +# -------------------------------------------------------------------------------------- +# Recursive descent parser for dependency specifier +# -------------------------------------------------------------------------------------- +def parse_requirement(source: str) -> ParsedRequirement: + return _parse_requirement(Tokenizer(source, rules=DEFAULT_RULES)) + + +def _parse_requirement(tokenizer: Tokenizer) -> ParsedRequirement: + """ + requirement = WS? IDENTIFIER WS? extras WS? requirement_details + """ + tokenizer.consume("WS") + + name_token = tokenizer.expect( + "IDENTIFIER", expected="package name at the start of dependency specifier" + ) + name = name_token.text + tokenizer.consume("WS") + + extras = _parse_extras(tokenizer) + tokenizer.consume("WS") + + url, specifier, marker = _parse_requirement_details(tokenizer) + tokenizer.expect("END", expected="end of dependency specifier") + + return ParsedRequirement(name, url, extras, specifier, marker) + + +def _parse_requirement_details( + tokenizer: Tokenizer, +) -> Tuple[str, str, Optional[MarkerList]]: + """ + requirement_details = AT URL (WS requirement_marker?)? + | specifier WS? (requirement_marker)? + """ + + specifier = "" + url = "" + marker = None + + if tokenizer.check("AT"): + tokenizer.read() + tokenizer.consume("WS") + + url_start = tokenizer.position + url = tokenizer.expect("URL", expected="URL after @").text + if tokenizer.check("END", peek=True): + return (url, specifier, marker) + + tokenizer.expect("WS", expected="whitespace after URL") + + # The input might end after whitespace. + if tokenizer.check("END", peek=True): + return (url, specifier, marker) + + marker = _parse_requirement_marker( + tokenizer, span_start=url_start, after="URL and whitespace" + ) + else: + specifier_start = tokenizer.position + specifier = _parse_specifier(tokenizer) + tokenizer.consume("WS") + + if tokenizer.check("END", peek=True): + return (url, specifier, marker) + + marker = _parse_requirement_marker( + tokenizer, + span_start=specifier_start, + after=( + "version specifier" + if specifier + else "name and no valid version specifier" + ), + ) + + return (url, specifier, marker) + + +def _parse_requirement_marker( + tokenizer: Tokenizer, *, span_start: int, after: str +) -> MarkerList: + """ + requirement_marker = SEMICOLON marker WS? + """ + + if not tokenizer.check("SEMICOLON"): + tokenizer.raise_syntax_error( + f"Expected end or semicolon (after {after})", + span_start=span_start, + ) + tokenizer.read() + + marker = _parse_marker(tokenizer) + tokenizer.consume("WS") + + return marker + + +def _parse_extras(tokenizer: Tokenizer) -> List[str]: + """ + extras = (LEFT_BRACKET wsp* extras_list? wsp* RIGHT_BRACKET)? + """ + if not tokenizer.check("LEFT_BRACKET", peek=True): + return [] + + with tokenizer.enclosing_tokens( + "LEFT_BRACKET", + "RIGHT_BRACKET", + around="extras", + ): + tokenizer.consume("WS") + extras = _parse_extras_list(tokenizer) + tokenizer.consume("WS") + + return extras + + +def _parse_extras_list(tokenizer: Tokenizer) -> List[str]: + """ + extras_list = identifier (wsp* ',' wsp* identifier)* + """ + extras: List[str] = [] + + if not tokenizer.check("IDENTIFIER"): + return extras + + extras.append(tokenizer.read().text) + + while True: + tokenizer.consume("WS") + if tokenizer.check("IDENTIFIER", peek=True): + tokenizer.raise_syntax_error("Expected comma between extra names") + elif not tokenizer.check("COMMA"): + break + + tokenizer.read() + tokenizer.consume("WS") + + extra_token = tokenizer.expect("IDENTIFIER", expected="extra name after comma") + extras.append(extra_token.text) + + return extras + + +def _parse_specifier(tokenizer: Tokenizer) -> str: + """ + specifier = LEFT_PARENTHESIS WS? version_many WS? RIGHT_PARENTHESIS + | WS? version_many WS? + """ + with tokenizer.enclosing_tokens( + "LEFT_PARENTHESIS", + "RIGHT_PARENTHESIS", + around="version specifier", + ): + tokenizer.consume("WS") + parsed_specifiers = _parse_version_many(tokenizer) + tokenizer.consume("WS") + + return parsed_specifiers + + +def _parse_version_many(tokenizer: Tokenizer) -> str: + """ + version_many = (SPECIFIER (WS? COMMA WS? SPECIFIER)*)? + """ + parsed_specifiers = "" + while tokenizer.check("SPECIFIER"): + span_start = tokenizer.position + parsed_specifiers += tokenizer.read().text + if tokenizer.check("VERSION_PREFIX_TRAIL", peek=True): + tokenizer.raise_syntax_error( + ".* suffix can only be used with `==` or `!=` operators", + span_start=span_start, + span_end=tokenizer.position + 1, + ) + if tokenizer.check("VERSION_LOCAL_LABEL_TRAIL", peek=True): + tokenizer.raise_syntax_error( + "Local version label can only be used with `==` or `!=` operators", + span_start=span_start, + span_end=tokenizer.position, + ) + tokenizer.consume("WS") + if not tokenizer.check("COMMA"): + break + parsed_specifiers += tokenizer.read().text + tokenizer.consume("WS") + + return parsed_specifiers + + +# -------------------------------------------------------------------------------------- +# Recursive descent parser for marker expression +# -------------------------------------------------------------------------------------- +def parse_marker(source: str) -> MarkerList: + return _parse_full_marker(Tokenizer(source, rules=DEFAULT_RULES)) + + +def _parse_full_marker(tokenizer: Tokenizer) -> MarkerList: + retval = _parse_marker(tokenizer) + tokenizer.expect("END", expected="end of marker expression") + return retval + + +def _parse_marker(tokenizer: Tokenizer) -> MarkerList: + """ + marker = marker_atom (BOOLOP marker_atom)+ + """ + expression = [_parse_marker_atom(tokenizer)] + while tokenizer.check("BOOLOP"): + token = tokenizer.read() + expr_right = _parse_marker_atom(tokenizer) + expression.extend((token.text, expr_right)) + return expression + + +def _parse_marker_atom(tokenizer: Tokenizer) -> MarkerAtom: + """ + marker_atom = WS? LEFT_PARENTHESIS WS? marker WS? RIGHT_PARENTHESIS WS? + | WS? marker_item WS? + """ + + tokenizer.consume("WS") + if tokenizer.check("LEFT_PARENTHESIS", peek=True): + with tokenizer.enclosing_tokens( + "LEFT_PARENTHESIS", + "RIGHT_PARENTHESIS", + around="marker expression", + ): + tokenizer.consume("WS") + marker: MarkerAtom = _parse_marker(tokenizer) + tokenizer.consume("WS") + else: + marker = _parse_marker_item(tokenizer) + tokenizer.consume("WS") + return marker + + +def _parse_marker_item(tokenizer: Tokenizer) -> MarkerItem: + """ + marker_item = WS? marker_var WS? marker_op WS? marker_var WS? + """ + tokenizer.consume("WS") + marker_var_left = _parse_marker_var(tokenizer) + tokenizer.consume("WS") + marker_op = _parse_marker_op(tokenizer) + tokenizer.consume("WS") + marker_var_right = _parse_marker_var(tokenizer) + tokenizer.consume("WS") + return (marker_var_left, marker_op, marker_var_right) + + +def _parse_marker_var(tokenizer: Tokenizer) -> MarkerVar: + """ + marker_var = VARIABLE | QUOTED_STRING + """ + if tokenizer.check("VARIABLE"): + return process_env_var(tokenizer.read().text.replace(".", "_")) + elif tokenizer.check("QUOTED_STRING"): + return process_python_str(tokenizer.read().text) + else: + tokenizer.raise_syntax_error( + message="Expected a marker variable or quoted string" + ) + + +def process_env_var(env_var: str) -> Variable: + if env_var in ("platform_python_implementation", "python_implementation"): + return Variable("platform_python_implementation") + else: + return Variable(env_var) + + +def process_python_str(python_str: str) -> Value: + value = ast.literal_eval(python_str) + return Value(str(value)) + + +def _parse_marker_op(tokenizer: Tokenizer) -> Op: + """ + marker_op = IN | NOT IN | OP + """ + if tokenizer.check("IN"): + tokenizer.read() + return Op("in") + elif tokenizer.check("NOT"): + tokenizer.read() + tokenizer.expect("WS", expected="whitespace after 'not'") + tokenizer.expect("IN", expected="'in' after 'not'") + return Op("not in") + elif tokenizer.check("OP"): + return Op(tokenizer.read().text) + else: + return tokenizer.raise_syntax_error( + "Expected marker operator, one of " + "<=, <, !=, ==, >=, >, ~=, ===, in, not in" + ) diff --git a/venv/lib/python3.10/site-packages/wheel/vendored/packaging/_structures.py b/venv/lib/python3.10/site-packages/wheel/vendored/packaging/_structures.py new file mode 100644 index 0000000000000000000000000000000000000000..90a6465f9682c886363eea5327dac64bf623a6ff --- /dev/null +++ b/venv/lib/python3.10/site-packages/wheel/vendored/packaging/_structures.py @@ -0,0 +1,61 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + + +class InfinityType: + def __repr__(self) -> str: + return "Infinity" + + def __hash__(self) -> int: + return hash(repr(self)) + + def __lt__(self, other: object) -> bool: + return False + + def __le__(self, other: object) -> bool: + return False + + def __eq__(self, other: object) -> bool: + return isinstance(other, self.__class__) + + def __gt__(self, other: object) -> bool: + return True + + def __ge__(self, other: object) -> bool: + return True + + def __neg__(self: object) -> "NegativeInfinityType": + return NegativeInfinity + + +Infinity = InfinityType() + + +class NegativeInfinityType: + def __repr__(self) -> str: + return "-Infinity" + + def __hash__(self) -> int: + return hash(repr(self)) + + def __lt__(self, other: object) -> bool: + return True + + def __le__(self, other: object) -> bool: + return True + + def __eq__(self, other: object) -> bool: + return isinstance(other, self.__class__) + + def __gt__(self, other: object) -> bool: + return False + + def __ge__(self, other: object) -> bool: + return False + + def __neg__(self: object) -> InfinityType: + return Infinity + + +NegativeInfinity = NegativeInfinityType() diff --git a/venv/lib/python3.10/site-packages/wheel/vendored/packaging/_tokenizer.py b/venv/lib/python3.10/site-packages/wheel/vendored/packaging/_tokenizer.py new file mode 100644 index 0000000000000000000000000000000000000000..dd0d648d49a7c1a62d25ce5c9107aa448a8a22d1 --- /dev/null +++ b/venv/lib/python3.10/site-packages/wheel/vendored/packaging/_tokenizer.py @@ -0,0 +1,192 @@ +import contextlib +import re +from dataclasses import dataclass +from typing import Dict, Iterator, NoReturn, Optional, Tuple, Union + +from .specifiers import Specifier + + +@dataclass +class Token: + name: str + text: str + position: int + + +class ParserSyntaxError(Exception): + """The provided source text could not be parsed correctly.""" + + def __init__( + self, + message: str, + *, + source: str, + span: Tuple[int, int], + ) -> None: + self.span = span + self.message = message + self.source = source + + super().__init__() + + def __str__(self) -> str: + marker = " " * self.span[0] + "~" * (self.span[1] - self.span[0]) + "^" + return "\n ".join([self.message, self.source, marker]) + + +DEFAULT_RULES: "Dict[str, Union[str, re.Pattern[str]]]" = { + "LEFT_PARENTHESIS": r"\(", + "RIGHT_PARENTHESIS": r"\)", + "LEFT_BRACKET": r"\[", + "RIGHT_BRACKET": r"\]", + "SEMICOLON": r";", + "COMMA": r",", + "QUOTED_STRING": re.compile( + r""" + ( + ('[^']*') + | + ("[^"]*") + ) + """, + re.VERBOSE, + ), + "OP": r"(===|==|~=|!=|<=|>=|<|>)", + "BOOLOP": r"\b(or|and)\b", + "IN": r"\bin\b", + "NOT": r"\bnot\b", + "VARIABLE": re.compile( + r""" + \b( + python_version + |python_full_version + |os[._]name + |sys[._]platform + |platform_(release|system) + |platform[._](version|machine|python_implementation) + |python_implementation + |implementation_(name|version) + |extra + )\b + """, + re.VERBOSE, + ), + "SPECIFIER": re.compile( + Specifier._operator_regex_str + Specifier._version_regex_str, + re.VERBOSE | re.IGNORECASE, + ), + "AT": r"\@", + "URL": r"[^ \t]+", + "IDENTIFIER": r"\b[a-zA-Z0-9][a-zA-Z0-9._-]*\b", + "VERSION_PREFIX_TRAIL": r"\.\*", + "VERSION_LOCAL_LABEL_TRAIL": r"\+[a-z0-9]+(?:[-_\.][a-z0-9]+)*", + "WS": r"[ \t]+", + "END": r"$", +} + + +class Tokenizer: + """Context-sensitive token parsing. + + Provides methods to examine the input stream to check whether the next token + matches. + """ + + def __init__( + self, + source: str, + *, + rules: "Dict[str, Union[str, re.Pattern[str]]]", + ) -> None: + self.source = source + self.rules: Dict[str, re.Pattern[str]] = { + name: re.compile(pattern) for name, pattern in rules.items() + } + self.next_token: Optional[Token] = None + self.position = 0 + + def consume(self, name: str) -> None: + """Move beyond provided token name, if at current position.""" + if self.check(name): + self.read() + + def check(self, name: str, *, peek: bool = False) -> bool: + """Check whether the next token has the provided name. + + By default, if the check succeeds, the token *must* be read before + another check. If `peek` is set to `True`, the token is not loaded and + would need to be checked again. + """ + assert ( + self.next_token is None + ), f"Cannot check for {name!r}, already have {self.next_token!r}" + assert name in self.rules, f"Unknown token name: {name!r}" + + expression = self.rules[name] + + match = expression.match(self.source, self.position) + if match is None: + return False + if not peek: + self.next_token = Token(name, match[0], self.position) + return True + + def expect(self, name: str, *, expected: str) -> Token: + """Expect a certain token name next, failing with a syntax error otherwise. + + The token is *not* read. + """ + if not self.check(name): + raise self.raise_syntax_error(f"Expected {expected}") + return self.read() + + def read(self) -> Token: + """Consume the next token and return it.""" + token = self.next_token + assert token is not None + + self.position += len(token.text) + self.next_token = None + + return token + + def raise_syntax_error( + self, + message: str, + *, + span_start: Optional[int] = None, + span_end: Optional[int] = None, + ) -> NoReturn: + """Raise ParserSyntaxError at the given position.""" + span = ( + self.position if span_start is None else span_start, + self.position if span_end is None else span_end, + ) + raise ParserSyntaxError( + message, + source=self.source, + span=span, + ) + + @contextlib.contextmanager + def enclosing_tokens( + self, open_token: str, close_token: str, *, around: str + ) -> Iterator[None]: + if self.check(open_token): + open_position = self.position + self.read() + else: + open_position = None + + yield + + if open_position is None: + return + + if not self.check(close_token): + self.raise_syntax_error( + f"Expected matching {close_token} for {open_token}, after {around}", + span_start=open_position, + ) + + self.read() diff --git a/venv/lib/python3.10/site-packages/wheel/vendored/packaging/markers.py b/venv/lib/python3.10/site-packages/wheel/vendored/packaging/markers.py new file mode 100644 index 0000000000000000000000000000000000000000..c96d22a5a445e7353cd2454dec4255d3785c07b3 --- /dev/null +++ b/venv/lib/python3.10/site-packages/wheel/vendored/packaging/markers.py @@ -0,0 +1,253 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +import operator +import os +import platform +import sys +from typing import Any, Callable, Dict, List, Optional, Tuple, Union + +from ._parser import ( + MarkerAtom, + MarkerList, + Op, + Value, + Variable, +) +from ._parser import ( + parse_marker as _parse_marker, +) +from ._tokenizer import ParserSyntaxError +from .specifiers import InvalidSpecifier, Specifier +from .utils import canonicalize_name + +__all__ = [ + "InvalidMarker", + "UndefinedComparison", + "UndefinedEnvironmentName", + "Marker", + "default_environment", +] + +Operator = Callable[[str, str], bool] + + +class InvalidMarker(ValueError): + """ + An invalid marker was found, users should refer to PEP 508. + """ + + +class UndefinedComparison(ValueError): + """ + An invalid operation was attempted on a value that doesn't support it. + """ + + +class UndefinedEnvironmentName(ValueError): + """ + A name was attempted to be used that does not exist inside of the + environment. + """ + + +def _normalize_extra_values(results: Any) -> Any: + """ + Normalize extra values. + """ + if isinstance(results[0], tuple): + lhs, op, rhs = results[0] + if isinstance(lhs, Variable) and lhs.value == "extra": + normalized_extra = canonicalize_name(rhs.value) + rhs = Value(normalized_extra) + elif isinstance(rhs, Variable) and rhs.value == "extra": + normalized_extra = canonicalize_name(lhs.value) + lhs = Value(normalized_extra) + results[0] = lhs, op, rhs + return results + + +def _format_marker( + marker: Union[List[str], MarkerAtom, str], first: Optional[bool] = True +) -> str: + assert isinstance(marker, (list, tuple, str)) + + # Sometimes we have a structure like [[...]] which is a single item list + # where the single item is itself it's own list. In that case we want skip + # the rest of this function so that we don't get extraneous () on the + # outside. + if ( + isinstance(marker, list) + and len(marker) == 1 + and isinstance(marker[0], (list, tuple)) + ): + return _format_marker(marker[0]) + + if isinstance(marker, list): + inner = (_format_marker(m, first=False) for m in marker) + if first: + return " ".join(inner) + else: + return "(" + " ".join(inner) + ")" + elif isinstance(marker, tuple): + return " ".join([m.serialize() for m in marker]) + else: + return marker + + +_operators: Dict[str, Operator] = { + "in": lambda lhs, rhs: lhs in rhs, + "not in": lambda lhs, rhs: lhs not in rhs, + "<": operator.lt, + "<=": operator.le, + "==": operator.eq, + "!=": operator.ne, + ">=": operator.ge, + ">": operator.gt, +} + + +def _eval_op(lhs: str, op: Op, rhs: str) -> bool: + try: + spec = Specifier("".join([op.serialize(), rhs])) + except InvalidSpecifier: + pass + else: + return spec.contains(lhs, prereleases=True) + + oper: Optional[Operator] = _operators.get(op.serialize()) + if oper is None: + raise UndefinedComparison(f"Undefined {op!r} on {lhs!r} and {rhs!r}.") + + return oper(lhs, rhs) + + +def _normalize(*values: str, key: str) -> Tuple[str, ...]: + # PEP 685 – Comparison of extra names for optional distribution dependencies + # https://peps.python.org/pep-0685/ + # > When comparing extra names, tools MUST normalize the names being + # > compared using the semantics outlined in PEP 503 for names + if key == "extra": + return tuple(canonicalize_name(v) for v in values) + + # other environment markers don't have such standards + return values + + +def _evaluate_markers(markers: MarkerList, environment: Dict[str, str]) -> bool: + groups: List[List[bool]] = [[]] + + for marker in markers: + assert isinstance(marker, (list, tuple, str)) + + if isinstance(marker, list): + groups[-1].append(_evaluate_markers(marker, environment)) + elif isinstance(marker, tuple): + lhs, op, rhs = marker + + if isinstance(lhs, Variable): + environment_key = lhs.value + lhs_value = environment[environment_key] + rhs_value = rhs.value + else: + lhs_value = lhs.value + environment_key = rhs.value + rhs_value = environment[environment_key] + + lhs_value, rhs_value = _normalize(lhs_value, rhs_value, key=environment_key) + groups[-1].append(_eval_op(lhs_value, op, rhs_value)) + else: + assert marker in ["and", "or"] + if marker == "or": + groups.append([]) + + return any(all(item) for item in groups) + + +def format_full_version(info: "sys._version_info") -> str: + version = "{0.major}.{0.minor}.{0.micro}".format(info) + kind = info.releaselevel + if kind != "final": + version += kind[0] + str(info.serial) + return version + + +def default_environment() -> Dict[str, str]: + iver = format_full_version(sys.implementation.version) + implementation_name = sys.implementation.name + return { + "implementation_name": implementation_name, + "implementation_version": iver, + "os_name": os.name, + "platform_machine": platform.machine(), + "platform_release": platform.release(), + "platform_system": platform.system(), + "platform_version": platform.version(), + "python_full_version": platform.python_version(), + "platform_python_implementation": platform.python_implementation(), + "python_version": ".".join(platform.python_version_tuple()[:2]), + "sys_platform": sys.platform, + } + + +class Marker: + def __init__(self, marker: str) -> None: + # Note: We create a Marker object without calling this constructor in + # packaging.requirements.Requirement. If any additional logic is + # added here, make sure to mirror/adapt Requirement. + try: + self._markers = _normalize_extra_values(_parse_marker(marker)) + # The attribute `_markers` can be described in terms of a recursive type: + # MarkerList = List[Union[Tuple[Node, ...], str, MarkerList]] + # + # For example, the following expression: + # python_version > "3.6" or (python_version == "3.6" and os_name == "unix") + # + # is parsed into: + # [ + # (, ')>, ), + # 'and', + # [ + # (, , ), + # 'or', + # (, , ) + # ] + # ] + except ParserSyntaxError as e: + raise InvalidMarker(str(e)) from e + + def __str__(self) -> str: + return _format_marker(self._markers) + + def __repr__(self) -> str: + return f"" + + def __hash__(self) -> int: + return hash((self.__class__.__name__, str(self))) + + def __eq__(self, other: Any) -> bool: + if not isinstance(other, Marker): + return NotImplemented + + return str(self) == str(other) + + def evaluate(self, environment: Optional[Dict[str, str]] = None) -> bool: + """Evaluate a marker. + + Return the boolean from evaluating the given marker against the + environment. environment is an optional argument to override all or + part of the determined environment. + + The environment is determined from the current Python process. + """ + current_environment = default_environment() + current_environment["extra"] = "" + if environment is not None: + current_environment.update(environment) + # The API used to allow setting extra to None. We need to handle this + # case for backwards compatibility. + if current_environment["extra"] is None: + current_environment["extra"] = "" + + return _evaluate_markers(self._markers, current_environment) diff --git a/venv/lib/python3.10/site-packages/wheel/vendored/packaging/requirements.py b/venv/lib/python3.10/site-packages/wheel/vendored/packaging/requirements.py new file mode 100644 index 0000000000000000000000000000000000000000..bdc43a7e98d87dba0c2069bfb4554f71d228cad4 --- /dev/null +++ b/venv/lib/python3.10/site-packages/wheel/vendored/packaging/requirements.py @@ -0,0 +1,90 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from typing import Any, Iterator, Optional, Set + +from ._parser import parse_requirement as _parse_requirement +from ._tokenizer import ParserSyntaxError +from .markers import Marker, _normalize_extra_values +from .specifiers import SpecifierSet +from .utils import canonicalize_name + + +class InvalidRequirement(ValueError): + """ + An invalid requirement was found, users should refer to PEP 508. + """ + + +class Requirement: + """Parse a requirement. + + Parse a given requirement string into its parts, such as name, specifier, + URL, and extras. Raises InvalidRequirement on a badly-formed requirement + string. + """ + + # TODO: Can we test whether something is contained within a requirement? + # If so how do we do that? Do we need to test against the _name_ of + # the thing as well as the version? What about the markers? + # TODO: Can we normalize the name and extra name? + + def __init__(self, requirement_string: str) -> None: + try: + parsed = _parse_requirement(requirement_string) + except ParserSyntaxError as e: + raise InvalidRequirement(str(e)) from e + + self.name: str = parsed.name + self.url: Optional[str] = parsed.url or None + self.extras: Set[str] = set(parsed.extras or []) + self.specifier: SpecifierSet = SpecifierSet(parsed.specifier) + self.marker: Optional[Marker] = None + if parsed.marker is not None: + self.marker = Marker.__new__(Marker) + self.marker._markers = _normalize_extra_values(parsed.marker) + + def _iter_parts(self, name: str) -> Iterator[str]: + yield name + + if self.extras: + formatted_extras = ",".join(sorted(self.extras)) + yield f"[{formatted_extras}]" + + if self.specifier: + yield str(self.specifier) + + if self.url: + yield f"@ {self.url}" + if self.marker: + yield " " + + if self.marker: + yield f"; {self.marker}" + + def __str__(self) -> str: + return "".join(self._iter_parts(self.name)) + + def __repr__(self) -> str: + return f"" + + def __hash__(self) -> int: + return hash( + ( + self.__class__.__name__, + *self._iter_parts(canonicalize_name(self.name)), + ) + ) + + def __eq__(self, other: Any) -> bool: + if not isinstance(other, Requirement): + return NotImplemented + + return ( + canonicalize_name(self.name) == canonicalize_name(other.name) + and self.extras == other.extras + and self.specifier == other.specifier + and self.url == other.url + and self.marker == other.marker + ) diff --git a/venv/lib/python3.10/site-packages/wheel/vendored/packaging/specifiers.py b/venv/lib/python3.10/site-packages/wheel/vendored/packaging/specifiers.py new file mode 100644 index 0000000000000000000000000000000000000000..6d4066ae2770a3112f37d0e30d9a98fe59c4861f --- /dev/null +++ b/venv/lib/python3.10/site-packages/wheel/vendored/packaging/specifiers.py @@ -0,0 +1,1011 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. +""" +.. testsetup:: + + from packaging.specifiers import Specifier, SpecifierSet, InvalidSpecifier + from packaging.version import Version +""" + +import abc +import itertools +import re +from typing import Callable, Iterable, Iterator, List, Optional, Tuple, TypeVar, Union + +from .utils import canonicalize_version +from .version import Version + +UnparsedVersion = Union[Version, str] +UnparsedVersionVar = TypeVar("UnparsedVersionVar", bound=UnparsedVersion) +CallableOperator = Callable[[Version, str], bool] + + +def _coerce_version(version: UnparsedVersion) -> Version: + if not isinstance(version, Version): + version = Version(version) + return version + + +class InvalidSpecifier(ValueError): + """ + Raised when attempting to create a :class:`Specifier` with a specifier + string that is invalid. + + >>> Specifier("lolwat") + Traceback (most recent call last): + ... + packaging.specifiers.InvalidSpecifier: Invalid specifier: 'lolwat' + """ + + +class BaseSpecifier(metaclass=abc.ABCMeta): + @abc.abstractmethod + def __str__(self) -> str: + """ + Returns the str representation of this Specifier-like object. This + should be representative of the Specifier itself. + """ + + @abc.abstractmethod + def __hash__(self) -> int: + """ + Returns a hash value for this Specifier-like object. + """ + + @abc.abstractmethod + def __eq__(self, other: object) -> bool: + """ + Returns a boolean representing whether or not the two Specifier-like + objects are equal. + + :param other: The other object to check against. + """ + + @property + @abc.abstractmethod + def prereleases(self) -> Optional[bool]: + """Whether or not pre-releases as a whole are allowed. + + This can be set to either ``True`` or ``False`` to explicitly enable or disable + prereleases or it can be set to ``None`` (the default) to use default semantics. + """ + + @prereleases.setter + def prereleases(self, value: bool) -> None: + """Setter for :attr:`prereleases`. + + :param value: The value to set. + """ + + @abc.abstractmethod + def contains(self, item: str, prereleases: Optional[bool] = None) -> bool: + """ + Determines if the given item is contained within this specifier. + """ + + @abc.abstractmethod + def filter( + self, iterable: Iterable[UnparsedVersionVar], prereleases: Optional[bool] = None + ) -> Iterator[UnparsedVersionVar]: + """ + Takes an iterable of items and filters them so that only items which + are contained within this specifier are allowed in it. + """ + + +class Specifier(BaseSpecifier): + """This class abstracts handling of version specifiers. + + .. tip:: + + It is generally not required to instantiate this manually. You should instead + prefer to work with :class:`SpecifierSet` instead, which can parse + comma-separated version specifiers (which is what package metadata contains). + """ + + _operator_regex_str = r""" + (?P(~=|==|!=|<=|>=|<|>|===)) + """ + _version_regex_str = r""" + (?P + (?: + # The identity operators allow for an escape hatch that will + # do an exact string match of the version you wish to install. + # This will not be parsed by PEP 440 and we cannot determine + # any semantic meaning from it. This operator is discouraged + # but included entirely as an escape hatch. + (?<====) # Only match for the identity operator + \s* + [^\s;)]* # The arbitrary version can be just about anything, + # we match everything except for whitespace, a + # semi-colon for marker support, and a closing paren + # since versions can be enclosed in them. + ) + | + (?: + # The (non)equality operators allow for wild card and local + # versions to be specified so we have to define these two + # operators separately to enable that. + (?<===|!=) # Only match for equals and not equals + + \s* + v? + (?:[0-9]+!)? # epoch + [0-9]+(?:\.[0-9]+)* # release + + # You cannot use a wild card and a pre-release, post-release, a dev or + # local version together so group them with a | and make them optional. + (?: + \.\* # Wild card syntax of .* + | + (?: # pre release + [-_\.]? + (alpha|beta|preview|pre|a|b|c|rc) + [-_\.]? + [0-9]* + )? + (?: # post release + (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*) + )? + (?:[-_\.]?dev[-_\.]?[0-9]*)? # dev release + (?:\+[a-z0-9]+(?:[-_\.][a-z0-9]+)*)? # local + )? + ) + | + (?: + # The compatible operator requires at least two digits in the + # release segment. + (?<=~=) # Only match for the compatible operator + + \s* + v? + (?:[0-9]+!)? # epoch + [0-9]+(?:\.[0-9]+)+ # release (We have a + instead of a *) + (?: # pre release + [-_\.]? + (alpha|beta|preview|pre|a|b|c|rc) + [-_\.]? + [0-9]* + )? + (?: # post release + (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*) + )? + (?:[-_\.]?dev[-_\.]?[0-9]*)? # dev release + ) + | + (?: + # All other operators only allow a sub set of what the + # (non)equality operators do. Specifically they do not allow + # local versions to be specified nor do they allow the prefix + # matching wild cards. + (?=": "greater_than_equal", + "<": "less_than", + ">": "greater_than", + "===": "arbitrary", + } + + def __init__(self, spec: str = "", prereleases: Optional[bool] = None) -> None: + """Initialize a Specifier instance. + + :param spec: + The string representation of a specifier which will be parsed and + normalized before use. + :param prereleases: + This tells the specifier if it should accept prerelease versions if + applicable or not. The default of ``None`` will autodetect it from the + given specifiers. + :raises InvalidSpecifier: + If the given specifier is invalid (i.e. bad syntax). + """ + match = self._regex.search(spec) + if not match: + raise InvalidSpecifier(f"Invalid specifier: '{spec}'") + + self._spec: Tuple[str, str] = ( + match.group("operator").strip(), + match.group("version").strip(), + ) + + # Store whether or not this Specifier should accept prereleases + self._prereleases = prereleases + + # https://github.com/python/mypy/pull/13475#pullrequestreview-1079784515 + @property # type: ignore[override] + def prereleases(self) -> bool: + # If there is an explicit prereleases set for this, then we'll just + # blindly use that. + if self._prereleases is not None: + return self._prereleases + + # Look at all of our specifiers and determine if they are inclusive + # operators, and if they are if they are including an explicit + # prerelease. + operator, version = self._spec + if operator in ["==", ">=", "<=", "~=", "==="]: + # The == specifier can include a trailing .*, if it does we + # want to remove before parsing. + if operator == "==" and version.endswith(".*"): + version = version[:-2] + + # Parse the version, and if it is a pre-release than this + # specifier allows pre-releases. + if Version(version).is_prerelease: + return True + + return False + + @prereleases.setter + def prereleases(self, value: bool) -> None: + self._prereleases = value + + @property + def operator(self) -> str: + """The operator of this specifier. + + >>> Specifier("==1.2.3").operator + '==' + """ + return self._spec[0] + + @property + def version(self) -> str: + """The version of this specifier. + + >>> Specifier("==1.2.3").version + '1.2.3' + """ + return self._spec[1] + + def __repr__(self) -> str: + """A representation of the Specifier that shows all internal state. + + >>> Specifier('>=1.0.0') + =1.0.0')> + >>> Specifier('>=1.0.0', prereleases=False) + =1.0.0', prereleases=False)> + >>> Specifier('>=1.0.0', prereleases=True) + =1.0.0', prereleases=True)> + """ + pre = ( + f", prereleases={self.prereleases!r}" + if self._prereleases is not None + else "" + ) + + return f"<{self.__class__.__name__}({str(self)!r}{pre})>" + + def __str__(self) -> str: + """A string representation of the Specifier that can be round-tripped. + + >>> str(Specifier('>=1.0.0')) + '>=1.0.0' + >>> str(Specifier('>=1.0.0', prereleases=False)) + '>=1.0.0' + """ + return "{}{}".format(*self._spec) + + @property + def _canonical_spec(self) -> Tuple[str, str]: + canonical_version = canonicalize_version( + self._spec[1], + strip_trailing_zero=(self._spec[0] != "~="), + ) + return self._spec[0], canonical_version + + def __hash__(self) -> int: + return hash(self._canonical_spec) + + def __eq__(self, other: object) -> bool: + """Whether or not the two Specifier-like objects are equal. + + :param other: The other object to check against. + + The value of :attr:`prereleases` is ignored. + + >>> Specifier("==1.2.3") == Specifier("== 1.2.3.0") + True + >>> (Specifier("==1.2.3", prereleases=False) == + ... Specifier("==1.2.3", prereleases=True)) + True + >>> Specifier("==1.2.3") == "==1.2.3" + True + >>> Specifier("==1.2.3") == Specifier("==1.2.4") + False + >>> Specifier("==1.2.3") == Specifier("~=1.2.3") + False + """ + if isinstance(other, str): + try: + other = self.__class__(str(other)) + except InvalidSpecifier: + return NotImplemented + elif not isinstance(other, self.__class__): + return NotImplemented + + return self._canonical_spec == other._canonical_spec + + def _get_operator(self, op: str) -> CallableOperator: + operator_callable: CallableOperator = getattr( + self, f"_compare_{self._operators[op]}" + ) + return operator_callable + + def _compare_compatible(self, prospective: Version, spec: str) -> bool: + # Compatible releases have an equivalent combination of >= and ==. That + # is that ~=2.2 is equivalent to >=2.2,==2.*. This allows us to + # implement this in terms of the other specifiers instead of + # implementing it ourselves. The only thing we need to do is construct + # the other specifiers. + + # We want everything but the last item in the version, but we want to + # ignore suffix segments. + prefix = _version_join( + list(itertools.takewhile(_is_not_suffix, _version_split(spec)))[:-1] + ) + + # Add the prefix notation to the end of our string + prefix += ".*" + + return self._get_operator(">=")(prospective, spec) and self._get_operator("==")( + prospective, prefix + ) + + def _compare_equal(self, prospective: Version, spec: str) -> bool: + # We need special logic to handle prefix matching + if spec.endswith(".*"): + # In the case of prefix matching we want to ignore local segment. + normalized_prospective = canonicalize_version( + prospective.public, strip_trailing_zero=False + ) + # Get the normalized version string ignoring the trailing .* + normalized_spec = canonicalize_version(spec[:-2], strip_trailing_zero=False) + # Split the spec out by bangs and dots, and pretend that there is + # an implicit dot in between a release segment and a pre-release segment. + split_spec = _version_split(normalized_spec) + + # Split the prospective version out by bangs and dots, and pretend + # that there is an implicit dot in between a release segment and + # a pre-release segment. + split_prospective = _version_split(normalized_prospective) + + # 0-pad the prospective version before shortening it to get the correct + # shortened version. + padded_prospective, _ = _pad_version(split_prospective, split_spec) + + # Shorten the prospective version to be the same length as the spec + # so that we can determine if the specifier is a prefix of the + # prospective version or not. + shortened_prospective = padded_prospective[: len(split_spec)] + + return shortened_prospective == split_spec + else: + # Convert our spec string into a Version + spec_version = Version(spec) + + # If the specifier does not have a local segment, then we want to + # act as if the prospective version also does not have a local + # segment. + if not spec_version.local: + prospective = Version(prospective.public) + + return prospective == spec_version + + def _compare_not_equal(self, prospective: Version, spec: str) -> bool: + return not self._compare_equal(prospective, spec) + + def _compare_less_than_equal(self, prospective: Version, spec: str) -> bool: + # NB: Local version identifiers are NOT permitted in the version + # specifier, so local version labels can be universally removed from + # the prospective version. + return Version(prospective.public) <= Version(spec) + + def _compare_greater_than_equal(self, prospective: Version, spec: str) -> bool: + # NB: Local version identifiers are NOT permitted in the version + # specifier, so local version labels can be universally removed from + # the prospective version. + return Version(prospective.public) >= Version(spec) + + def _compare_less_than(self, prospective: Version, spec_str: str) -> bool: + # Convert our spec to a Version instance, since we'll want to work with + # it as a version. + spec = Version(spec_str) + + # Check to see if the prospective version is less than the spec + # version. If it's not we can short circuit and just return False now + # instead of doing extra unneeded work. + if not prospective < spec: + return False + + # This special case is here so that, unless the specifier itself + # includes is a pre-release version, that we do not accept pre-release + # versions for the version mentioned in the specifier (e.g. <3.1 should + # not match 3.1.dev0, but should match 3.0.dev0). + if not spec.is_prerelease and prospective.is_prerelease: + if Version(prospective.base_version) == Version(spec.base_version): + return False + + # If we've gotten to here, it means that prospective version is both + # less than the spec version *and* it's not a pre-release of the same + # version in the spec. + return True + + def _compare_greater_than(self, prospective: Version, spec_str: str) -> bool: + # Convert our spec to a Version instance, since we'll want to work with + # it as a version. + spec = Version(spec_str) + + # Check to see if the prospective version is greater than the spec + # version. If it's not we can short circuit and just return False now + # instead of doing extra unneeded work. + if not prospective > spec: + return False + + # This special case is here so that, unless the specifier itself + # includes is a post-release version, that we do not accept + # post-release versions for the version mentioned in the specifier + # (e.g. >3.1 should not match 3.0.post0, but should match 3.2.post0). + if not spec.is_postrelease and prospective.is_postrelease: + if Version(prospective.base_version) == Version(spec.base_version): + return False + + # Ensure that we do not allow a local version of the version mentioned + # in the specifier, which is technically greater than, to match. + if prospective.local is not None: + if Version(prospective.base_version) == Version(spec.base_version): + return False + + # If we've gotten to here, it means that prospective version is both + # greater than the spec version *and* it's not a pre-release of the + # same version in the spec. + return True + + def _compare_arbitrary(self, prospective: Version, spec: str) -> bool: + return str(prospective).lower() == str(spec).lower() + + def __contains__(self, item: Union[str, Version]) -> bool: + """Return whether or not the item is contained in this specifier. + + :param item: The item to check for. + + This is used for the ``in`` operator and behaves the same as + :meth:`contains` with no ``prereleases`` argument passed. + + >>> "1.2.3" in Specifier(">=1.2.3") + True + >>> Version("1.2.3") in Specifier(">=1.2.3") + True + >>> "1.0.0" in Specifier(">=1.2.3") + False + >>> "1.3.0a1" in Specifier(">=1.2.3") + False + >>> "1.3.0a1" in Specifier(">=1.2.3", prereleases=True) + True + """ + return self.contains(item) + + def contains( + self, item: UnparsedVersion, prereleases: Optional[bool] = None + ) -> bool: + """Return whether or not the item is contained in this specifier. + + :param item: + The item to check for, which can be a version string or a + :class:`Version` instance. + :param prereleases: + Whether or not to match prereleases with this Specifier. If set to + ``None`` (the default), it uses :attr:`prereleases` to determine + whether or not prereleases are allowed. + + >>> Specifier(">=1.2.3").contains("1.2.3") + True + >>> Specifier(">=1.2.3").contains(Version("1.2.3")) + True + >>> Specifier(">=1.2.3").contains("1.0.0") + False + >>> Specifier(">=1.2.3").contains("1.3.0a1") + False + >>> Specifier(">=1.2.3", prereleases=True).contains("1.3.0a1") + True + >>> Specifier(">=1.2.3").contains("1.3.0a1", prereleases=True) + True + """ + + # Determine if prereleases are to be allowed or not. + if prereleases is None: + prereleases = self.prereleases + + # Normalize item to a Version, this allows us to have a shortcut for + # "2.0" in Specifier(">=2") + normalized_item = _coerce_version(item) + + # Determine if we should be supporting prereleases in this specifier + # or not, if we do not support prereleases than we can short circuit + # logic if this version is a prereleases. + if normalized_item.is_prerelease and not prereleases: + return False + + # Actually do the comparison to determine if this item is contained + # within this Specifier or not. + operator_callable: CallableOperator = self._get_operator(self.operator) + return operator_callable(normalized_item, self.version) + + def filter( + self, iterable: Iterable[UnparsedVersionVar], prereleases: Optional[bool] = None + ) -> Iterator[UnparsedVersionVar]: + """Filter items in the given iterable, that match the specifier. + + :param iterable: + An iterable that can contain version strings and :class:`Version` instances. + The items in the iterable will be filtered according to the specifier. + :param prereleases: + Whether or not to allow prereleases in the returned iterator. If set to + ``None`` (the default), it will be intelligently decide whether to allow + prereleases or not (based on the :attr:`prereleases` attribute, and + whether the only versions matching are prereleases). + + This method is smarter than just ``filter(Specifier().contains, [...])`` + because it implements the rule from :pep:`440` that a prerelease item + SHOULD be accepted if no other versions match the given specifier. + + >>> list(Specifier(">=1.2.3").filter(["1.2", "1.3", "1.5a1"])) + ['1.3'] + >>> list(Specifier(">=1.2.3").filter(["1.2", "1.2.3", "1.3", Version("1.4")])) + ['1.2.3', '1.3', ] + >>> list(Specifier(">=1.2.3").filter(["1.2", "1.5a1"])) + ['1.5a1'] + >>> list(Specifier(">=1.2.3").filter(["1.3", "1.5a1"], prereleases=True)) + ['1.3', '1.5a1'] + >>> list(Specifier(">=1.2.3", prereleases=True).filter(["1.3", "1.5a1"])) + ['1.3', '1.5a1'] + """ + + yielded = False + found_prereleases = [] + + kw = {"prereleases": prereleases if prereleases is not None else True} + + # Attempt to iterate over all the values in the iterable and if any of + # them match, yield them. + for version in iterable: + parsed_version = _coerce_version(version) + + if self.contains(parsed_version, **kw): + # If our version is a prerelease, and we were not set to allow + # prereleases, then we'll store it for later in case nothing + # else matches this specifier. + if parsed_version.is_prerelease and not ( + prereleases or self.prereleases + ): + found_prereleases.append(version) + # Either this is not a prerelease, or we should have been + # accepting prereleases from the beginning. + else: + yielded = True + yield version + + # Now that we've iterated over everything, determine if we've yielded + # any values, and if we have not and we have any prereleases stored up + # then we will go ahead and yield the prereleases. + if not yielded and found_prereleases: + for version in found_prereleases: + yield version + + +_prefix_regex = re.compile(r"^([0-9]+)((?:a|b|c|rc)[0-9]+)$") + + +def _version_split(version: str) -> List[str]: + """Split version into components. + + The split components are intended for version comparison. The logic does + not attempt to retain the original version string, so joining the + components back with :func:`_version_join` may not produce the original + version string. + """ + result: List[str] = [] + + epoch, _, rest = version.rpartition("!") + result.append(epoch or "0") + + for item in rest.split("."): + match = _prefix_regex.search(item) + if match: + result.extend(match.groups()) + else: + result.append(item) + return result + + +def _version_join(components: List[str]) -> str: + """Join split version components into a version string. + + This function assumes the input came from :func:`_version_split`, where the + first component must be the epoch (either empty or numeric), and all other + components numeric. + """ + epoch, *rest = components + return f"{epoch}!{'.'.join(rest)}" + + +def _is_not_suffix(segment: str) -> bool: + return not any( + segment.startswith(prefix) for prefix in ("dev", "a", "b", "rc", "post") + ) + + +def _pad_version(left: List[str], right: List[str]) -> Tuple[List[str], List[str]]: + left_split, right_split = [], [] + + # Get the release segment of our versions + left_split.append(list(itertools.takewhile(lambda x: x.isdigit(), left))) + right_split.append(list(itertools.takewhile(lambda x: x.isdigit(), right))) + + # Get the rest of our versions + left_split.append(left[len(left_split[0]) :]) + right_split.append(right[len(right_split[0]) :]) + + # Insert our padding + left_split.insert(1, ["0"] * max(0, len(right_split[0]) - len(left_split[0]))) + right_split.insert(1, ["0"] * max(0, len(left_split[0]) - len(right_split[0]))) + + return ( + list(itertools.chain.from_iterable(left_split)), + list(itertools.chain.from_iterable(right_split)), + ) + + +class SpecifierSet(BaseSpecifier): + """This class abstracts handling of a set of version specifiers. + + It can be passed a single specifier (``>=3.0``), a comma-separated list of + specifiers (``>=3.0,!=3.1``), or no specifier at all. + """ + + def __init__( + self, specifiers: str = "", prereleases: Optional[bool] = None + ) -> None: + """Initialize a SpecifierSet instance. + + :param specifiers: + The string representation of a specifier or a comma-separated list of + specifiers which will be parsed and normalized before use. + :param prereleases: + This tells the SpecifierSet if it should accept prerelease versions if + applicable or not. The default of ``None`` will autodetect it from the + given specifiers. + + :raises InvalidSpecifier: + If the given ``specifiers`` are not parseable than this exception will be + raised. + """ + + # Split on `,` to break each individual specifier into it's own item, and + # strip each item to remove leading/trailing whitespace. + split_specifiers = [s.strip() for s in specifiers.split(",") if s.strip()] + + # Make each individual specifier a Specifier and save in a frozen set for later. + self._specs = frozenset(map(Specifier, split_specifiers)) + + # Store our prereleases value so we can use it later to determine if + # we accept prereleases or not. + self._prereleases = prereleases + + @property + def prereleases(self) -> Optional[bool]: + # If we have been given an explicit prerelease modifier, then we'll + # pass that through here. + if self._prereleases is not None: + return self._prereleases + + # If we don't have any specifiers, and we don't have a forced value, + # then we'll just return None since we don't know if this should have + # pre-releases or not. + if not self._specs: + return None + + # Otherwise we'll see if any of the given specifiers accept + # prereleases, if any of them do we'll return True, otherwise False. + return any(s.prereleases for s in self._specs) + + @prereleases.setter + def prereleases(self, value: bool) -> None: + self._prereleases = value + + def __repr__(self) -> str: + """A representation of the specifier set that shows all internal state. + + Note that the ordering of the individual specifiers within the set may not + match the input string. + + >>> SpecifierSet('>=1.0.0,!=2.0.0') + =1.0.0')> + >>> SpecifierSet('>=1.0.0,!=2.0.0', prereleases=False) + =1.0.0', prereleases=False)> + >>> SpecifierSet('>=1.0.0,!=2.0.0', prereleases=True) + =1.0.0', prereleases=True)> + """ + pre = ( + f", prereleases={self.prereleases!r}" + if self._prereleases is not None + else "" + ) + + return f"" + + def __str__(self) -> str: + """A string representation of the specifier set that can be round-tripped. + + Note that the ordering of the individual specifiers within the set may not + match the input string. + + >>> str(SpecifierSet(">=1.0.0,!=1.0.1")) + '!=1.0.1,>=1.0.0' + >>> str(SpecifierSet(">=1.0.0,!=1.0.1", prereleases=False)) + '!=1.0.1,>=1.0.0' + """ + return ",".join(sorted(str(s) for s in self._specs)) + + def __hash__(self) -> int: + return hash(self._specs) + + def __and__(self, other: Union["SpecifierSet", str]) -> "SpecifierSet": + """Return a SpecifierSet which is a combination of the two sets. + + :param other: The other object to combine with. + + >>> SpecifierSet(">=1.0.0,!=1.0.1") & '<=2.0.0,!=2.0.1' + =1.0.0')> + >>> SpecifierSet(">=1.0.0,!=1.0.1") & SpecifierSet('<=2.0.0,!=2.0.1') + =1.0.0')> + """ + if isinstance(other, str): + other = SpecifierSet(other) + elif not isinstance(other, SpecifierSet): + return NotImplemented + + specifier = SpecifierSet() + specifier._specs = frozenset(self._specs | other._specs) + + if self._prereleases is None and other._prereleases is not None: + specifier._prereleases = other._prereleases + elif self._prereleases is not None and other._prereleases is None: + specifier._prereleases = self._prereleases + elif self._prereleases == other._prereleases: + specifier._prereleases = self._prereleases + else: + raise ValueError( + "Cannot combine SpecifierSets with True and False prerelease " + "overrides." + ) + + return specifier + + def __eq__(self, other: object) -> bool: + """Whether or not the two SpecifierSet-like objects are equal. + + :param other: The other object to check against. + + The value of :attr:`prereleases` is ignored. + + >>> SpecifierSet(">=1.0.0,!=1.0.1") == SpecifierSet(">=1.0.0,!=1.0.1") + True + >>> (SpecifierSet(">=1.0.0,!=1.0.1", prereleases=False) == + ... SpecifierSet(">=1.0.0,!=1.0.1", prereleases=True)) + True + >>> SpecifierSet(">=1.0.0,!=1.0.1") == ">=1.0.0,!=1.0.1" + True + >>> SpecifierSet(">=1.0.0,!=1.0.1") == SpecifierSet(">=1.0.0") + False + >>> SpecifierSet(">=1.0.0,!=1.0.1") == SpecifierSet(">=1.0.0,!=1.0.2") + False + """ + if isinstance(other, (str, Specifier)): + other = SpecifierSet(str(other)) + elif not isinstance(other, SpecifierSet): + return NotImplemented + + return self._specs == other._specs + + def __len__(self) -> int: + """Returns the number of specifiers in this specifier set.""" + return len(self._specs) + + def __iter__(self) -> Iterator[Specifier]: + """ + Returns an iterator over all the underlying :class:`Specifier` instances + in this specifier set. + + >>> sorted(SpecifierSet(">=1.0.0,!=1.0.1"), key=str) + [, =1.0.0')>] + """ + return iter(self._specs) + + def __contains__(self, item: UnparsedVersion) -> bool: + """Return whether or not the item is contained in this specifier. + + :param item: The item to check for. + + This is used for the ``in`` operator and behaves the same as + :meth:`contains` with no ``prereleases`` argument passed. + + >>> "1.2.3" in SpecifierSet(">=1.0.0,!=1.0.1") + True + >>> Version("1.2.3") in SpecifierSet(">=1.0.0,!=1.0.1") + True + >>> "1.0.1" in SpecifierSet(">=1.0.0,!=1.0.1") + False + >>> "1.3.0a1" in SpecifierSet(">=1.0.0,!=1.0.1") + False + >>> "1.3.0a1" in SpecifierSet(">=1.0.0,!=1.0.1", prereleases=True) + True + """ + return self.contains(item) + + def contains( + self, + item: UnparsedVersion, + prereleases: Optional[bool] = None, + installed: Optional[bool] = None, + ) -> bool: + """Return whether or not the item is contained in this SpecifierSet. + + :param item: + The item to check for, which can be a version string or a + :class:`Version` instance. + :param prereleases: + Whether or not to match prereleases with this SpecifierSet. If set to + ``None`` (the default), it uses :attr:`prereleases` to determine + whether or not prereleases are allowed. + + >>> SpecifierSet(">=1.0.0,!=1.0.1").contains("1.2.3") + True + >>> SpecifierSet(">=1.0.0,!=1.0.1").contains(Version("1.2.3")) + True + >>> SpecifierSet(">=1.0.0,!=1.0.1").contains("1.0.1") + False + >>> SpecifierSet(">=1.0.0,!=1.0.1").contains("1.3.0a1") + False + >>> SpecifierSet(">=1.0.0,!=1.0.1", prereleases=True).contains("1.3.0a1") + True + >>> SpecifierSet(">=1.0.0,!=1.0.1").contains("1.3.0a1", prereleases=True) + True + """ + # Ensure that our item is a Version instance. + if not isinstance(item, Version): + item = Version(item) + + # Determine if we're forcing a prerelease or not, if we're not forcing + # one for this particular filter call, then we'll use whatever the + # SpecifierSet thinks for whether or not we should support prereleases. + if prereleases is None: + prereleases = self.prereleases + + # We can determine if we're going to allow pre-releases by looking to + # see if any of the underlying items supports them. If none of them do + # and this item is a pre-release then we do not allow it and we can + # short circuit that here. + # Note: This means that 1.0.dev1 would not be contained in something + # like >=1.0.devabc however it would be in >=1.0.debabc,>0.0.dev0 + if not prereleases and item.is_prerelease: + return False + + if installed and item.is_prerelease: + item = Version(item.base_version) + + # We simply dispatch to the underlying specs here to make sure that the + # given version is contained within all of them. + # Note: This use of all() here means that an empty set of specifiers + # will always return True, this is an explicit design decision. + return all(s.contains(item, prereleases=prereleases) for s in self._specs) + + def filter( + self, iterable: Iterable[UnparsedVersionVar], prereleases: Optional[bool] = None + ) -> Iterator[UnparsedVersionVar]: + """Filter items in the given iterable, that match the specifiers in this set. + + :param iterable: + An iterable that can contain version strings and :class:`Version` instances. + The items in the iterable will be filtered according to the specifier. + :param prereleases: + Whether or not to allow prereleases in the returned iterator. If set to + ``None`` (the default), it will be intelligently decide whether to allow + prereleases or not (based on the :attr:`prereleases` attribute, and + whether the only versions matching are prereleases). + + This method is smarter than just ``filter(SpecifierSet(...).contains, [...])`` + because it implements the rule from :pep:`440` that a prerelease item + SHOULD be accepted if no other versions match the given specifier. + + >>> list(SpecifierSet(">=1.2.3").filter(["1.2", "1.3", "1.5a1"])) + ['1.3'] + >>> list(SpecifierSet(">=1.2.3").filter(["1.2", "1.3", Version("1.4")])) + ['1.3', ] + >>> list(SpecifierSet(">=1.2.3").filter(["1.2", "1.5a1"])) + [] + >>> list(SpecifierSet(">=1.2.3").filter(["1.3", "1.5a1"], prereleases=True)) + ['1.3', '1.5a1'] + >>> list(SpecifierSet(">=1.2.3", prereleases=True).filter(["1.3", "1.5a1"])) + ['1.3', '1.5a1'] + + An "empty" SpecifierSet will filter items based on the presence of prerelease + versions in the set. + + >>> list(SpecifierSet("").filter(["1.3", "1.5a1"])) + ['1.3'] + >>> list(SpecifierSet("").filter(["1.5a1"])) + ['1.5a1'] + >>> list(SpecifierSet("", prereleases=True).filter(["1.3", "1.5a1"])) + ['1.3', '1.5a1'] + >>> list(SpecifierSet("").filter(["1.3", "1.5a1"], prereleases=True)) + ['1.3', '1.5a1'] + """ + # Determine if we're forcing a prerelease or not, if we're not forcing + # one for this particular filter call, then we'll use whatever the + # SpecifierSet thinks for whether or not we should support prereleases. + if prereleases is None: + prereleases = self.prereleases + + # If we have any specifiers, then we want to wrap our iterable in the + # filter method for each one, this will act as a logical AND amongst + # each specifier. + if self._specs: + for spec in self._specs: + iterable = spec.filter(iterable, prereleases=bool(prereleases)) + return iter(iterable) + # If we do not have any specifiers, then we need to have a rough filter + # which will filter out any pre-releases, unless there are no final + # releases. + else: + filtered: List[UnparsedVersionVar] = [] + found_prereleases: List[UnparsedVersionVar] = [] + + for item in iterable: + parsed_version = _coerce_version(item) + + # Store any item which is a pre-release for later unless we've + # already found a final version or we are accepting prereleases + if parsed_version.is_prerelease and not prereleases: + if not filtered: + found_prereleases.append(item) + else: + filtered.append(item) + + # If we've found no items except for pre-releases, then we'll go + # ahead and use the pre-releases + if not filtered and found_prereleases and prereleases is None: + return iter(found_prereleases) + + return iter(filtered) diff --git a/venv/lib/python3.10/site-packages/wheel/vendored/packaging/tags.py b/venv/lib/python3.10/site-packages/wheel/vendored/packaging/tags.py new file mode 100644 index 0000000000000000000000000000000000000000..89f1926137dd2d2a6bd63616bf5b9f722fc8d584 --- /dev/null +++ b/venv/lib/python3.10/site-packages/wheel/vendored/packaging/tags.py @@ -0,0 +1,571 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +import logging +import platform +import re +import struct +import subprocess +import sys +import sysconfig +from importlib.machinery import EXTENSION_SUFFIXES +from typing import ( + Dict, + FrozenSet, + Iterable, + Iterator, + List, + Optional, + Sequence, + Tuple, + Union, + cast, +) + +from . import _manylinux, _musllinux + +logger = logging.getLogger(__name__) + +PythonVersion = Sequence[int] +MacVersion = Tuple[int, int] + +INTERPRETER_SHORT_NAMES: Dict[str, str] = { + "python": "py", # Generic. + "cpython": "cp", + "pypy": "pp", + "ironpython": "ip", + "jython": "jy", +} + + +_32_BIT_INTERPRETER = struct.calcsize("P") == 4 + + +class Tag: + """ + A representation of the tag triple for a wheel. + + Instances are considered immutable and thus are hashable. Equality checking + is also supported. + """ + + __slots__ = ["_interpreter", "_abi", "_platform", "_hash"] + + def __init__(self, interpreter: str, abi: str, platform: str) -> None: + self._interpreter = interpreter.lower() + self._abi = abi.lower() + self._platform = platform.lower() + # The __hash__ of every single element in a Set[Tag] will be evaluated each time + # that a set calls its `.disjoint()` method, which may be called hundreds of + # times when scanning a page of links for packages with tags matching that + # Set[Tag]. Pre-computing the value here produces significant speedups for + # downstream consumers. + self._hash = hash((self._interpreter, self._abi, self._platform)) + + @property + def interpreter(self) -> str: + return self._interpreter + + @property + def abi(self) -> str: + return self._abi + + @property + def platform(self) -> str: + return self._platform + + def __eq__(self, other: object) -> bool: + if not isinstance(other, Tag): + return NotImplemented + + return ( + (self._hash == other._hash) # Short-circuit ASAP for perf reasons. + and (self._platform == other._platform) + and (self._abi == other._abi) + and (self._interpreter == other._interpreter) + ) + + def __hash__(self) -> int: + return self._hash + + def __str__(self) -> str: + return f"{self._interpreter}-{self._abi}-{self._platform}" + + def __repr__(self) -> str: + return f"<{self} @ {id(self)}>" + + +def parse_tag(tag: str) -> FrozenSet[Tag]: + """ + Parses the provided tag (e.g. `py3-none-any`) into a frozenset of Tag instances. + + Returning a set is required due to the possibility that the tag is a + compressed tag set. + """ + tags = set() + interpreters, abis, platforms = tag.split("-") + for interpreter in interpreters.split("."): + for abi in abis.split("."): + for platform_ in platforms.split("."): + tags.add(Tag(interpreter, abi, platform_)) + return frozenset(tags) + + +def _get_config_var(name: str, warn: bool = False) -> Union[int, str, None]: + value: Union[int, str, None] = sysconfig.get_config_var(name) + if value is None and warn: + logger.debug( + "Config variable '%s' is unset, Python ABI tag may be incorrect", name + ) + return value + + +def _normalize_string(string: str) -> str: + return string.replace(".", "_").replace("-", "_").replace(" ", "_") + + +def _is_threaded_cpython(abis: List[str]) -> bool: + """ + Determine if the ABI corresponds to a threaded (`--disable-gil`) build. + + The threaded builds are indicated by a "t" in the abiflags. + """ + if len(abis) == 0: + return False + # expect e.g., cp313 + m = re.match(r"cp\d+(.*)", abis[0]) + if not m: + return False + abiflags = m.group(1) + return "t" in abiflags + + +def _abi3_applies(python_version: PythonVersion, threading: bool) -> bool: + """ + Determine if the Python version supports abi3. + + PEP 384 was first implemented in Python 3.2. The threaded (`--disable-gil`) + builds do not support abi3. + """ + return len(python_version) > 1 and tuple(python_version) >= (3, 2) and not threading + + +def _cpython_abis(py_version: PythonVersion, warn: bool = False) -> List[str]: + py_version = tuple(py_version) # To allow for version comparison. + abis = [] + version = _version_nodot(py_version[:2]) + threading = debug = pymalloc = ucs4 = "" + with_debug = _get_config_var("Py_DEBUG", warn) + has_refcount = hasattr(sys, "gettotalrefcount") + # Windows doesn't set Py_DEBUG, so checking for support of debug-compiled + # extension modules is the best option. + # https://github.com/pypa/pip/issues/3383#issuecomment-173267692 + has_ext = "_d.pyd" in EXTENSION_SUFFIXES + if with_debug or (with_debug is None and (has_refcount or has_ext)): + debug = "d" + if py_version >= (3, 13) and _get_config_var("Py_GIL_DISABLED", warn): + threading = "t" + if py_version < (3, 8): + with_pymalloc = _get_config_var("WITH_PYMALLOC", warn) + if with_pymalloc or with_pymalloc is None: + pymalloc = "m" + if py_version < (3, 3): + unicode_size = _get_config_var("Py_UNICODE_SIZE", warn) + if unicode_size == 4 or ( + unicode_size is None and sys.maxunicode == 0x10FFFF + ): + ucs4 = "u" + elif debug: + # Debug builds can also load "normal" extension modules. + # We can also assume no UCS-4 or pymalloc requirement. + abis.append(f"cp{version}{threading}") + abis.insert(0, f"cp{version}{threading}{debug}{pymalloc}{ucs4}") + return abis + + +def cpython_tags( + python_version: Optional[PythonVersion] = None, + abis: Optional[Iterable[str]] = None, + platforms: Optional[Iterable[str]] = None, + *, + warn: bool = False, +) -> Iterator[Tag]: + """ + Yields the tags for a CPython interpreter. + + The tags consist of: + - cp-- + - cp-abi3- + - cp-none- + - cp-abi3- # Older Python versions down to 3.2. + + If python_version only specifies a major version then user-provided ABIs and + the 'none' ABItag will be used. + + If 'abi3' or 'none' are specified in 'abis' then they will be yielded at + their normal position and not at the beginning. + """ + if not python_version: + python_version = sys.version_info[:2] + + interpreter = f"cp{_version_nodot(python_version[:2])}" + + if abis is None: + if len(python_version) > 1: + abis = _cpython_abis(python_version, warn) + else: + abis = [] + abis = list(abis) + # 'abi3' and 'none' are explicitly handled later. + for explicit_abi in ("abi3", "none"): + try: + abis.remove(explicit_abi) + except ValueError: + pass + + platforms = list(platforms or platform_tags()) + for abi in abis: + for platform_ in platforms: + yield Tag(interpreter, abi, platform_) + + threading = _is_threaded_cpython(abis) + use_abi3 = _abi3_applies(python_version, threading) + if use_abi3: + yield from (Tag(interpreter, "abi3", platform_) for platform_ in platforms) + yield from (Tag(interpreter, "none", platform_) for platform_ in platforms) + + if use_abi3: + for minor_version in range(python_version[1] - 1, 1, -1): + for platform_ in platforms: + interpreter = "cp{version}".format( + version=_version_nodot((python_version[0], minor_version)) + ) + yield Tag(interpreter, "abi3", platform_) + + +def _generic_abi() -> List[str]: + """ + Return the ABI tag based on EXT_SUFFIX. + """ + # The following are examples of `EXT_SUFFIX`. + # We want to keep the parts which are related to the ABI and remove the + # parts which are related to the platform: + # - linux: '.cpython-310-x86_64-linux-gnu.so' => cp310 + # - mac: '.cpython-310-darwin.so' => cp310 + # - win: '.cp310-win_amd64.pyd' => cp310 + # - win: '.pyd' => cp37 (uses _cpython_abis()) + # - pypy: '.pypy38-pp73-x86_64-linux-gnu.so' => pypy38_pp73 + # - graalpy: '.graalpy-38-native-x86_64-darwin.dylib' + # => graalpy_38_native + + ext_suffix = _get_config_var("EXT_SUFFIX", warn=True) + if not isinstance(ext_suffix, str) or ext_suffix[0] != ".": + raise SystemError("invalid sysconfig.get_config_var('EXT_SUFFIX')") + parts = ext_suffix.split(".") + if len(parts) < 3: + # CPython3.7 and earlier uses ".pyd" on Windows. + return _cpython_abis(sys.version_info[:2]) + soabi = parts[1] + if soabi.startswith("cpython"): + # non-windows + abi = "cp" + soabi.split("-")[1] + elif soabi.startswith("cp"): + # windows + abi = soabi.split("-")[0] + elif soabi.startswith("pypy"): + abi = "-".join(soabi.split("-")[:2]) + elif soabi.startswith("graalpy"): + abi = "-".join(soabi.split("-")[:3]) + elif soabi: + # pyston, ironpython, others? + abi = soabi + else: + return [] + return [_normalize_string(abi)] + + +def generic_tags( + interpreter: Optional[str] = None, + abis: Optional[Iterable[str]] = None, + platforms: Optional[Iterable[str]] = None, + *, + warn: bool = False, +) -> Iterator[Tag]: + """ + Yields the tags for a generic interpreter. + + The tags consist of: + - -- + + The "none" ABI will be added if it was not explicitly provided. + """ + if not interpreter: + interp_name = interpreter_name() + interp_version = interpreter_version(warn=warn) + interpreter = "".join([interp_name, interp_version]) + if abis is None: + abis = _generic_abi() + else: + abis = list(abis) + platforms = list(platforms or platform_tags()) + if "none" not in abis: + abis.append("none") + for abi in abis: + for platform_ in platforms: + yield Tag(interpreter, abi, platform_) + + +def _py_interpreter_range(py_version: PythonVersion) -> Iterator[str]: + """ + Yields Python versions in descending order. + + After the latest version, the major-only version will be yielded, and then + all previous versions of that major version. + """ + if len(py_version) > 1: + yield f"py{_version_nodot(py_version[:2])}" + yield f"py{py_version[0]}" + if len(py_version) > 1: + for minor in range(py_version[1] - 1, -1, -1): + yield f"py{_version_nodot((py_version[0], minor))}" + + +def compatible_tags( + python_version: Optional[PythonVersion] = None, + interpreter: Optional[str] = None, + platforms: Optional[Iterable[str]] = None, +) -> Iterator[Tag]: + """ + Yields the sequence of tags that are compatible with a specific version of Python. + + The tags consist of: + - py*-none- + - -none-any # ... if `interpreter` is provided. + - py*-none-any + """ + if not python_version: + python_version = sys.version_info[:2] + platforms = list(platforms or platform_tags()) + for version in _py_interpreter_range(python_version): + for platform_ in platforms: + yield Tag(version, "none", platform_) + if interpreter: + yield Tag(interpreter, "none", "any") + for version in _py_interpreter_range(python_version): + yield Tag(version, "none", "any") + + +def _mac_arch(arch: str, is_32bit: bool = _32_BIT_INTERPRETER) -> str: + if not is_32bit: + return arch + + if arch.startswith("ppc"): + return "ppc" + + return "i386" + + +def _mac_binary_formats(version: MacVersion, cpu_arch: str) -> List[str]: + formats = [cpu_arch] + if cpu_arch == "x86_64": + if version < (10, 4): + return [] + formats.extend(["intel", "fat64", "fat32"]) + + elif cpu_arch == "i386": + if version < (10, 4): + return [] + formats.extend(["intel", "fat32", "fat"]) + + elif cpu_arch == "ppc64": + # TODO: Need to care about 32-bit PPC for ppc64 through 10.2? + if version > (10, 5) or version < (10, 4): + return [] + formats.append("fat64") + + elif cpu_arch == "ppc": + if version > (10, 6): + return [] + formats.extend(["fat32", "fat"]) + + if cpu_arch in {"arm64", "x86_64"}: + formats.append("universal2") + + if cpu_arch in {"x86_64", "i386", "ppc64", "ppc", "intel"}: + formats.append("universal") + + return formats + + +def mac_platforms( + version: Optional[MacVersion] = None, arch: Optional[str] = None +) -> Iterator[str]: + """ + Yields the platform tags for a macOS system. + + The `version` parameter is a two-item tuple specifying the macOS version to + generate platform tags for. The `arch` parameter is the CPU architecture to + generate platform tags for. Both parameters default to the appropriate value + for the current system. + """ + version_str, _, cpu_arch = platform.mac_ver() + if version is None: + version = cast("MacVersion", tuple(map(int, version_str.split(".")[:2]))) + if version == (10, 16): + # When built against an older macOS SDK, Python will report macOS 10.16 + # instead of the real version. + version_str = subprocess.run( + [ + sys.executable, + "-sS", + "-c", + "import platform; print(platform.mac_ver()[0])", + ], + check=True, + env={"SYSTEM_VERSION_COMPAT": "0"}, + stdout=subprocess.PIPE, + text=True, + ).stdout + version = cast("MacVersion", tuple(map(int, version_str.split(".")[:2]))) + else: + version = version + if arch is None: + arch = _mac_arch(cpu_arch) + else: + arch = arch + + if (10, 0) <= version and version < (11, 0): + # Prior to Mac OS 11, each yearly release of Mac OS bumped the + # "minor" version number. The major version was always 10. + for minor_version in range(version[1], -1, -1): + compat_version = 10, minor_version + binary_formats = _mac_binary_formats(compat_version, arch) + for binary_format in binary_formats: + yield "macosx_{major}_{minor}_{binary_format}".format( + major=10, minor=minor_version, binary_format=binary_format + ) + + if version >= (11, 0): + # Starting with Mac OS 11, each yearly release bumps the major version + # number. The minor versions are now the midyear updates. + for major_version in range(version[0], 10, -1): + compat_version = major_version, 0 + binary_formats = _mac_binary_formats(compat_version, arch) + for binary_format in binary_formats: + yield "macosx_{major}_{minor}_{binary_format}".format( + major=major_version, minor=0, binary_format=binary_format + ) + + if version >= (11, 0): + # Mac OS 11 on x86_64 is compatible with binaries from previous releases. + # Arm64 support was introduced in 11.0, so no Arm binaries from previous + # releases exist. + # + # However, the "universal2" binary format can have a + # macOS version earlier than 11.0 when the x86_64 part of the binary supports + # that version of macOS. + if arch == "x86_64": + for minor_version in range(16, 3, -1): + compat_version = 10, minor_version + binary_formats = _mac_binary_formats(compat_version, arch) + for binary_format in binary_formats: + yield "macosx_{major}_{minor}_{binary_format}".format( + major=compat_version[0], + minor=compat_version[1], + binary_format=binary_format, + ) + else: + for minor_version in range(16, 3, -1): + compat_version = 10, minor_version + binary_format = "universal2" + yield "macosx_{major}_{minor}_{binary_format}".format( + major=compat_version[0], + minor=compat_version[1], + binary_format=binary_format, + ) + + +def _linux_platforms(is_32bit: bool = _32_BIT_INTERPRETER) -> Iterator[str]: + linux = _normalize_string(sysconfig.get_platform()) + if not linux.startswith("linux_"): + # we should never be here, just yield the sysconfig one and return + yield linux + return + if is_32bit: + if linux == "linux_x86_64": + linux = "linux_i686" + elif linux == "linux_aarch64": + linux = "linux_armv8l" + _, arch = linux.split("_", 1) + archs = {"armv8l": ["armv8l", "armv7l"]}.get(arch, [arch]) + yield from _manylinux.platform_tags(archs) + yield from _musllinux.platform_tags(archs) + for arch in archs: + yield f"linux_{arch}" + + +def _generic_platforms() -> Iterator[str]: + yield _normalize_string(sysconfig.get_platform()) + + +def platform_tags() -> Iterator[str]: + """ + Provides the platform tags for this installation. + """ + if platform.system() == "Darwin": + return mac_platforms() + elif platform.system() == "Linux": + return _linux_platforms() + else: + return _generic_platforms() + + +def interpreter_name() -> str: + """ + Returns the name of the running interpreter. + + Some implementations have a reserved, two-letter abbreviation which will + be returned when appropriate. + """ + name = sys.implementation.name + return INTERPRETER_SHORT_NAMES.get(name) or name + + +def interpreter_version(*, warn: bool = False) -> str: + """ + Returns the version of the running interpreter. + """ + version = _get_config_var("py_version_nodot", warn=warn) + if version: + version = str(version) + else: + version = _version_nodot(sys.version_info[:2]) + return version + + +def _version_nodot(version: PythonVersion) -> str: + return "".join(map(str, version)) + + +def sys_tags(*, warn: bool = False) -> Iterator[Tag]: + """ + Returns the sequence of tag triples for the running interpreter. + + The order of the sequence corresponds to priority order for the + interpreter, from most to least important. + """ + + interp_name = interpreter_name() + if interp_name == "cp": + yield from cpython_tags(warn=warn) + else: + yield from generic_tags() + + if interp_name == "pp": + interp = "pp3" + elif interp_name == "cp": + interp = "cp" + interpreter_version(warn=warn) + else: + interp = None + yield from compatible_tags(interpreter=interp) diff --git a/venv/lib/python3.10/site-packages/wheel/vendored/packaging/utils.py b/venv/lib/python3.10/site-packages/wheel/vendored/packaging/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..c2c2f75aa806282d322c76c2117c0f0fdfb09d25 --- /dev/null +++ b/venv/lib/python3.10/site-packages/wheel/vendored/packaging/utils.py @@ -0,0 +1,172 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +import re +from typing import FrozenSet, NewType, Tuple, Union, cast + +from .tags import Tag, parse_tag +from .version import InvalidVersion, Version + +BuildTag = Union[Tuple[()], Tuple[int, str]] +NormalizedName = NewType("NormalizedName", str) + + +class InvalidName(ValueError): + """ + An invalid distribution name; users should refer to the packaging user guide. + """ + + +class InvalidWheelFilename(ValueError): + """ + An invalid wheel filename was found, users should refer to PEP 427. + """ + + +class InvalidSdistFilename(ValueError): + """ + An invalid sdist filename was found, users should refer to the packaging user guide. + """ + + +# Core metadata spec for `Name` +_validate_regex = re.compile( + r"^([A-Z0-9]|[A-Z0-9][A-Z0-9._-]*[A-Z0-9])$", re.IGNORECASE +) +_canonicalize_regex = re.compile(r"[-_.]+") +_normalized_regex = re.compile(r"^([a-z0-9]|[a-z0-9]([a-z0-9-](?!--))*[a-z0-9])$") +# PEP 427: The build number must start with a digit. +_build_tag_regex = re.compile(r"(\d+)(.*)") + + +def canonicalize_name(name: str, *, validate: bool = False) -> NormalizedName: + if validate and not _validate_regex.match(name): + raise InvalidName(f"name is invalid: {name!r}") + # This is taken from PEP 503. + value = _canonicalize_regex.sub("-", name).lower() + return cast(NormalizedName, value) + + +def is_normalized_name(name: str) -> bool: + return _normalized_regex.match(name) is not None + + +def canonicalize_version( + version: Union[Version, str], *, strip_trailing_zero: bool = True +) -> str: + """ + This is very similar to Version.__str__, but has one subtle difference + with the way it handles the release segment. + """ + if isinstance(version, str): + try: + parsed = Version(version) + except InvalidVersion: + # Legacy versions cannot be normalized + return version + else: + parsed = version + + parts = [] + + # Epoch + if parsed.epoch != 0: + parts.append(f"{parsed.epoch}!") + + # Release segment + release_segment = ".".join(str(x) for x in parsed.release) + if strip_trailing_zero: + # NB: This strips trailing '.0's to normalize + release_segment = re.sub(r"(\.0)+$", "", release_segment) + parts.append(release_segment) + + # Pre-release + if parsed.pre is not None: + parts.append("".join(str(x) for x in parsed.pre)) + + # Post-release + if parsed.post is not None: + parts.append(f".post{parsed.post}") + + # Development release + if parsed.dev is not None: + parts.append(f".dev{parsed.dev}") + + # Local version segment + if parsed.local is not None: + parts.append(f"+{parsed.local}") + + return "".join(parts) + + +def parse_wheel_filename( + filename: str, +) -> Tuple[NormalizedName, Version, BuildTag, FrozenSet[Tag]]: + if not filename.endswith(".whl"): + raise InvalidWheelFilename( + f"Invalid wheel filename (extension must be '.whl'): {filename}" + ) + + filename = filename[:-4] + dashes = filename.count("-") + if dashes not in (4, 5): + raise InvalidWheelFilename( + f"Invalid wheel filename (wrong number of parts): {filename}" + ) + + parts = filename.split("-", dashes - 2) + name_part = parts[0] + # See PEP 427 for the rules on escaping the project name. + if "__" in name_part or re.match(r"^[\w\d._]*$", name_part, re.UNICODE) is None: + raise InvalidWheelFilename(f"Invalid project name: {filename}") + name = canonicalize_name(name_part) + + try: + version = Version(parts[1]) + except InvalidVersion as e: + raise InvalidWheelFilename( + f"Invalid wheel filename (invalid version): {filename}" + ) from e + + if dashes == 5: + build_part = parts[2] + build_match = _build_tag_regex.match(build_part) + if build_match is None: + raise InvalidWheelFilename( + f"Invalid build number: {build_part} in '{filename}'" + ) + build = cast(BuildTag, (int(build_match.group(1)), build_match.group(2))) + else: + build = () + tags = parse_tag(parts[-1]) + return (name, version, build, tags) + + +def parse_sdist_filename(filename: str) -> Tuple[NormalizedName, Version]: + if filename.endswith(".tar.gz"): + file_stem = filename[: -len(".tar.gz")] + elif filename.endswith(".zip"): + file_stem = filename[: -len(".zip")] + else: + raise InvalidSdistFilename( + f"Invalid sdist filename (extension must be '.tar.gz' or '.zip'):" + f" {filename}" + ) + + # We are requiring a PEP 440 version, which cannot contain dashes, + # so we split on the last dash. + name_part, sep, version_part = file_stem.rpartition("-") + if not sep: + raise InvalidSdistFilename(f"Invalid sdist filename: {filename}") + + name = canonicalize_name(name_part) + + try: + version = Version(version_part) + except InvalidVersion as e: + raise InvalidSdistFilename( + f"Invalid sdist filename (invalid version): {filename}" + ) from e + + return (name, version) diff --git a/venv/lib/python3.10/site-packages/wheel/vendored/packaging/version.py b/venv/lib/python3.10/site-packages/wheel/vendored/packaging/version.py new file mode 100644 index 0000000000000000000000000000000000000000..cda8e99935c8d92010b84437ae83d75031245d61 --- /dev/null +++ b/venv/lib/python3.10/site-packages/wheel/vendored/packaging/version.py @@ -0,0 +1,561 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. +""" +.. testsetup:: + + from packaging.version import parse, Version +""" + +import itertools +import re +from typing import Any, Callable, NamedTuple, Optional, SupportsInt, Tuple, Union + +from ._structures import Infinity, InfinityType, NegativeInfinity, NegativeInfinityType + +__all__ = ["VERSION_PATTERN", "parse", "Version", "InvalidVersion"] + +LocalType = Tuple[Union[int, str], ...] + +CmpPrePostDevType = Union[InfinityType, NegativeInfinityType, Tuple[str, int]] +CmpLocalType = Union[ + NegativeInfinityType, + Tuple[Union[Tuple[int, str], Tuple[NegativeInfinityType, Union[int, str]]], ...], +] +CmpKey = Tuple[ + int, + Tuple[int, ...], + CmpPrePostDevType, + CmpPrePostDevType, + CmpPrePostDevType, + CmpLocalType, +] +VersionComparisonMethod = Callable[[CmpKey, CmpKey], bool] + + +class _Version(NamedTuple): + epoch: int + release: Tuple[int, ...] + dev: Optional[Tuple[str, int]] + pre: Optional[Tuple[str, int]] + post: Optional[Tuple[str, int]] + local: Optional[LocalType] + + +def parse(version: str) -> "Version": + """Parse the given version string. + + >>> parse('1.0.dev1') + + + :param version: The version string to parse. + :raises InvalidVersion: When the version string is not a valid version. + """ + return Version(version) + + +class InvalidVersion(ValueError): + """Raised when a version string is not a valid version. + + >>> Version("invalid") + Traceback (most recent call last): + ... + packaging.version.InvalidVersion: Invalid version: 'invalid' + """ + + +class _BaseVersion: + _key: Tuple[Any, ...] + + def __hash__(self) -> int: + return hash(self._key) + + # Please keep the duplicated `isinstance` check + # in the six comparisons hereunder + # unless you find a way to avoid adding overhead function calls. + def __lt__(self, other: "_BaseVersion") -> bool: + if not isinstance(other, _BaseVersion): + return NotImplemented + + return self._key < other._key + + def __le__(self, other: "_BaseVersion") -> bool: + if not isinstance(other, _BaseVersion): + return NotImplemented + + return self._key <= other._key + + def __eq__(self, other: object) -> bool: + if not isinstance(other, _BaseVersion): + return NotImplemented + + return self._key == other._key + + def __ge__(self, other: "_BaseVersion") -> bool: + if not isinstance(other, _BaseVersion): + return NotImplemented + + return self._key >= other._key + + def __gt__(self, other: "_BaseVersion") -> bool: + if not isinstance(other, _BaseVersion): + return NotImplemented + + return self._key > other._key + + def __ne__(self, other: object) -> bool: + if not isinstance(other, _BaseVersion): + return NotImplemented + + return self._key != other._key + + +# Deliberately not anchored to the start and end of the string, to make it +# easier for 3rd party code to reuse +_VERSION_PATTERN = r""" + v? + (?: + (?:(?P[0-9]+)!)? # epoch + (?P[0-9]+(?:\.[0-9]+)*) # release segment + (?P
                                          # pre-release
+            [-_\.]?
+            (?Palpha|a|beta|b|preview|pre|c|rc)
+            [-_\.]?
+            (?P[0-9]+)?
+        )?
+        (?P                                         # post release
+            (?:-(?P[0-9]+))
+            |
+            (?:
+                [-_\.]?
+                (?Ppost|rev|r)
+                [-_\.]?
+                (?P[0-9]+)?
+            )
+        )?
+        (?P                                          # dev release
+            [-_\.]?
+            (?Pdev)
+            [-_\.]?
+            (?P[0-9]+)?
+        )?
+    )
+    (?:\+(?P[a-z0-9]+(?:[-_\.][a-z0-9]+)*))?       # local version
+"""
+
+VERSION_PATTERN = _VERSION_PATTERN
+"""
+A string containing the regular expression used to match a valid version.
+
+The pattern is not anchored at either end, and is intended for embedding in larger
+expressions (for example, matching a version number as part of a file name). The
+regular expression should be compiled with the ``re.VERBOSE`` and ``re.IGNORECASE``
+flags set.
+
+:meta hide-value:
+"""
+
+
+class Version(_BaseVersion):
+    """This class abstracts handling of a project's versions.
+
+    A :class:`Version` instance is comparison aware and can be compared and
+    sorted using the standard Python interfaces.
+
+    >>> v1 = Version("1.0a5")
+    >>> v2 = Version("1.0")
+    >>> v1
+    
+    >>> v2
+    
+    >>> v1 < v2
+    True
+    >>> v1 == v2
+    False
+    >>> v1 > v2
+    False
+    >>> v1 >= v2
+    False
+    >>> v1 <= v2
+    True
+    """
+
+    _regex = re.compile(r"^\s*" + VERSION_PATTERN + r"\s*$", re.VERBOSE | re.IGNORECASE)
+    _key: CmpKey
+
+    def __init__(self, version: str) -> None:
+        """Initialize a Version object.
+
+        :param version:
+            The string representation of a version which will be parsed and normalized
+            before use.
+        :raises InvalidVersion:
+            If the ``version`` does not conform to PEP 440 in any way then this
+            exception will be raised.
+        """
+
+        # Validate the version and parse it into pieces
+        match = self._regex.search(version)
+        if not match:
+            raise InvalidVersion(f"Invalid version: '{version}'")
+
+        # Store the parsed out pieces of the version
+        self._version = _Version(
+            epoch=int(match.group("epoch")) if match.group("epoch") else 0,
+            release=tuple(int(i) for i in match.group("release").split(".")),
+            pre=_parse_letter_version(match.group("pre_l"), match.group("pre_n")),
+            post=_parse_letter_version(
+                match.group("post_l"), match.group("post_n1") or match.group("post_n2")
+            ),
+            dev=_parse_letter_version(match.group("dev_l"), match.group("dev_n")),
+            local=_parse_local_version(match.group("local")),
+        )
+
+        # Generate a key which will be used for sorting
+        self._key = _cmpkey(
+            self._version.epoch,
+            self._version.release,
+            self._version.pre,
+            self._version.post,
+            self._version.dev,
+            self._version.local,
+        )
+
+    def __repr__(self) -> str:
+        """A representation of the Version that shows all internal state.
+
+        >>> Version('1.0.0')
+        
+        """
+        return f""
+
+    def __str__(self) -> str:
+        """A string representation of the version that can be rounded-tripped.
+
+        >>> str(Version("1.0a5"))
+        '1.0a5'
+        """
+        parts = []
+
+        # Epoch
+        if self.epoch != 0:
+            parts.append(f"{self.epoch}!")
+
+        # Release segment
+        parts.append(".".join(str(x) for x in self.release))
+
+        # Pre-release
+        if self.pre is not None:
+            parts.append("".join(str(x) for x in self.pre))
+
+        # Post-release
+        if self.post is not None:
+            parts.append(f".post{self.post}")
+
+        # Development release
+        if self.dev is not None:
+            parts.append(f".dev{self.dev}")
+
+        # Local version segment
+        if self.local is not None:
+            parts.append(f"+{self.local}")
+
+        return "".join(parts)
+
+    @property
+    def epoch(self) -> int:
+        """The epoch of the version.
+
+        >>> Version("2.0.0").epoch
+        0
+        >>> Version("1!2.0.0").epoch
+        1
+        """
+        return self._version.epoch
+
+    @property
+    def release(self) -> Tuple[int, ...]:
+        """The components of the "release" segment of the version.
+
+        >>> Version("1.2.3").release
+        (1, 2, 3)
+        >>> Version("2.0.0").release
+        (2, 0, 0)
+        >>> Version("1!2.0.0.post0").release
+        (2, 0, 0)
+
+        Includes trailing zeroes but not the epoch or any pre-release / development /
+        post-release suffixes.
+        """
+        return self._version.release
+
+    @property
+    def pre(self) -> Optional[Tuple[str, int]]:
+        """The pre-release segment of the version.
+
+        >>> print(Version("1.2.3").pre)
+        None
+        >>> Version("1.2.3a1").pre
+        ('a', 1)
+        >>> Version("1.2.3b1").pre
+        ('b', 1)
+        >>> Version("1.2.3rc1").pre
+        ('rc', 1)
+        """
+        return self._version.pre
+
+    @property
+    def post(self) -> Optional[int]:
+        """The post-release number of the version.
+
+        >>> print(Version("1.2.3").post)
+        None
+        >>> Version("1.2.3.post1").post
+        1
+        """
+        return self._version.post[1] if self._version.post else None
+
+    @property
+    def dev(self) -> Optional[int]:
+        """The development number of the version.
+
+        >>> print(Version("1.2.3").dev)
+        None
+        >>> Version("1.2.3.dev1").dev
+        1
+        """
+        return self._version.dev[1] if self._version.dev else None
+
+    @property
+    def local(self) -> Optional[str]:
+        """The local version segment of the version.
+
+        >>> print(Version("1.2.3").local)
+        None
+        >>> Version("1.2.3+abc").local
+        'abc'
+        """
+        if self._version.local:
+            return ".".join(str(x) for x in self._version.local)
+        else:
+            return None
+
+    @property
+    def public(self) -> str:
+        """The public portion of the version.
+
+        >>> Version("1.2.3").public
+        '1.2.3'
+        >>> Version("1.2.3+abc").public
+        '1.2.3'
+        >>> Version("1.2.3+abc.dev1").public
+        '1.2.3'
+        """
+        return str(self).split("+", 1)[0]
+
+    @property
+    def base_version(self) -> str:
+        """The "base version" of the version.
+
+        >>> Version("1.2.3").base_version
+        '1.2.3'
+        >>> Version("1.2.3+abc").base_version
+        '1.2.3'
+        >>> Version("1!1.2.3+abc.dev1").base_version
+        '1!1.2.3'
+
+        The "base version" is the public version of the project without any pre or post
+        release markers.
+        """
+        parts = []
+
+        # Epoch
+        if self.epoch != 0:
+            parts.append(f"{self.epoch}!")
+
+        # Release segment
+        parts.append(".".join(str(x) for x in self.release))
+
+        return "".join(parts)
+
+    @property
+    def is_prerelease(self) -> bool:
+        """Whether this version is a pre-release.
+
+        >>> Version("1.2.3").is_prerelease
+        False
+        >>> Version("1.2.3a1").is_prerelease
+        True
+        >>> Version("1.2.3b1").is_prerelease
+        True
+        >>> Version("1.2.3rc1").is_prerelease
+        True
+        >>> Version("1.2.3dev1").is_prerelease
+        True
+        """
+        return self.dev is not None or self.pre is not None
+
+    @property
+    def is_postrelease(self) -> bool:
+        """Whether this version is a post-release.
+
+        >>> Version("1.2.3").is_postrelease
+        False
+        >>> Version("1.2.3.post1").is_postrelease
+        True
+        """
+        return self.post is not None
+
+    @property
+    def is_devrelease(self) -> bool:
+        """Whether this version is a development release.
+
+        >>> Version("1.2.3").is_devrelease
+        False
+        >>> Version("1.2.3.dev1").is_devrelease
+        True
+        """
+        return self.dev is not None
+
+    @property
+    def major(self) -> int:
+        """The first item of :attr:`release` or ``0`` if unavailable.
+
+        >>> Version("1.2.3").major
+        1
+        """
+        return self.release[0] if len(self.release) >= 1 else 0
+
+    @property
+    def minor(self) -> int:
+        """The second item of :attr:`release` or ``0`` if unavailable.
+
+        >>> Version("1.2.3").minor
+        2
+        >>> Version("1").minor
+        0
+        """
+        return self.release[1] if len(self.release) >= 2 else 0
+
+    @property
+    def micro(self) -> int:
+        """The third item of :attr:`release` or ``0`` if unavailable.
+
+        >>> Version("1.2.3").micro
+        3
+        >>> Version("1").micro
+        0
+        """
+        return self.release[2] if len(self.release) >= 3 else 0
+
+
+def _parse_letter_version(
+    letter: Optional[str], number: Union[str, bytes, SupportsInt, None]
+) -> Optional[Tuple[str, int]]:
+    if letter:
+        # We consider there to be an implicit 0 in a pre-release if there is
+        # not a numeral associated with it.
+        if number is None:
+            number = 0
+
+        # We normalize any letters to their lower case form
+        letter = letter.lower()
+
+        # We consider some words to be alternate spellings of other words and
+        # in those cases we want to normalize the spellings to our preferred
+        # spelling.
+        if letter == "alpha":
+            letter = "a"
+        elif letter == "beta":
+            letter = "b"
+        elif letter in ["c", "pre", "preview"]:
+            letter = "rc"
+        elif letter in ["rev", "r"]:
+            letter = "post"
+
+        return letter, int(number)
+    if not letter and number:
+        # We assume if we are given a number, but we are not given a letter
+        # then this is using the implicit post release syntax (e.g. 1.0-1)
+        letter = "post"
+
+        return letter, int(number)
+
+    return None
+
+
+_local_version_separators = re.compile(r"[\._-]")
+
+
+def _parse_local_version(local: Optional[str]) -> Optional[LocalType]:
+    """
+    Takes a string like abc.1.twelve and turns it into ("abc", 1, "twelve").
+    """
+    if local is not None:
+        return tuple(
+            part.lower() if not part.isdigit() else int(part)
+            for part in _local_version_separators.split(local)
+        )
+    return None
+
+
+def _cmpkey(
+    epoch: int,
+    release: Tuple[int, ...],
+    pre: Optional[Tuple[str, int]],
+    post: Optional[Tuple[str, int]],
+    dev: Optional[Tuple[str, int]],
+    local: Optional[LocalType],
+) -> CmpKey:
+    # When we compare a release version, we want to compare it with all of the
+    # trailing zeros removed. So we'll use a reverse the list, drop all the now
+    # leading zeros until we come to something non zero, then take the rest
+    # re-reverse it back into the correct order and make it a tuple and use
+    # that for our sorting key.
+    _release = tuple(
+        reversed(list(itertools.dropwhile(lambda x: x == 0, reversed(release))))
+    )
+
+    # We need to "trick" the sorting algorithm to put 1.0.dev0 before 1.0a0.
+    # We'll do this by abusing the pre segment, but we _only_ want to do this
+    # if there is not a pre or a post segment. If we have one of those then
+    # the normal sorting rules will handle this case correctly.
+    if pre is None and post is None and dev is not None:
+        _pre: CmpPrePostDevType = NegativeInfinity
+    # Versions without a pre-release (except as noted above) should sort after
+    # those with one.
+    elif pre is None:
+        _pre = Infinity
+    else:
+        _pre = pre
+
+    # Versions without a post segment should sort before those with one.
+    if post is None:
+        _post: CmpPrePostDevType = NegativeInfinity
+
+    else:
+        _post = post
+
+    # Versions without a development segment should sort after those with one.
+    if dev is None:
+        _dev: CmpPrePostDevType = Infinity
+
+    else:
+        _dev = dev
+
+    if local is None:
+        # Versions without a local segment should sort before those with one.
+        _local: CmpLocalType = NegativeInfinity
+    else:
+        # Versions with a local segment need that segment parsed to implement
+        # the sorting rules in PEP440.
+        # - Alpha numeric segments sort before numeric segments
+        # - Alpha numeric segments sort lexicographically
+        # - Numeric segments sort numerically
+        # - Shorter versions sort before longer versions when the prefixes
+        #   match exactly
+        _local = tuple(
+            (i, "") if isinstance(i, int) else (NegativeInfinity, i) for i in local
+        )
+
+    return epoch, _release, _pre, _post, _dev, _local
diff --git a/venv/lib/python3.10/site-packages/wheel/vendored/vendor.txt b/venv/lib/python3.10/site-packages/wheel/vendored/vendor.txt
new file mode 100644
index 0000000000000000000000000000000000000000..14666103a82ea7fced3d8cffb8a9b2a9e03fb492
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/wheel/vendored/vendor.txt
@@ -0,0 +1 @@
+packaging==24.0
diff --git a/venv/lib/python3.10/site-packages/wheel/wheelfile.py b/venv/lib/python3.10/site-packages/wheel/wheelfile.py
new file mode 100644
index 0000000000000000000000000000000000000000..0a0f4596c566420135991713ee75ca29c4cff3ed
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/wheel/wheelfile.py
@@ -0,0 +1,227 @@
+from __future__ import annotations
+
+import csv
+import hashlib
+import os.path
+import re
+import stat
+import time
+from io import StringIO, TextIOWrapper
+from typing import IO, TYPE_CHECKING, Literal
+from zipfile import ZIP_DEFLATED, ZipFile, ZipInfo
+
+from wheel.cli import WheelError
+from wheel.util import log, urlsafe_b64decode, urlsafe_b64encode
+
+if TYPE_CHECKING:
+    from typing import Protocol, Sized, Union
+
+    from typing_extensions import Buffer
+
+    StrPath = Union[str, os.PathLike[str]]
+
+    class SizedBuffer(Sized, Buffer, Protocol): ...
+
+
+# Non-greedy matching of an optional build number may be too clever (more
+# invalid wheel filenames will match). Separate regex for .dist-info?
+WHEEL_INFO_RE = re.compile(
+    r"""^(?P(?P[^\s-]+?)-(?P[^\s-]+?))(-(?P\d[^\s-]*))?
+     -(?P[^\s-]+?)-(?P[^\s-]+?)-(?P\S+)\.whl$""",
+    re.VERBOSE,
+)
+MINIMUM_TIMESTAMP = 315532800  # 1980-01-01 00:00:00 UTC
+
+
+def get_zipinfo_datetime(timestamp: float | None = None):
+    # Some applications need reproducible .whl files, but they can't do this without
+    # forcing the timestamp of the individual ZipInfo objects. See issue #143.
+    timestamp = int(os.environ.get("SOURCE_DATE_EPOCH", timestamp or time.time()))
+    timestamp = max(timestamp, MINIMUM_TIMESTAMP)
+    return time.gmtime(timestamp)[0:6]
+
+
+class WheelFile(ZipFile):
+    """A ZipFile derivative class that also reads SHA-256 hashes from
+    .dist-info/RECORD and checks any read files against those.
+    """
+
+    _default_algorithm = hashlib.sha256
+
+    def __init__(
+        self,
+        file: StrPath,
+        mode: Literal["r", "w", "x", "a"] = "r",
+        compression: int = ZIP_DEFLATED,
+    ):
+        basename = os.path.basename(file)
+        self.parsed_filename = WHEEL_INFO_RE.match(basename)
+        if not basename.endswith(".whl") or self.parsed_filename is None:
+            raise WheelError(f"Bad wheel filename {basename!r}")
+
+        ZipFile.__init__(self, file, mode, compression=compression, allowZip64=True)
+
+        self.dist_info_path = "{}.dist-info".format(
+            self.parsed_filename.group("namever")
+        )
+        self.record_path = self.dist_info_path + "/RECORD"
+        self._file_hashes: dict[str, tuple[None, None] | tuple[int, bytes]] = {}
+        self._file_sizes = {}
+        if mode == "r":
+            # Ignore RECORD and any embedded wheel signatures
+            self._file_hashes[self.record_path] = None, None
+            self._file_hashes[self.record_path + ".jws"] = None, None
+            self._file_hashes[self.record_path + ".p7s"] = None, None
+
+            # Fill in the expected hashes by reading them from RECORD
+            try:
+                record = self.open(self.record_path)
+            except KeyError:
+                raise WheelError(f"Missing {self.record_path} file") from None
+
+            with record:
+                for line in csv.reader(
+                    TextIOWrapper(record, newline="", encoding="utf-8")
+                ):
+                    path, hash_sum, size = line
+                    if not hash_sum:
+                        continue
+
+                    algorithm, hash_sum = hash_sum.split("=")
+                    try:
+                        hashlib.new(algorithm)
+                    except ValueError:
+                        raise WheelError(
+                            f"Unsupported hash algorithm: {algorithm}"
+                        ) from None
+
+                    if algorithm.lower() in {"md5", "sha1"}:
+                        raise WheelError(
+                            f"Weak hash algorithm ({algorithm}) is not permitted by "
+                            f"PEP 427"
+                        )
+
+                    self._file_hashes[path] = (
+                        algorithm,
+                        urlsafe_b64decode(hash_sum.encode("ascii")),
+                    )
+
+    def open(
+        self,
+        name_or_info: str | ZipInfo,
+        mode: Literal["r", "w"] = "r",
+        pwd: bytes | None = None,
+    ) -> IO[bytes]:
+        def _update_crc(newdata: bytes) -> None:
+            eof = ef._eof
+            update_crc_orig(newdata)
+            running_hash.update(newdata)
+            if eof and running_hash.digest() != expected_hash:
+                raise WheelError(f"Hash mismatch for file '{ef_name}'")
+
+        ef_name = (
+            name_or_info.filename if isinstance(name_or_info, ZipInfo) else name_or_info
+        )
+        if (
+            mode == "r"
+            and not ef_name.endswith("/")
+            and ef_name not in self._file_hashes
+        ):
+            raise WheelError(f"No hash found for file '{ef_name}'")
+
+        ef = ZipFile.open(self, name_or_info, mode, pwd)
+        if mode == "r" and not ef_name.endswith("/"):
+            algorithm, expected_hash = self._file_hashes[ef_name]
+            if expected_hash is not None:
+                # Monkey patch the _update_crc method to also check for the hash from
+                # RECORD
+                running_hash = hashlib.new(algorithm)
+                update_crc_orig, ef._update_crc = ef._update_crc, _update_crc
+
+        return ef
+
+    def write_files(self, base_dir: str):
+        log.info(f"creating '{self.filename}' and adding '{base_dir}' to it")
+        deferred: list[tuple[str, str]] = []
+        for root, dirnames, filenames in os.walk(base_dir):
+            # Sort the directory names so that `os.walk` will walk them in a
+            # defined order on the next iteration.
+            dirnames.sort()
+            for name in sorted(filenames):
+                path = os.path.normpath(os.path.join(root, name))
+                if os.path.isfile(path):
+                    arcname = os.path.relpath(path, base_dir).replace(os.path.sep, "/")
+                    if arcname == self.record_path:
+                        pass
+                    elif root.endswith(".dist-info"):
+                        deferred.append((path, arcname))
+                    else:
+                        self.write(path, arcname)
+
+        deferred.sort()
+        for path, arcname in deferred:
+            self.write(path, arcname)
+
+    def write(
+        self,
+        filename: str,
+        arcname: str | None = None,
+        compress_type: int | None = None,
+    ) -> None:
+        with open(filename, "rb") as f:
+            st = os.fstat(f.fileno())
+            data = f.read()
+
+        zinfo = ZipInfo(
+            arcname or filename, date_time=get_zipinfo_datetime(st.st_mtime)
+        )
+        zinfo.external_attr = (stat.S_IMODE(st.st_mode) | stat.S_IFMT(st.st_mode)) << 16
+        zinfo.compress_type = compress_type or self.compression
+        self.writestr(zinfo, data, compress_type)
+
+    def writestr(
+        self,
+        zinfo_or_arcname: str | ZipInfo,
+        data: SizedBuffer | str,
+        compress_type: int | None = None,
+    ):
+        if isinstance(zinfo_or_arcname, str):
+            zinfo_or_arcname = ZipInfo(
+                zinfo_or_arcname, date_time=get_zipinfo_datetime()
+            )
+            zinfo_or_arcname.compress_type = self.compression
+            zinfo_or_arcname.external_attr = (0o664 | stat.S_IFREG) << 16
+
+        if isinstance(data, str):
+            data = data.encode("utf-8")
+
+        ZipFile.writestr(self, zinfo_or_arcname, data, compress_type)
+        fname = (
+            zinfo_or_arcname.filename
+            if isinstance(zinfo_or_arcname, ZipInfo)
+            else zinfo_or_arcname
+        )
+        log.info(f"adding '{fname}'")
+        if fname != self.record_path:
+            hash_ = self._default_algorithm(data)
+            self._file_hashes[fname] = (
+                hash_.name,
+                urlsafe_b64encode(hash_.digest()).decode("ascii"),
+            )
+            self._file_sizes[fname] = len(data)
+
+    def close(self):
+        # Write RECORD
+        if self.fp is not None and self.mode == "w" and self._file_hashes:
+            data = StringIO()
+            writer = csv.writer(data, delimiter=",", quotechar='"', lineterminator="\n")
+            writer.writerows(
+                (
+                    (fname, algorithm + "=" + hash_, self._file_sizes[fname])
+                    for fname, (algorithm, hash_) in self._file_hashes.items()
+                )
+            )
+            writer.writerow((format(self.record_path), "", ""))
+            self.writestr(self.record_path, data.getvalue())
+
+        ZipFile.close(self)
diff --git a/venv/lib/python3.10/site-packages/xxhash-3.5.0.dist-info/INSTALLER b/venv/lib/python3.10/site-packages/xxhash-3.5.0.dist-info/INSTALLER
new file mode 100644
index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/xxhash-3.5.0.dist-info/INSTALLER
@@ -0,0 +1 @@
+pip
diff --git a/venv/lib/python3.10/site-packages/xxhash-3.5.0.dist-info/LICENSE b/venv/lib/python3.10/site-packages/xxhash-3.5.0.dist-info/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..36b248ce00511fd76f358eb0f5543ca448d0e443
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/xxhash-3.5.0.dist-info/LICENSE
@@ -0,0 +1,22 @@
+Copyright (c) 2014-2020, Yue Du
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright notice,
+      this list of conditions and the following disclaimer in the documentation
+      and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/venv/lib/python3.10/site-packages/xxhash-3.5.0.dist-info/METADATA b/venv/lib/python3.10/site-packages/xxhash-3.5.0.dist-info/METADATA
new file mode 100644
index 0000000000000000000000000000000000000000..986b3b46b7c465f39edfcfefb921430ae9a58082
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/xxhash-3.5.0.dist-info/METADATA
@@ -0,0 +1,522 @@
+Metadata-Version: 2.1
+Name: xxhash
+Version: 3.5.0
+Summary: Python binding for xxHash
+Home-page: https://github.com/ifduyue/python-xxhash
+Author: Yue Du
+Author-email: ifduyue@gmail.com
+License: BSD
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Requires-Python: >=3.7
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+
+python-xxhash
+=============
+
+.. image:: https://github.com/ifduyue/python-xxhash/actions/workflows/test.yml/badge.svg
+    :target: https://github.com/ifduyue/python-xxhash/actions/workflows/test.yml
+    :alt: Github Actions Status
+
+.. image:: https://img.shields.io/pypi/v/xxhash.svg
+    :target: https://pypi.org/project/xxhash/
+    :alt: Latest Version
+
+.. image:: https://img.shields.io/pypi/pyversions/xxhash.svg
+    :target: https://pypi.org/project/xxhash/
+    :alt: Supported Python versions
+
+.. image:: https://img.shields.io/pypi/l/xxhash.svg
+    :target: https://pypi.org/project/xxhash/
+    :alt: License
+
+
+.. _HMAC: http://en.wikipedia.org/wiki/Hash-based_message_authentication_code
+.. _xxHash: https://github.com/Cyan4973/xxHash
+.. _Cyan4973: https://github.com/Cyan4973
+
+
+xxhash is a Python binding for the xxHash_ library by `Yann Collet`__.
+
+__ Cyan4973_
+
+Installation
+------------
+
+.. code-block:: bash
+
+   $ pip install xxhash
+   
+You can also install using conda:
+
+.. code-block:: bash
+
+   $ conda install -c conda-forge python-xxhash
+
+
+Installing From Source
+~~~~~~~~~~~~~~~~~~~~~~~
+
+.. code-block:: bash
+
+   $ pip install --no-binary xxhash xxhash
+
+Prerequisites
+++++++++++++++
+
+On Debian/Ubuntu:
+
+.. code-block:: bash
+
+   $ apt-get install python-dev gcc
+
+On CentOS/Fedora:
+
+.. code-block:: bash
+
+   $ yum install python-devel gcc redhat-rpm-config
+
+Linking to libxxhash.so
+~~~~~~~~~~~~~~~~~~~~~~~~
+
+By default python-xxhash will use bundled xxHash,
+we can change this by specifying ENV var ``XXHASH_LINK_SO``:
+
+.. code-block:: bash
+
+   $ XXHASH_LINK_SO=1 pip install --no-binary xxhash xxhash
+
+Usage
+--------
+
+Module version and its backend xxHash library version can be retrieved using
+the module properties ``VERSION`` AND ``XXHASH_VERSION`` respectively.
+
+.. code-block:: python
+
+    >>> import xxhash
+    >>> xxhash.VERSION
+    '2.0.0'
+    >>> xxhash.XXHASH_VERSION
+    '0.8.0'
+
+This module is hashlib-compliant, which means you can use it in the same way as ``hashlib.md5``.
+
+    | update() -- update the current digest with an additional string
+    | digest() -- return the current digest value
+    | hexdigest() -- return the current digest as a string of hexadecimal digits
+    | intdigest() -- return the current digest as an integer
+    | copy() -- return a copy of the current xxhash object
+    | reset() -- reset state
+
+md5 digest returns bytes, but the original xxh32 and xxh64 C APIs return integers.
+While this module is made hashlib-compliant, ``intdigest()`` is also provided to
+get the integer digest.
+
+Constructors for hash algorithms provided by this module are ``xxh32()`` and ``xxh64()``.
+
+For example, to obtain the digest of the byte string ``b'Nobody inspects the spammish repetition'``:
+
+.. code-block:: python
+
+    >>> import xxhash
+    >>> x = xxhash.xxh32()
+    >>> x.update(b'Nobody inspects')
+    >>> x.update(b' the spammish repetition')
+    >>> x.digest()
+    b'\xe2);/'
+    >>> x.digest_size
+    4
+    >>> x.block_size
+    16
+
+More condensed:
+
+.. code-block:: python
+
+    >>> xxhash.xxh32(b'Nobody inspects the spammish repetition').hexdigest()
+    'e2293b2f'
+    >>> xxhash.xxh32(b'Nobody inspects the spammish repetition').digest() == x.digest()
+    True
+
+An optional seed (default is 0) can be used to alter the result predictably:
+
+.. code-block:: python
+
+    >>> import xxhash
+    >>> xxhash.xxh64('xxhash').hexdigest()
+    '32dd38952c4bc720'
+    >>> xxhash.xxh64('xxhash', seed=20141025).hexdigest()
+    'b559b98d844e0635'
+    >>> x = xxhash.xxh64(seed=20141025)
+    >>> x.update('xxhash')
+    >>> x.hexdigest()
+    'b559b98d844e0635'
+    >>> x.intdigest()
+    13067679811253438005
+
+Be careful that xxh32 takes an unsigned 32-bit integer as seed, while xxh64
+takes an unsigned 64-bit integer. Although unsigned integer overflow is
+defined behavior, it's better not to make it happen:
+
+.. code-block:: python
+
+    >>> xxhash.xxh32('I want an unsigned 32-bit seed!', seed=0).hexdigest()
+    'f7a35af8'
+    >>> xxhash.xxh32('I want an unsigned 32-bit seed!', seed=2**32).hexdigest()
+    'f7a35af8'
+    >>> xxhash.xxh32('I want an unsigned 32-bit seed!', seed=1).hexdigest()
+    'd8d4b4ba'
+    >>> xxhash.xxh32('I want an unsigned 32-bit seed!', seed=2**32+1).hexdigest()
+    'd8d4b4ba'
+    >>>
+    >>> xxhash.xxh64('I want an unsigned 64-bit seed!', seed=0).hexdigest()
+    'd4cb0a70a2b8c7c1'
+    >>> xxhash.xxh64('I want an unsigned 64-bit seed!', seed=2**64).hexdigest()
+    'd4cb0a70a2b8c7c1'
+    >>> xxhash.xxh64('I want an unsigned 64-bit seed!', seed=1).hexdigest()
+    'ce5087f12470d961'
+    >>> xxhash.xxh64('I want an unsigned 64-bit seed!', seed=2**64+1).hexdigest()
+    'ce5087f12470d961'
+
+
+``digest()`` returns bytes of the **big-endian** representation of the integer
+digest:
+
+.. code-block:: python
+
+    >>> import xxhash
+    >>> h = xxhash.xxh64()
+    >>> h.digest()
+    b'\xefF\xdb7Q\xd8\xe9\x99'
+    >>> h.intdigest().to_bytes(8, 'big')
+    b'\xefF\xdb7Q\xd8\xe9\x99'
+    >>> h.hexdigest()
+    'ef46db3751d8e999'
+    >>> format(h.intdigest(), '016x')
+    'ef46db3751d8e999'
+    >>> h.intdigest()
+    17241709254077376921
+    >>> int(h.hexdigest(), 16)
+    17241709254077376921
+
+Besides xxh32/xxh64 mentioned above, oneshot functions are also provided,
+so we can avoid allocating XXH32/64 state on heap:
+
+    | xxh32_digest(bytes, seed=0)
+    | xxh32_intdigest(bytes, seed=0)
+    | xxh32_hexdigest(bytes, seed=0)
+    | xxh64_digest(bytes, seed=0)
+    | xxh64_intdigest(bytes, seed=0)
+    | xxh64_hexdigest(bytes, seed=0)
+
+.. code-block:: python
+
+    >>> import xxhash
+    >>> xxhash.xxh64('a').digest() == xxhash.xxh64_digest('a')
+    True
+    >>> xxhash.xxh64('a').intdigest() == xxhash.xxh64_intdigest('a')
+    True
+    >>> xxhash.xxh64('a').hexdigest() == xxhash.xxh64_hexdigest('a')
+    True
+    >>> xxhash.xxh64_hexdigest('xxhash', seed=20141025)
+    'b559b98d844e0635'
+    >>> xxhash.xxh64_intdigest('xxhash', seed=20141025)
+    13067679811253438005L
+    >>> xxhash.xxh64_digest('xxhash', seed=20141025)
+    '\xb5Y\xb9\x8d\x84N\x065'
+
+.. code-block:: python
+
+    In [1]: import xxhash
+
+    In [2]: %timeit xxhash.xxh64_hexdigest('xxhash')
+    268 ns ± 24.1 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
+
+    In [3]: %timeit xxhash.xxh64('xxhash').hexdigest()
+    416 ns ± 17.3 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
+
+
+XXH3 hashes are available since v2.0.0 (xxHash v0.8.0), they are:
+
+Streaming classes:
+
+    | xxh3_64
+    | xxh3_128
+
+Oneshot functions:
+
+    | xxh3_64_digest(bytes, seed=0)
+    | xxh3_64_intdigest(bytes, seed=0)
+    | xxh3_64_hexdigest(bytes, seed=0)
+    | xxh3_128_digest(bytes, seed=0)
+    | xxh3_128_intdigest(bytes, seed=0)
+    | xxh3_128_hexdigest(bytes, seed=0)
+
+And aliases:
+
+    | xxh128 = xxh3_128
+    | xxh128_digest = xxh3_128_digest
+    | xxh128_intdigest = xxh3_128_intdigest
+    | xxh128_hexdigest = xxh3_128_hexdigest
+
+Caveats
+-------
+
+SEED OVERFLOW
+~~~~~~~~~~~~~~
+
+xxh32 takes an unsigned 32-bit integer as seed, and xxh64 takes
+an unsigned 64-bit integer as seed. Make sure that the seed is greater than
+or equal to ``0``.
+
+ENDIANNESS
+~~~~~~~~~~~
+
+As of python-xxhash 0.3.0, ``digest()`` returns bytes of the
+**big-endian** representation of the integer digest. It used
+to be little-endian.
+
+DONT USE XXHASH IN HMAC
+~~~~~~~~~~~~~~~~~~~~~~~
+Though you can use xxhash as an HMAC_ hash function, but it's
+highly recommended not to.
+
+xxhash is **NOT** a cryptographic hash function, it is a
+non-cryptographic hash algorithm aimed at speed and quality.
+Do not put xxhash in any position where cryptographic hash
+functions are required.
+
+
+Copyright and License
+---------------------
+
+Copyright (c) 2014-2024 Yue Du - https://github.com/ifduyue
+
+Licensed under `BSD 2-Clause License `_
+
+CHANGELOG
+-----------
+
+v3.5.0 2024-08-17
+~~~~~~~~~~~~~~~~~
+
+- Build wheels for Python 3.13
+
+v3.4.1 2023-10-05
+~~~~~~~~~~~~~~~~~
+
+- Build wheels for Python 3.12
+- Remove setuptools_scm
+
+v3.4.0 2023-10-05
+~~~~~~~~~~~~~~~~~
+
+*Yanked* due to wheels building problem.
+
+v3.3.0 2023-07-29
+~~~~~~~~~~~~~~~~~
+
+- Upgrade xxHash to v0.8.2
+- Drop support for Python 3.6
+
+v3.2.0 2022-12-28
+~~~~~~~~~~~~~~~~~
+
+This is the last version to support Python 3.6
+
+- Build Python 3.11 wheels.
+- Remove setup.py test_suites, call unittest directly
+
+v3.1.0 2022-10-19
+~~~~~~~~~~~~~~~~~
+
+- Type annotations.
+- Enabled muslinux wheels building.
+
+v3.0.0 2022-02-25
+~~~~~~~~~~~~~~~~~
+
+- New set `algorithms_available` lists all implemented algorithms in `xxhash`
+  package.
+- Upgrade xxHash to v0.8.1.
+- Drop support for EOL Python versions, require python >= 3.6 from now on.
+- Migrate to github actions and build arm64 wheels for macOS.
+- Always release GIL.
+
+
+v2.0.2 2021-04-15
+~~~~~~~~~~~~~~~~~
+
+- Fix Travis CI OSX dpl python2.7 get-pip.py error
+
+v2.0.1 2021-04-15
+~~~~~~~~~~~~~~~~~
+
+- Only to trigger Python 3.9 wheels building.
+
+v2.0.0 2020-08-03
+~~~~~~~~~~~~~~~~~
+
+- **Require xxHash version >= v0.8.0**
+- Upgrade xxHash to v0.8.0
+- XXH3 hashes: `xxh3_64`, `xxh3_128`, and their oneshot functions
+
+v1.4.4 2020-06-20
+~~~~~~~~~~~~~~~~~
+
+- Upgrade xxHash to v0.7.3
+- Stop using PEP393 deprecated APIs
+- Use XXH(32|64)_canonicalFromHash to replace u2bytes and ull2bytes
+
+v1.4.3 2019-11-12
+~~~~~~~~~~~~~~~~~
+
+- Upgrade xxHash to v0.7.2
+- Python 3.8 wheels
+
+v1.4.2 2019-10-13
+~~~~~~~~~~~~~~~~~
+
+- Fixed: setup.py fails when reading README.rst and the default encoding is not UTF-8
+
+v1.4.1 2019-08-27
+~~~~~~~~~~~~~~~~~
+
+- Fixed: xxh3.h in missing from source tarball
+
+v1.4.0 2019-08-25
+~~~~~~~~~~~~~~~~~
+
+- Upgrade xxHash to v0.7.1
+
+v1.3.0 2018-10-21
+~~~~~~~~~~~~~~~~~
+
+- Wheels are now built automatically
+- Split CFFI variant into a separate package `ifduyue/python-xxhash-cffi `_
+
+v1.2.0 2018-07-13
+~~~~~~~~~~~~~~~~~
+
+- Add oneshot functions xxh{32,64}_{,int,hex}digest
+
+v1.1.0 2018-07-05
+~~~~~~~~~~~~~~~~~
+
+- Allow input larger than 2GB
+- Release the GIL on sufficiently large input
+- Drop support for Python 3.2
+
+v1.0.1 2017-03-02
+~~~~~~~~~~~~~~~~~~
+
+- Free state actively, instead of delegating it to ffi.gc
+
+v1.0.0 2017-02-10
+~~~~~~~~~~~~~~~~~~
+
+- Fixed copy() segfault
+- Added CFFI variant
+
+v0.6.3 2017-02-10
+~~~~~~~~~~~~~~~~~~
+
+- Fixed copy() segfault
+
+v0.6.2 2017-02-10
+~~~~~~~~~~~~~~~~~~
+
+- Upgrade xxHash to v0.6.2
+
+v0.6.1 2016-06-26
+~~~~~~~~~~~~~~~~~~
+
+- Upgrade xxHash to v0.6.1
+
+v0.5.0 2016-03-02
+~~~~~~~~~~~~~~~~~~
+
+- Upgrade xxHash to v0.5.0
+
+v0.4.3 2015-08-21
+~~~~~~~~~~~~~~~~~~
+
+- Upgrade xxHash to r42
+
+v0.4.1 2015-08-16
+~~~~~~~~~~~~~~~~~~
+
+- Upgrade xxHash to r41
+
+v0.4.0 2015-08-05
+~~~~~~~~~~~~~~~~~~
+
+- Added method reset
+- Upgrade xxHash to r40
+
+v0.3.2 2015-01-27
+~~~~~~~~~~~~~~~~~~
+
+- Fixed some typos in docstrings
+
+v0.3.1 2015-01-24
+~~~~~~~~~~~~~~~~~~
+
+- Upgrade xxHash to r39
+
+v0.3.0 2014-11-11
+~~~~~~~~~~~~~~~~~~
+
+- Change digest() from little-endian representation to big-endian representation of the integer digest.
+  This change breaks compatibility (digest() results are different).
+
+v0.2.0 2014-10-25
+~~~~~~~~~~~~~~~~~~
+
+- Make this package hashlib-compliant
+
+v0.1.3 2014-10-23
+~~~~~~~~~~~~~~~~~~
+
+- Update xxHash to r37
+
+v0.1.2 2014-10-19
+~~~~~~~~~~~~~~~~~~
+
+- Improve: Check XXHnn_init() return value.
+- Update xxHash to r36
+
+v0.1.1 2014-08-07
+~~~~~~~~~~~~~~~~~~
+
+- Improve: Can now be built with Visual C++ Compiler.
+
+v0.1.0 2014-08-05
+~~~~~~~~~~~~~~~~~~
+
+- New: XXH32 and XXH64 type, which support partially update.
+- Fix: build under Python 3.4
+
+v0.0.2 2014-08-03
+~~~~~~~~~~~~~~~~~~
+
+- NEW: Support Python 3
+
+v0.0.1 2014-07-30
+~~~~~~~~~~~~~~~~~~
+
+- NEW: xxh32 and xxh64
diff --git a/venv/lib/python3.10/site-packages/xxhash-3.5.0.dist-info/RECORD b/venv/lib/python3.10/site-packages/xxhash-3.5.0.dist-info/RECORD
new file mode 100644
index 0000000000000000000000000000000000000000..a4deed74ef79cb63b3f264e0921dd1377291800a
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/xxhash-3.5.0.dist-info/RECORD
@@ -0,0 +1,13 @@
+xxhash-3.5.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+xxhash-3.5.0.dist-info/LICENSE,sha256=-OnvAMeL5NLaUmssN-QJnJIMf-C52UO_Da6y78MKOls,1313
+xxhash-3.5.0.dist-info/METADATA,sha256=aOhABacmLK77bNvom4oKADT9-ncKSNTTFSpg_W4C460,12618
+xxhash-3.5.0.dist-info/RECORD,,
+xxhash-3.5.0.dist-info/WHEEL,sha256=zd9lUdeN8h8tI6EpE4xfM3xHpjsKaIYsfi-zYUo9uGE,151
+xxhash-3.5.0.dist-info/top_level.txt,sha256=1PPSBP-gnjG59E5bigzMTzmT6BVWjHwnpzMiisPWZ5I,15
+xxhash/__init__.py,sha256=mPEdihxDMU0rjLWum3FrU9Ua2jQ-rzfewYgIg-J-Jlc,1147
+xxhash/__init__.pyi,sha256=Te-hUGiCW_4Y65lyrGCOgeQrL35XTFM-qunbz0R9MiE,1786
+xxhash/__pycache__/__init__.cpython-310.pyc,,
+xxhash/__pycache__/version.cpython-310.pyc,,
+xxhash/_xxhash.cpython-310-x86_64-linux-gnu.so,sha256=nBcQ-I4iVzzOgAJuws5AcVY7Q0brU2x6UvjFZ9ADamQ,830856
+xxhash/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+xxhash/version.py,sha256=XReL1sQus4Ya1yVQP1CQM6QXZImpmcFcDBME8MisuLw,44
diff --git a/venv/lib/python3.10/site-packages/xxhash-3.5.0.dist-info/WHEEL b/venv/lib/python3.10/site-packages/xxhash-3.5.0.dist-info/WHEEL
new file mode 100644
index 0000000000000000000000000000000000000000..9f9c09c04f1e8d15a6b9621db63fc8588693b1cc
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/xxhash-3.5.0.dist-info/WHEEL
@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: setuptools (72.2.0)
+Root-Is-Purelib: false
+Tag: cp310-cp310-manylinux_2_17_x86_64
+Tag: cp310-cp310-manylinux2014_x86_64
+
diff --git a/venv/lib/python3.10/site-packages/xxhash-3.5.0.dist-info/top_level.txt b/venv/lib/python3.10/site-packages/xxhash-3.5.0.dist-info/top_level.txt
new file mode 100644
index 0000000000000000000000000000000000000000..46a6ce2f1ac8b49207db6601355076641e92f163
--- /dev/null
+++ b/venv/lib/python3.10/site-packages/xxhash-3.5.0.dist-info/top_level.txt
@@ -0,0 +1,2 @@
+_xxhash
+xxhash